CHAPTERS
Workshop goals: from slides to hands-on coding
The speaker opens by noting that many attendees have heard the term “Claude Managed Agents” but don’t yet know what it is. They set expectations for a technical, laptop-open session using a starter repo to build something deployable.
What Claude Managed Agents provides: production primitives via API
Claude Managed Agents is introduced as a set of API endpoints that provide a scalable, production-ready agent stack. The speaker emphasizes “pick the primitives you need” and highlights built-in reliability, context handling, multi-agent support, and observability.
Core building blocks: Agents, Environments, Sessions, Events
The talk breaks the platform into four main primitives and explains how they connect. An agent is a template (prompt/tools/MCP), environments define sandbox behavior, sessions represent ongoing conversations, and events drive the interaction stream.
Event taxonomy: user, agent, session lifecycle, and span events
The speaker outlines the major event types and what each is used for in production. They also describe outcomes as a structured rubric that Claude iterates against to self-check work.
New infrastructure options: self-hosted sandboxes and MCP tunnels
The session covers newly announced features for keeping data inside a private perimeter. Self-hosted sandboxes let you bring your own container runtime, and MCP tunnels securely connect private MCP servers without exposing them publicly.
Demo setup: starter repo and the “Deal Desk” multi-agent app
The speaker introduces the workshop repo structure (starter vs solution) and explains the demo product: a contrived M&A “deal desk” chat UI. The finished app showcases multi-agent delegation with different personas (macro trends vs financial analysis).
First implementation steps: listing sessions from the API
Running the starter app reveals unimplemented endpoints. The speaker implements the sessions listing using the Anthropic SDK, demonstrating how quickly the UI becomes functional once the API is wired up.
Fetching session details and inspecting configured tools/MCP
Next, the demo implements retrieving a specific session. The UI then shows raw API data such as the agent in use, tool availability, MCP connections (e.g., Linear), and potential outcomes configuration.
Chat wiring: sending events and streaming responses (delegated to Claude Code)
The speaker explains that chat requires both submitting session events and streaming server-to-client events, which is more complex. They then use Claude Code (with a built-in “Claude API skill”) to implement the remaining TODOs automatically.
Docs tour: endpoints for agents, environments, sessions, multi-agent, vaults, memory
While Claude Code runs, the speaker walks through the official developer docs. They highlight endpoints across primitives plus credential vaults (secure token injection) and memory stores (persistent learning across sessions).
Console tour: agent versioning, templates, and live session observability
The speaker demonstrates the developer console experience for guided setup and monitoring. Key features include agent templates, agent version history/rollback, and live traces of multi-agent execution and tool calls.
Running the full workflow: create a session, enable MCP + memory, use outcomes
With the app working, the speaker creates a new session using Linear MCP and memory stores. They send an outcome-based request to evaluate multiple target companies, prompting tool use, delegation, and iterative self-critique against the rubric.
Q&A and wrap-up: extensibility, and what Managed Agents saves you from building
A question about plugins leads to discussion of future extensibility and how agent definitions already resemble plugin-like components. The talk closes by contrasting Managed Agents with the effort of building your own agent loop, storage, sandbox fleet, auth, and reliability tooling.
