On April 8, 2026 Anthropic launched Claude Managed Agents. It's not a new model. It's an infrastructure layer that solves three problems each team used to have to build on its own: sandboxing, orchestration and persistent sessions.
The immediate reaction from much of the ecosystem was to treat it as a shortcut. "I no longer need to build my own orchestration layer." That's true. But it hides the question that really matters: what happens with everything Managed Agents explicitly does not solve?
Anthropic's own documentation is transparent on this point. The service is "intentionally unopinionated" about prompt engineering, tool definition, context strategy, guardrails and agent failure modes. That remains the team's responsibility. And that "that" is precisely where most agents in production die today.
This is where Spec-Driven Development stops being one methodology among many and becomes the policy layer Managed Agents needs so as not to be a shortcut to breaking agents faster.
The current moment of agentic orchestration
Data from the Claude Managed Agents launch and 2026 enterprise adoption
What Anthropic has just solved
Claude Managed Agents breaks the agent down into three independent components and offers them as a managed service:
Stateless inference and orchestration. It decides which tool to use, when and with what inputs. Anthropic manages it for you.
Isolated execution environments. Claude invokes execute(name, input). Containers only spin up when used, which is why worst-case time to first token drops by more than 90%.
Durable history outside the context window. It allows agents to be resumed with wake(sessionId) and long executions to be sustained without losing state.
This architecture is elegant. It decouples reasoning from execution the same way operating systems decoupled software from hardware decades ago. What matters for a CTO is that you now have production-ready infrastructure without having to build it. Lower latency, automatic recovery from failures, many-to-many scaling and long sessions without overflowing the context.
For teams that have spent months duct-taping sessions in Redis, spinning up containers by hand and patching orchestration between agents, this is a real leap.
What Managed Agents explicitly does not solve
Reading the official documentation carefully, Anthropic lists five things that remain the responsibility of the team deploying the agent:
The harness is agnostic to the specific instructions you give Claude. If your prompt is generic, your agent is generic — with or without Managed Agents behind it.
Which tools you expose to the agent, with what contract and what semantics, remains your design. Managed Agents invokes them; it doesn't think them through for you.
When to compress the history, when to summarize, which events to keep. Persistence exists; deciding what to do with it is yours.
What the agent can and cannot do, what validation applies before a destructive action, which circuit breakers stop it. Managed Agents doesn't opine — and it shouldn't.
How you know whether the agent's output meets the original business intent. If you don't define it, the agent meets the prompt — but not necessarily the task.
These five responsibilities are what separate an agent that "works in a demo" from an agent that generates measurable impact in production. And they are exactly what SDD standardizes.
Why SDD is the missing methodology layer
Spec-Driven Development, as we explain in detail in Spec-Driven Development: AI in controlled code, is not a tool. It's a way of elevating the specification to a source of truth above the code and, in this context, above the prompt.
When you map the five responsibilities Managed Agents leaves to the team against the components of SDD, the overlap is almost perfect.
Mapping SDD → responsibilities Managed Agents leaves to the team
The operational reading is direct: the team that uses Managed Agents without a structured specification layer is building on the best available infrastructure but with no architecture. It works until it doesn't. And when it stops working, debugging in a persistent event log of a multi-stage workflow with no explicit quality criteria is exactly the kind of problem that consumes months.
It's the same principle we develop in multi-stage AI workflows 2026: the quality of the workflow depends on the quality of the initial specification and the context that flows between phases. The model is secondary. The platform is secondary. What makes the difference is the architecture of the process.
Combined architecture: SDD as the policy layer, Managed Agents as the execution layer
The clean way to think about this combination is to separate two layers that today most teams mix without realizing it:
The spec translates into prompts, tools and guardrails
Claude Managed Agents (or alternative)
Executes the how: sandboxing, orchestration, persistent sessions and failure recovery.
- Brain: inference and decision harness
- Hands: execution sandboxes and tools
- Session: durable log and resumption
- Scaling: multi-agent and many-to-many
This separation has an important practical benefit: it protects you from vendor lock-in.
One of the most serious criticisms of the Managed Agents launch is that migration isn't trivial. Session data lives in Anthropic's infrastructure, the harness format is specific to Claude and moving a production agent to another platform means rebuilding the orchestration layer.
If your policy layer lives in versioned specifications, tool contracts defined in a standard format and auditable acceptance criteria, the execution layer becomes replaceable. Managed Agents today, another platform tomorrow, an on-premise deployment with your own harness when a compliance requirement demands it. The spec doesn't change. What changes is only the engine.
The strategic insight: teams that adopt Managed Agents without a specification layer pay twice — once for the technical lock-in, once for the methodological lock-in. Teams that adopt it with SDD on top capture the benefit of the infrastructure without being tied to it.
Three cases where this combination changes the ROI
The abstract is better understood with concrete cases. Three patterns where the SDD + Managed Agents combination materially changes what a mid-market team can deliver.
1. Autonomous code-to-deployment with control points
The agent receives a product spec, breaks it down into a plan, generates the code, runs the tests, opens the PR and waits for human validation before the merge. Today, building this with your own orchestration means 6-8 weeks of plumbing. With Managed Agents, the plumbing disappears. What remains is the spec, the review criteria and the guardrails: exactly SDD.
Without SDD: the agent improvises at each phase, review becomes a human bottleneck and the ROI dilutes into rework. With SDD: the agent operates within explicit limits, review validates against auditable criteria and the team sustains -75% time per feature as a realistic benchmark.
2. Document processing with business validation
Legal or finance receive contracts, invoices or case files. An agent extracts, classifies, validates and feeds the internal systems. Managed Agents gives you the persistent session and the invocation of reading, OCR and ERP-writing tools. SDD gives you the criteria for which fields are critical, which exceptions require human intervention and how output quality is validated.
Without a business spec, the agent does what you technically ask it — but the result isn't reliable for a regulated department. With a spec, human validation concentrates on the exceptions that matter.
3. Internal product agents that cross domains
Research feeds a PRD, the PRD generates stories, the stories determine acceptance criteria, the criteria reach the implementation agent. A pipeline like this, with Managed Agents, is simple to set up. Without SDD, it produces artifacts that look complete but don't connect with the product's original intent. With SDD, each phase inherits the structured context of the previous one and traceability reaches all the way to the root spec.
How to start: minimum SDD + orchestration stack in 30 days
If you're evaluating Managed Agents for a specific use case, the most expensive mistake isn't taking too long to adopt it. It's adopting it before you have the specification layer solved. The correct order is:
Immutable rules: what the agent can do, what it can't, which tools it can invoke, what data it touches, which actions require human approval. This translates into tool scope configuration in Managed Agents.
What input each phase expects, what output it produces, which acceptance criteria apply. The template is the contract the agent has to meet.
Prompts stop being ad hoc text and become versioned artifacts in the repo. Each prompt references the spec that backs it. Managed Agents executes them but doesn't invent them.
Each execution leaves a trace in the session log and is validated against the template criteria. What fails feeds the next iteration of the spec, not of the prompt. That way learning accumulates iteration after iteration.
This minimum stack is reproducible. It doesn't require a full organizational transformation to start — it does require that someone on the team take explicit responsibility for maintaining the specs as the source of truth. It's exactly the role an AI Center of Excellence fulfills when it's well designed, and it's the core of onext AI-Accelerated Development: our methodology for industrializing AI development by combining SDD, context engineering and agent governance in a single system.
Why this window is short
Managed Agents isn't the end of the race. It's the start of a new phase. The next iteration of the product will include multi-agent coordination and self-evaluation, today in research preview. When those capabilities enter GA, teams that haven't solved the specification layer will deploy agents that coordinate with each other and self-evaluate against criteria no one has written in a structured way. The result will be a kind of agentic debt we haven't yet seen at scale.
The good news: the market isn't educated yet. Few vendors are explicitly positioning SDD as the policy layer over an orchestration platform. Thoughtworks included SDD in the Technology Radar but hasn't connected it with orchestration platforms. McKinsey talks about orchestration but not spec-driven. Anthropic provides the platform but is "intentionally unopinionated" about how you govern it. The methodological gap remains open.
The teams that cover that gap before the market closes it will be able to say, 12 months from now, that they arrived first at the combination that has already become standard. Those that don't will pay the bill of a brilliant infrastructure on top of an improvised methodology.
Managed Agents gives you the engine. SDD gives you the steering wheel. Driving without a steering wheel isn't going faster — it's going nowhere, faster.
Primary sources: "Claude Managed Agents overview" (Anthropic Docs, Apr 2026), "Scaling Managed Agents: Decoupling the brain from the hands" (Anthropic Engineering, Apr 2026), "Anthropic's Claude Managed Agents gives enterprises a new one-stop shop but raises vendor lock-in risk" (VentureBeat), "Agentic coding at enterprise scale demands spec-driven development" (VentureBeat), "Spec-Driven Development — Adoption at Enterprise Scale" (InfoQ), "The 95% problem" (MIT NANDA / State of AI in Business 2026).
Further reading: Spec-Driven Development: AI in controlled code | Multi-stage AI workflows 2026 | Context Engineering: the discipline for teams with AI | AI agents in production: the quality gap
onext methodology: onext AI-Accelerated Development is the methodology with which onext's AI Centers of Excellence implement SDD as the policy layer over agentic orchestration platforms (Managed Agents, LangGraph, in-house deployments) so that migration between engines is replaceable and control of the agent stays in the team's hands. Without stopping deliveries.
Jordi García is Tech Lead at onext. He works on bringing AI into governed production across development and product teams —with Spec-Driven Development, context engineering and human verification at every step— and authors onext's technical insights on the method, quality and cost of applied AI.
LinkedIn →