How to get to production faster with Claude Managed Agents

Learn how Claude Managed Agents accelerate production with reliable, secure, and observable AI agent infrastructure.

Ask about this video. Answers come from its transcript only — with the timestamp, so you can check them.

Generated from the transcript and can be wrong — check the timestamp.

Key Takeaways

Claude Managed Agents simplify building and deploying reliable, secure AI agents.
Long-running, outcome-oriented tasks require robust infrastructure beyond prompting.
Observability and event tracking are crucial for understanding agent behavior.
Developers previously struggled with context management and infrastructure blockers.
The platform supports multi-agent coordination and continuous learning for improved results.

What the video covers

Introduction to Claude Managed Agents by Jess Yan and Lance Martin from Anthropic.
Discussion on exponential AI capabilities and increasing complexity in agentic development.
Challenges developers face including context management, infrastructure, and observability.
Overview of Claude Managed Agents platform solving reliability, security, and tooling issues.
Explanation of agent configuration, environment setup, and session lifecycle.
Detailed event topology covering user, agent, session, and span events for observability.
Demo of 'Pascal' agent analyzing grocery store data with real-time event streaming.
Use of console for debugging, bottleneck identification, and performance analysis.
Advanced features including persistent memory, reflection, and continuous agent improvement.
Partnerships with platforms like Asana and Notion to extend agent capabilities.

Chapters

What are Claude Managed Agents?

Claude Managed Agents are a platform developed by Anthropic that combines infrastructure, tooling, and observability to enable developers to build reliable, secure, and customizable AI agents for long-running and complex tasks.

How do Claude Managed Agents improve reliability and security?

The platform provides automatic context management, checkpointing, retries, and tool permissioning to ensure agents can run reliably over long time horizons while maintaining security and human oversight.

What kind of tasks can Claude Managed Agents handle?

They can handle tasks ranging from short interactions to multi-day or multi-week workflows, including multi-agent coordination for complex pipelines such as M&A processes or predictive analytics.

Full Transcript — Download SRT & Markdown

Speaker A

The stage, members of the technical staff of Anthropic, Jess Yan and Lance Martin. Hey, everyone. Hope everyone's having a great time at Code with Claude. I'm Jess Yan, product for Claude Managed Agents. I'm Lance Martin, DevX team, and I do whatever Jess

Speaker A

tells me. That's 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

Speaker A

deep dive into the primitives, a couple of demos to bring some sizzle to 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

Speaker A

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.

Speaker A

So a couple of years ago, you might have had Opus write and test a single component. You might be testing a flaky test suite.

Speaker A

And this would be minutes, maybe an hour of focused work. You'd be steering it heavily along the way, and you'd be correcting it as it went off course. More recently with our latest models, we're seeing that people are running things overnight, walking away,

Speaker A

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

Speaker A

teams will be running 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

Speaker A

long-arising tasks, these become much greater issues. You have an agent working for hours, weeks, or days, and need to be reliable. You also need to be secure.

Speaker A

And also, new interaction modes become possible when you have agents working over long time horizons. So, for example, with chatbots, it's pretty instantaneous for short horizon interactions. Long horizon agents require something we call outcome-oriented tasks.

Speaker A

So you give an agent a task and an outcome, like a rubric, that indicates what completion means. You also need the ability for agents to stop and resume over the course of long execution, potentially to ask questions and to clarify their work. Famously,

Speaker A

start and resume is the most human-like of interaction patterns because there's nothing more human than procrastination. 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

Speaker 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

Speaker A

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

Speaker A

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,

Speaker A

randomized outputs. And this is very unlike traditional software development of the past. How do you know if your agent 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,

Speaker A

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

Speaker A

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

Speaker A

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 that agent to use an environment which you can configure. You can configure the networking, packages, and this

Speaker A

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'll talk about a little bit more later. And

Speaker A

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

Speaker A

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

Speaker A

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 the agent running? Is it idle? Is it waiting for

Speaker A

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's data set, a grocery store called Just-In-Time, and it

Speaker A

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

Speaker A

it with a bit of a demo. So we're starting the agent execution right now.

Speaker A

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.

