Yesterday Anthropic launched managed agents. The pitch: build and deploy agents 10x faster. The product: a cloud sandbox where you define your agent's tasks, tools, and guardrails, and Anthropic handles the infrastructure. $0.08 per session-hour plus standard API token costs. Notion, Rakuten, Asana, and Sentry are already using it. The console has a nice UI where you describe what you want in plain English and it writes the system prompt for you.
I watched someone spend three hours testing it. The sandbox works. The MCP auth is smooth — you click connect, do an OAuth sign-in, and your ClickUp or Slack credentials get stored in a vault. The agent runs, does web searches, writes files, comes back with results. It's real.
And then he tried to make the agent check his ClickUp board every 30 minutes. Can't. No scheduled triggers. He tried to have ClickUp trigger the agent via webhook when a task moved columns. Can't. No event triggers. Each time the agent woke up, it had zero memory of the session before.
He ended up saying he'd rather use trigger.dev.
A sandbox isn't an agent
Credit where it's due. Setting up sandboxed execution for an AI agent is genuinely annoying. You need a container, networking rules, file isolation, tool permissions, credential management. If you've never done it, it takes days. If you have, it still takes hours every time you spin up a new project. Managed agents compress that to minutes.
But a sandbox is infrastructure. An agent is infrastructure plus behavior. The behavior is the hard part — when does it run, what triggers it, what does it remember, when does it stop, how does it coordinate with other agents. Managed agents ship the infrastructure and call it the agent.
The Anthropic engineering post describes the architecture as decoupling the "brain" (Claude), the "hands" (sandboxes), and the "session" (event logs). The containers are stateless by design — "cattle rather than pets." That's good infrastructure engineering. It's also the exact property that makes agents useless for anything that needs continuity.
No cron, no webhooks, no memory
The three things that make an agent feel like it's actually working for you:
Scheduled runs. You want the agent to check something every morning, summarize your inbox, scan for competitor moves, process a queue. Managed agents can't do this. There's no cron. You trigger sessions via API calls, which means you need an external scheduler — n8n, trigger.dev, a cron job on your own server — to wake the agent up. At that point you're managing infrastructure to manage the managed infrastructure.
Event triggers. You want the agent to react when something happens — a Slack message, a GitHub PR, a ClickUp task moving to "Ready." Managed agents can't do this either. No webhooks, no event subscriptions, no integration triggers. The video reviewer built a ClickUp research agent and wanted tasks to automatically kick off the agent. He had to manually send API calls instead. His quote: "You're telling me Anthropic has a model too dangerous to release but they can't give us scheduled crons in the cloud?"
Memory between sessions. Each managed agent session starts fresh. It reads its system prompt and nothing else. It doesn't know what it found yesterday, what it already tried, or what worked. Anthropic teased persistent memory as a coming feature — gated behind an early access form. For now, every session is a first session.
These aren't edge cases. These are the first three things you need the moment an agent goes from "demo" to "I depend on this." The product ships the demo layer and calls it production.
What production actually looks like
I've been running nanika — a multi-agent orchestrator for Claude Code — for about four months now. Over 500 missions completed. The infrastructure part (sandboxing, container isolation, process management) took maybe two weeks of that time. The rest was everything managed agents don't ship.
Nanika has a scheduler daemon that runs cron jobs. An agent can wake up at 6am, scan for news, draft summaries, and go back to sleep. It has channels — Telegram and Discord integrations where a message in a chat triggers a mission. That's the event trigger. It has a SQLite-backed learning database where every mission's outcomes get scored, and the next mission reads those scores before it starts. That's the memory.
It also has the two things Anthropic teased as early-access features. Multi-agent orchestration: each mission gets decomposed into PHASE lines with dependency graphs, and workers run in parallel where the graph allows. Self-evaluation: a subsystem called nen watches mission outcomes, scores proposals by category, and adjusts how aggressively the system proposes new work based on what's been working.
None of this is hard because of infrastructure. All of it is hard because of the intelligence problems. When should the agent stop searching and start writing? What's worth remembering from a session that produced 40 pages of output? How do you decompose "research competitor landscape" into subtasks that don't overlap or miss gaps? How do you know the agent is doing the wrong thing confidently?
Those questions don't get easier when someone else runs the sandbox. They're the same questions whether you're on a managed cloud or a laptop.
Start here, leave soon
I keep thinking about Heroku. In 2010 Heroku was the fastest way to get a web app running. git push heroku main and you had a live URL in seconds. Thousands of developers shipped their first production apps on Heroku. Most serious teams eventually migrated off. Not because Heroku was bad — it was great at what it did. Because the things you need at scale (custom buildpacks, database tuning, background jobs, cron) weren't there, or were there at a price that stopped making sense.
Managed agents are doing the same thing for a different generation. They'll get thousands of people from "I've never built an agent" to "I have an agent that answers questions about my ClickUp" in an afternoon. That's genuinely valuable. The console UI alone removes a real barrier for people who've only used Claude through the chat interface.
The problem is the framing. "10x faster to production" implies the hard part is done. It isn't. The hard part starts the moment you need the agent to run without you babysitting it — on a schedule, in response to events, with memory of what it did before. At that point you either glue together external services to fill the gaps, or you build your own orchestrator and the managed sandbox becomes dead weight.
The roadmap or the product
Anthropic teased three features behind early access: outcomes (agents self-evaluate against success criteria), multi-agent orchestration (agents invoke other agents), and persistent memory (state survives across sessions). If those ship, managed agents become a fundamentally different product. A product that competes with the local orchestrator pattern. A product where "10x faster to production" might actually be true.
But there's a gap between a roadmap and a product. Right now, the shipped version has none of those three. The shipped version is a sandbox with a nice UI, OAuth-based MCP auth, and an API you call when you want something to happen. Everything that makes an agent an agent — rather than a script you trigger manually — is either missing or behind a form.
I don't think managed agents are bad. I think they're early. Early is fine if you name it. "We built the hosting layer, the intelligence layer is coming" is an honest pitch. "10x faster to production" is a pitch that makes people think the work is done.
The work isn't done. It's barely started. And the part that's done is the easy part.