Anthropic Launches Claude Managed Agents to Offload AI Infrastructure

Claude

The platform automates context and tool management so developers can transition from short-horizon chatbots to continuous, multi-day agentic workflows that optimize their own performance.

AI-assisted summary of How to get to production faster with Claude Managed Agents — original source. Check the original for full context.

Source published: 2026-05-06

Detailed notes

## Background Published on May 06, 2026, by the Claude channel on YouTube, this video introduces Claude Managed Agents on the Claude Platform. According to the page description, the session explores how Managed Agents handles infrastructure, state management, permissioning, and model upgrades so developers can build and deploy production-grade agents at scale without wasting development cycles.

## TL;DR In this presentation, Jess Yen and Lance Martin outline the shift from simple prompting to long-horizon agentic development, which introduces complex infrastructure and security challenges. They unveil Claude Managed Agents, a platform designed to solve major developer pain points like context management, infrastructure blocks, and lack of observability by providing a secure harness and a rich event topology. Through live demos of "Pascal" and a "Boss Agent" CEO dashboard, they showcase advanced capabilities such as multi-agent orchestration, outcomes, and autonomous optimization loops that achieved a 73% improvement in performance. The session concludes with a look at community partnerships and resources to help developers get started building in minutes.

## Atmosphere & style The session has an engaging, collaborative, and forward-looking tech-keynote vibe, anchored by the professional yet accessible dynamic between Jess Yen and Lance Martin. It feels fast-paced and innovative, balancing technical depth with lighthearted moments, such as Martin joking about human-like procrastination and Claude-generated background music. The narrative moves from diagnosing frustrating developer struggles to a sense of breakthrough and empowerment as live demos show autonomous agents successfully optimizing complex tasks in real time.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=0s) The bottleneck in AI development has shifted from model intelligence to the infrastructure required to manage complex, delegated tasks. - [00:00](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=0s) Task horizons are expanding from short-horizon prompt engineering to long-horizon, autonomous multi-agent processes running for days or weeks. - [00:00](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=0s) Long-horizon tasks require outcome-oriented framing against a rubric rather than instantaneous chatbot interactions. - [03:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=195s) Research showed that prior to Claude Managed Agents, one in three developers struggled with context management. - [03:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=195s) Half of the surveyed developers reported that infrastructure concerns, such as credential management and human-in-the-loop coordination, were their top production blockers. - [03:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=195s) Traditional software debugging fails with agents due to the probabilistic nature of AI, leading to a critical lack of formal observability. - [03:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=195s) Claude Managed Agents provides an infrastructure harness that handles tool execution, context management, and automatic checkpointing. - [06:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=375s) The platform utilizes a four-category event topology consisting of User, Agent, Session, and Span events to handle complex outputs. - [06:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=375s) Claude Managed Agents includes a built-in debug agent that analyzes session logs to identify performance bottlenecks. - [08:45](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=525s) Developers can use a specialized Claude Code skill (`\claude-api`) to programmatically configure and manage agents via YAML files and a CLI. - [08:45](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=525s) Advanced features include multi-agent orchestration where Claude can clone itself and delegate tasks to specialized sub-agents. - [08:45](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=525s) The platform introduces persistent memory stores in public beta, allowing agents to retain knowledge across sessions. - [08:45](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=525s) The Dreaming Platform allows agents to autonomously reflect and codify new learnings into memories between operational runs. - [11:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=675s) Optimization can be divided into an inner loop for autonomous rubric fulfillment and an outer loop for developer-driven instruction updates. - [11:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=675s) An autonomous optimization loop reduced a dashboard rendering baseline from 37 seconds to 10 seconds, representing a 73% performance improvement. - [11:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=675s) The autonomous performance gains were achieved via parallelized tool calls, fast mode, prompt optimization, and multi-agent delegation.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=0s) The Shift to Long-Horizon Agentic Development

Jess Yen (Product for Claude Managed Agents) and Lance Martin (DevX team) introduce themselves and outline the agenda: the AI exponential, the motivations behind Claude Managed Agents, a deep dive into its primitives, live demos, and getting started resources.

