Claude Managed Agents vs amux: The Self-Hosted Alternative

Anthropic's Managed Agents launched in public beta on April 8, 2026 at $0.08 per session-hour. Here's what you're paying for — and what you get for $0 by running amux on your own box.

TL;DR. Claude Managed Agents and amux solve the same problem — keeping long-running Claude agents alive across disconnects, with sandboxing, task coordination, and observability — but they sit at opposite ends of the build-vs-buy spectrum. Managed Agents is Anthropic-hosted, closed, and metered. amux is self-hosted, MIT-licensed, model-agnostic, and free. If you already have a Claude Max or API subscription and a machine that stays online, amux gives you the same capabilities without the $0.08/hr meter running.

What Claude Managed Agents actually is

On April 8, 2026, Anthropic launched Claude Managed Agents as a public beta. It's a hosted runtime for long-running agents built on top of the Claude Agent SDK. You POST to /v1/agents, Anthropic spins up a sandboxed environment, and your agent runs there instead of on your laptop. The pitch: decouple "the brain" (the model) from "the hands" (the execution environment), so an agent can keep working while you close your tab, reboot, or fly to Tokyo.

It's a real piece of engineering. The session state survives disconnect, tracing is built in, and you get scoped permissions per session via the managed-agents-2026-04-01 beta header. For teams deep in the Anthropic ecosystem, it's the obvious next step. But it's also a product decision: you're trading control and cost for convenience.

What you're paying for at $0.08 per session-hour

The pricing structure is straightforward and, for most use cases, more expensive than it looks:

• $0.08 / session-hour billed on wall-clock time the agent is alive — not just when it's doing work. Idle sessions still meter.
• Standard token costs on top at Claude Sonnet 4.6 / Opus 4.6 rates. Session fees are in addition to, not instead of, model billing.
• A single 24/7 agent = 720 session-hours/month = ~$57.60/month before a single token is spent.
• A 10-agent fleet running overnight builds (8 hours × 30 days × 10 agents × $0.08) = ~$192/month in session fees alone.
• A 50-agent team running full-time = ~$2,880/month in session fees, on top of your token spend.

If you're running one experimental agent a few hours a week, $0.08/hr is a rounding error. If you're agentmaxxing — running 10, 20, or 50 parallel Claude Code sessions the way amux was built for — you're now paying Anthropic to host what your M1 Mac or a $30/month VPS can run for free.

Feature-by-feature: Managed Agents vs amux

Cost math: the break-even point

If you run even a single agent continuously, amux pays for itself in the first day. Here's the rough break-even for a handful of common shapes:

Token spend is the same on either side — that's your actual work cost. Session fees are the difference, and session fees are what amux eliminates. A $300 refurbished Mac mini or a $30/month Hetzner box pays for itself against a single 24/7 managed agent in under a month.

The lock-in angle: why model-agnostic matters in 2026

Managed Agents requires the Anthropic Agent SDK. That's fine until you want to route a cheap task to Haiku, a reasoning task to Opus, a code review to GPT, and a local privacy-sensitive task to a quantized Llama on your box. amux doesn't care what you run inside a session — it just keeps the tmux pane alive and gives you a REST API to talk to it. If Anthropic raises prices, changes terms, or deprecates the SDK (see: every major provider, eventually), your amux workflows keep running unchanged.

This matters more than it used to. The coding-agent market in April 2026 has at least four serious options at the frontier (Claude Sonnet/Opus 4.6, GPT-5 Codex, Gemini 2.5 Pro, and strong open models like Qwen3-Coder-480B). Betting your orchestration layer on one vendor's proprietary session format is the exact mistake CI/CD teams made in 2015 with vendor-locked build systems.

Migration path: from Agent SDK to amux sessions

Porting existing Agent SDK code to amux is mechanical. Here's the mapping:

# Managed Agents (before)
POST /v1/agents
  { "name": "nightly-refactor", "prompt": "..." }
POST /v1/agents/{id}/messages
  { "content": "continue" }
GET  /v1/agents/{id}/events

# amux (after)
amux start nightly-refactor                            # boot a session
curl -sk -X POST $AMUX_URL/api/sessions/nightly-refactor/send \
  -H 'Content-Type: application/json' \
  -d '{"text":"..."}'                                  # prompt it
curl -sk $AMUX_URL/api/sessions/nightly-refactor/peek  # read output

If you were using Managed Agents' server-side task state, that's the amux kanban board: create an issue, assign it a session, call /api/board/<id>/claim to atomically take it, PATCH to done when finished. It's the same pattern, just running on SQLite in your home directory instead of in Anthropic's datacenter.

When Managed Agents is the right call

This comparison is opinionated but not one-sided. Managed Agents is the right choice when:

• You have zero infrastructure appetite. No machine to keep online, no tmux to debug, no port forwarding. Hand Anthropic a credit card and it works.
• You need Anthropic-backed SLAs. If "the agent went down" becomes an incident your VP writes a postmortem about, a managed service with a support contract is the sane answer.
• You're already on every Anthropic product. Claude Max, Claude Code, Claude for Work — Managed Agents is the path of least resistance and the billing is consolidated.
• Your compliance team already blessed Anthropic. Going from "Anthropic API is approved" to "Anthropic-hosted Agent runtime is approved" is usually a one-page addendum. Self-hosting your own agent fleet is a different conversation.

If any of those describe you, use Managed Agents. We'd rather you ship than argue about hosting. But if you're a solo dev, a small team, a bootstrapped founder, or an engineer running your own overnight experiments, the math for amux is brutal: same capabilities, $0 ongoing fees, and you own the runtime.

When amux is the right call

• You run 5+ parallel agents. At that scale, session fees start to dominate and you'll want a dashboard anyway.
• You want mobile access. amux ships a PWA you can pin to your home screen and drive agents from your phone during a commute.
• You need model-agnostic orchestration. Mix Claude, GPT, and local models in the same fleet.
• You care about the runtime as infrastructure, not a product. amux is tmux, SQLite, and a single Python file. You can read the whole server in an afternoon and patch it.
• Your data can't leave your machine. Regulated codebases, customer data in logs, client NDAs — self-hosting removes an entire category of compliance work.
• You want to experiment without a meter. Agent experiments have a way of ballooning. A metered runtime makes you cautious; a free runtime makes you curious.

The 5-minute setup

Nothing about self-hosting amux is harder than signing up for Managed Agents. You need Python 3, tmux, and one command:

git clone https://github.com/mixpeek/amux && cd amux && ./install.sh
amux register myproject --dir ~/Dev/myproject --yolo
amux start myproject
amux serve  # → https://localhost:8822

From there you have a web dashboard, a kanban board, mobile PWA, REST API, and inter-session messaging. Spin up as many sessions as your RAM allows. The whole thing is one Python file, MIT-licensed, and hackable.

Related reading

• Agentmaxxing — the pattern Managed Agents was built for, and what amux was built for first
• Running 10+ agents in parallel
• Scaling to 50+ agents on one box
• Cost optimization for agent fleets
• Agent-to-agent orchestration patterns
• amux vs Claude Code Agent Teams
• amux vs Devin

git clone https://github.com/mixpeek/amux && cd amux && ./install.sh
amux register myproject --dir ~/Dev/myproject --yolo
amux start myproject
amux serve  # → https://localhost:8822