Introducing Managed Deep Agents | Interrupt 26

Ajouté : 2026-05-30

[00:00:07]Hi folks. I'm Sydney and I am an open source engineer at LangChain.

[00:00:12]Hi, I'm Victor. I'm a product manager.

[00:00:14]And today we're going to be walking through managed deep agents. But before we talk about that, Sydney's going to walk us through deep agents as a harness.

[00:00:24]So, first off, what is an agent?

[00:00:28]An agent is a simple model and tool calling loop. A model calling tools in a loop until it completes a task and returns a final result.

[00:00:39]What is a harness?

[00:00:41]We can define a harness as or we can define an agent as a model plus a harness.

[00:00:48]So, the harness is everything that connects the model to the real world.

[00:00:52]Everything around the model that helps it complete tasks.

[00:00:56]So, this is made up of skills, memory, the base system prompt, tools, sub agents, and any additional context.

[00:01:07]What's the job of a harness?

[00:01:10]So, the job of a harness is to get the model the right context at the right time for the given task.

[00:01:17]A model is only as powerful as the context that it's given. And so, the harness exists to bridge this gap.

[00:01:26]Why do you need a harness? Well, agents have a lot of jobs.

[00:01:30]Agents need to work in an environment where they can take actions.

[00:01:35]This action taking is what gives them agency. That's what makes agents useful.

[00:01:41]They need to connect to your data so that their actions are relevant for your use case.

[00:01:48]They need to manage growing context over long runs so that they can avoid context overflow.

[00:01:56]They need to be able to parallelize tasks to complete complex tasks efficiently.

[00:02:02]They need to connect with a human in the loop for sensitive workflows.

[00:02:07]And finally, ideally, they improve over time so that they remain relevant and useful.

[00:02:14]So, what is Deep Agents?

[00:02:17]Deep Agents is a customizable agent harness that's purpose-built for complex real-world tasks.

[00:02:26]First, I'm going to cover the four main capabilities that are part of the Deep Agents harness, and then we'll do kind of a deep dive into each one.

[00:02:35]So, first up, we have the execution environment. This is the backbone of a Deep Agent, and it all starts with the file system.

[00:02:45]Optionally, you can also augment this with a sandbox or, similarly, a code interpreter.

[00:02:53]Next, we have, I think, the most important capability, uh, which is context management. So, there are lots of utilities built into Deep Agents that help with this tall order.

[00:03:04]That includes skill support, out-of-the-box support for short- and long-term memory, summarization capabilities, context offloading, and prompt caching.

[00:03:18]The third capability is delegation.

[00:03:20]As agents run for longer amounts of time and take on complex workflows, they need to be able to plan and organize tasks, and then also use sub-agents to get delegate work.

[00:03:34]Finally, we build steering into the Deep Agents harness with first-class human-in-the-loop support.

[00:03:43]So, now for our deep dive.

[00:03:45]Starting with the execution environment, which I mentioned is the backbone of a Deep Agent, this capability powers all of the rest.

[00:03:53]So, we start with the file system.

[00:03:56]An agent uses a file system to read and write scratch files as it tackles work, load and store persistent memories in the hot path, invoke skills when relevant for a given task, and many more things.

[00:04:12]Agents are excellent at using file systems. They are trained in a an environment to use file systems, and also trained on lots of code.

[00:04:24]And that's why giving an agent a sandbox, or lighter weight cousin, the code interpreter, is very powerful.

[00:04:32]When you give an agent these code execution tools, you give it a secure environment to write and run code, which makes an agent capable of much, much more creative problem-solving, um and kind of dynamic run-time behavior.

[00:04:48]The second capability is context management.

[00:04:53]Deep Agent ships with built-in summarization and context offloading.

[00:04:58]You can see on the graph here, periodically, Deep Agent will evict large messages, so that can be human messages, tool results, tool calls, to the file system so that we don't build up context in the window too quickly.

[00:05:14]Additionally, summarization is triggered less frequently, but every so often when the history starts to approach the model's context limit.

[00:05:23]Both of these are in an effort to avoid context overflow, which is a problem that plagues long-running agents, or high-context agents, or both.

[00:05:32]Deep Agent also ships with built-in memory support.

[00:05:36]I would argue that memory is maybe the most important kind of context, because it's the context that changes from run to run, and allows your agent to improve over time.

[00:05:48]It also ships with provider agnostic prompt caching.

[00:05:52]This is incredibly important for long-running high context agents that need to operate cost-effectively.

[00:06:00]Finally, Deep Agent ships with skill support out of the box.

[00:06:05]Skills are part of the context management system um because of a system called progressive disclosure.

[00:06:11]So, Deep Agent loads some minimalistic information about what skills your agent has available up front into the system prompt. And then we give the agent the power to dynamically pull in full skill resources and invoke those skills in their scripts when relevant for a given task.