Yen explains that as model capabilities increase exponentially, task horizons and the complexity of delegated work are growing. The bottleneck is no longer intelligence, but infrastructure. A few years ago, a developer might have used Claude Opus to write and test a single component or fix a flaky test suite—a process taking minutes or an hour of focused work with heavy manual steering. Today, developers run agents overnight to resolve entire linear backlogs. In the near future, multi-agent coordinated teams will run end-to-end processes like an entire M&A pipeline, which historically took quarters of human effort. This evolution from simple prompts to days of continuous work requires a true agentic runtime rather than just prompting scaffolding.

Martin highlights that long-horizon tasks introduce severe reliability and security challenges. When an agent runs for hours, weeks, or days, it must be secure and reliable. This shift enables new interaction modes. While chatbots offer instantaneous, short-horizon interactions, long-horizon agents require "outcome-oriented tasks" where developers provide a task and a rubric indicating what completion looks like. Additionally, agents need the ability to stop and resume execution to clarify questions. Martin jokes that this start-and-resume pattern is highly human-like because "there's nothing more human than procrastination."

- **The Bottleneck Shift**: Transitioning from intelligence bottlenecks to infrastructure bottlenecks. - **Task Horizon Evolution**: Moving from minutes of focused work to overnight backlog resolution, and eventually to multi-quarter team projects. - **Outcome-Oriented Tasks**: Shifting from immediate chat responses to running against a rubric of completion criteria.

---

[03:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=195s) Developer Pain Points and the Launch of Claude Managed Agents

Yen shares research conducted prior to launching Managed Agents, which revealed that developers were struggling significantly with building agents on their own: * **Context Management**: One in three developers struggled with context. While context is powerful, having the wrong context at the wrong time is a massive distraction. * **Infrastructure Blockers**: Half of the surveyed developers cited infrastructure concerns as their number one production blocker, specifically around credential management, security, access, and keeping a human in the loop. * **Lack of Observability**: A majority of users reported running agents with no formal observability. Because agents run on probabilistic models with randomized outputs, traditional software debugging doesn't work. Developers struggled to evaluate if their agent was performing well.

To solve these issues, Anthropic built Claude Managed Agents. The platform combines infrastructure and a secure harness—handling tool permissioning, tool execution, automatic context management, checkpointing, and retries—with foundational building blocks. It also includes a rich observability platform. "We don't want these agents to be running on Vibes," Yen emphasizes; developers must understand exactly what their agent is doing to improve it.

Martin explains the mental model of Managed Agents. Developers define an agent via a configuration (specifying the model, prompt, tools, and skills) and allow it to interact with a configured environment (defining networking and packages where the agent can write code). Each execution is a "session." Sessions can contain resources (like GitHub repositories) and outcomes, and they emit events that developers can process to monitor progress.

---

[06:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=375s) Event Topology and the "Pascal" Demo

Yen walks through the event topology of Managed Agents, which is categorized into four broad areas to handle the complex outputs of long-running tasks: 1. **User Events**: Used to steer, guide, or interrupt the agent, and define exit criteria. 2. **Agent Events**: Convey what the agent is doing, such as running tools, compacting context over time, or delegating tasks. 3. **Session Events**: Track the lifecycle of the work (e.g., running, idle, or waiting for user input). 4. **Span Events**: Provide broader instrumentation to group related events together.

To demonstrate these concepts, Yen introduces "Pascal," an example agent built to run on a hypothetical grocery store dataset for a store named "Just." Pascal leverages a preloaded container with Python packages to produce rich analytics and insights in minutes.

During the live demo, Yen shows the real-time event stream updating in the console, which provides a "single pane of glass" to analyze both the agent's configuration and its environment. Pascal analyzes products (discovering that bananas are highly popular), analyzes shoppers (finding that Sunday morning is peak grocery time), and builds a predictive model to determine customer reorder probabilities based on demographic profiles. Once complete, the full event stream is available in the console. A built-in "debug agent" analyzes the session log, identifies bottlenecks, and recommends actions that can be fixed directly in Claude Code.

---

[08:45](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=525s) Advanced Capabilities: Multi-Agent, Memory, and Outcomes

Martin explains how developers can get started practically. He highlights a built-in skill in Claude Code: by typing `\claude-api`, developers can access a specialized skill that understands managed agents. Martin admits, "I don't write a lot of managed agents code myself. I have Claude Code do it." The platform also features a powerful CLI to configure agents as YAML files and programmatically manage sessions, alongside "artisanal" cookbooks.

