Managed Deep Agents | Deploying mission critical agents to production

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: Managed Deep Agents | Deploying mission critical agents to production · Channel: LangChain · 15:32 · Watch on YouTube

Topics: AI agents, AI evaluation and benchmarks

Summary

Victor introduces Deep Agents as customizable agent harnesses designed to provide models with the right context at the right time, using capabilities such as file systems, delegation, and human-in-the-loop controls. He presents Managed Deep Agents as a way to bundle the harness with production infrastructure so teams can focus more on agent logic, evaluation, and iteration. The talk covers deployment workflows, identity and credentials, memory and access control, context versioning, and evaluations. It also announces integrations and features, including Parallel, HTTP channels, user-scoped memories, and Slack file transfers.

Key points

An agent uses tools to reason and complete a task; a harness includes the additional skills, tools, context, and subagents that support it.
Deep Agents are customizable harnesses intended to give models the right context at the right time.
Core Deep Agent capabilities include a virtual file system for execution and context management, delegation to subagents, and human-in-the-loop interrupts.
Managed Deep Agents bundle the harness and infrastructure, including deployment, streaming, checkpointing, sandboxes, and tracing.
The MDA workflow lets developers initialize an agent, run it locally with MDA dev, and deploy it with MDA deploy.
Managed Deep Agents support reconciling users across channels and handling user, agent, or service-account credentials, including pausing for authentication when needed.
Memory and access controls can distinguish procedural and personal memories and apply different permissions depending on the channel.
Context Hub supports versioning and collaboration on instructions, skills, and memory; MDA eval initializes a Harbor environment and records results in LangSmith.
Announced features include a Parallel integration, HTTP channels, sandbox file-system APIs, user-scoped memories, connections, and Slack file transfers.

Chapters

Start	Chapter	Summary
00:05	Deep Agents and their core components	Victor defines agents, harnesses, and Deep Agents, then explains their execution environment, context management, delegation, and human-in-the-loop capabilities.
03:50	Taking agents into production	The talk describes the challenges of production infrastructure and how Managed Deep Agents combines infrastructure and the harness to simplify deployment.
07:34	Building and authenticating an organizational agent	Using a go-to-market agent as an example, Victor explains its project structure and how users, credentials, and access are handled across channels.
10:45	Memory, context versioning, and evaluation	Victor discusses memory types and channel-based access control, Context Hub collaboration, and using Harbor evaluations to improve agents.
12:53	Integrations, customers, and new features	The talk highlights customer experiences and announces the Parallel integration along with HTTP channels, sandbox file access, user-scoped memories, connections, and Slack file transfers.

Quotes

the model is only as powerful as the context that we give it. — 01:10

we wanted to make this process very very easy. — 05:22

Getting started is really easy. — 07:01

So, we’re really excited to announce this integration. — 12:53

Concepts and entities

Deep Agents, Managed Deep Agents, LangChain, LangGraph, LangSmith, Context Hub, Harbor, Parallel, Magical, Victor

Full transcript (original language)

00:05 Hi everyone, I’m Victor. I’m a product manager here at Langchain. I primarily focus on our runtime products and today we’re going to talk about deploying mission critical agents into production. Um we’re going to start first with like a little refresher on what deep agents are and then we’ll talk about managed deep agents and why we’re so excited about them. So the first place we always love to start with this is what is an agent? Um it’s a question we get a lot and the core idea of an agent is it’s a model using tools um in order to complete a task and this is based on the React style agents that have become

00:38 popular um over a year ago and that’s based on like reason and action. So they’re going to use tools they’re going to reason over it to accomplish a task for you. The next question we often get is what is a harness? So a harness is basically everything else that we bake in to create the agent. So that can be skills, it can be tools, context, sub aents, really all of these different things that we put into an agent um in order for it to accomplish a task. Why why do we do this? Like why do we go through all the effort of building a harness, building an agent and and going

01:10 through all this development? And that’s to get the model the right context at the right time. So a lot of times um when we’re building an agent, we know that the model is only as powerful as the context that we give it. and we need to always be able to get it the right context at the right time. Deep agents is a customizable harness that we can build for any domain specific task. So we took a lot of the learnings of coding agents and different harnesses that are out there in the wild and we’ve really put it into this very customizable base harness that you can use for virtually any use case.