[00:06:29]All of this this umbrella of context management is again catering to that need for a harness to get the model the right context at the right time for the given task.

[00:06:43]The third capability of the Deep Agent harness is delegation.

[00:06:48]So, the Deep Agent harness is equipped with a planning tool that allows the model to organize work for challenging tasks.

[00:06:57]It's also equipped with sub agent support out of the box.

[00:07:01]Sub agents can be general purpose or specialized.

[00:07:05]So, for example, if you were building a coding agent, maybe you would want to attach some specialized sub agents for architecture design, for code review and security review, and then test writing and execution.

[00:07:20]Why are so Why are sub agents so important?

[00:07:24]Well, first, they operate with isolated context, and they actually help with overall context management.

[00:07:30]So, when you when the main agent invokes a sub agent, it starts with fresh context only relevant to its given task, and then it returns just a streamlined final result back to that main agent so that it doesn't pollute the main context window.

[00:07:46]Secondly, they can be used to parallelize work.

[00:07:49]So you your agent can run tasks end-to-end more efficiently with that parallelization.

[00:07:56]Finally, sub-agents can use any model and any provider.

[00:08:00]So you can match model capability with task complexity.

[00:08:06]The fourth and final capability of the Deep Agent harness is support for steering via first-class human-in-the-loop primitives.

[00:08:15]So human-in-the-loop is really critical for two things.

[00:08:19]The first is getting real-time user feedback on sensitive actions or tool calls as we mentioned before.

[00:08:26]And the second is getting real-time feedback when feedback is needed from the user to unblock the model.

[00:08:34]So what does this look like? There's four common decision patterns that we build into Deep Agents.

[00:08:40]The first is an approval flow. So maybe you're approving an email before it's sent.

[00:08:45]Second is an edit. So maybe editing a tweet before it's published. The third is a reject decision, rejecting a proposed financial transaction.

[00:08:54]And the fourth is the respond pattern.

[00:08:56]So that's when the agent interrupts and asks the user for a question to unblock its future progress.

[00:09:03]So we've done a deep dive into the capabilities of the Deep Agent harness.

[00:09:07]Now let's talk about why Deep Agents.

[00:09:11]Deep Agents is provider agnostic. You can use any provider and any model, swap it anytime, and even mix and match. Your main agent can use a different model than your sub-agents.

[00:09:23]You can use major providers like Anthropic, OpenAI, Google.

[00:09:28]You can use local models with Ollama.

[00:09:31]Or you can use the increasingly performant and much cheaper open-source models like Fireworks from providers like Fireworks, Nvidia, Open Router, Base Ten.

[00:09:45]Deep Agents is highly customizable.

[00:09:48]Here's a quick recap of what that core agent loop looks like.

[00:09:52]And here's what the Deep Agents loop looks like.

[00:09:55]Deep Agents provides a set of hooks around the core agent loop. We call this system middleware.

[00:10:02]And middleware enables basically any custom logic that you want to add to your agent.

[00:10:08]That might look like bespoke business logic, deterministic code at any point, policy enforcement like PII reduction, or dynamic agent control. For example, changing the model and tools available at runtime based on the task at hand.

[00:10:25]Even with a capable harness, going to production is really hard.

[00:10:29]Your agent needs to run for long periods of time and recover from unexpected failures, handle human in the loop and unpredictable behavior, support bursty traffic, all while maintaining a secure posture, and keeping up with ever-changing interoperability standards.

[00:10:48]And now, I'm going to hand it off to Vic, who's going to cover how we make this easy.

[00:10:52]Awesome. Thank you, Sydney.

[00:10:54]All right.

[00:10:56]So, we just saw what a Deep Agent is.

[00:10:58]Now, we're going to talk about what it takes to actually take one of these Deep Agents into production. I see a few familiar faces in the crowd of people that have actually taken these agents and served them to customers in production. Um so, we've kind of seen this firsthand.

[00:11:11]Today, we're going to talk about how we're introducing managed Deep Agents in private beta in order to make this process as easy as possible.

[00:11:19]So, there's kind of four core pillars to what managed Deep Agents are. First is the harness, which Sydney just walked through.

[00:11:25]The second is the runtime, which is how we can actually use this agent in production.

[00:11:30]The third is going to be an integration with context hub. And then lastly, the way that we can execute safe code in a sandbox.

[00:11:39]So, let's first talk about this runtime.

[00:11:41]So, managed deep agents is actually built on top of LangSmith deployment, which means we get a lot of primitives to handle that real-time kind of interaction and scalability that agents will actually need in production.

[00:11:52]This means we get endpoints for creating, updating, even invoking our agents wherever we need them.

[00:11:57]We'll get a purpose-built task queue and horizontal scaling in order to handle kind of the bursty request loads that your agents might experience.

[00:12:04]You can imagine a use case of support agent, your systems go down, and now everyone's hitting that support agent all at once. You need to be able to handle that traffic well.