Yen details several advanced capabilities shipped recently: * **Multi-Agent Orchestration**: Claude can clone itself and delegate to pre-configured sub-agents, decomposing complex tasks into smaller, high-fidelity units. * **Outcomes**: Claude iterates continuously until it satisfies predefined exit criteria. * **Memory (Public Beta)**: Claude reads and writes to persistent memory stores so it does not have to start every session from scratch. * **Dreaming Platform**: Announced by colleague Mahesh, this allows Claude to reflect and codify new learnings into memories between runs, meaning "agents can literally improve between every single run."

---

[11:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=675s) The "Boss Agent" Demo and Optimization Results

Martin showcases a demo inspired by a prompt from Angela, Anthropic's Head of Product: "What would the AGI-peeled CEO have at his disposal?" He built an interface where a user types a question, and a managed agent queries mock organizational data to render custom SVG visualizations in a browser.

The setup uses a "Boss Agent" with sandbox orchestration to handle retries, a custom tool to render code to the browser, and outcomes. Martin defined a rubric instructing a separate sub-agent to spin up upon completion, analyze the generated page, take a screenshot, measure timing, and send the analysis back to the main agent.

This setup enables two optimization loops: * **The Inner Loop**: The agent uses outcomes to autonomously iterate and optimize against the rubric. * **The Outer Loop**: If the user dislikes the output, they give feedback to Claude Code. Claude Code uses the CLI to pull the session log, reflect on the rubric and instructions, update them, and kick off a new session.

Through this autonomous optimization, the agent improved its performance significantly. Starting from an inefficient baseline, the agent autonomously figured out how to parallelize tool calls, use fast mode, optimize prompts, and employ multi-agent delegation for multiple charts. This reduced the dashboard rendering time from 37 seconds down to 10 seconds—a 73% improvement achieved entirely autonomously.

The demo video plays, showing the "Boss Agent" in action generating three simultaneous visualizations on the CEO dashboard, accompanied by background music that Martin jokes was generated by Claude.

- **Baseline Performance**: ~37 seconds. - **Optimized Performance**: ~10 seconds. - **Autonomous Strategies Used**: Parallelized tool calls, fast mode, prompt optimization, and multi-agent delegation.

---

[15:00](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=900s) Community and Getting Started

Yen wraps up the presentation by thanking the developer community. She notes that building Claude Managed Agents was highly collaborative, involving partnerships with innovative companies like Asana and Notion to extend their platforms' capabilities.

She displays two QR codes on screen: one linking to the developer documentation and another linking to an interactive quick start designed to help developers build an agent in minutes. Yen and Martin close by thanking the audience and expressing excitement for what developers will build next.

## Notable quotes > [00:00](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=0s) The bottleneck is no longer intelligence, but infrastructure. — Jess Yen

> [00:00](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=0s) there's nothing more human than procrastination. — Lance Martin

> [03:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=195s) We don't want these agents to be running on Vibes, — Jess Yen

> [08:45](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=525s) I don't write a lot of managed agents code myself. I have Claude Code do it. — Lance Martin

> [08:45](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=525s) agents can literally improve between every single run. — Jess Yen

