CHAPTERS
- 0:15 – 1:11
Why Claude Managed Agents: technical deep dive + build-along goal
The speaker opens by gauging audience familiarity and sets expectations for a hands-on, code-first workshop. The aim is that attendees leave able to start building with Claude Managed Agents immediately.
- •Audience poll on awareness vs. understanding of Managed Agents
- •Shift from high-level slides to laptop-out coding
- •Promise: build something you could deploy to production today
- 1:11 – 2:41
What Claude Managed Agents provides: production agent primitives via API
A high-level definition is given: Claude Managed Agents is a set of endpoints that provide production-ready agent infrastructure. The speaker highlights the “pick primitives you need” approach and the platform features handled for you.
- •API endpoints available with any Anthropic API key
- •Primitives: computer access, tool harness, retries/error recovery
- •Context/memory management and multi-agent support
- •Built-in observability in the developer console
- 2:41 – 5:42
Core building blocks: Agents, Environments, Sessions, Events
The talk breaks the system into four main primitives and explains how they relate. This frames the mental model for the rest of the build portion.
- •Agent as a template: system prompt, skills, tools, MCP connections
- •Per-tool permission controls (auto vs. human approval)
- •Environment defines sandbox/container behavior (network, preinstalls)
- •Sessions as ongoing conversations; can preload repos/files
- •Events as the continuous stream between client and agent
- 5:42 – 7:12
Event model deep dive: user inputs, interrupts, tool results, outcomes
The speaker details the event types you can send into a session and why they matter for steering and reliability. Special focus is given to “outcomes,” a rubric-driven iteration loop for higher-quality completion.
- •User events can include text/images/documents
- •Interrupts to stop/steer unsafe or incorrect behavior
- •Tool results + human-in-the-loop confirmations
- •Outcomes as specs/rubrics that Claude iterates against until satisfied
- 7:12 – 8:13
Agent/session-side events: tools, compaction, lifecycle state, spans
Now the talk covers events emitted by the system back to the client for transparency and resilience. These include agent actions, session lifecycle transitions, and span markers for long operations.
- •Agent events: responses, tool executions, compaction, multi-agent coordination
- •Session events: retries, errors, idle/terminate transitions, outcome-processing status
- •Span events mark start/end of long-running work
- 8:13 – 9:44
Enterprise connectivity: self-hosted sandboxes + MCP tunnels
The speaker explains new capabilities for keeping sensitive data inside your own perimeter. Self-hosted sandboxes and MCP tunnels enable secure execution and private tool access without exposing infrastructure to the public internet.
- •Bring-your-own sandboxes (Cloudflare/Modal/Vercel or custom)
- •Anthropic requests a sandbox; you spawn/connect it
- •MCP tunnels for private MCP servers behind a secure tunnel
- •Avoid exposing internal services over the public internet
- 9:44 – 12:15
Demo setup: starter repo + ‘Deal Desk’ multi-agent app concept
The workshop shifts into the coding portion. The speaker introduces a public starter repository and a contrived M&A “deal desk” app to demonstrate multi-agent workflows and a production-style UI.
- •Repo contains starter and solution versions
- •App: simple chat UI with sessions list and session details panel
- •Goal: use multi-agent feature with specialized sub-agents (macro, finance, etc.)
- •Fake companies and data sources; focus is architecture/patterns
- 12:15 – 15:16
Implementing basics: listing sessions and retrieving session details
Hands-on implementation begins: the app initially breaks because key endpoints are stubbed. The speaker wires up session listing and session retrieval using the Anthropic SDK, validating the UI populates correctly.
- •Run local server (Bun) and hit missing-implementation errors
- •Implement sessions.list via Anthropic SDK
- •Implement session retrieval (get session) and display metadata
- •Inspect returned data: tools, MCP connections, configuration
- 15:16 – 17:17
Building the chat loop: sending events + streaming responses (with Claude Code)
Attention turns to the more complex part: sending session events and streaming agent-generated events to the client. The speaker delegates implementation to Claude Code using its built-in Claude API skill.
- •Two key pieces: submit session events and stream event responses
- •Claude Code used to scan TODOs and implement correctly
- •Claude API skill helps it use Managed Agents APIs effectively
- •Speaker notes: “Claude can help you build your own Claude”
- 17:17 – 18:17
Docs + API surface tour: endpoints for agents, environments, sessions, multi-agent
While Claude Code runs, the speaker tours the documentation and endpoint categories. This maps the earlier primitives to concrete API resources, including sub-endpoints for events, streaming, and resources.
- •Endpoints for creating/updating/fetching agents and environments
- •Session endpoints: list events, stream events, manage uploaded resources
- •Multi-agent endpoints for spawned threads/sub-agents
- •Additional endpoints: credential vaults and memory stores
- 18:17 – 21:18
Security + personalization primitives: credential vaults and memory stores
The talk explains how to securely connect user tools (via MCP auth) and persist learning across sessions. The key point is that secrets can be injected without appearing in Claude’s context window.
- •Credential vaults store MCP auth tokens securely with Anthropic
- •Tokens injected at tool-call time without entering model context
- •Memory stores enable read/write memories over time across sessions
- •Ability to review and edit memories when Claude is wrong
- 21:18 – 24:22
End-to-end run: create a session, trigger an outcome, and watch multi-agent work in console
With the app working, the speaker creates a new session configured with Linear MCP and memory stores, then submits an outcome-style request. They demonstrate live observability in the console, including spawned sub-agents, tool calls (e.g., web search), and timing/debug signals.
- •Create session with MCP + memory stores enabled
- •Use an outcome/rubric prompt to drive iterative evaluation
- •Console session view: see spawned agents as parallel threads
- •Inspect tool inputs/outputs and measure call durations
- 24:22 – 27:22
Q&A and wrap: plugin extensibility + why Managed Agents reduces infra burden
A question about “plugins” prompts a brief roadmap-style answer: agent definitions are plugin-like, more extensibility is being explored. The speaker closes by contrasting DIY agent loops with Managed Agents’ out-of-the-box infrastructure (state, storage, sandboxes, auth).
- •Q&A: plugin support not fully available yet; ecosystem alignment in progress
- •DIY complexity: agent loop, hosting, context/state transitions, tool/MCP integration
- •Need for durable event storage, sandbox fleet management, and secure user auth
- •Managed Agents provides these primitives and production scaffolding by default
