Where personal agents live

Until recently, the agents people actually used did tasks. You gave one a job, it worked for a few minutes or a few hours, and then it was done. Whatever it learned along the way mostly got thrown away.

Personal agents are different, and I think the difference is bigger than it looks. A personal agent doesn't finish. It sits alongside one person for months or years, and its value comes less from what it can do on any given day than from what it has accumulated about that person. A personal agent you started yesterday and one that has known you for three years can run on the same model with the same tools, and the second is far more useful.

I keep coming back to this while building Mirian, a personal finance agent. Money is a good place to see it, because almost nothing about money makes sense in isolation. A $400 charge is alarming or completely normal depending on whether it happens every March. Whether you can afford something depends on what last month looked like, what next month usually looks like, and what you said you were saving for. An agent that sees one transaction at a time can describe your money. To make decisions about it, it needs the history: every transaction, rolled up into what a day, a week and a month normally look like for you.

Notice what that does to the shape of the work. A personal agent is mostly asleep. Mirian wakes when a transaction arrives, and on a schedule, once a day, once a week and once a month, and otherwise does nothing at all. When it wants to do something that matters, it has to ask, and then wait, sometimes for days, for an answer. It's long-lived rather than long-running. And the most valuable thing in the whole system is the thing that builds up slowly while it sleeps.

The obvious design

This autumn three of the biggest AI companies shipped personal agents, and all three made the same choice. Meta's Muse runs each person's agent on its own cloud computer.^[1] xAI's Grok Bot gives each bot its own computer, which it uses to drive websites and sign into your tools.^[2] OpenAI's Dots each get a cloud computer and browser that you can open and watch.^[3] And today Meta released Muse Wonder, models trained specifically for agents like these, with what Meta calls Active Memory: carrying what matters about you from one conversation to the next.^[4]

It's easy to see why they all did it. A computer with a browser can use almost anything, including all the services that will never have an API. It's how people use computers, so it's how you'd naturally imagine an assistant using one. And it leaves the hard product work with the company: Muse checks with you before it sends an email or spends money, and keeps an audit trail; Dots let you write your own rules for what needs approval. For booking things, chasing bills and filling in forms, I think these will be very good, and building your own would be a waste of time.

But giving the agent a computer quietly decides something else. The agent's memory now lives where the computer lives, inside the product, kept however the product sees fit. Grok Bot's memory belongs to the individual bot. Muse lets you tell it to forget things. Dots carry context across every surface you talk to them on. None of them says much about what's kept, how you'd query it, or how you'd take it with you. That's fine when memory is a convenience. It's a different matter when memory is the point, because a memory of what matters to you is not the same thing as a history, and it can't answer the same questions.

For finance there's also trust. Handing a company your complete financial history is a bigger step than handing it your calendar. Some people will be fine with that, and Meta says it keeps Muse data away from its ad systems and plans a version where only you hold the key. But for Mirian the history isn't a feature of the agent. It is the product. So I wanted to build it myself, which meant answering a question the consumer products answer for you: where does an agent that's asleep almost all the time actually live?

Building one

The quickest way to build one is to let the model provider hold the state. Providers increasingly offer to keep conversations and memory for you, so your app can stay stateless and each user becomes a thread in your account. For a prototype that's the right call. But it's the off-the-shelf arrangement again, one level down: every user's history sits with the model provider, and changing models means getting all of it out first.

Holding the state yourself means solving a different problem. If you give every person an agent with its own computer and leave it running, you're paying for a few hundred thousand computers to sit waiting for someone to buy a coffee. Nobody can afford that, so anyone running agents at scale has to find a way for them to sleep. There are two serious answers right now, and what's interesting is that they're opposites.

Google's answer is to freeze the computer. Its open-source Agent Executor, AX, runs each agent in a sandbox on a data plane called Agent Substrate.^[5] When an agent goes idle, Substrate snapshots the sandbox, memory and disk, to storage, and gives the machine to someone else. When the agent is needed, it's thawed onto any free machine in under a second. Their demo runs about 250 agents on 8 machines.