> [11:15](https://www.youtube.com/watch?v=E9gaQHrw_rg&t=675s) What would the AGI-peeled CEO have at his disposal? — Angela

## Mentioned Jess Yen, Lance Martin, Angela, Mahesh, Claude Managed Agents, Claude Platform, Claude Opus, Claude Code, Claude, Pascal, Just, Python, YAML, Asana, Notion, GitHub

[Source](https://www.youtube.com/watch?v=E9gaQHrw_rg)

中文简报

Anthropic 推出 Claude Managed Agents 以减轻 AI 基础设施负担该平台实现了上下文和工具管理的自动化，让开发者能够从短周期聊天机器人过渡到可运行数天、并能自主优化性能的智能体工作流。在本次演讲中，Jess Yen 和 Lance Martin 阐述了从简单提示词开发向长周期智能体开发的转变，指出了这一演进所带来的复杂基础设施与安全挑战。他们推出了 Claude Managed Agents，该平台旨在通过提供安全运行框架与丰富的事件拓扑，解决上下文管理、基础设施阻碍及缺乏可观测性等主要开发者痛点。通过“Pascal”与“Boss Agent” CEO 仪表板的现场演示，他们展示了多智能体编排、结果呈现以及使性能提升 73% 的自主优化循环等先进能力。演讲最后展望了社区合作伙伴关系与相关资源，旨在帮助开发者在数分钟内快速上手构建。 AI 开发的瓶颈已从模型智能转向支持复杂长周期自主任务的基础设施；任务形态正从短周期的提示工程演变为以评测规则（Rubric）为导向、可运行数天甚至数周的自主多智能体流程。 (0:00) Anthropic 调查显示，在 Claude Managed Agents 推出前，三分之一的开发者受困于上下文管理，半数开发者将凭据与权限等基础设施问题视作投产的最大阻碍，同时智能体的概率性输出导致传统调试失效且缺乏可观测性。 (3:15) Claude Managed Agents 提供了涵盖工具执行、自动上下文管理和检查点备份的基础设施框架，并通过包含 User、Agent、Session 与 Span 四大类事件的事件拓扑（Event Topology）实现对复杂执行过程的深度监控与调试。 (6:15) 平台新增了多智能体编排、按成果迭代（Outcomes）、持久化记忆（Memory）以及运行间反思学习的 Dreaming 机制，演示中“Boss Agent”自主通过并行调用工具与委托子任务，将仪表盘渲染耗时从 37 秒缩短至 10 秒（提升 73%）。 (8:45)

Reading summary

Anthropic's Jess Yen and Lance Martin argue that as AI capabilities expand toward long-horizon tasks, the primary barrier to production has shifted from model intelligence to infrastructure and observability. To address this, Claude Managed Agents provides a dedicated runtime with built-in harness security, state management, and event-level instrumentation. The Infrastructure Bottleneck in Long-Horizon Tasks (0:00) Yen explains that development workloads are progressing from brief, interactive steering—such as fixing a test file in an hour—to overnight backlog resolution, and eventually toward multi-quarter collaborative workflows like M&A pipelines. Martin notes that running agents over extended hours or days demands outcome-oriented tasks governed by completion rubrics rather than prompt-response chat loops, alongside execution models that can pause, clarify questions, and resume safely. Anthropic's internal developer research revealed that infrastructure limitations severely impede this transition. Half of surveyed developers cited infrastructure challenges—specifically credential management, environment security, access controls, and maintaining human oversight—as their primary blocker to production. Additionally, one in three developers reported difficulties with context management, while a majority operated without formal observability tools suited for non-deterministic model evaluation. Managed Architecture and Structured Event Observability (3:15) Claude Managed Agents replaces ad hoc prompt scaffolding with an integrated runtime. In Martin's mental model, developers define an agent through a configuration specifying the model, system prompts, tools, and skills, which then runs inside a configured compute environment with controlled networking and package dependencies. The runtime automatically manages tool permissioning, tool execution, context compaction, checkpointing, and retries across individual execution sessions. To eliminate reliance on speculative debugging, the platform streams four structured event types: user events for steering or exit criteria, agent events for tool execution and context changes, session events for lifecycle states, and span events for grouped operational instrumentation. In a demonstration using a grocery store dataset agent named Pascal, this stream surfaced in a console view alongside an automated debug agent that inspects session logs for performance bottlenecks and recommends code edits directly within Claude Code. Delegation Primitives, Persistence, and Outcomes (8:45) The platform introduces orchestration primitives designed to handle complex, decomposed workflows. With multi-agent orchestration, an agent can clone itself to delegate subtasks to specialized sub-agents. Through outcomes, an agent repeatedly iterates against predefined criteria until completion conditions are verified. Platform interactions can be orchestrated via a command-line interface using YAML configuration files or managed automatically through Claude Code using a dedicated API skill. Yen highlights persistent state mechanisms, including a public beta for memory that allows agents to read and write records across discrete sessions. Furthermore, Anthropic introduced a background platform referred to as "Dreaming," which enables agents to evaluate completed runs and synthesize new memories during idle periods so that operational strategies improve across subsequent sessions. Autonomous Optimization and Rendering Benchmarks (11:15) To evaluate autonomous execution, Martin demonstrated a "Boss Agent" configured to answer queries by querying organizational data and rendering SVG visualizations in a browser. The system split execution into two operational loops: an inner loop where the agent iteratively refined output against a rubric using an auxiliary verification agent that measured load times and analyzed screenshots, and an outer loop where user feedback prompted Claude Code to update session rubrics and rerun tasks programmatically. Over successive iterations without manual code modifications, the agent autonomously applied optimization strategies, including tool call parallelization, model fast modes, prompt tuning, and delegating visual charts to parallel sub-agents. These autonomous modifications reduced dashboard render times from a baseline of 37 seconds to 10 seconds, representing a 73% performance improvement. Anthropic developed Managed Agents in collaboration with platform partners such as Asana and Notion, offering quick-start guides and developer documentation to accelerate adoption. While managed infrastructure and automated rubric loops demonstrably reduce latency and operational overhead in structured benchmarks, the reliability of autonomous multi-agent systems on unconstrained, real-world workflows remains reliant on continuous evaluation.

精炼阅读摘要

Jess Yen与Lance Martin指出，AI代理开发的瓶颈已由模型智能转向底层基础设施；Anthropic推出的Claude Managed Agents通过提供安全运行时、标准化事件观测及记忆机制，旨在解决长周期自主任务在生产环境中的工程挑战与可靠性问题。长周期任务转型与三大生产阻碍 (0:00) Yen解释称，随着底层模型能力提升，代理任务的生命周期正在从分钟级的单组件调试，扩展至通宵运行的代码积压处理，甚至可能在未来涵盖跨季度的复杂端到端流程（如企业并购）。Martin强调，支持数小时乃至数天的长周期运行必须依赖高可靠且安全的运行时系统；交互模式也必须从即时问答，转向基于明确验收标准（rubric）的结果导向型任务，并支持类似于人类工作习惯的随时暂停与恢复机制。在平台发布前的调研中，开发者构建代理时普遍面临三大生产瓶颈：三分之一的受访开发者受困于上下文管理，错误的上下文常对模型构成干扰；半数受访者将基础设施列为首要生产阻碍，主要涵盖凭据安全、执行权限、网络隔离及人工介入逻辑；此外，多数团队在缺乏正式可观测性的状态下运行代理，由于概率模型的输出具有随机性，传统软件调试手段失效，导致开发者难以准确量化和评估代理的表现。托管运行时与全链路事件可观测性 (3:15) 为替代开发者自建的脆弱脚手架，Claude Managed Agents提供了封装工具鉴权、沙箱执行、自动上下文压缩、检查点恢复及重试逻辑的托管运行时。Martin阐述了其心智模型：开发者通过定义配置设定模型、提示词、工具与技能，使其在预配置的网络和包环境中运行，每一次独立执行均被视作包含特定资源与交付目标的“会话”（session）。为消除“凭感觉运行”的不确定性，平台建立了覆盖长周期任务的四类事件拓扑：用户事件（用于交互引导与退出控制）、代理事件（反映工具调用、上下文压缩与子任务委派）、会话事件（追踪运行与等待状态）和跨度事件（聚合关联操作）。在“Pascal”杂货店数据分析演示中，代理在预载Python容器内完成了用户画像与复购概率建模；会话结束后，内置的调试代理可自动分析全量事件日志，定位执行瓶颈并给出修改建议，供开发者在Claude Code中直接优化。多代理协同编排与持久记忆体系 (8:45) 在工作流与高级特性方面，平台提供了深度集成的开发工具链。Martin介绍，开发者可以通过Claude Code内置的`\claude-api`专用技能，或利用命令行工具配合YAML配置文件对代理及会话进行程序化管理，无需手工编写大量胶水代码。近期上线的功能重点拓展了复杂协作与跨会话能力：首先是多代理编排，Claude可克隆自身并将子任务分发至预设的专用代理；其次是结果导向机制（Outcomes），使代理能够围绕预设的退出条件持续循环推进；再次是开放公测的持久记忆（Memory），允许代理跨会话读写存储，摆脱单次执行的状态遗忘；最后，团队推出的“造梦平台”（Dreaming Platform）使Claude能在两次运行的间隙进行反思，将新经验沉淀为系统知识，实现任务运行之间的自主能力迭代。双循环自主优化与仪表盘性能实测 (11:15) Martin通过“Boss Agent”企业高管可视化看板演示了系统的端到端自主优化能力。该方案结合了沙箱环境、代码渲染工具及独立的评估子代理，评估代理在主任务完成后自动捕获页面截图、分析布局并测算执行耗时。整个系统形成了双循环结构：内循环依靠代理针对验收标准进行自主试错与重试；外循环则在用户提出改进要求时，由Claude Code利用CLI拉取会话日志、反思修改提示词与规则配置，再触发新一轮运行。在完全自主的优化迭代中，该代理自主摸索出并行化工具调用、启用快速模式、精简提示词以及分派多代理并发生成图表等策略。测试数据显示，看板渲染生成的整体耗时从基准的37秒缩减至10秒，在无需人工干预代码逻辑的前提下实现了73%的运行效率提升。 Claude Managed Agents通过基础设施封装与双循环机制，展示了从提示工程向全托管长周期代理演进的路径；然而，在多代理自主探索与高度委派的生产环境中，如何在享受自适应性能优化的同时，有效控制随机性输出并确保关键业务系统的确定性，仍需更多工程实践的检验。

Source quotes

[0:00] Jess Yen: The bottleneck is no longer intelligence, but infrastructure. [0:00] Lance Martin: there's nothing more human than procrastination. [3:15] Jess Yen: We don't want these agents to be running on Vibes, [8:45] Lance Martin: I don't write a lot of managed agents code myself. I have Claude Code do it. [8:45] Jess Yen: agents can literally improve between every single run. [11:15] Angela: What would the AGI-peeled CEO have at his disposal?

Original transcript

[0:00] Thank you. please welcome to the stage members of technical staff of anthropic jess yan and lance mark Hey, everyone. Hope everyone having a great time at Code with Cloud I Jess Yen product for Cloud Managed Agents I Lance Martin DevX team and I do whatever Jess tells me That news to me But today we have a great agenda for you guys First, we'll be starting with the AI exponential and how that has materially changed agentic development. We'll talk about the motivations for why we built Cloud Managed Agents, a deep dive into the primitives, a couple of demos to bring some sizzle to life, life, and then we'll walk you through our getting started resources so that you can start building some agents of your own. All right, so we're all familiar with how our model capabilities are increasing exponentially, but as these capabilities increase, so do the task horizons and the complexity of the work that we're delegating to our agents. We're seeing that the bottleneck is increasingly infrastructure and not intelligence. So a couple years ago, you might have had Opus write and test a single component. You might be testing a flaky test suite. And this would be minutes, maybe an hour of focused work. You be steering it heavily along the way and you be correcting it as it went off course More recently with our latest models we seeing that people are running things overnight walking away waking up the next morning and seeing that their entire linear backlog has been resolved by an agent In the not too distant future we might see agents take on work that historically took quarters of teams working on it. Multi-agent coordinated teams will be running a a full M&A pipeline end-to-end. And as tasks evolve from prompts to hours and hours and days of work, we need not just prompting scaffolding, but a true agentic runtime. That's right. With managed agents, one of the main things we've solved is reliability and security. So with long-horizon tasks, these become much greater issues. You have an agent working for hours, weeks, or days, and need to be reliable. We also need to be secure. And also, new interaction modes become possible when you have agents working over long time horizons. So for example, with chatbots, there is pretty instantaneous for short horizon interactions. Long horizon agents require something we call outcome-oriented tasks. So you give an agent a task and an outcome like a rubric that indicates what completion means We also need the ability for agents to stop and resume over the course of long execution potentially to ask questions to clarify their work Famously, start and resume is the most human-like of interaction patterns because there's nothing more human than procrastination. Right. So it's clear that we expect a lot of our agents, and that means historically we've pushed that burden onto you guys, the developers. We've expected a lot of you as well. In research that we conducted prior to launching managed agents, we found that developers were seriously struggling. So one in three were struggling with context management. Context at the right time can be incredibly powerful. It's the knowledge that the agent needs to do work. But context at the wrong time can be a huge distraction. Half of our developers were citing that infra concerns were their number one production blocker. This is some of the concerns that Lance was talking about, about credential management, security and access, keeping a human in the loop. And then lastly, a majority of our users are saying that their agents are running with no formal observability. These agents are running off of predictive models, randomized outputs, and this is very unlike traditional software development of the past. How do you know if your agent [5:00] is doing something good if it is producing random or probabilistic outputs. So enter cloud managed agents. We built this platform so that you don't have to. We combined infrastructure and harness, so tool permissioning, tool execution, automatic context management, checkpointing retries, with foundational building blocks that Lance will go into in a bit later. That makes it easy to understand how to compose a customizable agent quickly. And then lastly, we paired it with a rich observability platform. We don't want these agents to be running on Vibes. You should be able to understand exactly what your agent is doing and how you can improve it. Yeah, that's right. And so using managed agents is actually really simple. The mental model is basically as follows. You're defining an agent. Agent you can think of as a configuration. It has a particular model, has a prompt, has tools, has skills. You're laying that out and then you're allowing the agent to use an environment which you configure. You can configure the networking packages and this is where the agent can for example write code and any given execution of the agent is a session Now sessions can have resources for example GitHub repos They can have something like an outcome which we talk about a little bit more later And these sessions emit events which Jess will cover here briefly that you can then handle and process and use to understand what the agent is doing. So let's walk the event topology. As agents do more and more complex tasks, the event types that are produced are more and more complex as well. And so we've separated them into four broad categories. So there are user events. You steer the agent, you guide it, you interrupt it, you define exit criteria. There are agent events. These convey what the agent is doing, what tools it's running, how it's compacting its context over time, who it's delegating to. There are session events which help you track the lifecycle of your work. So is Is the agent running? Is it idle? Is it waiting for your inputs? And then lastly, there are span events. This is broader instrumentation that lets you group related events together. So we'll pivot to an example agent that we've built. We call it Pascal. It runs on a hypothetical grocery store data set a grocery store called Just And it produces rich analytics and insights in minutes leveraging its preloaded container loaded with a set of Python packages You can see every event in console, and you can even diagnose the event stream after the fact. So we'll walk through it with a bit of a demo. So we're starting the agent execution right now. You can see that the events are updating real-time in console, and console supports a single pane of glass that lets you analyze the agent's configuration as well as its environment as you're looking at the events produced. Pascal has started to cook. It's starting to produce some outputs. It first starts with an analysis of the products. We're learning that bananas are really, really popular. The second output that it'll create is an analysis of the shoppers. And we're learning that Sunday morning is peak grocery time. And lastly, my favorite output is a bit of a predictive model, where it's analyzing what is the reorder probability for a single customer given its demographic profile. Now that the agent has finished its completion the full event stream is available in console and we can analyze its performance We offer a debug agent in console so that you can look at the event stream analyze bottlenecks figure out ways to improve the agent going forward, and take recommended actions. So it looks like it has identified a few bottlenecks, which we can then go fix directly in Cloud code. Yeah, so what you saw is the console showing two really cool things. It's showing you the trace for everything that happened in the session. It allows you to analyze what happened using Cloud to look at the session log and give you analytics, insights, and so forth. Now, how do you practically get started? First, I want to promote something that I worked on quite a bit is a skill built into Cloud Code and shipped globally. In Cloud Code today, if you use the backslash cloud-api, you will access our skill, which understands managed agents extremely well. And I use this all the time. In fact, I don't write a lot of managed agents code myself. I have Cloud Code do it. It's a very nice trick. And I'll show you some very nice tricks later for how it can also be used to grab session logs and and so forth. It uses the CLI to grab those logs. CLI is very powerful, lets you configure agents, [10:00] As for example, YAML files, which you can check in. It allows you to grab sessions programmatically, which is very useful for working with code agents. And we also have cookbooks. Artisanal code. Yes. So this is what we've been building with since we launched. But I wanted to also touch on some of the more advanced capabilities that we've been shipping over the last couple of weeks. Each one extends the capabilities of the agentic experiences that you can offer. So first, there's multi-agent orchestration. Claude can clone itself. Claude can delegate to pre-configured additional agents. And this allows complex tasks to be decomposed into smaller units that are achieved with better fidelity. We have outcomes, which we've talked about a little bit earlier in this presentation, where Claude iterates until it satisfies predefined exit criteria. You define the goal. Claude keeps going until it's finished. A couple of weeks ago, we launched memory to public beta. With memory solutions, Claude doesn't have to start each new session fresh. Instead, it's reading and writing to persistent memory stores. And then lastly today my colleague Mahesh announced our dreaming platform Here Claude is reflecting and codifying new learnings into new memories Agents can literally improve between every single run So we'll showcase another demo now that showcases how Claude Managed Agents uses outcomes and multi-agent to produce great outputs. Previously saw in console our analysis of a single session. Lance will walk through how we can do this programmatically at scale through the course of multiple sessions. Yeah, so this is actually one of the most fun demos I had to build for this conference. And it came from a number of weeks ago. Angela, our head of product, actually prompted me with a question, what would the AGI-peeled CEO have at his disposal, at her disposal? So this is an interface where you just type in a question, it will query fake organizational data and render visualizations based on the input for anything that this fake CEO wants to know. If you use, for example, the Cloud app, you understand artifacts. It's basically just cloud producing SVG and rendering that, in this case in a browser, as a visualization. So we'll show this right now. Now, all I'm doing is I set up a manage agent. You can see session. It has a sandbox orchestration to handle things like retries I giving it one custom tool the ability to render code to a browser And what going to do is based upon the user input it going to render visualization We'll see that in a bit, which will show different, for example, graphs or tables, based upon what this fake CEO wants to know. Now, this is where I used outcomes. And I want to make this is really clear because I thought this was really cool. So outcomes allows you to specify a rubric. You're passing instructions, which means the agent runs and when the agent finishes, a separate sub-agent spins up, looks at the artifacts produced, in this case my page. And for example, in this case I specified produce timing and take a screenshot, do an analysis, send the analysis back to the main agent. So what was really cool here is I used I used outcomes to make this much faster. As you'll see shortly, the CEO will ask a question, it's gonna render visualizations, and I want it to be fast. And I use outcomes to do that. Now, one nice thing is when I kick off a run with outcomes, the manager will iterate against that outcome over time And when it finishes in my particular case I would look at the results see the dashboard and I might have feedback I say ah I don like this What I would do is I would then tell Claude Code my feedback, and it could use our CLI to pull the session log, reflect on the session, look at the rubric, look at the agent instructions, update those, and kick off a new session. This is what I call the outer loop. These two things work together really nicely. You have an inner loop that's using outcomes with managed agents, give it a rubric, cook against that rubric, produce an output. And then this outer loop is looking at that output as a user and saying, okay, I don't like this. And allowing, for example, a code agent, like Cloud Code, to modify the rubric or modify instructions and kick off a new session. So these two work really nicely together. And these are actually my results. And you'll see the demo very shortly. I start with a pretty inefficient baseline. And these are all discovered autonomously with manage agent just using the rubric to optimize timing. It figured out how to optimize or basically She paralyzed tool calls. It figured out to use fast mode, perform prompt optimization and for inputs that produce multiple charts that uses multi-agent, which saves around seven seconds going from around 37 seconds down to 10 seconds for rendering and all figured out autonomously with a managed agent using outcomes. [15:00] So now we can see the results. Here's boss agent in action. We're able to analyze top line metrics. Yep, and I'm glad my music got included here. Did Claude make that music? Yes. Nice. Um, yeah, so this this one's actually cool. This is actually using multi-agent to produce three visualizations simultaneously on my hypothetical AGI-pilled CEO dashboard. Cool. So I want to wrap some of these demos with just saying that the process of building Cloud managed agents was made so much more meaningful because we were working with users like you. Throughout the whole course of this whole build of the platform, we got to partner with with super innovative agendic partners who are trying to use CLAW to extend the capabilities of their platforms. So Asana and Notion are highlighted here, but we heard feedback from all of you guys throughout the course of our public release, and it been so gratifying to see what you guys are building on top of our platform We really excited to help you guys ship faster and faster We excited to keep pushing this platform forward And please always reach out to us if you have feedback These QR codes are where you can get started. So one links to our developer docs, one links to a rich interactive quick start where you're able to walk our primitives and build an agent in minutes. And then, yeah, just another thank you to our great developer community. Yeah, thank you. All right. Thank you.