Errand is an open-source AI teammate with its own computer. You give it a task, let it work, and come back later to the same conversation, the same machine, and whatever files it left there. It keeps going after you close the app; you don’t have to keep the laptop open or stay around to nudge it along.
If that shape sounds like Grok Bot or Muse, it should. The difference is that Errand is open sourced under Apache 2.0, the model is whichever provider you already use, and the computer it runs on is Runta, which we also build.
One morning with Errand
Every morning I want to know what happened since yesterday across my inboxes, repos, Slack channels, and meeting notes. Before leaving for the office I gave Errand that task. I asked it to say why it mattered, and flag anything waiting on a decision from me.
Then I closed the laptop and left.
When I got in, the result was waiting: six items, one of them something important I’d nearly forgotten. Errand had been working on its own computer the whole time, with access to my accounts, without the model ever seeing the credentials.
That’s the whole experience. Give your teammate something to do, go about your morning, pick up the result when you’re ready.
Why we built Errand
That routine sounds simple, but it needs one thing most agents don’t have: somewhere to keep working while you’re away. A computer that doesn’t vanish when the app closes. A place to keep files, use the services you’ve connected, and leave a record you can read when you get back.
That’s what we’ve been building at Runta. Runta is the execution environment underneath the agent. The agent decides what to do next; Runta gives it a place to do the work, along with control over what it can reach, visibility into what it did, and the ability to save and restore where it was.
Errand is a reference application for Runta. We built it because a persistent computer, controlled access, and recoverable state are abstract until they’re part of something you can actually use. Not having to build those pieces into the app also meant we could spend our time on the part you touch: integrations, workflows and first class experience.
What Runta handled underneath
In the morning example, closing the laptop didn’t stop the work because the agent was running on a Runta-hosted computer. The app was the interface, not the machine doing the job.
That computer also held the agent’s files and working state, so coming back to Errand doesn’t mean starting from an empty workspace.
Access to my accounts went through Runta’s credential controls. The agent’s requests carry placeholders instead of real secrets; Runta swaps in the real credentials at the gateway on the way out. The agent can make an authenticated call without ever holding the credential.
Everything the agent did is traced, tool call by tool call, so if a task goes sideways you can see where. Runta also watches token usage at the network layer and flags repeated calls and oversized outputs that quietly grow the model’s context, which is how wasted work usually hides.
For tasks that need recovery, Runta can checkpoint the filesystem and running processes and restore them later, which is more than saving a transcript. The briefing didn’t need a restore, but it’s there for tasks that do.
Errand brings together the task, the conversation, and the agent’s behavior. Runta handles the environment they run in.
Running it inside your own walls
Grok Bot and Muse are someone else’s agent on someone else’s machine, running someone else’s model. For a lot of people that’s fine. For teams with data that can’t leave, or models that have to go through an internal endpoint, it isn’t.
Errand is built for the second case. The app is open source, the model can be any endpoint you already trust, including your own, and every task leaves a trace you can read. The runtime is hosted on Runta today. We’re building a bring-your-own-cloud option so the agent’s machine, its files, and its trace can stay inside your own account.
Start with one concrete task you’ve been putting off. Tell Errand what information it can use and what a useful result looks like. Then close the laptop, and come back to see what it got done.
Try Errand
Errand is still early. We hope you’ll build on it, take it in your own direction, and turn it into even better agent products.
The source is on GitHub. Building from source needs a Runta account and a model provider configured for your agents; the Runta docs cover the runtime side.