CHAPTERS
- 0:52 – 1:49
Agenda and what Managed Agents aims to solve
Jess and Lance open by outlining the session: why agent development is changing, why Claude Managed Agents exists, a primitives deep dive, demos, and how to get started. They frame the talk around helping developers ship agentic systems to production faster.
- •Speakers and roles: Product (Jess) + DevX (Lance)
- •Roadmap of topics: AI exponential → motivations → primitives → demos → resources
- •Positioning: production-ready agent runtime, not just prompting
- 1:49 – 3:02
The AI capability curve is shifting the bottleneck to infrastructure
As model capabilities improve, agents are being asked to do longer, more complex work—moving from minutes to overnight runs and eventually to quarter-scale projects. This makes infrastructure, not intelligence, the limiting factor for real-world deployment.
- •Task horizons expanding: component-level work → overnight backlog clearing → multi-quarter work
- •More autonomy requires less human steering and more resilient systems
- •Long-horizon work demands a true runtime beyond simple prompt scaffolding
- 3:02 – 4:02
Reliability, security, and long-horizon interaction patterns
Long-running agents magnify reliability and security risks and create new interaction needs. The team introduces outcome-oriented tasks, plus the ability to pause, resume, and ask clarifying questions over long executions.
- •Reliability becomes critical when tasks run hours/days/weeks
- •Security concerns increase with credentials, access, and tool use
- •Outcome-oriented tasks: define completion via rubric/criteria
- •Stop/resume and clarification as core long-horizon UX
- 4:02 – 5:10
Developer pain points: context, production infra, and observability gaps
Anthropic’s pre-launch research found developers struggling with context management, infra concerns, and a lack of observability. Agents are probabilistic systems, so traditional debugging and confidence signals are harder without purpose-built instrumentation.
- •1 in 3 struggle with context management (right context vs. distraction)
- •Infra is a top production blocker: credentials, access, HITL workflows
- •Most agents lack formal observability
- •Need to evaluate “random/probabilistic” behavior with better tooling
- 5:10 – 5:44
What Claude Managed Agents provides: runtime + building blocks + observability
Managed Agents is presented as a platform combining execution infrastructure (permissions, context, retries) with composable agent primitives and a rich observability console. The goal is to avoid agents “running on vibes” by making behavior inspectable and improvable.
- •Infrastructure/harness: tool permissioning & execution, auto context mgmt, checkpointing, retries
- •Composable primitives to build customizable agents quickly
- •Observability platform to understand actions and improve performance
- •Designed so teams don’t have to build the platform themselves
- 5:44 – 6:27
Core mental model: Agents, Environments, Sessions, Resources, Outcomes, Events
Lance introduces how to think about the system: an agent is configuration, it runs inside a configurable environment, and each run is a session. Sessions can include resources and outcomes, and they emit events you can process and analyze.
- •Agent = configuration (model, prompt, tools, skills)
- •Environment = sandbox setup (networking, packages, code execution)
- •Session = one execution instance; can attach resources (e.g., GitHub repo)
- •Outcomes define success criteria for the session
- •Event stream is the foundation for understanding behavior
- 6:27 – 6:58
Event topology: user, agent, session, and span events
Jess breaks down the event system into four categories that cover steering, agent actions, lifecycle state, and instrumentation. This structure supports both real-time monitoring and post-hoc diagnosis of complex long-running work.
- •User events: steer/interrupt/define exit criteria
- •Agent events: tool runs, context compaction, delegation details
- •Session events: lifecycle (running/idle/waiting)
- •Span events: group related events for broader tracing/instrumentation
- 6:58 – 8:21
Demo 1 — ‘Pascal’ analytics agent with real-time console tracing
Jess demonstrates Pascal, an analytics agent running in a preloaded Python environment on a hypothetical grocery dataset. The console shows configuration, environment, and live events while the agent produces multiple analytics outputs end-to-end.
- •Pascal runs on ‘Just in Time’ grocery dataset inside a container with Python packages
- •Single pane of glass: view config/environment alongside live event stream
- •Outputs: product analysis (bananas popularity), shopper analysis (Sunday peak), reorder probability model
- •Real-time updates and full post-run trace available in console
- 8:21 – 9:15
Post-run debugging: analyzing bottlenecks and taking recommended actions
After completion, the full event stream can be inspected to diagnose issues and improve agent performance. The console includes a debugging assistant that reviews traces and highlights bottlenecks that can be fixed in development workflows like Claude Code.
- •Full session trace persists for after-the-fact analysis
- •Debug agent in console surfaces bottlenecks and improvement ideas
- •Connects insights back to implementation changes (e.g., in Claude Code)
- 9:15 – 10:11
Getting started tools: Claude Code skill, CLI workflows, and cookbooks
Lance outlines practical onboarding: a Managed Agents-aware skill inside Claude Code, a powerful CLI for agent configuration and session log retrieval, and cookbooks for patterns. The theme is accelerating development by generating and iterating on agent code quickly.
- •Claude Code skill via “\Claude-API” to generate Managed Agents code
- •CLI supports YAML-configured agents that can be checked into repos
- •Programmatic session access/log retrieval enables automation at scale
- •Cookbooks provide reusable patterns and examples
- 10:11 – 11:43
Advanced capabilities: orchestration, outcomes, Memory, and ‘dreaming’
Jess highlights recent additions that expand what agent experiences can do. These include multi-agent delegation, outcomes-based iteration, persistent memory across sessions, and a new ‘dreaming’ workflow where agents reflect and improve between runs.
- •Multi-agent orchestration: delegate to preconfigured agents for better decomposition/fidelity
- •Outcomes: agent iterates until exit criteria are met
- •Memory (public beta): persistent read/write stores across sessions
- •Dreaming: reflect + codify learnings into new memories; improve between runs
- 11:43 – 15:33
Demo 2 — ‘Boss Agent’ dashboard: outcomes-driven speedups + multi-agent charts
Lance demos a CEO-style interface that answers questions by querying synthetic org data and rendering SVG visualizations in a browser. Outcomes are used as a rubric-driven evaluator loop to optimize performance, and multi-agent parallelism speeds up multi-chart rendering.
- •User asks questions; agent renders SVG visualizations (artifacts) in a browser
- •Managed Agent setup: sandbox + retries/orchestration + custom render-to-browser tool
- •Outcomes rubric spawns an evaluator sub-agent (e.g., timing, screenshot, analysis feedback)
- •Inner loop (outcomes iteration) + outer loop (Claude Code updates instructions/rubric via CLI logs)
- •Autonomous optimizations: parallel tool calls, fast mode, prompt optimization, multi-agent for multi-chart outputs (≈37s → ≈10s)
- 15:33 – 17:25
Closing: partner feedback, resources, and where to start
Jess closes by crediting design partners and the broader developer community for shaping the platform. They point viewers to documentation and an interactive quickstart to begin building agents quickly, and invite ongoing feedback.
- •User/developer feedback informed the platform throughout the build
- •Partner examples mentioned: Asana, Notion
- •QR codes: developer docs + interactive quickstart to build an agent in minutes
- •Invitation to reach out with feedback; final thanks
