All right, let's go. I did not know that video was going to be made, so yeah, it was great though. It was great. We're really excited to be here. This is our second year doing it, and so we decided to make it two days instead of one. We've got a stacked lineup for everyone here. I think it's going to be a blast. We've got a lot to share. And so we're thrilled and honored that you guys decided to join us for these two days.
Last year, we kicked off Interrupt by talking about how building agents was hard. It was easy to build a prototype, but it was hard to get to production. There was a lot of challenges that you encountered along the way. And over the past year, we've seen that a number of companies, including a lot that are speaking here today, have figured out how to overcome those hurdles and bring agents into production. It's still not easy to build agents and bring them into production, but we've figured out some of the things that are needed to make that a reality. Building agents is different than building software. That's why it's a new challenge. That's why you need new tools and new skills. And I think it's important to think about why it's different than building software.
There's two things that we think make it different. One is the inputs themselves. So agents take in natural language. Natural language can be infinite in its dimensions. It can be any number of words, or now things can start to be images, or videos, or even audio files. And so the input space to agents is really, really large. The output space is also really large. LLMs themselves are non-deterministic, and even if they were deterministic, they're still really sensitive to small changes in the prompt. And so when you have this really big input space and this really non-robust system, you end up with an overall agentic system that's really hard to actually predict how it's going to do before you actually launch it and you actually put it in front of users and you actually have them experience it. And the teams that have figured out how to build agents reliably, they ship early and then they iterate quickly. And this is a pattern that we've seen again and again from companies that have managed to bring agents into production.
As they do this iteration, through some manner, they've landed on this new agent development lifecycle, parallel to the software development lifecycle that people use to build and ship software, but it's different because agents are different. They require more iteration and the steps at each of those phases are slightly different. And so the mastery of this lifecycle, whether people call it that or not, is really what people are doing when they're building organizations and building tools to help ship agents. And everything that we do at LangChain can be described by fitting into this lifecycle. We want to figure out what the agents of the future look like, and we want to build all the tools to help make them a reality. And so we think a lot about what this lifecycle looks like and how we can help that. And so today, I want to talk about how we view this lifecycle. And I want to talk about a number of things that we are launching to make it easier for teams to iterate quickly through this lifecycle.
So first, I want to talk about build, building agents. This is how we got started. So this is what LangChain was. This was a package launched a month before ChatGPT. And it was really around building these LLM and agentic applications. Fun fact, we had a class called Agent in LangChain before a ChatGPT launch. I remember it. I was on, I think, I was in San Diego for Thanksgiving and was just trying to decide what to call it. And I ended up calling it AgentExecutor instead of Agent. So, you know, we're not great at naming and that's maybe the first example of that. But we had this concept of an agent and it was in LangChain. Then we launched LangGraph a little over a year later. As we saw that the applications that people were building, they may have started off as chains, but they were becoming more complex graphs. And that was the idea behind LangGraph. We then launched LangChain 1.0, and then about nine months ago, we launched Deep Agents. Deep Agents is an evolution of this as well. And so I want to talk a little bit more about Deep Agents right now, because that's where we think the future is really headed.
So the core idea of an agent, from the original AgentExecutor days in LangChain to now, is basically, it's pretty simple. It's an LLM running in a loop calling tools. There's a bunch of stuff that can happen around that loop. There's a bunch of specific tools you can add in. But when people talk about agents, this is essentially what they're talking about. A user request comes in, you call the LLM, the LLM decides to call a tool, you then execute that tool, and you keep on doing that until the LLM decides that it's finished. That's the core idea of an agent, and that's always been the case. So what is Deep Agents? Deep Agents is an agent harness, and it basically adds more batteries-included things. It supercharges this loop. What are some of the things that it adds? It adds an execution environment. So agent harnesses need a place to run. A really common way to run them is in a sandbox. You give it access to a file system, you give it access to code, it can read files, write files, execute code. That's its execution environment. And so when people talk about agent harnesses, they often talk about coding agents. Part of that coding agent is its execution environment. Sandboxes are one extreme. You can write and execute code. And then on the other extreme, we have what we call a virtual file system in Deep Agents. This is basically a database that we expose to the agent as a file system. LLMs are great at reading and writing files. And so you can kind of trick it into having this kind of mock execution environment. But the point is you give it an environment to interact with.
Deep Agents and other agent harnesses come with a lot of built-in context management. So skills and memory are examples of this. Summarization is an example of short-term memory when the conversation gets too long and you summarize it. Context offloading, how do you deal with really long tool calls? This is logic that's built into the agent harness. Prompt caching is another example of this where you want to make sure that you're caching the initial part of your request so that it can be faster and cheaper in the future. And so all of this context management is built into the harness and it does it automatically for you. Steering is really important. So these agents, these Deep Agents, they're long-horizon agents, but that doesn't mean they're fully autonomous. You still need the human in the loop. And so Deep Agents comes with really good human-in-the-loop controls. And then lastly, delegation. Agent harnesses can be used to kick off other agents, whether that's planning agents or other sub-agents for different tasks. And so all of that delegation, communicating with those sub-agents and having them communicate back to you, all of that is specified in an agent harness. And so Deep Agents contains all of these different things. We spend a ton of time doing both research and applied AI work to make sure that the way we do summarization is the best, the way that we do sub-agents is the best.
And so today, one of the things that we're launching is Deep Agents 0.6, a new version of Deep Agents. There's three big things in it that are informed by three trends that we see in the industry. So one trend we see in the industry is the rise of open models. DeepSeek V4 launched last week, and it's just as performant on certain tasks as frontier models. So open-source models are getting better. And the other thing that's happening is cost is rising. The cost of frontier models keeps on going up and up, and usage keeps on going up and up. And so one of the things that we think will happen more and more is more usage of open-source models. And so with Deep Agents 0.6, we want to make it the best place to use open-source models. So we're launching native support for GLM-5, DeepSeek, and Nemotron models. We have best-in-class integrations with inference partners like Fireworks, Baseten, and NVIDIA. And the easiest way to try out open-source models in a harness is by coding. And so we're launching Deep Agents Code as an open-source example of how to build a coding agent on top of Deep Agents. And we're making it really, really good for open-source models.
The second thing that we're seeing is a lot of attention around the execution environment. So we talked about this. We talked about the virtual file system, which is a really simple way to let the agent interact with what it thinks is a file system, but it's just a pretty simple database under the hood. And then on the other extreme, we have a full-blown code sandbox where the agent can write and execute code, spin up a web server, any of that. And so this is a spectrum. But what sits in the middle? And so in Deep Agents 0.6, we're launching CodeInterpreter. What CodeInterpreter is, we use QuickJS, which is a JavaScript runtime. And it basically lets the agent write and execute code in this kind of like REPL-like environment. So it's a subset of the JavaScript language, and you can't do everything that you can do in a sandbox. So you can't run Docker or things like that, but you can still write and call tools programmatically. You can manipulate data files. You can read and write from the file system here as well. And so we think this is a really interesting middle ground where it's super lightweight to deploy. So this is the benefit of it. You don't have to spin up a separate sandbox for each agent. You can just deploy this, and it's really easy to run in a multi-tenant way, but you still get a lot of benefits that you get from coding.
The third trend that we've seen is that it's still really hard, but really important to build delightful UIs. UIs matter, interacting with the agents matter. And one thing that's happened is these agents have gotten more and more complicated, and the events that they're emitting are correspondingly more and more complicated. They emit text, they emit tool calls, images, reasoning, sub-agents, stuff. How do you do that? And so we want to make it as easy as possible for people to run agent harnesses and hook them up to delightful UIs that they build for their customers. And so the third launch in Deep Agents 0.6 is better support for streaming. So we have a brand new streaming protocol. We have four different front-end SDKs for different front-end languages. And we're partnering with UI frameworks like CopilotKit, Assistant UI, and Vercel to make sure it's really tightly integrated. UIs are a big part of building agents, and we want to make it the easiest way to do so. So if you haven't already tried out Deep Agents, please go try it out today. This is where we think the future is heading. We think agent harnesses are getting more and more robust, more and more production-ready. And Deep Agents is our version of that.
I want to talk about the test phase next. So you've built your agent. How do you know if it's actually working? This is where LangSmith evaluations comes in, something we've been building over the past two years. Testing for agents looks different than testing for software. You want to build up datasets, so reference inputs and reference outputs, or maybe criteria to score how it's doing. You want to define metrics. How do you know if the agent is passing? This could be correctness. This could be hallucinations. But you want to define some metrics that work for your use case. And then you run your agent over these datasets, and you score them on these metrics, and you create these experiments, and you can use these experiments to hill climb on certain things. Or you can use them to make sure that you're not regressing as you're making changes. Evaluations are a key part of LangSmith, and we're launching some stuff around this today. But I'm going to talk about that later. So I'm going to go on to deploy next.
So you've built your agent. It's running locally. Now you want to go to production. There's a bunch of challenges that are going to emerge as you do that. First, you have to go from a single user, just you. Now you're serving many in production. Environment variables and memory, these now have to be specific to the users that you're interacting with. Auth, you need to control who can access it. You can't just open it up to everyone. And then when it runs locally and it dies, you're just testing it. You can resume from there. But you need to run it durably when you're running it at scale. And so a year ago, we launched LangSmith deployments to help with this. So there's a bunch of features built into this. We launched about 30 different API endpoints to handle streaming, human-in-the-loop, auth, other things like that. It's a single standard deployment pattern. Today it's served over 100 million agent runs and is trusted by companies like Workday, Cisco, Etsy, Podium, and ByteDance. But we also realized that LangSmith deployments isn't the only thing you'll need to bring an agent into production. We've talked about how agents need an execution environment, and one of the best execution environments is a sandbox. So whether the agent is a coding agent or not, reading and writing code can be really impactful for the agent. It can manipulate data that way. It can use CLIs that way. And so we generally think that a lot of agents will need the ability to write and execute code in sandboxes. And so today, we're excited to announce that LangSmith Sandboxes is generally available.
We think this is a big part of agents in the future, and so we made it really easy to spin up sandboxes in less than a second. There's persistence for these sandboxes, so that will survive across interactions. It supports snapshots and forks. One of the coolest things we've done is this auth proxy. So if you want to give the LLM, the agent, the ability to use something that requires an API key, you don't actually want it to see that API key because then it could get prompt injected and leak it. And so we have an auth proxy that sits outside the sandbox and basically intercepts traffic and inserts that in. And this is all part of the LangSmith SDK, and it's completely framework-agnostic. So you can use it with Deep Agents, you can use it without Deep Agents, you can use it for testing agents, you can use it for RL, you can use it for running agents from production. We're really excited to see how people use it. We've already had a number of customers using it. Monday, for example, uses it for their AI assistant Sidekick, and we're excited by the feedback that we've gotten so far.
Another big part of bringing agents to production is context. So LLMs by themselves, they don't know anything, or they don't know everything. Humans don't know everything. When we need to look up things, we go to a library. We look at books to learn things, we read them, and that's exactly what agents do as well. They do that with context. And that context has evolved over the years as LLMs have gotten better. So we had a prompt hub in LangSmith for the longest time where you could store versioned prompts. And prompts were the things that kind of like guided agents, but over the past few months and years, we've seen that the context provided to agents has graduated from prompts into things like AGENTS.md files, so really detailed instructions, and skills that these agents have used. A lot of these are shaped by coding agent standards. Both of these are open standards, by the way, so they're part of open foundations. And so as the context that LLMs have needed has evolved from prompts into these AGENTS.md and skills, so has our tooling for that. So today, we're excited to launch LangSmith Context Hub.
And so, what's in this Context Hub? So, you can take your AGENTS.md files, you can take your skills, you can take your like LLM wikis, so this thing that Karpathy did where he basically ran an LLM and had it generate wikis, which are condensed knowledge in markdown files. We think that's going to become a more and more common pattern. So you can take all of this, you can store it in Context Hub, you get versioning, you get tags, you get comments, and then you can use these. You can pull them down locally, you can run them in your coding CLI, you can run them in Deep Agents as a virtual file system, so we have an integration there, or you can use them in whatever agent harness you have. We think Context Hub is a first start at memory. We think memory is really, really important to agents in the future. We think AGENTS.md and skills, you can absolutely view those as an early form of memory. And those are open standards. So that's a great thing because we think memory should be open. We think memory should not be locked in to an LLM, to a framework, or to a platform. And so even though we're building Context Hub, we want this idea of context to be really open. And so we're working with a number of companies, including Redis, Elastic, Mongo, and Pinecone, to turn this first stab at memory into something that's an open standard for memory, for agents. So we think everything should be open.
And lastly, we've got monitor. So you've launched it. But how do you know what the agent's actually doing? This is where a lot of the core LangSmith functionality around tracing comes in. So you can make sure that you can see the step of every agent and what the inputs are and what the outputs are. Dashboards, so you can track cost and latency over time. Online evals, so you can run LLM as a judge or code over these traces, get some feedback and then attach that or just capture user feedback. All of this is part of LangSmith Observability. We've been building a lot here over the past two years and over the past few months. We've got a few very big launches here, but we're going to save that for a little bit later. So this is the agent development lifecycle, and this is what it looks like to bring agents and maintain agents in production. And when you do it once for an agent, that's fine. When you do it for 10 or when you do it for 100 agents, that's when you really need to start to think about the governance of all of this. How do you do this at scale? How do you do this in a cost-efficient and secure way? And so specifically, two of the concerns that we've seen emerge around governance over the past few months have been cost and data exposure. LLMs are getting expensive. How do you know how much agents are spending, how much specific users are spending on agents, and how do you avoid surprise bills? On the data exposure side, LLMs are great at working with data, but they shouldn't be able to access every source of data. And so how do you control what they can and can't see? Today, we're launching LangSmith LLM Gateway in beta to help with that.
You guys can't just pick and choose which announcements you clap for. You've got to applaud for all of them. They're all great. So what is LangSmith LLM Gateway? So you've got your agents, they're running. LangSmith LLM Gateway basically sits between them and their LLM calls. You can set spend limits. You can have visibility, total visibility over spend. And then you can also set guardrails to help with PII and secret detection. It integrates with a bunch of coding agents out there. So you can use it. We know that coding agents is the most popular thing that people are using. And that's where a lot of these costs are happening. And so we've made sure to integrate it with a lot of coding agents out there. It integrates with all the LLM providers that LangChain can help you access, and everything's traced automatically to LangSmith.
So this is the full agent development lifecycle. Everything that we're building kind of fits into this. And we recognize that there's a lot in here. Taking an agent and going to production and going through this lifecycle involves a bunch of different pieces. And so we want to make it as easy as possible for people to take all these pieces, take Deep Agents, which is our agent harness under the hood, and really, really easily go to production. And so to make that into a single API, today we're announcing in private preview, Managed Deep Agents.
So Managed Deep Agents is a single API for interacting with all these different components. So it runs the Deep Agents harness under the hood. It's deployed with LangSmith deployments. And so that's where the agent will run. The models that you can access include any models out there. So we obviously integrate with OpenAI and Anthropic, but also with the open-source model providers like Fireworks and Baseten. All of the agent instructions and memory are stored in Context Hub, so that as you or your users or the agent itself updates them, you can see them there and version them there and track them there. These agents, when they're deployed, you basically want to deploy the agent over here and then give it access to a sandbox to run and write tools over here. And you want those to be separate. And so that's the architecture that we took. And we used LangSmith Sandboxes to help power those sandboxes under the hood. MCPs are how you connect them to tools. So you can provide MCPs directly, or you can use Arcade or another partner that provides access to a lot of MCP servers to do that. And all of this streams out in the new streaming protocol that we announced. So you can integrate it super seamlessly with CopilotKit, Assistant UI, and other frameworks.
So combining everything, LangChain open source and LangSmith power this whole agent development lifecycle. And we think that traces sit at the center of this lifecycle. And so we spend a lot of time as a company thinking about traces and thinking about how to build the best experience around them. Everyone does. But there's no one at the company who thinks more about traces than my co-founder, Ankush. He's been thinking for the past almost a year around how we can make the experience around traces the best possible experience, because this is what powers that whole loop. And so we're launching a lot of really cool things around this, but in order to talk about traces and his love of traces, I'd like to welcome onto the stage my co-founder, Ankush Gola.
