Part 2 of this series ended with the problem pod as the unit: people and agents assembled around one problem, sharing one context, dissolved when the problem is solved. The footer promised an answer to whose judgment does it get built on, and the answer is short. The owner’s. The judgment worth encoding sits with the person who decides, and the person who decides has to feel an agent take something off their plate before they’ll drive any of this. So the first pod is the owner, a few agents, and one problem.
What I didn’t expect, when I started writing this part, was that the answer to where does that pod run would change under me in a few weeks.
What showed up this summer
Since August, a wave of products has launched that are, underneath, the same thing. The most visible are Grok Bot, Muse, and Instinct. An agent that runs around the clock on a computer the vendor operates, with a browser, an email connection, a calendar, a way to pay for things, and memory that carries over between sessions. Each started from a different wedge: one out of a social network, one out of a family of consumer apps, one out of a text thread. They’re all heading to the same place: an agent with full control of a machine, doing what a person at a computer does, whether or not anyone is watching.
None of this is new to the founders I know who have been running their own version of it, on a Mac mini or a rented server, since the spring. What’s new is that it’s packaged. The closed products are a more mature version of the same idea, with the rough edges filed off, the connectors pre-wired, and someone else patching the box.
The difference from the chat assistants most people use is not intelligence. It’s who starts the work. A chat session begins when a person opens it and ends when they close it. These agents invert that. They check the mail at seven, notice the schedule changed at two, chase the vendor, and come back the way a good executive assistant does, with the one thing they need from you to keep going. Approve this. Pick one of these two. The person stops being the operator and becomes the one who unblocks.
I’ve been a heavy user of Muse since a few days after it launched, and I had a fair comparison ready. Earlier this year I’d built my own agents for family logistics: the calendar, the school and club emails, the reminders, all driven by cron jobs I maintained. So I ran the same use case through both, side by side. The product experience is much smoother. It handled the schedule changes and the reminders at least as well as mine did, and it took me out of the maintenance work entirely, which is the part I hadn’t valued properly until it was gone. Within a week it had replaced them.
The infrastructure is the same
If you look past the packaging, every one of these products is the same seven layers, and so is every open framework that does the same job.
A machine that persists.
A harness on it, the scaffolding that turns a model into something that wakes up, checks things, and keeps state.
Memory.
An identity, the address and accounts the agent acts through.
Connectors to the tools.
A broker that decides what the agent may do.
A model.
One detail changed how I think about the price tags. I asked the agent I use what it was running on. Two cores, eight gigabytes of memory, a small disk, a stock Linux. That’s the smallest machine any cloud provider sells, five to twelve dollars a month. Nobody is paying for the machine. They’re paying for the other six layers, assembled, and for not being the person who maintains them.
Which is why I don’t think build-versus-buy is the interesting question here. It blurs what is going on. The question worth asking is what the closed products won’t let you do, and why.
Closed agents and open agents
The agent layer is now splitting the way the LLM model layer did. There are closed setups, where the vendor owns the machine, the harness, the memory, the identity, and the model, and you use it on their terms. And there are open setups, where the same seven layers run on something you control and any model or agent can plug in. The memory in an open setup doesn’t have to be a folder of files, either. It can be a database, or a repository under version control so every change to what the agent knows is tracked and reversible. How to structure that memory is a topic of its own, and we’ll go into it properly later in the series.
The closed ones share one constraint that isn’t a bug. None of them will let another agent in. Grok Bot runs only xAI models. Muse runs only Meta’s. Instinct is proprietary end to end. This is structural, not temporary. Every one of these companies is competing to be the entry point, the thing you open first and the thing everything else routes through. Letting a competitor’s agent onto the box would give away the position they’re spending the subsidy to win.
And the entry point is worth a great deal to them because of what accumulates there. Every correction you make to the agent’s work, every preference it learns, every account it opens under an address on their domain. That’s the layer that compounds. It’s also the layer that makes leaving expensive. Some of them will let you export the memory as a plain file, which is worth doing regularly. I did, and what came back was one file: facts and workflow rules, already filtered by the agent’s own judgment about what mattered. It was accurate. It was also all I could see. I have no view of how it will organise that memory when the data grows, what it will keep and drop when the context is mixed, or which of the tasks it runs on its own it will prioritise when they conflict. That’s not a complaint about the product. It’s the nature of the arrangement: the memory is managed for you, and therefore out of your control. And the correction history, the accounts, and the identity stay theirs unless you built it otherwise.
The open side is further along than most people assume. OpenClaw is the infrastructure, Hermes is the closest thing to a product, and there are already projects that skip shipping an agent altogether and simply run the agent subscriptions you already pay for as the bots. The agent is a worker you can swap. The setup is what you keep.
I use several agents side by side. Each is wired better into something than the others, the way people are, and the best one for a given job has changed every few months. That’s the argument for the open setup in one sentence. In a closed product, you get one agent, on its terms, until you leave. In an open one, the newest agent plugs into the same memory, the same identity, and the same keys the day it ships, and the old one goes without taking a year of context with it.
I don’t think one side wins this. Open and closed models have ended up side by side, and I expect the same here: closed agents for the person who wants it to work on day one, open setups for anyone who needs to choose their agents and keep their memory. For a business, that second description is usually the right one. But the closed products are ahead today on the things that matter most to someone who isn’t technical, and that’s worth being honest about.
What the closed ones are teaching
The closed products are the spec for what an open setup should have, and each has solved one layer well.
Muse: the broker. Every action the agent takes is approved by something outside the model, grants are scoped to a connector and a task and expire, and one-time codes and password resets are filtered out of the mail the agent can read. This is the layer the open frameworks are weakest on; OpenClaw’s second major release shipped without sandboxing on by default, and its skills marketplace has already had a malicious skill found in it.
Instinct: the identity. The agent gets its own email address, so its actions are attributable, it can open accounts as itself, and revoking it is one deletion. The idea is right. The address should be on your domain, not theirs.
Grok Bot: the reach. The agent can work inside the user’s own laptop. It’s the most powerful thing any of them do, and it collapses the boundary the separate machine existed to provide. Worth having, worth doing deliberately.
All of them: the habits. One machine per pod, a log a person can read, and coming back for approval rather than asking permission up front. Those transfer directly.
The sequence
So what I’d suggest to an owner is not a choice between building and buying. It’s both, in order.
Rent one now. Feel what it’s like to have something run overnight and come back with one question. Learn the approval habit. Keep the exported memory in a folder you own from the first week.
Then, at the first tell, build your own. The tell is usually one of three:
You want an agent the vendor won’t allow.
The data is something you couldn’t explain to a client.
A second person needs a pod of their own that reads from the same memory.
That last one is where the questions change, and it’s what Part 4 is about.
The 24/7 agent is here, and it’s worth using today. Don’t marry the first one.
Next: the second pod. What happens to memory, keys, and privacy when a team shares them.
→ A group of us are running our businesses through AI agents and sharing what works as we go. If that's you, or you'd like it to be, join the community. The next part goes into the open setups in detail: memory, keys, and privacy once a team shares them. Subscribe if you want it when it lands.