01:41 The anatomy of a of a deep agent is really comprised of four core areas. The first being the execution environment. Um, and this is really core to the philosophy of deep agents is we sort of abstract away the file system for the agent. So us as developers, we can define sort of this wall between your model and the files it interacts with through a virtual file system. That file system can actually live anywhere. It could be S3 files. It could even be a sandbox where your agent can write and execute code or its lighter weight cousin, a code interpreter or a ripple. What’s really cool about this too is

02:13 this helps with context management. So things like uh progressive disclosure of skills, doing things like cross thread memory. So you want to remember things about agents or about users across threads, you can do that in that with the file system. Um we can do things like summarization. So as our context grows and grows, we’re able to summarize that previous conversation, compact it down and store it in the file system. And then we can also offload context. So let’s say we retrieve like a very large tool response, we can actually offload that into the file system rather than directly loading that

02:45 into our um our our model’s context window. The third kind of key area is delegation. So delegation is the ability for the model to plan reason over that plan and then kick off sub agents to execute things. And then lastly is human in the loop. Um human in the loop is very core to everything that we do here at Langchain. Um this this conference is actually named after the interrupt function which is a function of langraph. Um, deep agents is built on top of that langraph runtime. So you have that ability to interrupt and pause for execution. So a good example of taking a deep agent

03:16 into production is a customer of ours which is Magrical. Magical has a a ton of different use cases but primarily focuses on a pharmaceutical research agent. Um, and this is for their pharmaceutical researchers to be able to load in a domain specific harness that is able to reason over a certain knowledge base for that particular researchers domain, synthesize all of those results and respond back with a cohesive report report with cited sources and all of that. They were able to build all of this with deep agents and a task that used to take them weeks to spin up a new agent for a researcher

03:50 now just takes a few hours by putting this all into the deep agents harness and deploying it onto Langmith. Cool. So, let’s talk about like what it takes to take an agent from something that works uh locally and actually put it into production. So, there’s kind of like three core areas of building an agent. The first is the business logic and this is what we think is the most important thing for um developers and for teams to bring is this core idea of like their expertise and the different instructions and skills that your agent might use. The second is the harness

04:21 itself which we talked about uh as deep agents gives our agent the ability to use files and do context management and all these wonderful things. And the third area is going to be infrastructure. So infrastructure is probably the the more boring area but the most important area when you talk about actually taking an agent and putting into production in a way that others can use it. Cool. So one of the first things that we do um when we’re building an agent, right, is we’re prototyping it locally. we get it running locally on our machine and it works great and we’re really excited and then we want to go and actually share this with everyone else.

04:52 Um this is actually a very very valuable stage. Uh this is this is where we can kind of prove the magic of the agent, right? That that the agent can actually do what we’re designing it for. What happens then is we try to go into production and now we need to think about a lot of different things, right? We need to think about where people are going to use this agent, the different surfaces you might want your agent to be used from. um how you’re going to reconcile where those where those different surfaces are entering into your actual runtime. You need to be able to queue up the runs so that your agent can kind of serve them reasonably. You need to be able to establish streaming.

05:22 You need to do all these different things in order to have this agent run reliably in production. And it requires kind of different things uh that your team has to consider from an infrastructure standpoint. With managed deep agents, we wanted to make this process very very easy. So what we’ve done is we’ve sort of bundled together the harness and the infrastructure to make it really really easy for your teams to work on primarily the business logic and actually improving your agents with eval with traces with engine and iterating on your actual agent logic rather than focusing on the infrastructure and the harness level stuff. So this is kind of what it

05:55 looks like that that previous graph of all these different boxes that you had to manage yourself now becomes very easy with managed deep agents. It runs on our proven Langmith deployment um for things like streaming, checkpointing, um off handlers, things of that nature. It integrates directly with Langmith sandboxes for all of that sandbox control when you need agents to run and execute code. It also uses context hub, which we’ll talk about a little bit later, but allows us to kind of coordinate on instructions and skills with business users and iterate on things. And then of course, it plugs into our LLM gateway and traces as well. And what’s really nice is on the left

