I have been running agents in production for about three years, and the gap between what a hosted runtime like Claude Managed Agents (Anthropic’s managed service that wraps a model in a tool-calling loop) and what I could build at home was always wider than the marketing admitted. The hosted version won not on cleverness but on plumbing. Sessions, tool definitions, sandboxed code execution, retries, memory that survives a crash. Each layer was a weekend I did not want to spend.
This week an open source project landed that promises to close most of that gap. I read the release notes twice, poked at the docs, and talked to two of the maintainers. Here is what I actually think it changes, and what I think it does not.
The runtime architecture is the part worth caring about
Most agent frameworks ship with the marketing primitives and skip the boring ones. The boring ones are what actually run in production. This project ships the boring ones.
Sessions have stable identifiers you can resume across crashes. Tools are defined in plain files you can read and diff, not a registry that lives behind a vendor login. Sub-agents spawn from inside another agent, run their task, and report back with structured output. Code execution happens inside a sandbox whose configuration is a file you can audit, not a black box someone else patches.
Memory is the part that matters most for daily work. In a hosted runtime, conversation history lives in whatever store the vendor picked with whatever retention window they decided was fine. Here, sessions sit on your disk in a JSON file you control. When a refactor takes a week, the full decision trail is sitting next to your code. That is a small thing until you spend four hours trying to remember why a tool was defined the way it was.
Model choice is vendor-neutral on purpose. Anthropic, OpenAI, anything Ollama (a tool that runs large language models on consumer hardware) can serve. The interesting design choice is the routing layer. You can wire a small local model into the cheap calls (file lookup, simple lookups, log formatting) and reserve a frontier model for the work where reasoning actually costs. That kind of hybrid routing is what a hosted platform actively does not want you to do, because it cuts their bill roughly in half.
Six features worth knowing before you spend time on it.
- Sessions, tools, sub-agents, and code execution as first-class primitives, not bolt-ons.
- Model routing that mixes local and hosted endpoints per task, not per account.
- On-disk memory in a format that survives container restarts and accidental deletes.
- Tool definitions stored in your repo, version-controlled alongside the code that uses them.
- A sandbox defined as configuration, not as a runtime assumption.
- License terms that let you fork the whole project and ship it inside a paid product.
Where the open source twin stops matching the managed tier
The fairest way to think about this is to ask what the vendor used to do for you that you are now doing yourself. The answer is everything except the model call.
When a sandbox escape lands in a dependency, the vendor patches it. When an agent goes into a loop at 3 a.m. and your customers start receiving nonsense, the vendor answers the page. When someone wires a tool to a malicious URL and your costs spike, the vendor absorbs the abuse until you cut them off. None of those jobs disappear. They all become yours.
Two practical costs show up immediately.
- The first incident response you write becomes a recurring job you own, and it never gets smaller.
- The model bill is no longer buried inside a vendor invoice, which sounds like a win until you realize you can no longer hide from it.
The fit test is straightforward.
- Pick self-hosted if you already operate services at home, you want client data to never touch third-party logs, or you want to validate agent workflows before committing to a vendor contract.
- Stay on the managed tier if you need someone else to be on call, your agents touch production systems with compliance requirements, or your team would rather pay the premium than build the operations layer.
There is no shame in either call. The right answer depends on your blast radius, and a five-person team running internal automations is a different blast radius than a regulated company shipping customer-facing work.
What the next six months of release notes will look like
The pattern in this space is predictable. A managed platform ships a feature, the open source community reverse-engineers it badly for a few months, then ships a working clone that the managed platform has to compete with. That pattern is the reason Anthropic and OpenAI both price their tiers the way they do.
What is different this cycle is the speed. The first managed agent platforms took about eighteen months to be matched. This one took roughly six. The gap is collapsing because the build blocks have stabilized (model APIs, sandbox runtimes, structured tool calling) and the open source maintainers no longer need to reinvent them. They can focus on the orchestration layer, which is the part that was always the actual work.
Three bets I would make on what happens next.
- The hosted tier starts bundling in things the open source version cannot easily replicate, like integrated evaluation suites and audit logs that satisfy compliance reviewers.
- The open source version adds first-class support for running inside Kubernetes, because the home-server crowd keeps asking for it on GitHub.
- Pricing on the hosted tier shifts from per-token to per-agent or per-session, because per-token stopped making sense once the routing layer was in the box.
None of that is actionable today, but it tells you where the next twelve months are headed.
A practical weekend plan if you want to try it
The fastest path is to skip the framework shootout and just use this one on a real task. Pick something you already do by hand that takes twenty minutes. A weekly report. A dependency audit. A markdown cleanup pass on a directory of old notes. The task does not matter as long as it is yours.
Run the agent against a local model first. You want to see the loop work without burning API credits, and you want to know what the failure modes look like before any real file is at stake. Once the loop is trusted, swap in a frontier model for one specific call inside the same agent, the part where you actually need a clever answer. That is the move that pays rent, and it is the move a hosted tier makes harder than it needs to be.
A few details that will save you from the most common first-day mistake.
- Run the agent inside a worktree or a fresh branch. Throwing the attempt away should be one command, not a recovery plan.
- Keep the first tool set small. Two or three tools is plenty to learn the loop. Add more after you have run the agent end to end at least ten times.
- Log everything for the first month. You will want the conversations later, both for debugging and for explaining to your team why the agent did what it did.
Trade-offs
Self-hosting an agent runtime saves the vendor bill and gives you control over memory and model routing, and it costs you the support contract, the managed SLA, and the team that used to absorb incidents on your behalf. For a solo developer or a small team running internal work, the trade is more than fair, and the savings show up the first month you stop paying for someone else’s uptime rotation. For a regulated company shipping customer-facing automations, the math flips and the hosted tier is probably still the right call until you have a person whose job is keeping the runtime healthy.
Two specific numbers worth putting on the page before you commit.
- You inherit the operational rotation. Uptime, sandbox patching, and incident response are all yours now.
- You inherit a visible model bill. Easier to budget is not the same as easier to ignore.
Bottom line
If you have been waiting for an open source agent runtime that actually matches the managed tier on the boring parts, this is the release to try on a real task this weekend. Start with something you already do by hand, run it against a local model for the first few hours, and only escalate to a frontier model after you trust the loop. The vendor lock-in argument for managed agents just got a lot weaker, and the first month of saved bills is the proof.