Speaker A

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.

Speaker A

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

Speaker A

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,

Speaker A

analyze bottlenecks, figure out ways to improve the agent going forward, and take recommended actions.

Speaker A

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

Speaker A

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

Speaker A

a bit. It's a skill built into Cloud Code and shipped globally. In Cloud Code today, if you

Speaker A

lot of managed agents code myself. I have Cloud Code do it. It is a very nice trick, and I will show you some very nice tricks later for how it can also be used to grab session logs and so forth. It uses the

Speaker A

CLI to grab those logs. CLI is very powerful, lets you configure agents 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. ARTISAN

Speaker A

ALCODE. 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 weeks. Each one extends the capabilities of the agentic

Speaker A

experiences that you can offer. So first, there's multi-agent orchestration. Cloud 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.

Speaker A

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.

Speaker A

Claude keeps going until it's finished. A couple of weeks ago, we launched memory to public beta. And with memory solutions, Claude doesn't have to start each new session fresh.

Speaker A

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.

Speaker A

So we'll showcase another demo now that showcases how Claude Managed Agents uses outcomes and multi-agent to produce great outputs. Previously, you saw in console our analysis of a single session. Lance will walk through how we can do this programmatically

Speaker A

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

Speaker A

question, what would the AGI Pilled 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

Speaker A

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

Speaker A

up a manage agent, you can see session, it has a sandbox, orchestration to handle things like retries, I'm giving it one custom tool, the ability to render code to a browser. Based on the user's input, it's going to render visualization,

Speaker A

which will show different graphs or tables based on what this fake CEO wants to know. This is where I used outcomes. I want to make sure this is really clear because I thought this was really cool. Outcomes allows

Speaker A

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

Speaker A

and take a screenshot, do an analysis, send the analysis back to the main agent.

Speaker A

So what was really cool here is I used outcomes to make this much faster.

Speaker A

As you'll see shortly, The CEO will ask a question, it's going to render visualizations, and I want it to be fast. I use outcomes to do that. Now, one nice thing is when I kick off a run with outcomes, the manager will iterate

Speaker A

against that outcome over time. And when it finishes, in my particular case, I would look at the result, see the dashboard, and I might have feedback. I say, I don't like this. What I would do is I would then tell Claude Code my

Speaker A

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

Speaker A

together really nicely. You have an inner loop that's using outcomes with managed agents, given 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

Speaker A

allowing, for example, the code agent, like Cloud Code, to modify the rubric or modify instructions and kick off a new session. These two work really nicely together. These are my results, and you'll see the demo very shortly. I start with a pretty inefficient

Speaker A

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 parallelize tool calls, it figured out how to use fast mode, perform prompt optimization, and for inputs that

Speaker A

produce multiple charts, it 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. So now we can see the results. Here's boss agent in action. We're able to analyze top line metrics.

Speaker A

Yep. And I'm glad my music got included here. Did Claude make that music? Yes.

Speaker A

Nice. Yeah, so this one is actually cool. This is actually using multi-agent to produce three visualizations simultaneously on my hypothetical AGI-pilled CEO dashboard. Cool.

Speaker A

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,

Speaker A

we got to partner with super innovative agentic partners who are trying to use Claw to extend the capabilities of their platforms. So Asana and Notion are highlighted here, but we We heard feedback from all of you guys throughout the course of our public

Speaker A

release, and it's been so gratifying to see what you guys are building on top of our platform. We're really excited to help you guys ship faster and faster. We're excited to keep pushing this platform forward. And please always reach out to us if

Speaker A

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,

Speaker A

yeah, just another thank you to our great developer community. Yeah, thank you. All right.

Topics:Claude Managed AgentsAI agentsAnthropicagentic developmentAI infrastructureobservabilitycontext managementmulti-agent systemsAI productionagent debugging

Get More with the SozAI App

Transcribe recordings, audio files, and YouTube videos — with AI summaries, speaker detection, and unlimited transcriptions.

App Store Google Play

Or transcribe another YouTube video here →

Free tools: TXT to SRT · SRT Validator · Merge SRT · Subtitle to Text · All tools