06:29 side you’ll see this agent interface is we do a really good job of allowing you to use different use your agent from different interfaces and reconcile those. So since we’re handling all of this infrastructure, we now can make it really easy for you as a developer to define the agent. So rather than um kind of defining it in your own logic, we can go ahead and give you this folder structure in order to define things. So your agent will live in like the agent.ts um or agent.py. So this works for Python or TypeScript. your instructions, skills, tools, identity, all of these different primitives that you need to add to the agent itself will

07:01 live in different folders or different files in your directory. Getting started is really easy. So, all we’re going to do is run MDA init and give our agent a name. That’ll scaffold this project directory for us. After we add in all of that logic, we can then go ahead and run MDA dev. And that’s going to start up a local agent server for us, which is the same server that powers Langmith deployment. So you’re able to test everything out locally and make sure that it’s working as intended. And then once you’re ready to actually go into production, all you need to do is run MDA deploy. And that’s going to go ahead and deploy it onto Langmith’s managed infrastructure. This makes it really,

07:34 really easy to go from an idea to a prototype, something that works locally and then into production. Cool. So let’s take a look at an actual example of an agent that you might want to build and and someone something that people in your organization might use. This is sort of an example that we use a lot internally here at Langchain, which is our go to market agent and it’s something that anyone in our organization can interact with in order to do anything related to go to market. So, we’re going to ask it to prep me for a certain meeting and draft an email for

08:04 me to review and that kind of gets sent into this GTM agent. The way that this looks and the way that we can design this agent is really quite easy. This now all maps to different files. So again our agent definitions at the beginning the sort of playbook for how we wanted to do different things can live in both the instructions and the skills and then all of the connections to different business systems like Salesforce Gong all these other sort of platforms lives in tools and then we can define how users authenticate and how we remember things about users in the other two files. So, one of the core things that when we talk about building agents with

08:37 customers, there’s kind of four scary things that then get brought up when you bring it into production is how do we identify who’s who’s asking this agent to do what you know prep for the email or prep for the meeting. Whose data is it going to use? Which memory is it going to be able to reference or edit? And then lastly, what happens if it is actually missing access when that run it gets initiated. So jumping into the first one, this is something that we thought about a lot with managed deep agents is being able to reconcile the callers between different surface areas. So we have first class support for different channels in in managed deep agents. You

09:08 can really easily just create a slack application, go ahead and use this agent, but you also might want to expose this agent in your web UI or your web application or your own platform. And you don’t want to have to have a user always like reauthenticate and re go through the permissioning over and over again. So what we did is built a very nice off handler that will help you reconcile those users and you can have them reconcile across these different surface areas and that all gets passed into the runtime for the manage deep agent quite easily. The second is whose account should it use. So as a developer we might want to define certain connections certain tools

09:40 that your agent can use and connect them in a certain way. So we might want to say okay when it uses our CRM tool for example we always want it to use um the user’s credentials. So we want to have it operate on behalf of the caller. So, if I’m in a DM with this agent and I say, “Prep me for this meeting.” It’s then going to be able to use my Salesforce credentials and go and access that. There’s other scenarios where you might want your agent to have its own agent scope credentials or be able to have service account credentials. We make this really easy in managed deep agents with this connections primitive. So, all you need to do is define these connections, upload tokens, if they’re user based, we’ll actually handle that

10:14 for you. And how we handle that is really easily midtask. So since we have built-in human in the loop in deep agents and in the langraph runtime, what happens is when you make a request and the agent doesn’t have a particular token for a particular user and it’s an on behalf of token, it’s actually able to really easily pause, ask the user to go ahead and authenticate. They’ll click the link, everything um proceeds as normal and this will happen indefinitely since we have the uh the interrupts checkpointed. The second or the third kind of core area that becomes interesting is memory.

