Ship your first Managed Agent — Transcript
Full transcript
- 0:15[music]
- 0:19>> All right. Hello everyone. It's great to
- 0:21see you all here today for our session
- 0:23on shipping your first manage agent.
- 0:25Let's go ahead and get started. My name
- 0:27is Isabella He. I'm a member of
- 0:29technical staff at Anthropic on the
- 0:31Applied AI team.
- 0:32The Applied AI team at Anthropic sits at
- 0:34the intersection of products, research,
- 0:36and our customers, which means that I
- 0:38get to contribute internally to products
- 0:39at Anthropic like Claude code and our
- 0:41Claude harnesses, as well as work
- 0:43externally with our customers that are
- 0:45building on top of Claude and on top of
- 0:47our harnesses.
- 0:48So, my goal today is to get you all
- 0:50hands-on with actually building on top
- 0:52of manage agents, understanding how the
- 0:54harness works under the hood, and
- 0:56getting you ready to actually ship your
- 0:57first incident response management.
- 1:00So, the quick overview of today's
- 1:01agenda. We're going to cover first a
- 1:03quick refresher of Claude manage agents.
- 1:06I want to talk you through a little bit
- 1:07about how this harness works under the
- 1:08hood and what makes it so special. Our
- 1:11team put a lot of thought into the
- 1:12architectural design of Claude manage
- 1:14agents to make sure that it runs ready
- 1:16and reliably for production-ready
- 1:18agents. So, I want to talk you through a
- 1:19little bit of how that works so that
- 1:21then when we transition to the second
- 1:23portion here, which is the hands-on
- 1:25workshop, you'll actually understand
- 1:27what each of the primitives you're
- 1:28building actually mean for your agents
- 1:30under the hood.
- 1:32So, for the majority of today's session,
- 1:33I want you all to actually have your
- 1:35laptops open, building alongside me,
- 1:37actually working inside of a repository,
- 1:39and getting you ready to actually spin
- 1:41up a working incident response agent.
- 1:44Lastly, we'll talk a little bit about
- 1:45beyond the basics. Today's session is
- 1:47the first session of a couple of other
- 1:49ones that will build on top of this on
- 1:50Claude manage agents.
- 1:52Specifically, right after this one, I
- 1:53think there's another session on
- 1:54dreaming, which is one of my favorite
- 1:56new features with Claude manage agents
- 1:58for self-improving agents and memory
- 2:00built into the harness. So, encourage
- 2:02everyone to dive in a little bit deeper
- 2:04into what else is in the box after we
- 2:06set you all up for success today with a
- 2:08quick introduction.
- 2:10So, let's first touch a little bit about
- 2:11how we got here with Claude manage
- 2:13agents.
- 2:14When we first released the very first
- 2:16Claude back in 2023, we released a
- 2:19messages API alongside access to Claude.
- 2:22This provided raw model access to all
- 2:24Claude models. This became the very
- 2:27first way that people could
- 2:28programmatically build on top of Claude
- 2:30and essentially gave a way for people to
- 2:32access tokens in and tokens out via our
- 2:35Claude models.
- 2:36This also meant that for everyone
- 2:38building on top of Claude models, they
- 2:40had to implement all the various
- 2:41primitives themselves. Things like
- 2:43context management, the actual agent
- 2:45loop, compaction, etc. All the
- 2:47primitives that come alongside making
- 2:49the agent work.
- 2:50When models were less intelligent back
- 2:52in the early days of let's say 2023,
- 2:55some of these primitives were much
- 2:56simpler because agents could simply do
- 2:57less. But, as we evolved into now with
- 3:00higher model intelligence and as agents
- 3:02are able to take on more complex tasks
- 3:04and actually take actions within
- 3:06environments and come to actually do
- 3:08entire tasks for humans,
- 3:10the primitives that come alongside
- 3:12context management and managing an
- 3:14agent's ability to execute API calls and
- 3:16tool calls becomes much more complex.
- 3:19So, that's when we moved to the agent
- 3:20SDK, which became a harness that allows
- 3:23you to programmatically call Claude
- 3:25code, one of our agents at Anthropic.
- 3:28So, Claude code is something that an
- 3:30agent has access to a computer and takes
- 3:32actions within file system. So, the
- 3:34agent SDK became a way for you to make
- 3:36Claude much more powerful by leveraging
- 3:38the power of Claude code within a
- 3:40harness.
- 3:41The main thing here though is that with
- 3:43the agent SDK,
- 3:45developers still had to manage hosting
- 3:46and scaling on their own and making sure
- 3:49that the agent SDK would be safe to run
- 3:50within their containers.
- 3:53That's only then evolved into Claude
- 3:54managed agents, which is the first
- 3:57harness to be able to handle scaling and
- 3:59production ready components for you by
- 4:01Anthropic,
- 4:02providing things like a purpose-built
- 4:04harness, sandboxing, observability, tool
- 4:06runtime, all within a managed
- 4:08infrastructure system. This means that
- 4:10developers can focus on task and agent
- 4:12configuration, custom tool logic, the
- 4:15things that actually matter for bringing
- 4:17domain expertise and customizability to
- 4:19your agents, where you're handing off
- 4:21the rest of all the primitives and core
- 4:24compute and primitives of essentially
- 4:26managing the basics of agent running to
- 4:28Anthropic.
- 4:30So, that brings me to managed agents as
- 4:33the fastest way to build production
- 4:35ready agents on Claude.
- 4:36We've seen people build 10 to 15 times
- 4:38faster to production with Claude managed
- 4:40agents by leveraging our purpose-built
- 4:43harness.
- 4:44Part of the reason why we built Claude
- 4:45managed agents is because is because
- 4:47harnesses should evolve alongside your
- 4:49agents.
- 4:50For example, back when we were building
- 4:52ourselves on top of models like Sonnet
- 4:544.5, we noticed that Sonnet 4.5 emitted
- 4:57a particular behavior called context
- 4:59anxiety. This meant that with Sonnet
- 5:014.5, Claude started wrapping up tasks
- 5:03early even when it still had room to
- 5:05spare in its context window.
- 5:07To manage that in our harness, we then
- 5:09added some mitigations to combat against
- 5:12this early stopping behavior.
- 5:14But, when Opus 4.5 then came out, we
- 5:16actually saw this behavior go away,
- 5:18making all that work we had done inside
- 5:20of the harness essentially obsolete
- 5:21because Claude had evolved beyond that
- 5:23behavior that we had built into the
- 5:25harness to manage.
- 5:26So, the takeaway there is that it's a
- 5:28lot of work to maintain harnesses and
- 5:30make sure that they actually evolve
- 5:31alongside your agents, which is why with
- 5:33Claude managed agents, we want to make
- 5:35it really easy for Claude and Anthropic
- 5:37to handle all the complexities that come
- 5:39with compaction, caching, things like
- 5:41context anxiety, all these various
- 5:44primitives that come with actually
- 5:45making agent production ready and
- 5:46getting the most out of Claude. So
- 5:48again, you can focus on the tasks,
- 5:50tools, and things that actually matter
- 5:51for building agents on Claude.
- 5:55So three primary resources go into
- 5:57building on Claude managed agents.
- 6:00First is the agent's endpoint, which is
- 6:02the persona and capabilities. This is
- 6:04the core system prompt that powers your
- 6:06agent. Essentially here, you're defining
- 6:08the model, the MCP servers, the skills,
- 6:11the various components that your agent
- 6:12can actually leverage when it's able to
- 6:14run in that agent loop.
- 6:16The next is the environments.
- 6:18You can think of this as the hands of
- 6:20the agent, where the previous one is the
- 6:22brain of the agent where the agent is
- 6:23thinking through what to execute, and
- 6:25then it's using an environment to
- 6:27actually have a space and a container to
- 6:29actually take action on your behalf.
- 6:32Sessions are next the way to tie
- 6:34together agents and environments.
- 6:36A single session has a spun up on an
- 6:39agent instance within an environment. So
- 6:41you can connect the two together and
- 6:43actually stream events back to your user
- 6:45and start to take action on behalf of
- 6:47your humans as part of a Claude powered
- 6:49agent.
- 6:51A key thing here, as I alluded to
- 6:53briefly before, Claude managed agent has
- 6:56the agent loop run server side.
- 6:58This means that a lot of the
- 6:59complexities that come with managing
- 7:01hosting and scaling are abstracted away.
- 7:03And when you close your laptop or you
- 7:05hit hard refresh on your agent that
- 7:07you're building on Claude managed
- 7:08agents, everything is maintained and you
- 7:10don't have to worry about durability,
- 7:12reliability, all these various aspects
- 7:14that usually come to bite you when
- 7:16you're trying to turn your agent from a
- 7:17prototype into production.
- 7:22And lastly here, before we dive into the
- 7:24hands-on portion, is I want to talk you
- 7:26through a key design decision that went
- 7:28into Claude managed agents.
- 7:32Previously, with a lot of agent
- 7:33harnesses, we saw the agent loop coupled
- 7:35tightly with tool execution.
- 7:38This design pattern made sense and still
- 7:39makes sense for some agents because you
- 7:41want to give the agent powerful
- 7:43abilities to actually take action within
- 7:45the environment. For instance, with
- 7:46Cloud Code, we want the agent to be able
- 7:48to access various files on your
- 7:50computer, take action within a file
- 7:51system, and therefore it makes sense for
- 7:53the agent to have access to all those
- 7:55tools spun up on every container.
- 7:58But, we also realized there are some
- 7:59constraints for this, especially with
- 8:01some agents where you essentially want
- 8:03to be able to decouple the hands from
- 8:06the brains of the agents.
- 8:08For instance,
- 8:09credentials and uh
- 8:11credentials and security became a huge
- 8:13concern.
- 8:14With the ability to have the agent
- 8:16access your file system, you can
- 8:18actually add very distinct sandboxing by
- 8:20decoupling these two components, where
- 8:22the agent is no longer able to access
- 8:24the actual credentials without
- 8:25encryption by decoupling the hands from
- 8:27the sandbox of the agent.
- 8:30The other aspect here is actually you
- 8:32can see huge benefits by doing these
- 8:34decoupling on things like time to first
- 8:36token and latency.
- 8:38Previously, with the agent loop into
- 8:40execution in the same box, you had to
- 8:42spin up containers for every single
- 8:43session that you're spinning up in the
- 8:44agent, which contributed to additional
- 8:47latency from a time to first time to
- 8:48first token perspective.
- 8:50But, with this now decoupled, our teams
- 8:52actually saw reductions in time to first
- 8:53token along the lines of over 90%
- 8:57reduction in TTFT for our P95 metrics on
- 9:01latency.
- 9:02So, here you can start to see the power
- 9:03of this design decision coming through
- 9:05from the perspective of safety,
- 9:07reliability, latency, and everything
- 9:10else that you care about when it comes
- 9:11to building production-ready agents.
- 9:15All right, so now it's time for the
- 9:17exciting part of today's session, which
- 9:19is where I want you all to open up your
- 9:20laptops and go to this URL here to
- 9:23actually clone a repository, and let's
- 9:26start to actually feel the magic of
- 9:27everything that I just talked through.
- 9:29So, I'm going to give everyone a second
- 9:31to just go over to that URL there
- 9:33and just spin up the repository that we
- 9:35have ready for you.
- 9:37All right, so here are some additional
- 9:39commands that I want you all to run to
- 9:40make sure this is all set up on your
- 9:42computers.
- 9:43So, the first step many of you might
- 9:44have done already, but just take that
- 9:46repository, hit the URL, get clone it,
- 9:50and then I want you to CD into the
- 9:52specific repository for the session,
- 9:54which is ship your first manage agent.
- 9:56And then, if you're on Mac, you'll see
- 9:57those two commands on the side, the
- 9:59Python and the source. Um, there's a
- 10:01command there for Windows as well.
- 10:03And you'll just do the rest there where
- 10:04you want to install the requirements,
- 10:06copy over the environment key into your
- 10:08.env file. Um, here you'll put in the
- 10:10Anthropic API key that hopefully all of
- 10:12you also received from the QR code for
- 10:14free credits earlier. And lastly, we'll
- 10:16just run the app.
- 10:17All right, let's go ahead and dive in,
- 10:19but as I mentioned before, let me just
- 10:21show everyone where these instructions
- 10:23are. If you go into the repository in
- 10:25the link and then go to ship your first
- 10:27manage agents, you scroll down on the
- 10:28read me, you'll see all the setup
- 10:30instructions here. So, feel free to do
- 10:32this, um, as we go along or even in your
- 10:34own time later today and continue
- 10:36playing around with it, but as I
- 10:37mentioned before, everything will be
- 10:39also shown on the screen to follow along
- 10:41with. So, do not worry if you did not
- 10:42have time to fully get it set up on your
- 10:44laptop.
- 10:46Without further ado, let's go ahead and
- 10:47dive in. So, once you run streamlit run
- 10:50app.py, you should be able to see a URL
- 10:53that looks like this and a page that
- 10:54looks like this.
- 10:56What we're doing here is we're going to
- 10:58be simulating an agent, um, interaction
- 11:00here where we have an incident that's
- 11:02going to come up. A lot of you who might
- 11:04be software engineers in the room will
- 11:06be intimately familiar with the pain
- 11:08that comes alongside incident response.
- 11:10If you are software engineer, you might
- 11:12be woken up at, let's say, 3:00 a.m. in
- 11:14the morning, 2:00 a.m. in the morning
- 11:15when you're out around on on vacation as
- 11:17you're on call, and this is usually a
- 11:19very painful portion of a software
- 11:21engineer's life, uh, because when you're
- 11:23on call, it means that if a server goes
- 11:24down or a service goes down, you have to
- 11:26be immediately the one there to respond
- 11:28and tackle the incident. Usually for a
- 11:30human, this means diving into metrics
- 11:32and logs and deployments. You can
- 11:35actually investigate what's going on.
- 11:37And so, what we're going to do is we're
- 11:39going to now have an agent run on Claude
- 11:41manage agents to do all this for us. So,
- 11:43that when we get woken up by 3:00 a.m.,
- 11:46we can hand it off to an agent, or maybe
- 11:47we don't even get woken up at all if
- 11:48Claude is able to do everything for us.
- 11:51Okay. So, let's now go ahead and dive
- 11:53into the code here.
- 11:55What we're going to open up here is we
- 11:57have the agent.py file on the left and
- 12:00the agent complete on the right. If you
- 12:02want to challenge yourself, you can of
- 12:03course try to implement everything
- 12:05yourself here or with Claude. Um but,
- 12:07what we're going to do just for
- 12:07simplicity's sake is just copy over
- 12:09various elements from the completed file
- 12:11onto the incomplete file one by one. So,
- 12:14you can see how these primitives compose
- 12:15our agent one piece at a time.
- 12:18So, let's go ahead and start off with
- 12:20this very first part, which is the
- 12:21agent.
- 12:23We mentioned before that the agent is
- 12:24the one that defines the persona and the
- 12:26capabilities of the agent here. So,
- 12:28that's model, the system prompts, and
- 12:30the tools in our case for our agent
- 12:33here.
- 12:34So, let me go ahead and copy over what
- 12:37we see there on the screen. And you can
- 12:39see here that we're defining the SRE
- 12:41agent. We're going to use Claude Opus
- 12:444.7 here. And I've preconfigured a
- 12:47system prompt and tools for the agent.
- 12:50We can actually take a quick look into
- 12:51what that system prompt and tool looks
- 12:53like here.
- 12:54For the system prompt, you can see that
- 12:55it's actually extremely simple for the
- 12:57agent that we're defining today. You can
- 12:59of course add more complexity and
- 13:00constraints here, but we actually see a
- 13:02very simple prompt working for our agent
- 13:04that we're building today. We're just
- 13:06telling it that it's an SRE agent. It's
- 13:08responsible for coming in and debugging
- 13:09incidents, and it has access to various
- 13:12tools like metrics, recent deployments,
- 13:14get diff. These are tools that you would
- 13:16want as a developer if you're actually
- 13:18managing an incident response as well,
- 13:20like the ability to actually fetch logs
- 13:22so you can see exactly what's going
- 13:23wrong.
- 13:24So, we're going to give those same tools
- 13:25and the same instructions over to our
- 13:27agent.
- 13:29So now that we've configured this on the
- 13:30screen and feel free for those of you
- 13:32who are able to spin it up on your own
- 13:33laptops to just follow along with
- 13:35exactly what I'm doing, which is copying
- 13:37over this portion from the right onto
- 13:39the left here.
- 13:42And then when we flip back over to the
- 13:43screen, what we'll see is this wasn't
- 13:45there until I just added that there, but
- 13:47we can now actually have a unique
- 13:49identifier attached to the agent that
- 13:51we're building.
- 13:54Okay, so that's step one. Now let's go
- 13:56ahead and move on to step two,
- 13:59which is the environment where the agent
- 14:01is going to actually do work in.
- 14:04All of you here were very lucky for
- 14:05those of you who were able to come
- 14:06yesterday as well to code with Cloud
- 14:08London. We actually just released
- 14:10yesterday the ability to bring your own
- 14:12containers and your own compute to Cloud
- 14:13Managed Agents, which means that you can
- 14:15actually execute the agent for the tools
- 14:17and the actual ability for the agent's
- 14:19actions to work within your own
- 14:20infrastructure and not just Entropic's
- 14:22managed infrastructure. So that's an
- 14:24exciting update that just came to Code
- 14:26with Cloud London. Um before today's
- 14:28purposes, you can actually see if we
- 14:29copy over this environment configuration
- 14:32here.
- 14:33We're defining our SRE agent to work
- 14:35within the Entropic cloud and here we're
- 14:38just giving it unrestricted access from
- 14:40a networking perspective.
- 14:41We've made Cloud Managed Agents very
- 14:43composable and very customizable. So
- 14:46this networking list here is actually an
- 14:48allowed list. If you want your agent to
- 14:50only be able to access specific sites
- 14:52and URLs, you can restrict this down as
- 14:54much as you would like.
- 14:55We also released um Cloud MCP tunnels,
- 14:59which actually also gives you the
- 15:00ability to run MCP servers within a
- 15:02private environment instead of on the
- 15:04public network as well. So again, just
- 15:06offering various components to help you
- 15:08make sure that your agents are as
- 15:10production ready and as secure as
- 15:11possible.
- 15:13So now that we've defined this
- 15:14environment here, let's flip back over
- 15:16and we just saw that environment piece
- 15:18come into our agent as well. So here we
- 15:21have unique identifier for an agent and
- 15:22an environment.
- 15:24And that will next help us as we go
- 15:26along with setting up the rest of our
- 15:28agents as we start to get into session
- 15:29definitions here.
- 15:33The next thing that we have to do is
- 15:34actually give our agent the ability to
- 15:37look at logs.
- 15:39With Cloud Code, that is one of the
- 15:41first times where we realized the power
- 15:42of giving the agent access to files and
- 15:44a file system. Here with Cloud Managed
- 15:47Agents, we're leveraging essentially the
- 15:48files API by uploading the metrics and
- 15:50logs to the agent. So the agent can
- 15:52start to run code and process through
- 15:53those files.
- 15:55So here we've attached the log here as a
- 15:58file for our agent. So we just also saw
- 16:00that populate and come through. Again
- 16:02here, the key takeaway is as much data
- 16:05as you're able to give the agent um as
- 16:07possible is what makes it so powerful.
- 16:09Context engineering is a huge portion
- 16:11that comes to actually making an agent
- 16:13powerful. And this is where we see the
- 16:14developers spending the majority of
- 16:16their time working on top of primitives
- 16:18like Cloud Managed Agents is managing
- 16:20context and managing what types of files
- 16:22are uploaded, how the agent processes
- 16:24those files. These are components that
- 16:26you compose yourself and are very
- 16:27customizable on top of Cloud Managed
- 16:29Agents to make it work as far and as
- 16:31wide as you want it to.
- 16:33Okay. So now let's go ahead and start to
- 16:35define the session that we have here.
- 16:38The session is going to oops, the
- 16:40session is going to bind the agent and
- 16:42the environment and also mount the log
- 16:45here. So you can see we're passing in
- 16:46the agent ID, the environment ID, and
- 16:49the resources that we're giving to the
- 16:51agent.
- 16:52And this is going to give it the ability
- 16:54to start to actually act and interact
- 16:56with me as a user.
- 16:59Let's go ahead and just complete the
- 17:01rest of this here so that we can
- 17:02actually start to run our agent.
- 17:05What we want to do is now also give the
- 17:07ability for the agent to come in and
- 17:09stream responses to me as we go along.
- 17:15There we go.
- 17:19Okay, and the key portion here is that
- 17:22when our Cloud Managed Agents runs
- 17:24within a single session, instead of
- 17:25responding in tokens in and tokens out,
- 17:27it actually works in units of events.
- 17:30Events here are things like user
- 17:31messages or agent tool calls, agent
- 17:33responses, so that every event can be
- 17:35logged from an observability
- 17:37perspective, as well as streamed back to
- 17:38the user for the user to see the agent
- 17:40responding as it calls tools and as it
- 17:42starts to populate responses. This is
- 17:44crucial for both a user experience
- 17:46perspective, so user starts to see
- 17:48things as they come through and not just
- 17:50when Claude finishes an entire task, and
- 17:52also from an observability perspective,
- 17:55and Claude Managed Agents actually has a
- 17:56very neat console built in for looking
- 17:59at everything the agent is doing, and a
- 18:00lot of observability features built into
- 18:02Claude Managed Agents.
- 18:05Okay, the last step here of just being
- 18:07able to put our agent together, you can
- 18:09start to see that our agent is actually
- 18:11starting to come together. We can start
- 18:13to create sessions and we can start to
- 18:15do things. Um, what we're actually going
- 18:17to see here though is that if I send
- 18:19something like hi to the agent, it can
- 18:21respond, um, but it doesn't actually
- 18:23have the ability to be able to call the
- 18:24various tools that we want it to yet,
- 18:26because we haven't connected that
- 18:28locally to what we want the agent to do
- 18:30when it calls tools like get metrics.
- 18:33So, the agent is ready. The agent is
- 18:34actually defined on the server side
- 18:35already. The missing piece here is just
- 18:38to finally give it our local tools
- 18:40so the agent can start to take action
- 18:42here on my computer or my
- 18:43infrastructure.
- 18:47Okay, so now that we have that copied
- 18:49over, the agent is going to be able to
- 18:50start to call get metrics, get recent
- 18:53deploys, get diffs, so it can truly
- 18:55start to take action in terms of helping
- 18:57us debug this incident.
- 19:00The last thing I'm going to do here is
- 19:01also just to make sure I give my agent
- 19:03the ability to delete sessions.
- 19:08So, that's when I come in, I can start
- 19:10to hit this delete button and delete
- 19:12sessions as I compose my agent. And this
- 19:15is also crucial from a security
- 19:17perspective. If you want to make sure
- 19:19that, you know, nothing is being
- 19:21retained for sessions that you don't
- 19:23want on the cloud or on your
- 19:24infrastructure, you can actually just
- 19:26come in and proactively manage how
- 19:28sessions are deleted. And once they're
- 19:30deleted, they will be also removed from
- 19:31every single log aspect here, so that
- 19:34you can truly make sure that whatever
- 19:36data you want managed is managed
- 19:37actively and proactively via Cloud
- 19:40Manager agents.
- 19:42Okay.
- 19:43So, with that all set up, let's go ahead
- 19:45and give our agent a test run here.
- 19:49I'm going to click the new session here,
- 19:51and I'm going to just go ahead and ask
- 19:53the agent to debug my incident for me.
- 20:03You can see here that because we gave
- 20:05the agent access to tools like
- 20:07sandboxing and bash, and get recent
- 20:10deploys,
- 20:11the agent is starting to really take
- 20:13powerful actions on my behalf here. It's
- 20:15come in, it's run the sandbox command.
- 20:17We can open this up and see what this
- 20:19looks like.
- 20:20Um we can see that it's actually coming
- 20:21in and looking at what the logs were
- 20:23added to.
- 20:25It's then come in and called this tool
- 20:27called get recent deploys,
- 20:29which is coming in and returning results
- 20:31like what the recent deployments look
- 20:32like, the metrics. We can see this from
- 20:35a user perspective if you click on the
- 20:37tabs here, but this is essentially the
- 20:39data that's actually being passed into
- 20:41the agent via these local tools that we
- 20:43define.
- 20:46And again, we can start to see the magic
- 20:47of that streaming that we implemented
- 20:49come through as well, because we saw
- 20:51these tools come in as they were being
- 20:53called from the agent. We saw the user
- 20:55prompt come in as soon as I prompted it
- 20:57to the agent, and the agent is actually
- 20:59streaming responses to me as it comes
- 21:01through with more token response and
- 21:03outputs, as well as as it calls more
- 21:05tool as it goes along as well.
- 21:11Okay, so what we're going to start to
- 21:12see is the agent being able to help us
- 21:14actually debug what's going on here,
- 21:16which we can see here that the incident
- 21:17is that there's something going wrong
- 21:19with our P99 latency that seems to be 10
- 21:22times above the baseline.
- 21:24The agent is coming in and debugging
- 21:25everything for us. Looks like it's
- 21:27taking another second there.
- 21:29So some of the major design decisions
- 21:31that come in here when you're designing
- 21:32a real site reliability site incident
- 21:35response agent for your systems is to
- 21:38think deeply about the various
- 21:39components that go in and the various
- 21:41MCP servers and skills that you want to
- 21:43give your agent. Here we've defined, of
- 21:45course, a very, very simple agent, but
- 21:47for lots of the SRE agents that we
- 21:49build, we actually also think about
- 21:50things like how can we give the agent a
- 21:52skill to actually execute and run
- 21:54runbooks.
- 21:55Runbooks are things where as teams debug
- 21:58incidents, they note down and document
- 22:00how they debug that incident so that
- 22:01they can do it again for a future
- 22:03session or future incident. You want to
- 22:05give the agent the same access to the
- 22:07materials that you would have as a human
- 22:09developer. So something like a runbook
- 22:11skill where the agent is actually able
- 22:12to look at example runbooks or fetch
- 22:15other postmortems from other incident
- 22:17responses. That is something that is
- 22:19very powerful for the agent to be able
- 22:21to understand how to work within your
- 22:23systems and debug incidents
- 22:25successfully.
- 22:29Okay, let's go ahead and take a look at
- 22:31the agent here.
- 22:34Let's see.
- 22:38I'm going to go ahead and just start a
- 22:39new session here to make sure everything
- 22:41is working well.
- 22:44All right, let's say debug
- 22:46my incident for me.
- 22:49Okay, hopefully this one works.
- 22:51Is anyone able to get it working on
- 22:52their laptops better than I have on the
- 22:54screen? Okay, we got some success in the
- 22:55room, so hopefully this will work as it
- 22:57goes along.
- 23:08>> Okay, looks like we are streaming. We're
- 23:09getting everything in.
- 23:12Let the agent go.
- 23:14Okay, agent is checking logs, debugging
- 23:16everything.
- 23:19So, if we just also look through some of
- 23:20the data here as the agent is working,
- 23:23the data that's actually being passed in
- 23:25for our agent here is all local just for
- 23:28our sake of our purposes for our demo
- 23:29now workshop that we're running today.
- 23:31But, with the ability for you to run
- 23:33your agents within a container and
- 23:35infrastructure, you can start to see how
- 23:37things like your get metrics tool that
- 23:38are currently pulling from JSON can be
- 23:40easily moved to something like DataDog
- 23:42or other production systems for your
- 23:44infrastructure from that perspective.
- 23:46So, everything that you see here that is
- 23:48currently local can be something that's
- 23:49easily movable into infrastructure as
- 23:51well via Cloud Manager agents.
- 24:04Okay. Let's all cross our fingers and
- 24:06see if this one works.
- 24:17Oh, there we go. Success.
- 24:19Okay, so the agent has come in. You can
- 24:21see here that if we scroll through all
- 24:23the tool calls, everything is persisted
- 24:25in the cloud from a logs perspective.
- 24:27All of this will also be logged in the
- 24:28observability console.
- 24:30And then the agent has come back to us
- 24:32with the incident response here. It says
- 24:34that this seems to be caused by a
- 24:36database pool exhaustion. Seems like a
- 24:39commit that someone added here from
- 24:41Alice to refactor the order summary
- 24:44builder introduced a query that then
- 24:47caused the pool resources to be
- 24:49exhausted. So, it's looking at and
- 24:50giving us the exact everything that went
- 24:52wrong from all the metrics they were
- 24:54able to call. It ruled out various other
- 24:56causes, and then it's also giving us
- 24:58recommended actions to take.
- 25:00Another key component here in a lot of
- 25:01other incident response management
- 25:03agents that we built is actually giving
- 25:05the agent to actually go ahead and fix
- 25:07everything that it's been able to find.
- 25:10By giving the agent then access to
- 25:11something like Cloud Code for instance,
- 25:13you can actually imagine this agent can
- 25:14then go into your code base, suggest
- 25:16fixes, put up a PR, and essentially do
- 25:19everything that it needs to do to help
- 25:21you go from initial incident all the way
- 25:23to fixing the root cause. So again here
- 25:26for demo purposes, we're stopping at
- 25:27just the agent giving us the recommended
- 25:29actions, but I want you all to imagine
- 25:31the possibilities of where this can go
- 25:33if we give our agent more tools, more
- 25:35ability to take actions, access to your
- 25:37code base, ability to put up PRs,
- 25:39ability to fix incidents, so that you as
- 25:42a human developer can just become the
- 25:43oversight and watch over the agents as
- 25:46they take action, and you no longer have
- 25:47to go through and do manual steps like
- 25:50actually following the agent's
- 25:51instructions here to fix the root cause
- 25:53of the incident.
- 25:55So another key component of what we've
- 25:57built here on Cloud Manage Agents is
- 25:59session persistence. So when I come in
- 26:02and hit hard refresh on the screen,
- 26:04we're seeing that the agent is listing
- 26:05the sessions and everything is retained
- 26:08from all the sessions that we just ran.
- 26:11We also have the previous sessions that
- 26:12we ran all retained in the cloud. Looks
- 26:14like this one actually came back to us
- 26:15as well.
- 26:17Um and the previous sessions where we
- 26:18just said hi, everything is retained in
- 26:20the cloud, and we didn't have to deal
- 26:21with things like database and deployment
- 26:23of our agent and moving it from our
- 26:25laptops to production. Everything is
- 26:27already maintained server side.
- 26:30We can also see the ability to delete
- 26:31sessions come in. So I've run that
- 26:33delete, and now we have that um running
- 26:36the session here. Now we have that
- 26:38removed from our list here.
- 26:41Another thing that I want you to take a
- 26:42note of, which we'll talk through a
- 26:43little bit in just a second, is the
- 26:45states of the session. Here we can see
- 26:47that the sessions are now idle. Just now
- 26:49as they they running, they were in a
- 26:50running state.
- 26:52We have the sessions managed by state
- 26:54here as part of that same durability and
- 26:56maintenance and reliability of the
- 26:58session. So, when I come in and ask the
- 27:00agent something else like, "Who are
- 27:02you?" I was able to easily resume the
- 27:05session and execute as it goes along
- 27:07within that same session window. So,
- 27:09state management here is really
- 27:10important to how manage agents works
- 27:12under the hood.
- 27:15All right.
- 27:18So, now as if we just take a quick step
- 27:20back and look through everything we were
- 27:22able to accomplish. We started with an
- 27:24empty agent here just built on a couple
- 27:26of primitives on Cloud Managed Agents.
- 27:28We then went and defined the agent
- 27:30definition, the persona, the
- 27:31capabilities. We gave the agent an
- 27:33environment. We gave the agent data and
- 27:36context to operate over.
- 27:38We then gave the agent sessions
- 27:40combining the agent definitions to an
- 27:42environment so the agent can think
- 27:44through which tools to call from an
- 27:46agent loop perspective. And then it can
- 27:48actually call those tools and take
- 27:49action on our behalf.
- 27:51We then came in and streamed the
- 27:52responses to the user into our logs,
- 27:54implemented some local tools as well as
- 27:56the ability to delete sessions. And
- 27:58within this Streamlit app here, we saw
- 28:01how that actually affected from a front
- 28:02end perspective how our agent was
- 28:04actually able to be presented to our
- 28:05users by adding all of these primitives
- 28:07together.
- 28:10So, now let's go ahead and move back
- 28:12over to the slides to do a quick recap
- 28:14and talk through some of the lessons of
- 28:15what we learned about how Cloud Managed
- 28:17Agents works under the hood. But
- 28:19hopefully for all of you who were able
- 28:20to actually build on your laptops, you
- 28:22all were able to just build a site
- 28:24reliability agent. So, congrats to you
- 28:25all.
- 28:27But let's go ahead and dive in a little
- 28:29bit here into understanding what
- 28:30actually happened when we put all those
- 28:32pieces together.
- 28:34The first thing we saw is that we saw
- 28:36session speak in events and not
- 28:37responses in and tokens in tokens out
- 28:40from a request response perspective like
- 28:42we see typical with things like message
- 28:43API or other APIs that we see.
- 28:46With Cloud Managed Agents, instead of
- 28:48just having a request response, we
- 28:49actually have events appended to the
- 28:51logs.
- 28:52Again, this is a huge portion of why
- 28:54Cloud Managed Agents is so reliable and
- 28:56secure, because events are coming
- 28:58through and just added into an existing
- 29:00session logs, so that it's easy to then
- 29:02resume a session and kick back off where
- 29:04you left off, and it's easy to then come
- 29:06in and look at everything from a log
- 29:08perspective. This is also really
- 29:09important from a reliability perspective
- 29:11when we separate the hands from the
- 29:13brain of the agent. If a container goes
- 29:15down, we can just spin that container
- 29:17back up again, and we don't have to
- 29:18restart the entire agent loop alongside
- 29:21that container.
- 29:24The next thing here is that we saw the
- 29:26ability to implement local tools.
- 29:29And we implemented in our workshop these
- 29:31local tools defined in JSON and loading
- 29:33them in via our local files here. We
- 29:36were then actually able to see how with
- 29:38our Cloud Managed Agents Harness, the
- 29:40execution of the agent is completely
- 29:42separate from the agent loop.
- 29:44We defined everything that executed
- 29:46locally on our laptops and our scripts,
- 29:48um and our agent loop ran on the cloud
- 29:50inside of Anthropic's managed
- 29:51infrastructure.
- 29:53Again here, especially with what we just
- 29:55released with bring your own compute and
- 29:57bring your own sandboxing here, you can
- 29:59swap out where you want that agent to
- 30:01execute its tools in your own
- 30:02infrastructure or on Anthropic managed
- 30:04infrastructure, but within your own
- 30:06environments and your own containers as
- 30:08well as you spin them up. Moving from
- 30:10things like loading our tools in from
- 30:12JSON into anywhere you want to have your
- 30:15tools run, like a Data Dog client using
- 30:17the same wire protocol, making it very
- 30:20easy to then go from initially building
- 30:22the agent for Cloud Managed Agents to
- 30:24then actually producing it and deploying
- 30:26it on production-ready infrastructure.
- 30:31Next thing we saw here as we thought
- 30:33about how our sessions are being
- 30:34streamed into our users and what we see
- 30:37from a front end perspective
- 30:39is that we saw when our events were
- 30:41being able to be streamed to our users,
- 30:43these were in the forms of actually
- 30:44things we care about as a user. We saw
- 30:46events come in and we saw the agent's
- 30:48ability to actually log everything to
- 30:51its observability console.
- 30:53And another key thing here is that as we
- 30:55think about how sessions are controlled
- 30:56in Cloud Managed Agents, you can
- 30:58actually think about the state as being
- 30:59something very powerful when you can
- 31:01start to take action on behalf of
- 31:03events.
- 31:05What that means is that we saw a couple
- 31:07of key states for sessions in CMA or
- 31:09Cloud Managed Agents.
- 31:11We went from idle to running,
- 31:12rescheduling if the agent needs to retry
- 31:14anything, or terminated if any of the
- 31:16sessions fail.
- 31:18And so the agent is able to restart from
- 31:20a reliability perspective, a
- 31:21resumability perspective, but also it
- 31:23can actually do some very powerful
- 31:25things.
- 31:26For instance, you can actually have a
- 31:27webhook run, and when an event happens
- 31:30from a webhook, the agent receives that
- 31:32webhook in and can then do something
- 31:34like resume a session or kickstart a
- 31:35specific state based on external events.
- 31:39So again, this powerful form of having
- 31:41events and sessions be the core concepts
- 31:43of how Cloud Managed Agents runs means
- 31:45that you can make it very, very easy to
- 31:47compose your agent however you want it
- 31:49to, and have the agent listen for things
- 31:51that happen both internally and
- 31:52externally via webhooks to take actions
- 31:55or resume your agent as you desire.
- 31:59And lastly here, something that we saw
- 32:01come through through the agent that we
- 32:02all built for the site reliability
- 32:04agent, is that everything lives in the
- 32:06cloud from the agent loops perspective.
- 32:09The conversation is persisted. When we
- 32:11hard refresh the page, we saw that those
- 32:13same sessions were maintained. And we
- 32:15saw that if we were able to, let's say,
- 32:17exit out of the agent and come back, we
- 32:19didn't have to manage anything from a
- 32:21database perspective or wire up where
- 32:23the agent is stored. We were just able
- 32:25to have all of that persisted in the
- 32:27cloud, again making it very, very easy
- 32:29to go to production-ready agents.
- 32:35And lastly here, I just want to talk you
- 32:36through we just built the very basic
- 32:38form of Claude managed agents. We saw
- 32:40what was possible with just the very,
- 32:42very simple primitives that we all built
- 32:44with, the basic level of what you can do
- 32:46with Claude managed agents. And already
- 32:48there we were able to have something
- 32:49that would usually take us a lot of time
- 32:51to spin up from a production
- 32:52perspective. All of compaction, caching,
- 32:55tool calling, all of that was handled
- 32:57for us there's via Claude managed
- 32:59agents.
- 33:00And even if we wanted to go beyond that
- 33:02to make our agent much, much more
- 33:03powerful,
- 33:04we can do things like add in skills, add
- 33:06in subagents, add in memory, add in
- 33:09outcomes. These are all core components
- 33:11that we offer to developers out of the
- 33:13box from Claude managed agents.
- 33:16I'll just briefly talk you through a
- 33:17couple of the key components, but want
- 33:18to encourage everyone to check out our
- 33:20documentation, what's publicly available
- 33:22on Claude managed agents, attend the
- 33:24session after this one on dreaming to
- 33:26dive in deeper onto these topics.
- 33:29Subagents or multi-agents is a way for
- 33:31you to have an orchestrator agent spin
- 33:33up context with other agents so that you
- 33:35can manage it from a context engineering
- 33:37perspective where subagents can then
- 33:39handle tasks and have their own context
- 33:41windows and contribute back to the main
- 33:42agent making it much more powerful from
- 33:44a parallelization perspective as well as
- 33:47the ability for context management.
- 33:49Memory is something that's always very
- 33:50important as we're building agents. I
- 33:52hear a lot of questions about how you
- 33:54can build self-improving agents or
- 33:55agents that learn from user corrections,
- 33:57agents that start to remember user
- 33:59preferences. That's where we're offering
- 34:01memory and a dreaming service for Claude
- 34:03managed agents out of box.
- 34:05What dreaming means for managed agents
- 34:07is that Claude can actually come in and
- 34:08also look through its own memory logs
- 34:11and determine what to keep and determine
- 34:13how it can actually start to memorize
- 34:15and manage context for its own memory.
- 34:17So, it can actually be able to really
- 34:18accurately remember which parts of your
- 34:20user preferences matter and which part
- 34:22of user corrections you want to retain
- 34:24for future sessions you run on that same
- 34:26agent.
- 34:28Outcomes is another one of my favorites
- 34:29where for Claude managed agents, this
- 34:31means that you can actually define a
- 34:32rubric for your agent outcomes. So, you
- 34:35can start to think of your agent's tasks
- 34:36as something where you want the agent to
- 34:38reach a desired outcome instead of just
- 34:40executing calls and doing things on your
- 34:42behalf, but not associating that to a
- 34:44result that you want.
- 34:46So, with outcomes, you can define a
- 34:48rubric of exactly what you want the
- 34:49agent to produce, and it'll figure out
- 34:51along the way which tool calls and what
- 34:53it needs to do to execute towards that
- 34:55final result.
- 34:57Vaults is something also that I hear
- 34:59come up a lot as of interest for Cloud
- 35:01Managed Agents because managing user
- 35:03credentials is something that's very
- 35:04painful from an access management
- 35:06perspective, making sure that your
- 35:08agents are secure and safe to run.
- 35:10So, for vaults and Cloud Managed Agents,
- 35:11there's actually an encryption that
- 35:13happens between where the credentials
- 35:14are stored on a separate endpoint and
- 35:16what the agent is actually able to
- 35:18access. So, you can manage these
- 35:19credentials on a per user, per session
- 35:21basis, all very safely and securely. And
- 35:24this relies in large part during to that
- 35:26architecture that I described earlier of
- 35:28how the brains and the hands of the
- 35:29agent are separated, so that credentials
- 35:31can be stored very securely in these
- 35:33vaults. This means that you don't have
- 35:35to set up your own secret stores or your
- 35:37own credential stores, and you can just
- 35:39rely on the built-in capability here.
- 35:42There are a couple other things here
- 35:43that I won't have time to go through in
- 35:44depth. So, again, encourage everyone to
- 35:46check them out in more detail. There are
- 35:47things like the ability to do web hooks
- 35:49and really make this agent run on
- 35:51external events, things like detailed
- 35:53and fine-grained permission policies,
- 35:55the MCP servers that I mentioned where
- 35:57we just released new MCP uh server
- 36:00controls as well. And something that I
- 36:02also love just to briefly touch on is
- 36:04the console agent builder where we have
- 36:06built in a lot of capability and
- 36:07functionality into the default developer
- 36:09console, where you can start to see a
- 36:11beautiful observability dashboard come
- 36:13through and other ways for you to define
- 36:15Cloud Managed Agents right there on your
- 36:16consoles.
- 36:20So, just as a quick recap to end us off
- 36:22here of what we were able to accomplish
- 36:24today, hopefully everyone leaves here
- 36:26with a bit of a mental model about how
- 36:27manage agents actually works under the
- 36:29hood and be proud of yourselves for
- 36:31everyone that was able to come in and
- 36:33build on your laptops and actually ship
- 36:35a site reliability agent so you can all
- 36:37leave here being very happy with
- 36:39yourselves that you were able to come in
- 36:40and save future developers hours of time
- 36:42of being woken up at 3:00 a.m. or 2:00
- 36:44a.m. in the morning and being able to
- 36:45handle incidents for them.
- 36:47And next you also learned a little bit
- 36:49about where to go next for how you can
- 36:50really start to unlock the power that
- 36:52comes with manage agents and think about
- 36:53how your agents can become super powered
- 36:56with all of these additional
- 36:57functionalities.
- 36:59So that is where I'll end up today but
- 37:01thank you all so much for coming. I'll
- 37:03be around on the side.
- 37:04>> [music and applause]
About this transcript
This page contains the full transcript of Ship your first Managed Agent by Claude, generated from the public captions YouTube serves with the video. The transcript has 7,185 words across 1,107 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.
What you can do with it
Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to choose a caption track available on the video.
Free YouTube transcript tool
YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.