Anthropic Engineers Reveal How to Build AI Agents with Claude Opus 5.5

Summary

The presentation explains how to build agents with Claude Managed Agents (CMA), covering the agent runtime, sandbox architecture, API workflow, multi-agent coordination, persistent memory, and scheduled tasks.

Agent architecture and harnesses

An agent is a model operating in a loop with tools: it chooses an action, calls a tool, receives the result, and repeats until the task is complete.

A harness wraps the model to manage tool execution, context, session state, and other capabilities the model does not provide on its own. Harnesses encode assumptions about model behavior, so those assumptions may need to change as models improve.

The speakers contrasted a prior approach—which put the session log, harness, and sandbox together in one container—with a more resilient design that separates them into:

• Session: An append-only record of events.
• Brain: The harness and model loop.
• Hands: Sandboxes and external tools, such as MCP servers.

This separation makes components replaceable. If a sandbox or harness fails, it can be restarted and the session can resume from its event log. Keeping the event log append-only also lets the system change how it compacts or selects context without rewriting the record.

The new design was reported to reduce time to first token by about 90%, because the model can begin inference before a sandbox is provisioned.

Sandboxes should be isolated, particularly for untrusted code. The speakers recommended limiting each task’s blast radius and avoiding shared execution environments where possible.

Building an agent: APIs and quick start

The basic CMA workflow has three steps:

1. Create an environment to define sandbox settings, such as network access and installed packages.
2. Create an agent with a name, model, system prompt, and tools.
3. Create a session for a unit of work, then exchange events through its event stream.

The introductory demo created a joke-telling agent. Users could configure it through the console’s quick start or use the API directly. The platform manages hosting, the harness, sandbox provisioning, scaling, and event-log storage; developers build their product and workflows around those services.

Workshop: research agents and orchestration

The hands-on workshop built a financial-research application in stages:

• A chat interface sends user messages to a session and streams agent events back to the browser.
• A research agent gains a skill for retrieving and analyzing SEC filings, plus specialized sub-agents for financial analysis and risk review.
• Outcomes let developers specify the task, a rubric for completion, and a maximum number of iterations. After the main agent finishes, a verifier sub-agent checks the work against the rubric and can prompt further attempts.
• A shared memory store allows knowledge to carry across sessions. Agents can check prior research and contribute findings for later sessions.
• A custom tool lets a coordinating agent launch separate sessions for multiple companies. Those sessions can run their own sub-agents and outcome checks, after which a custom harness can aggregate the results.
• Deployments schedule sessions using an agent definition, schedule, initial messages, and optional resources such as memory stores or files.
• The workshop also demonstrated dreaming, a research-preview feature that analyzes recent session transcripts and memory to identify gaps and improve a memory store. Speakers said they had seen evaluation improvements, while emphasizing that teams should validate results with their own evals. Direct updates to skills and prompts were described as possible future extensions.

Security, integration, and operational details

• In production, credentials can be managed through vaults. A placeholder is provided to the session, and the real secret is substituted only for approved domains, reducing the risk of a prompt-injected agent exposing credentials.
• Agents can access company systems through an MCP server or CLI. MCP tunnels can connect private systems without exposing an MCP server publicly. Self-hosted sandboxes are another option when the agent needs access to a customer’s network or specialized compute.
• The standard managed sandbox’s dependencies are set at environment creation and then cached. Files and repositories can also be uploaded or installed.
• CMA provides event-level observability through the API and console. Developers can inspect session events and latency; exporting to a separate observability system would require building an API connector.
• The speakers said sessions can run for many hours and that compaction is handled by the platform. They cited production sessions lasting around ten hours.
• For configuration management and CI/CD, they described using the Anthropic CLI with YAML-defined resources checked into a codebase.
• The speakers characterized CMA as a hosted, API-oriented harness inspired by lessons from Claude Code, rather than Claude Code packaged as a service.

Limitations and guidance raised in Q&A

• Session rewind and forking were not available at the time, though session forking was on the roadmap.
• Fine-grained RBAC was limited; workspaces were the main way to separate access. Per-customer workspaces were recommended when strict data segregation is required.
• Per-session token or cost budgets were being explored but were not then available.
• The platform supported Claude models only at the time of the discussion.
• There was no visual graph-based orchestration interface yet. Developers could implement orchestration with sessions, sub-agents, custom tools, and their own harness.
• The speakers recommended using representative evals to assess agent quality and verify whether changes to prompts, skills, memory, or dreaming actually help.

Reviews, guides, and tutorials

• Introductory tutorial: Build a joke-telling agent by creating an environment, agent, and session, then test it through the console.
• Hands-on research-desk workshop: Build a chat UI, add SEC-research skills and sub-agents, define outcomes and verification, coordinate multiple research sessions, schedule deployments, and explore dreaming.
• Workshop materials: Attendees were directed to a repository with a workshop skill intended to guide them through the steps later. Slides and other conference workshop resources were also mentioned.
• Practical guidance: Use isolated sandboxes, protect credentials with vaults, design interfaces that outlast changing model assumptions, and validate behavior with evals.

Main speakers and sources

• Priyanka introduced agent and harness concepts, explained the Managed Agents architecture, and demonstrated the basic agent setup.
• Gabe led the research-desk workshop and discussed multi-agent coordination, outcomes, memory, deployments, and dreaming.
• Attendees asked questions about security, infrastructure, memory, evals, scaling, and organizational access controls.
• Travis and Rohan assisted with workshop logistics and audience questions.