10:45 Um there’s a lot of different uh approaches to memory and we wanted to have really good defaults for this. So the first kind of convention is agent level memory or procedural memory. We have a really great way for your agent to be able to take and remember certain procedural things about users and manage deep agents. The second is user level memory. So personal preferences that I tell the agent about myself. Um and it’s really important that your agent is able to kind of take these different types of memory. And this is where control starts to come into place. So, one thing that we’ve built into manage deep agents is allowing you to define the access

11:17 control based on the channel that it’s calling from. So, if I’m in a Slack DM, for example, it can use my personal memories. It can use my personal credentials. It can take personal memories about me, and that’s totally fine. But if I’m talking in a shared channel with my other co-workers, I probably don’t want it to be able to unveil certain information about me. So, as a developer, I can define those those sort of primitives um if I need to. Another really nice part of manage deep agents is we get version control for our agent context with context hub. So we’re able to store all of our instructions,

11:48 skills, and memory inside of a context hub repo. And that will allow us to collaborate in this in the surface within lang. Um which is really great for kind of iterating on different things like instructions, having version control over it, promoting it to production, things of that nature. Promoting it to production though can be scary. So, one things that we built into manage deep agents that we’ve um really spent a lot of time on was its integration with Harbor as an eval framework. So, I know we’ve talked about Harbor today, but we really think it’s a great great way for running evals. Um,

12:21 but what we found from customers is that it can be a bit difficult to get started with. So, we wanted to make it really easy for managed deep agents. If you run this MDA eval in it, it’ll go ahead and initialize a Harbor environment for you. Help you set up the tasks, help you set up the checks. All of that will get traced into Langmith and show up in your Langmith experiments tab and you’re able to kind of improve your agent over time. You can rerun the same tasks and you can actually hill climb your agent right in your own machine. One of the things that we’re announcing today is our integration with Parallel.

12:53 So, we’re really excited to announce this integration. Um, it’s going to be free during our public beta. So, please feel free to go ahead and use it. Um, but the way that it works is essentially you can just go ahead and add this tool to your managed deep agent. You don’t have to add any parallel API keys, anything like that. It’ll all kind of work just out of the box. So, we’re really excited about partnering with Parallel on this for managed deep agents. So something that we’ve um really really enjoyed was working not only internally with our own agent use cases like our go to market agent um open suite which is like a software factory type agent and

13:25 iterating on that for managed deep agents but also working with a lot of our customers. Um and we wanted to highlight two customers in particular. Um Zahed from Kith was instrumental in really helping us getting started with some of the primitives of collaborating with no code users with business users. Um also setting up how connections and memory will work. So, it’s been really great working with Zahed and we we value him as a partner. Additionally, Derek from Consensus um has been really really great to see how he’s actually used managed deep agents in a way that um we really intended it to be used. So, him

13:57 and his team of developers kind of go around the org there at Consensus and they build out different deep agent use cases um for different parts of the org. And because manage deep agents handles all of the infrastructure, they’re able to really easily kind of go and deploy these agents. And they’ve been able to really rapidly um increase the amount of agents that are being used across consensus, which is really exciting. Um so what’s new as of today in managed deep agents? The first is um HTTP channels. And the primitive here allows you to basically define your own custom channels. So we have great pre-built

14:29 integrations for Slack, for example, but we know that you might want to use your agents in a variety of different ways across a variety of different surfaces. So we make it very easy for you now to define how your agent responds to certain events where it then responds to those events for you. So um it’s very very easy now with the new HTTP channels. We also added much better um APIs for accessing your sandbox’s file system. So not only can the agent access the file system, but you as a user can now access it from your front ends in different places. The third is user scope memories. So as I mentioned um we

15:00 thought a lot about user scope memories and how to do it reliably and safely and that’s now available in manage deep agents. And then of course connections which is how we’re going to actually authenticate and define that as developers is now available. The the second to last is file transfers in Slack. So very commonly you’re going to want to collaborate on files. You maybe want an agent to create a PowerPoint for you, create a PDF. You want to be able to iterate on it with right within Slack and that is now first class and managed deep agents. And lastly, um the built-in search with parallel that I just mentioned. Awesome. Thank you all for for joining

15:32 today. Um we’re really excited to announce uh manage deep agents in our point8 release and we can’t wait to see what you build with it and build your domain specific agents. Thank you.