Source: raw/The_Secrets_of_Claude_s_Agent_Platform_From_the_Team_Who_Built_It.md (Dan Shipper’s AI and I podcast — youtube.com/watch?v=lLypHkIVLqc)
Long-form interview with Angela (Head of Product, Claude Platform) and Caitlin (Head of Engineering, Claude Platform) at Anthropic, hosted by Dan Shipper from Every. Conducted around the launch of Claude Managed Agents (the Code with Claude 2026 announcement). Frames the platform’s evolution narrative — completion endpoint → tool calling → managed agents — and articulates Anthropic’s opinionated primitives + verifiable-outcome design philosophy. The most concrete public articulation to date of why Managed Agents was built and where the platform is heading.
Speakers
- Angela — Head of Product, Claude Platform. Joined Anthropic ~early 2026.
- Caitlin — Head of Engineering, Claude Platform. Previously Stripe.
- Dan Shipper (host) — Co-founder of Every; also runs internal agent products on Mac minis with Claude in a loop, ~1k-line Python file. Set up a Slack bot via Managed Agents during the recording (driven by Codex in the in-app browser).
Key Takeaways
- Platform abstraction climbs with model autonomy. GPT-3 era = completion endpoint. Tool-calling era = completion + tools + chat sessions. Managed Agents era = “Claude on a computer with memory and all this other stuff.” Each generation moves to a higher-order abstraction “in pursuit of helping you get the best outcomes out of something.”
- Path dependence in primitives is real and locks the model. Anthropic explicitly chose file systems and skills as Claude primitives. “What we end up treating as the right path and the right primitives need to be very carefully thought through” — Angela. Wrong primitive choices “tend to lock the model” — over-optimization on reasoning vs. computer use produces different model trajectories across labs.
- Harness + model are pairing, not commoditizing. Older generation: generic harness, hot-swap models. Next generation: “the harness and the model get very paired.” Hot-swapping happens at the agent layer (harness+model pairing), not the model layer. Cursor and similar may already be running per-model harnesses.
- Drastic harness-eval differences. Anthropic tried “a bunch of different harnesses” for Memory in Managed Agents — each performed drastically differently in the eval suite. “There is a lot of alpha in [harness engineering].”
- Same platform for first-party and third-party. All Anthropic first-party products (Claude Code, Cowork, Managed Agents) run on the same external API and primitives as customers.
- Why they built it: infrastructure is the wall, not harness engineering. Customers expected harness work to be hard (prompt caching, context window, tool design); Agent SDK fixed that. Then “everyone hits the same problem of like, oh, wow, I either need to keep a server constantly running or I need to use infrastructure that will spin up and spin down, and I need to store the transcript data, and I need secure sandboxing” — Caitlin. Sandbox death = whole agent dies. Managed Agents removes that wall.
- Two target users. (1) Internal company automation — “legal team needs to review marketing copy” type agents (Stripe Minions, Ramp’s equivalent, Vercel’s “AI software factory” framing from Guillermo Rauch). (2) Companies building agents into products they expose to their customers.
- Quick-start = primitives education for everyone. The chat-based onboarding is not primarily for non-technical users; it’s so anybody — technical or not — can wrap their head around the API primitives. Non-technical use is a side effect.
- Anyone-can-PR loop emerges naturally. Anthropic’s internal legal-review agent now gets PR-driven improvements from the marketing/legal users themselves via Claude Code. Infrastructure team approves PRs when the system is centrally owned. “It’s funny.”
- “Managed agents all the way down.” End-state UX: a user-facing Claude that is itself a managed agent, mediating to a fleet of specialised managed agents. Each layer tuned/prompted for its slice. User just thinks they’re “talking to Claude.”
- Multi-agent orchestration is harness exploration at a higher level. Concrete archetypes the team has seen: (a) Advisor strategy — separate execution from advice; (b) Adversarial pair — one generates, one critiques; (c) Swarm — many small pieces recombine, good for bug hunting; (d) Best-of-N; (e) Deep / wide research patterns. Each strategy good for specific use cases. “We can hill climb at multiple layers of abstraction” once primitives are LEGO-like.
- Verifiable outcome is the destination. “Maybe the end state of these things is that everything compresses down to an outcome and a budget. And that’s probably about it.” Outcome = a spec a human can define, that the system interprets and regrades over and over. Coding example: “the actual PR getting merged” is the verifiable outcome.
- One-year vision: less harness engineering, less model selection, less prompt engineering. Claude becomes “good enough at understanding itself that it can write itself on the fly” — figures out which model, spins up sub-agents. User parameters compress to outcome + budget. Caitlin’s gating concern: the platform must scale to handle agents that are “literally constantly running and recreating themselves.”
Platform evolution narrative
Three named eras, each defined by what’s stateful:
| Era | Surface | What’s persisted |
|---|---|---|
| GPT-3 | Completion endpoint | Nothing — tokens in, tokens out |
| Tool-calling era | Messages API + tools + chat sessions | Conversation state |
| Managed Agents era | Messages API + sandboxed code execution + memory + skills + vaults | Sessions, agent identity, credentials, files |
The through-line Caitlin draws: “as Claude continues to get better and more autonomous, we find ourselves needing to evolve the platform to be sort of higher and higher order abstraction.” Each generation lifts work off the user — first the prompt, then the harness, now the infrastructure.
Path dependence and harness+model pairing
Two intertwined claims:
-
Primitive choice locks the model. Choosing file systems + skills as Claude’s native abstractions tends to produce a model that’s good at file-system-shaped problems. Other labs over-optimising on reasoning produce models that are great at reasoning but worse at “computer-shaped” tasks. “Being really thoughtful about what you choose to actually include or give kind of the model more natively is really important” — Angela.
-
Harness no longer separates from model. The previous era’s “build a generic harness, hot-swap models across labs” pattern worked when models moved at similar pace and shared similar primitives. For next-gen models, harness and model are paired. Redundancy via other models still happens — but at the agent layer (harness+model unit), not the model layer.
The Memory eval is the in-house example: Anthropic tried multiple harness approaches for Memory in Managed Agents; the eval suite showed drastic per-harness performance differences. Implication for builders: harness engineering is genuine alpha, but the alpha is paired to the model.
Why Anthropic built Managed Agents
The narrative arc:
- Anthropic builds internal agents for its own use — a few Mac minis running Claude in a loop, ~1k-line Python file (parallel to Dan Shipper’s Every setup).
- Each rebuild iterates the infra. Multiple internal projects ship variants. “We ourselves were like, okay, we’re done building this for ourselves.”
- Productize the learned platform. “We’re doing it once in a way that’s going to really work from everything that we’ve learned, but also for all the people who are doing it.” Mac mini works for prototype; production scale = infrastructure wall.
Customers expect harness engineering to be the hard part. It’s not. Infrastructure is. Every team Anthropic talks to ships a great Mac-mini prototype, then “everybody hits an infrastructure wall” — uptime, sandbox lifecycle, transcript storage, secure isolation. Managed Agents is the answer.
Two target users
| User | Pattern | Example |
|---|---|---|
| Internal company automation | Workflow-specific agent + thin app on top | Legal-reviews-marketing-copy agent at Anthropic; Stripe Minions; Ramp’s internal platform; Vercel’s “AI software factory” framing |
| Agents-in-product | Customer-facing agent surface | Built into the company’s product, exposed to end users |
For both, the value prop is the same: don’t burn engineering resources on infrastructure or harness engineering tweaks — Managed Agents handles them.
Internal use case: legal-review-of-marketing-copy agent
Concrete shape Anthropic ships internally:
- Marketer writes copy.
- Submits to a thin app (built on top of Managed Agents).
- Agent reviews first, then forwards to legal’s inbox with the first-pass review attached, OR clears the marketer outright if rules permit.
- Legal-team users pop open Claude Code and submit PRs to the agent’s prompt/skills when they want to tweak behaviour.
- The agent gets better over time without the platform team in the loop.
Why it isn’t just a skill:
- Form factor for collaboration. Multiple users, multiple agents, one shared session log.
- Human-in-the-loop authentication. Legal reviewers need to approve/escalate, not auto-execute.
- Multi-session orchestration. Stitching separate sessions across roles can’t fit a single skill.
Skills do live inside the agent (the legal reviewer agent loads “here’s what rules we have to follow” as a skill, plus MCP servers for external context). The agent is the form-factor wrapper around the skill set.
Skill vs agent vs sub-agent
- Skill = packaged instruction + maybe scripts. Loaded into a model.
- Agent = skill set + MCP set + form-factor surface (chat / Slack / app) + multi-session orchestration + identity/credentials.
- Sub-agent = an agent spawned by another agent for a sub-task. In the managed-agents-all-the-way-down model, the user-facing chat agent spawns specialised sub-agents that themselves are managed agents.
Multi-agent orchestration patterns
Recently launched. Patterns Anthropic sees customers use:
| Pattern | Shape | Best for |
|---|---|---|
| Advisor strategy | One executes, one advises | Code review, planning, second-opinion loops |
| Adversarial pair | Generator + adversary critiquing | Robustness testing, edge-case generation |
| Swarm | Many small agents, recombine outputs | Bug hunting (named explicitly), parallel exploration |
| Best-of-N | Run N variants, pick best | Quality-bar tasks |
| Deep research | Sequential agents drilling into a topic | Long-horizon research |
| Wide research | Parallel agents covering breadth | Survey-style research |
The mental model: orchestration is itself a harness layer. Once primitives are LEGO-like, builders can hill-climb at the orchestration level — not just the model or single-agent level.
Verifiable outcome philosophy
The destination Anthropic is steering toward: every agent run reduces to (outcome, budget).
- Outcome = a spec a human can define and the system can interpret + regrade over and over.
- Budget = the constraint envelope (cost, time, context).
- Coding’s verifiable outcome example: the PR gets merged. Not “the model wrote good code” — the merge event itself.
Today’s evals (domain-specific scoring rubrics, harness diff testing) are still load-bearing. The vision is for the model to internalise grading well enough that human-defined outcomes become the only spec.
The host’s joke crystallises it: “Claude, make me a billion dollars. Your budget is $10. Go.” Caitlin’s reply: “Maybe Mythos could do that.” (Reference to Claude Mythos.)
Agent decommissioning lifecycle
The “stale agents pile up” problem is real and Anthropic addresses it via skills:
- Model-upgrade skills ship to help users migrate agents to new model versions when one launches.
- Most-AGI-pilled users run agents monitoring agents for staleness (no Anthropic-blessed pattern yet).
- Frame the upgrade event as a breaking change — eval coverage makes it easier; without evals it’s risky.
- Decommissioned agents need a “funeral” / archive lifecycle (host’s framing — Anthropic acknowledges but doesn’t ship a primitive yet).
One-year vision
Asked where the platform is in May 2027:
Angela’s vision (product side):
- Outcome + budget become the only user parameters.
- Claude figures out itself — picks the model, spins up sub-agents, decides architecture.
- Less harness engineering, less prompt engineering, less model selection.
- Today’s high-level harness-architecture innovation moves into the model.
Caitlin’s vision (engineering side):
- Platform must scale to “agents constantly running and recreating themselves.”
- Long-running requests, varied workloads, 24/7 token throughput.
- “I never want the ability of the platform itself to be able to scale to get in the way of what people would otherwise be able to accomplish.”
Neither expects “outcome-only with airtight budget” by 2027 — the outcome part may land first, with error bars on the budget side.
Try It
- Compare your harness against Managed Agents. If you’re running Claude in a loop on Mac mini / VPS, list which infrastructure problems you’ve solved (sandbox isolation, transcript storage, credential vault, scaling) and which you haven’t. Most teams have not hit the wall yet — that’s the gap Managed Agents closes.
- Pick a primitive — file systems, skills — and lean in. The talk is explicit: Anthropic wants you to use file systems + skills as the agent’s native abstractions. Don’t roll your own RAG store / inline-context tricks where a file system would do.
- Use the quick-start as a primitives tutorial. Even if you’re a Claude Code power user, run through the Managed Agents quick-start once — it’s designed to teach the API primitives, not the no-code path.
- Benchmark one orchestration pattern. Pick advisor / adversarial / swarm. Run it on a real internal task. Record outcome + cost vs. single-agent baseline. The Memory eval story implies harness-shape matters more than people expect.
- Define a verifiable outcome for one agent. Not “agent did well” — a concrete checkable event (PR merged, ticket closed at SLA, review approved by both parties). Use it as the eval signal.
- Plan agent retirement. When a new Claude model lands, audit your agents’ staleness before migrating. Use the upgrade skills (when shipped) or write your own version-bump skill.
Open Questions
- Episode date and exact host context. Frontmatter has no date; Dan Shipper’s AI and I runs weekly — episode likely shipped early-to-mid May 2026 around the Managed Agents launch.
- Cursor’s harness architecture. Angela’s intuition is “teams who fall on similar perspectives” run per-model harnesses, but she doesn’t confirm Cursor specifically.
- Anthropic agent-decommissioning primitive. Acknowledged as a real pain but no platform answer shipped yet.
- Public reference implementations. Caitlin notes Anthropic publishes reference implementations alongside major API surfaces. Specific pointers (which blog posts, repos) not enumerated in transcript.
- Agent identity + Slack one-click. Vaults exist as a primitive; the “tell Claude ‘add Slack’ and it just handles everything” capability is roadmapped but not shipped.
Related
- Managed Agents — the API surface this interview is about.
- Code with Claude 2026 — Opening Keynote — May 7 conference launch event for Managed Agents primitives (Memory, Dreaming, Multi-agent orchestration, Outcomes). This podcast is the team’s expanded commentary on the same surface.
- Memory and Dreaming for Self-Learning Agents (Mahes) — the Memory eval story Caitlin references (drastic harness differences) is the work Mahes’ talk dives deep on.
- The Thinking Lever (Matt Bleifer) — adaptive thinking + effort dial; Bleifer’s “default to extra high if you don’t eval” mirrors the verifiable-outcome thesis here.
- The Expanding Toolkit (Lucas) — “scaffolding moves into the model” thesis is the model-side counterpart to Angela’s “harness engineering moves into the model” vision.
- Asana AI Teammates (Ara) — customer build on the platform; Asana’s grader-replaces-Messages-API-loop story is a concrete instance of the infrastructure-wall pattern Caitlin describes.
- Cookbook: Managed Agents — Multiagent + Outcomes — the public reference implementations Caitlin mentions; covers multi-agent + outcomes APIs.
- Claude Mythos Preview — Caitlin’s “maybe Mythos could do that” callback; aligns with the verifiable-outcome end-state.
- Claude Cowork — a sister first-party product running on the same platform, Operator-track surface for the same orchestration patterns.
- Claude Design — another first-party product on the same platform; reinforces the “same platform internally and externally” claim.
- Agent Skills Overview — the skill primitive Angela champions as Claude’s native abstraction.
- Skills vs MCP vs Plugins — the decision framework underneath Angela’s “use skills, use file systems” guidance.
- 2026 Claude Code AIOS Pattern — the multi-agent-all-the-way-down framing here is the canonical version of what AIOS implementations are converging on independently.