[00:12:13]Lastly is SDKs in order to use these agents wherever you need them, integrations with Copilot Kit, Assistant UI for Gen UI, the list goes on.

[00:12:23]The second kind of core pillar of this production runtime is durable execution.

[00:12:27]This is one of those things that is a little boring to think about, but it is very, very reliable in production. So, because we run deep agents on top of the LangGraph runtime, we're able to actually checkpoint each step that your agent takes in production.

[00:12:39]This means that these are all stored in durable storage, and we can resume and restart from any one of these checkpoints. So, if your agent fails on step 49 of 50, you don't have to restart that whole run again, you can pick up and retry from from step 49.

[00:12:53]Lastly, we have the ability to replay and fork our agent from any point in time with that state.

[00:12:58]This enables some advanced use cases where we're close, so you know, something like, "Oh, I want to I want to fork this conversation from here." But it also enables human approval through human in the loop.

[00:13:07]Since everything is checkpointed into this database, we're able to await human input indefinitely. This is what enables ambient agent use cases such as LangSmith engine, which you hear about in the next session.

[00:13:20]Security and auth are very, very important to production agents. You need multiple layers of auth in order to kind of serve these production agent use cases. The first is going to be inbound from your actual application. How do you authenticate that this user is who they say they are and they're allowed to use this agent?

[00:13:36]The second is going to be outbound from inside the agent to your external services. You might have tools or MCP tools that you need to be able to reliably authenticate with and assume the correct permissions at runtime.

[00:13:46]The third is actually who has the ability to create, update, and manage these agents. Whether it is your AI engineers internally or maybe your CTO wants to get in there and make a quick change, you need to have that level of R back and A back to enable who actually has permissions to make these changes.

[00:14:02]>> [snorts] >> Agent interoperability is becoming more and more important as you want to use your agents in a variety of different use cases.

[00:14:09]One thing that's core to LangSmith deployment that we're bringing in to manage deep agents is the ability to use your agent via remote graph. That means that you can call your agent that is built on managed deep agents in a custom LangGraph application that's deployed on LangSmith elsewhere in just one line of code.

[00:14:23]Second is the ability to support A to A protocol. So, a lot of agents are using A to A today as a way to kind of handle this agent to agent communication layer and we support this out of the box in both our standard LangSmith deployment and also managed deep agent.

[00:14:37]The third is being able to bring this agent where you actually do work. We have a lot of agents that we build internally and deploy on LangSmith deployment and we'd love to use them where we're doing work. Whether it's deep agents code or it's Cloud Desktop, you want to be able to bring this agent and use it where you need it.

[00:14:53]We thought of all of these different production use cases so that you don't have to. Things like double texting, canceling a run mid-flight, are all things that actually take real engineering work and will take you weeks if not months to build. We have this all out of the box for you.

[00:15:07]The third kind of core pillar here is the context of integration.

[00:15:13]Oop.

[00:15:13]So, Context Hub is built into managed deep agents and it's how we version and save every one of these files that your agent actually operates and runs on. So, things like the agent MD and the skills that Harrison mentioned during the keynote are becoming more and more popular.

[00:15:27]Memories that your agents is taking about your users, these all get saved and saved in version inside of Context Hub so that your team is able to control different different levels of promotion, right? Like we can start in staging, go to production for different skills, things of that nature. And you can really democratize these skills across different agents.

[00:15:46]The next kind of core feature that is part of Context Hub in this managed deep agents primitive is our integration with LangSmith engine. You're going to hear more about LangSmith engine in the next session, but essentially what it'll be able to do is take real production usage of these deep agents, make some quality improvements, some changes to your prompts, your system or your skills, things of that nature, and that'll lead to better behavior over time as this loop in this engine continues to build.

[00:16:12]The fourth kind of key component of managed deep agents is sandboxes.

[00:16:17]So, as Sydney mentioned before, increasingly nearly every agent is becoming a coding agent. Even a research agent use case, they might want to be able to crunch some quick stats and add them to a report. You want to enable your agents to do these things in production because it can lead to a lot more creative results. That's why we're launching LangSmith sandboxes and we're integrating them directly with managed deep agents.

[00:16:36]There's a few core features to this kind of LangSmith sandbox primitive. The first being an off proxy in order to at runtime inject in those credentials that your sandbox is using securely so that none of your important environment variables are exposed the actual agent or the actual sandbox itself.

[00:16:53]And the second is the ability to snapshot and restore so that your agent always has the correct execution environment.

[00:16:59]We'll have a session on this for a deeper dive tomorrow with Mikhail, but they are very very excellent for most agent use cases.

[00:17:07]So, this is kind of everything that you need all together in order to take an idea or a working deep agent and take it into production.

[00:17:15]That's why we're launching managed deep agents and we're starting the private beta as of today. So we encourage you all to jump on the wait list and thanks for the time.

[00:17:25]>> [applause]