Cloudflare's answer is to take the agent out of the computer. A Durable Object is a small addressable actor with its own SQLite database, which sleeps when nothing is happening and wakes on a request, a message or an alarm it set for itself.^[6] There's no machine to freeze, because what the agent knows is kept as rows. As of today that includes a serious agent: OpenCode 2.0 can now run inside one, keeping its sessions, messages and event log in the object's database.^[7] Tellingly, the example strips out OpenCode's shell and file tools, because there's no filesystem or processes to give it.^[8] When it needs a real computer it borrows one, and if that computer dies, the agent doesn't.

Each approach is good at exactly what the other is bad at. Freezing the computer means the agent doesn't have to know anything about it. Any agent, any toolchain, any half-finished build comes back exactly as it was. Taking the agent out of the computer only works if the agent was written for it; OpenCode works because it was built expecting to be evicted. On the other hand, a snapshot is opaque. You can restore it, but you can't ask it anything. And it's a picture of one particular process, so restoring it gives you that process back, old code and all. Data can be queried, and the next version of your code can read it.

There are practical differences too. AX is something you operate: a Kubernetes cluster, a registry, Redis and the Substrate control plane, all of it young.^[9] A Durable Object is something you deploy, though the OpenCode harness is experimental, and anything that needs a real toolchain still means running a sandbox as well.

Over a few hours, the difference between an image and a history barely matters, and if your agent needs a whole Linux machine for its whole life, freezing the machine is hard to beat. Over a few years, it's most of what matters.

Mirian

So Mirian keeps its history as data. Each person gets one durable agent with its own database. A new transaction wakes it, and so does a daily, a weekly and a monthly alarm, each rolling the history up a level. In between it sleeps and costs next to nothing. When it wants to do something that matters it asks, goes back to sleep, and picks the decision up whenever the answer comes, a minute later or a week later.

What decided it was a simple test. Mirian doesn't need to resume a frozen process from last March. It needs to know what last March looked like, and to still know it after I've shipped a hundred new versions of the code.

Who the history belongs to

I think this points at something bigger than one finance agent.

The models are converging. Every few months a different lab has the best one, and the gap between the best and the third best keeps shrinking. None of this means Mirian gives them up: Muse Wonder is available through Meta's API, so the same model that runs Muse can run Mirian. You can rent whichever model is best this month, and next month you can rent another. The history can't be rented. It builds up slowly, it's specific to one person, and it's what makes the agent worth using. So I expect the value in personal agents to end up with whoever holds the history, not whoever trains the model.

If that's right, people are going to care a lot about who that is. At the moment the default is to hand it over wholesale. The agent, its memory and the model all live in one company's tenancy, and the model sees whatever the product decides it should. The alternative is that you hold the history, and a model provider gets what it needs for a particular question, under a grant you chose and can take back. Switching models then means moving a grant rather than starting over.

We've been through a version of this before. For years, money apps got at your bank data by asking for your password and scraping your account. Open banking replaced that, in the UK and Europe at least, with access you grant to a specific app, for specific data, and can revoke. I suspect personal agents will go the same way, and for the same reason: once the data is valuable enough, people stop being willing to hand over all of it to get a little of what it's good for.

The consumer products may well move in this direction. Meta has said it's planning a version of Muse where only you hold the encryption key. But a key to a box someone else built is not the same as a history you can take anywhere.

What makes this practical is that you don't have to choose between the two. The obvious objection to a personal agent you build or own is that nobody wants another app. But the general-purpose agents are now good enough at using tools that they can call out to a specialist when it's worth it. If Mirian is useful, your Muse or your Dot can ask it whether you can afford the trip and get back an answer grounded in three years of transactions, without ever seeing the transactions. You can live entirely inside one model provider's product, and it still feels seamless.

So owning your history doesn't cost you the convenience of a general assistant. What it gets you is control over what that history is used for, and an agent built for one purpose that does it properly. And because it answers questions rather than handing over the data, it makes every other agent you use better informed, without your finances having to live with the same company that sells you ads.

So far, most of the argument about agents has been about which one is smartest, and which sandbox to run it in. For agents that live alongside a person for years, I suspect the question that ends up mattering is a quieter one: where their history lives, and who it belongs to.

Notes