AI Engineer
Anthropic abandoned monolithic agent containers because orchestration harnesses encode temporary model flaws that go stale with every upgrade, separating immutable session logs from pluggable sandboxes to eliminate credential leaks and accelerate response times.
AI-assisted summary of Decoupling the Brain from the Hands: Claude Managed Agents (Part 1 of 4) — Anthropic — original source. Check the original for full context.
Source published:
Key ideas
- Anthropic redesigned Claude Managed Agents by decoupling the monolithic container into three modular interfaces: an append-only session log, the brain (model plus harness), and pluggable hands (sandboxes and MCP tools). (7:45)
- By deferring execution sandbox provisioning until tool calls are explicitly needed, the decoupled architecture dropped time to first token by approximately 90%. (10:00)
- Outbound tool requests now route through an egress authentication proxy that injects credentials outside the sandbox perimeter, structurally preventing prompt injection attacks from stealing tokens. (9:05)
- The developer API surface for managed agents standardizes around three primary primitives: Environments (/v1/environments), Agents (/v1/agents), and Sessions (/v1/sessions) driven via bidirectional event streams. (13:49)
Detailed notes
## Background This video was published on YouTube by the AI Engineer channel on October 12, 2026, documenting a workshop from the AI Engineer World's Fair 2026. It features Priyanka Phatak and Gabe Cemaj from Anthropic explaining why the team moved away from their initial monolithic container architecture for Claude Managed Agents in favor of decoupling the session, harness, and sandbox environments.
## TL;DR Priyanka Phatak outlines the fundamental anatomy of an AI agent—model, harness, and sandbox—and explains how Anthropic's initial monolithic container design created an unmanageable 'pet' prone to debugging bottlenecks and security vulnerabilities. To solve this, Anthropic rearchitected the platform by separating the state into an append-only session log, treating the harness and Claude as the 'brain,' and relegating sandboxes and MCP connections to pluggable, disposable 'hands.' This modular architecture stripped credentials out of untrusted execution environments via an egress proxy and lowered time to first token by approximately 90%. Finally, the talk walks through the core developer primitives—Environments, Agents, and Sessions—and sets up a hands-on console quick start for attendees.
## Atmosphere & style The presentation carries the practical, authentic energy of a live engineering workshop in a packed conference room, balancing polished technical depth with real-world conference friction like Wi-Fi dropouts and mic passing. Phatak speaks with clear, battle-tested authority, framing Anthropic's early architectural missteps with candid humor through classic DevOps metaphors like 'pets versus cattle.' The atmosphere feels collaborative and pragmatic, drawing the audience directly from high-level distributed systems theory into hands-on console setup.
## Bulletin - [07:45](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=465s) Anthropic redesigned Claude Managed Agents by decoupling the monolithic container into three modular interfaces: an append-only session log, the brain (model plus harness), and pluggable hands (sandboxes and MCP tools). - [10:00](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=600s) By deferring execution sandbox provisioning until tool calls are explicitly needed, the decoupled architecture dropped time to first token by approximately 90%. - [09:05](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=545s) Outbound tool requests now route through an egress authentication proxy that injects credentials outside the sandbox perimeter, structurally preventing prompt injection attacks from stealing tokens. - [13:49](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=829s) The developer API surface for managed agents standardizes around three primary primitives: Environments (/v1/environments), Agents (/v1/agents), and Sessions (/v1/sessions) driven via bidirectional event streams.
## Key takeaways - [02:05](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=125s) At its foundational level, an agent consists of three core components: a model, an orchestration harness, and an isolated sandbox execution environment. - [03:06](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=186s) Orchestration harnesses inherently encode model-specific assumptions and workarounds, such as context-resetting logic for Sonnet 4.5's context anxiety, which can quickly become obsolete in newer models like Opus 4.5. - [04:16](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=256s) Sandboxes provide an isolated blast radius to safely execute untrusted, agent-generated code across tasks without risking system compromise. - [05:10](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=310s) The initial V1 architecture bundled the session log, harness loop, and sandbox into a single 'pet' container, which created severe debugging bottlenecks and customer privacy issues. - [06:05](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=365s) Monolithic containers complicated network connectivity to private VPCs and prevented internal debugging without exposing sensitive customer source code. - [07:45](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=465s) Separating the architecture into the Session (state), Brain (reasoning), and Hands (execution) turned brittle pet containers into disposable, interchangeable cattle. - [07:45](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=465s) Because sandboxes are treated as tools by the brain, a sandbox crash is handled as a standard tool failure rather than a fatal session termination. - [09:05](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=545s) Injecting API credentials via an egress proxy ensures Claude and the execution sandbox never see or store raw secrets, eliminating token theft via prompt injection. - [10:00](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=600s) An immutable, append-only session event log allows flexible context compaction strategies—such as summarization or sliding windows—without dropping underlying history. - [10:00](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=600s) Decoupling inference from execution runtime dropped time to first token by roughly 90% because compute sandboxes only spin up on demand. - [11:09](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=669s) Interfaces must be designed to outlast model-specific assumptions, ensuring agent infrastructure remains stable as foundation model capabilities evolve. - [13:49](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=829s) The platform architecture models tasks via Environments for sandbox boundaries, Agents for persona and tool definition, and Sessions for runtime task state. - [15:18](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=918s) All runtime agent communication is mediated through a bidirectional event stream supporting messages, tool invocations, status updates, and user interrupts.
## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=0s) Introductions and Workshop Agenda
Priyanka Phatak opens the session to a full room, introducing herself as a Member of Technical Staff at Anthropic where she leads the engineering team responsible for Claude Managed Agents. Having been at Anthropic for a little over two years, she has spent the past twelve months focusing entirely on building agentic infrastructure. She welcomes attendees alongside Gabe Cemaj, also a Member of Technical Staff on her team, who notes that he has been at Anthropic for just over a year and has spent almost his entire tenure working on managed agents.
Priyanka outlines the roadmap for the workshop, explaining that while the overall two-hour block is broken into four recorded sections, it functions as a single continuous session. The talk begins with an architectural evolution story tracing how Anthropic built and scaled managed agents, including the early pitfalls, operational lessons, and architectural pivots. Following that, the session shifts into a two-part hands-on portion: first, a no-code walkthrough using the Claude platform console where participants prompt their way to an initial agent, and second, an interactive coding segment led by Gabe Cemaj using Claude Code (or any preferred coding agent) to build a more complex financial agent, concluding with an open Q&A.
```mermaid flowchart LR accTitle: Workshop Structure accDescr: Three-stage sequence of the Claude Managed Agents workshop agenda. A["Evolution Story<br/>Architecture & Pitfalls"] --> B["Console Quick Start<br/>Prompting First Agent"] B --> C["Hands-on Coding<br/>Financial Agent"] C --> D["Open Q&A"] ```
[02:05](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=125s) What Makes an Agent Work: Models, Harnesses, and Sandboxes
Priyanka breaks down the fundamental machinery of an agent to its core components: a model, a harness, and a sandbox. At the most fundamental level, an agent is simply a model running in a loop with tools. The foundation model evaluates the state, decides on the next appropriate action, and executes tool calls iteratively until the user's task is resolved.
An audience member briefly interrupts from the back of the room to ask if a link to the slide deck is available. Priyanka and Gabe apologize for the visibility issues in the back, noting that it is difficult to distribute the deck mid-presentation, but promise to share the slides immediately afterward while encouraging attendees to raise hands for roaming microphones whenever they have questions.
[03:06](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=186s) Harnesses and Model-Specific Assumptions
Priyanka explains that a harness is the orchestration layer wrapped around the model. It handles the mechanics of calling tools in a loop, manages the context window, and fills in gaps where model capabilities fall short. Crucially, a harness inherently codifies assumptions about what a specific model cannot do. Because models improve rapidly, these workarounds can become obsolete from one model generation to the next.
To illustrate this, Priyanka shares a concrete engineering example involving model behavior: “A good example is our Sonnet 4.5 model had something what we called context anxiety.” When Sonnet 4.5 sensed it was nearing the edge of its context window, it would prematurely rush to complete the task. To mitigate this behavior, engineers had to build a context-resetting mechanism into the harness. However, when the team transitioned to Opus 4.5, that limitation vanished entirely, rendering the specialized context-reset logic unnecessary. Priyanka emphasizes that building a robust harness requires designing around these shifting quirks without letting temporary workarounds permanently constrain future model updates.
[04:16](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=256s) Sandboxes and Limiting Blast Radius
The third component of an agent is the sandbox—essentially a secure computer or isolated execution environment where Claude can run the code it generates to accomplish tasks. In this environment, the agent requires the ability to inspect files, edit codebases, and install dependencies. Priyanka highlights Claude Code as an everyday example of this pattern: a harness executing locally on a developer's machine with direct access to local files and system commands.
However, running agent-generated code in production introduces significant security and stability concerns. Because agents generate untrusted and potentially buggy code, the execution environment must remain tightly contained within a hardened container. Priyanka highlights the importance of workload isolation, stating: “So typically you want to execute every task in a separate container so you're not mixing up and you're not increasing the blast radius for your tasks.”
[05:10](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=310s) The First Architecture: The "Pet" Container
Priyanka details the initial architecture of Claude Managed Agents, which Anthropic shipped to early access customers in December. In this early V1 design, the engineering team packaged every component into a single container. The session log (the append-only record tracking all task events), the harness execution loop, and the sandbox where tool commands executed all coexisted within the same container boundary.
Initially, this unified model offered clear operational simplicity: - There were no complex service boundaries or distributed network hops to design. - Everything operated locally within the container filesystem. - File modifications were as fast and direct as local system calls.
Despite these immediate conveniences, this monolithic setup soon presented fundamental engineering roadblocks that forced the team to rethink their design.
```mermaid flowchart TD accTitle: Architecture V1 Monolithic Container accDescr: Depicts the early monolithic architecture where the session log, harness, and sandbox all lived inside a single container. subgraph Pet["Single Monolithic Container ('The Pet')"] SL["Session Event Log"] H["Harness / Agent Loop"] SB["Sandbox & Tool Execution"] SL <--> H H <--> SB end ```
[06:05](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=365s) The "Pet vs. Cattle" Problem and Failure Modes
The core architectural flaw of the V1 container was that Anthropic had inadvertently created an infrastructure "pet." Evoking the classic DevOps analogy, Priyanka contrasts a pet—a uniquely named, hand-tended resource that requires intense care to nurse back to health if it fails—with cattle, which are interchangeable, disposable instances that can be replaced automatically the moment one goes down.
Priyanka explains how this single-container design degraded operability in production: - **Opaque debugging:** Because everything ran inside one black box, the team could not distinguish between a network packet drop and a dead container. Diagnosing issues required engineers to establish fragile WebSocket streams directly into the running container. - **Privacy and customer data boundaries:** Containers held live customer data and proprietary source code, which meant internal Anthropic engineers could not inspect or troubleshoot broken sessions without violating strict customer privacy walls. - **Network connectivity hurdles:** If an enterprise customer needed the agent to connect to a Model Context Protocol (MCP) server located inside their private VPC, Anthropic faced an awkward dilemma: either establish complex VPC network peering connections or ship the proprietary harness to the customer to run on their own infrastructure.
Confronted with these structural roadblocks, the team abandoned the monolithic container model in favor of a clean separation of concerns.
[07:45](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=465s) Decoupling the Brain from the Hands
To solve the pet problem, Anthropic broke the monolithic agent container into three discrete, independently replaceable interfaces: the Session, the Brain, and the Hands. By establishing strict service boundaries, every component except the immutable session history became interchangeable "cattle."
```mermaid flowchart LR accTitle: Decoupled Agent Architecture accDescr: The decoupled architecture showing the session log, the brain (Claude + harness), and the hands (sandboxes and MCP tools) mediated by an egress proxy. Session[("Session<br/>Append-only Log")]
subgraph Brain["The Brain"] Claude["Claude"] Harness["Harness / Agent Loop"] Claude <--> Harness end
subgraph Hands["The Hands"] Sandbox["Ephemeral Sandboxes"] Proxy["Egress Auth Proxy"] Tools["External MCP Tools"] Sandbox -->|Outbound call| Proxy Proxy -->|Injects secret| Tools end
Session <-->|"Resume / Append"| Harness Harness -->|"Tool invocation"| Sandbox Harness -->|"Tool invocation"| Tools ```
Priyanka details how each layer functions in the decoupled architecture: 1. **The Session:** An append-only historical log of every event, action, input, and response that has occurred throughout the task. It represents the single source of truth and the only stateful asset that must be preserved. 2. **The Brain:** The cognitive engine, combining Claude with the orchestration harness. If the harness crashes, a brand-new harness instance boots up, replays the event log from the session, and resumes task execution from the exact point of failure without losing progress. 3. **The Hands:** Ephemeral execution sandboxes and MCP tool connections provisioned on demand. To Claude, interacting with a sandbox is treated as just another tool call; if a sandbox container crashes, the error reports back to the brain as a failed tool call, allowing Claude to simply spin up a fresh sandbox and continue execution.
[09:05](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=545s) Keeping Credentials Out of the Sandbox
Decoupling the architecture also resolved a major security risk: prompt injection attacks aimed at credential theft. In the legacy V1 container, authentication credentials and API tokens lived inside the execution environment alongside Claude, making them vulnerable if an agent was tricked into printing the environment variables or writing secret tokens to a readable file.
In the decoupled design, credentials never enter the execution sandbox. Instead, when an agent initiates an outbound network request to an authenticated API or external MCP endpoint, the call routes through an egress proxy: - The proxy intercepts the outbound traffic outside the sandbox perimeter. - The proxy injects the necessary access tokens, bearer headers, or credentials at the network boundary. - The external service receives the authenticated request without the model or sandbox ever holding the raw secrets.
As Priyanka points out, this design provides structural immunity against credential-leaking attacks: “That way the model never sees your credentials or your tokens which means you can never prompt inject Claude to say like hey give me your tokens or print out the tokens or write them to a file.”
[09:49](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=589s) Flexible Compaction Strategies
A further benefit of separating the session log from execution is the ability to handle long-running context through flexible compaction strategies. Because the session is maintained as an independent, append-only ledger of discrete events, Anthropic can modify how context is summarized, truncated, or pruned without altering the underlying compute runtime or dropping critical operational history. Work continues uninterrupted, and historical events remain intact even as context windows are dynamically optimized.
[10:00](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=600s) Flexible Compaction, Faster First Token, and Pluggable Hands
Priyanka Phatak explains that moving away from the monolithic container design fundamentally changed how session history is managed. Because the underlying event stream is strictly append-only, raw interactions are never mutated or thrown away during compaction. This separation allows the compaction strategy to operate independently: it can inspect the entire event log to synthesize an executive summary for Claude's context window, or it can selectively pull in only the trailing $N$ events depending on the task requirements.
```mermaid flowchart TD accTitle: Decoupled Agent Architecture accDescr: Flow diagram showing the separation between the append-only event log, the brain harness, and pluggable hands.
subgraph Storage ["State Management"] Log["Append-Only Event Log"] Compact["Flexible Compaction Strategy"] Log --> Compact end
subgraph Core ["The Brain"] Harness["Interchangeable Harness"] Claude["Claude Inference"] Compact --> Harness Harness <--> Claude end
subgraph Execution ["The Hands"] Sandbox["Container Sandbox"] VPC["Customer VPC"] MCP["MCP Server"] end
Harness -->|"On-demand spawn"| Sandbox Harness --> VPC Harness --> MCP ```
This decoupled model also eliminates the startup latency overhead of container sandboxes. Because Claude can begin inference immediately without waiting for execution infrastructure to spin up, the time to first token dropped by approximately 90%. A sandbox container is only spawned when the model explicitly issues an action that requires code execution, resulting in a much snappier interaction loop. Furthermore, the harness acts as a centralized "brain" capable of driving multiple, interchangeable "hands," including customer virtual private clouds (VPCs), Model Context Protocol (MCP) servers, or isolated container sandboxes.
- Append-only event streams store every atomic interaction, ensuring no raw session data is discarded. - Compaction strategies can be modified dynamically (e.g., full historical summarization versus sliding window of the last $N$ events). - Decoupling reduced time to first token by roughly 90% by deferring container provisioning until tool execution is required. - Execution targets ("hands") are pluggable and include sandboxes, remote customer VPCs, and external MCP servers.
---
[11:09](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=669s) Interfaces Outlasting Assumptions and Audience Q&A
Highlighting the primary architectural insight from building Claude Managed Agents, Phatak emphasizes the vulnerability of tying system infrastructure to model behaviors. As foundation models rapidly advance, the internal reasoning patterns and prompt requirements baked into orchestration loops quickly become obsolete. By decoupling the architecture into modular interfaces, the Anthropic team ensured the core platform can evolve without breaking backwards compatibility.
> “So, if you take one thing home from this, it's that harnesses encode assumptions and assumptions can go stale. So we designed interfaces to outlast these assumptions and made the architecture more flexible.” — Priyanka Phatak
When an audience member asks to revisit the prior slide to clarify the three core interfaces, Phatak reviews the tripartite separation that future-proofs the system: 1. **The Append-Only Session Log:** An immutable ledger recording all inbound and outbound events. 2. **The Interchangeable Harness:** The execution loop orchestrating model calls and context compaction, easily swappable as model capabilities advance. 3. **The Hands:** Pluggable execution environments (sandboxes, bash environments, MCP connectors, and external API tool calls) invoked on demand.
---
[11:39](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=699s) API Credit Claiming and Workshop Logistics
Phatak transitions the session into the interactive, hands-on workshop segment. To allow attendees to build directly alongside the presentation, Anthropic provided complimentary platform API credits. Attendees are instructed to scan an on-screen QR code and either authenticate using an existing account or register a new one at the Claude platform.
As attendees pull out their smartphones to claim credits, minor conference logistics arise. Phatak pauses for about thirty seconds, fielding issues from attendees experiencing venue Wi-Fi instability ("Oh, there are problems with the internet. Oh, no."). To ensure audience questions can be heard across the room, she coordinates with Gabe Cemaj and brings in team member Travis to circulate with a handheld microphone while the platform credits propagate to user accounts over the span of a minute or two.
---
[13:49](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=829s) Core APIs: Environments, Agents, and Sessions
To introduce the developer surface of Claude Managed Agents, Phatak walks through the three foundational API objects required to build a simple "joke teller" agent before writing code in the console.
```mermaid flowchart LR accTitle: Core API Lifecycle Flow accDescr: Sequence diagram showing the three stages from Environment to Agent to Session.
subgraph Prep ["Configuration"] Env["1. Environment\n(v1/environments)\n• Network rules\n• Packages"] Agent["2. Agent\n(v1/agents)\n• Model choice\n• System prompt\n• Toolsets"] end
subgraph Exec ["Runtime"] Session["3. Session\n(v1/sessions)\n• Agent ID + Env ID\n• Idle until triggered"] end
Env --> Session Agent --> Session ```
The setup follows a clean, three-step resource lifecycle:
1. **Environments API (`/v1/environments`):** Defines the sandbox template and isolation boundaries. Developers specify networking configurations (ranging from completely unrestricted network access to whitelists restricted to specific domains or MCP endpoints) and configure pre-installed base software packages. 2. **Agent API (`/v1/agents`):** Specifies the persona and cognitive configuration. Developers supply an identifier (e.g., `joke-teller`), select a foundation model (such as Claude Opus, Claude Sonnet, or Claude Haiku), establish the system prompt (e.g., instructing the agent to act as a comedian and tell a fresh joke), and attach tool sets. Typical deployments include the standard `agent_toolset`, which equips Claude with low-level execution primitives like `bash`, file reading, file writing, and `grep`. 3. **Sessions API (`/v1/sessions`):** The operational runtime unit representing a concrete task. Instantiating a session links an `agent_id` with an `environment_id`. When initially provisioned, the session enters an idle state where no compute resources are consumed until an initial trigger event is received.
---
[15:18](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=918s) The Event Stream Architecture and Console Quick Start
Once a session is established, all communication flows through a bidirectional event stream. Phatak illustrates how input events sent by the user trigger corresponding lifecycle and output events from the agent harness:
| Event Type | Direction | Purpose / Behavior | |:--- |:--- |:--- | | `user_message` | Inbound (User $\to$ Agent) | Sends natural language instructions (e.g., *"Tell me a joke about distributed systems"*). | | `custom_tool_use` | Outbound (Agent $\to$ User) | Emitted when Claude requests an action delegated to client-side code rather than the sandbox. | | `tool_result` | Inbound (User $\to$ Agent) | Returns the client-side execution output back into Claude's event stream. | | `session_error` | System Outbound | Dispatched if execution encounters an unhandled runtime failure. | | `status_idle` | System Outbound | Marks that execution has finished and the sandbox is inactive, saving compute. | | `interrupt` | Inbound (User $\to$ Agent) | Immediately aborts the agent loop and halts ongoing work. |
Phatak notes that advanced architectural capabilities—including complex multi-agent orchestration and persistent cross-session memory—will be covered in depth by Gabe Cemaj later in the workshop. She directs attendees to navigate directly to `platform.claude.com` and open the Managed Agents section, guiding the audience toward the built-in "Quick Start" interactive tour to deploy their first agent via the console interface while team members circulate the room to troubleshoot setup questions.
## Notable quotes > [11:09](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=669s) So, if you take one thing home from this, it's that harnesses encode assumptions and assumptions can go stale. So we designed interfaces to outlast these assumptions and made the architecture more flexible. — Priyanka Phatak
> [04:16](https://www.youtube.com/watch?v=Uv0nAf_7tyU&t=256s) So typically you want to execute every task in a separate container so you're not mixing up and you're not increasing the blast radius for your tasks. — Priyanka Phatak
## Mentioned Priyanka Phatak, Gabe Cemaj, Claude Managed Agents, Anthropic, Sonnet 4.5, Opus 4.5, Claude Code, Claude Haiku, Model Context Protocol, AI Engineer
## Video description The first version of Claude Managed Agents put everything in one container. Here's why Anthropic split it apart.
NEXT UP: AI ENGINEER CODE SUMMIT Join us in SF for the second annual AIE CODE Summit, Nov 10–12, our last flagship summit of 2026. Applications live now: https://aie.codes
Priyanka Phatak, who leads the Claude Managed Agents engineering team at Anthropic, defines an agent as a model in a loop with tools, plus a harness and a sandbox, and explains why harnesses encode assumptions that go stale with each new model. She walks through the first architecture, where the session, harness and sandbox shared one hard-to-debug 'pet' container, and the redesign into an append-only session log, a brain (harness plus Claude) and hands (sandboxes and tools). Credentials stay out of the sandbox and time to first token dropped about 90%. Then she introduces the core APIs with a simple joke-teller agent.
This is part 1 of 4 of the Claude Managed Agents workshop from Anthropic.
In this video: • Why harnesses carry model-specific assumptions • Decoupling session, harness and sandbox into replaceable parts • Injecting credentials at an egress proxy so Claude never sees them • The core flow: environment, agent, session, events
SPEAKERS Priyanka Phatak, Member of Technical Staff, Anthropic (leads the Claude Managed Agents engineering team)
Gabe Cemaj, Member of Technical Staff, Anthropic GitHub: https://github.com/gcemaj
LINKS Claude Managed Agents docs: https://platform.claude.com/docs/en/managed-agents/overview Scaling Managed Agents: Decoupling the brain from the hands: https://www.anthropic.com/engineering/managed-agents
CHAPTERS 0:00 Welcome and intros 0:58 Workshop agenda 2:05 What makes an agent work 3:06 Harnesses and model assumptions 4:16 Sandboxes and limiting blast radius 5:10 First architecture: all in one container 6:05 The pet vs cattle problem 7:45 Decoupling the brain from the hands 9:05 Keeping credentials out of the sandbox 9:49 Flexible compaction, faster first token 10:49 One brain, many hands 11:09 Interfaces outlast assumptions 11:39 Claiming API credits 12:24 Q&A: the three core interfaces 13:49 Building a joke-teller agent 15:18 Sessions and the event stream 16:33 Console quick start
Recorded at the AI Engineer World's Fair 2026 in San Francisco. Subscribe for more talks from the engineers building with AI.
AI Engineer: https://ai.engineer YouTube: https://www.youtube.com/@aiDotEngineer X: https://x.com/aiDotEngineer LinkedIn: https://www.linkedin.com/company/aidotengineer/
#Claude #AIAgents #AIEngineer
[Source](https://www.youtube.com/watch?v=Uv0nAf_7tyU)