. Guys, welcome to Interrupt. I'm so excited. This is the -- yeah, let's go. This is the -- this is the first time we're doing this. And I'm so excited and honored that all of you chose to, you know, take a day to spend it with us in the amazing lineup of speakers and sponsors that we have here.

To hear and learn about agents and AI and everything that's going on. We've tried to pull out all the stops. We made that video. That was all AI-generated. So we've really tried to make it an incredible experience. And we're really excited for what the day has in store. It feels incredible that we're doing this.

Little over two years ago, we launched LangChain as an open source project, a nights and weekends thing. It was really born out of talking to folks who were building things with AI at events like this. And, you know, that was a month before ChatGPT was launched. And after that, there was this huge explosion of interest in the space as people wanted to take these ideas that they saw and use them on their data in their company for their application.

And there was clearly something that captured the imagination of folks who were building at the time. Even if, you know, the models were way worse than they are today. And even if there was still a lot of work to do, there was that spark of imagination and of interest.

And we saw a lot of people getting started. And that's where LangChain was. It was helping people get started building quickly these prototypes that could amaze and wow. And then we saw that there was a lot of struggle when you tried to go to production. And I think this has been a story that we saw relatively quickly, but it's continued to be the trend over the past two years or so.

It's easy to get something working. That's the magic of these LLMs. They're, you know, powerful and amazing. But it's hard to get that to something that's reliable enough to actually move the lever in real business applications. And that's both bad because it's not easy, but that's also good because that means there's a lot of value to be created from everyone here.

And this delta between the ease of prototyping and the difficulty of getting this production is really what led us to turn what was an open source project into something more than that, into a company, and build a company around it. And this is a slide from the original -- not with the background, obviously, but the language.

This was from our original pitch deck when we were starting the company in terms of what we wanted to do, what the mission was. And we want to make intelligent agents ubiquitous. We think that LLMs are amazing. We think they're super powerful. They can transform the types of applications that we can build.

But we think there's a lot of tooling that needs to be built around them to really help us take advantage of all their capabilities. And so this was the mission that we set out with. And over the past few years of working with you all on these problems, we've learned a little bit about what that looks like.

But we've also learned that there's a lot left to do. So for a few minutes right now, I want to talk about some of the things that we've learned, but also where we're headed and what the next things we think are. So what are some of the ingredients of building agents?

Let's maybe start there. What goes into them? One core component is obviously prompting. The new things about agents are the LLMs. That's why we're all here. And when you interact with LLMs, you prompt it. You send it. You send it some text. You get back some response. And so being good at prompting is a core component of building these agents.

We also think that engineering is a core component. So our target audience is developers. We think that there is a lot of engineering skills that go into building reliable agents, whether it's the tools that they're using and interacting with, whether it's the patterns that they're using to do the data pipelines that bring the context to the LLM at the right point in time, whether it's the deployment.

There's a lot of engineering that goes into building agents. There's a lot of product sense and product skills as well. So this is similar to the product engineer before. But now when we're building these agents, we're often building them to do workflows that a human or a group of humans would do.

And so having the product sense and intuition and skill to understand those flows and then try to replicate them with an agent is a really important skill. And finally, there's some aspects of machine learning that are involved. So most prominently with evals, we see this being a great way to test and measure these agents and capture the non-determinism with some metrics over time.

And there's other things like fine tuning as well. And so there's absolutely some aspect of machine learning here. And the combination of all of these skills has really burgeoned into what we see being the agent engineer. And so this combines different aspects of all of these. And it's early on.

So this is still being defined how much and which of these areas are important. But we see this new profile of builder, which combines all of these, representing the agent engineer. And so when we think about Langchain and the mission of the company, in order to make these intelligent agents ubiquitous, we want to support all the agent engineers out there.

And I think we're a room full of agent engineers here, or at least people who are trying to be, who are moving in that direction. And so this is how we think of the personas that we're trying to speak to and empower. And so when we think about that, I think one question that we ask ourselves is what will the agents of the future look like?

We want to see what those agents look like and then build tools to help build those agents. That's what's interesting to us. That's why we're all here. And so as we think about what these agents look like, there are a few beliefs that we have. And so I want to walk through three of them which we think are more kind of like in the present now and then three of them which we think are in the future.

So the first belief that we have is that agents will rely on many different models. So what does that mean? So over the past year and the last few months specifically, there have been a lot of different models coming on to the playing field. They have different strengths and weaknesses.

Some of them are really costly, but they can reason for a long time. Some of them are faster and they're better for specific tasks. Some of them are great at reasoning. Some of them are great at writing. And so there's this whole ecosystem of models out there giving developers the choice to choose which model is best for them at a particular point in their agent.

So an agent might use many different models and we see that being an increasingly common thing. And this is really where we've turned the original LangChain package into. So there was a lot in the original LangChain. A lot of it was aimed at making it easy to get started.

And a big part of that was the integrations. And that's really what we've focused and doubled down on in the past year or so. We've turned LangChain into a place for integrations of all types, but specifically for language models as we've seen this be the key component of building these applications.

And it's provided a stable ecosystem for interacting with all the different model providers and model options that are out there. As we've really focused in on this being the core use case for LangChain, we've seen that the stability and focus that this has has caused LangChain to continue to grow.

So this speaks to the model optionality that developers want as well. And so in the last month alone, LangChain did 70 million monthly downloads. That's in the last month alone, not aggregate. And we see this trend where developers increasingly want the flexibility to switch between models. And I think this is interesting to not look at by alone, but also if you compare to a benchmark, which we all have in our mind when we think of Gen.ai, which is Open.ai, you know, they're what people think of.

And if you look at their kind of like download stats over the last few months, you'll actually notice that LangChain, again, driven by the different model options that are out there, has actually become more popular in terms of Python downloads than the Open.ai SDK. And this speaks to the fact that developers want model optionality, and they're choosing LangChain to get it.

The second belief that we have is that reliable agents start with the right context. So what does this mean? So prompting is really important. The prompt that you construct to pass into the LLM will determine what comes out of the LLM that will determine the behavior of the agent.

This prompt isn't just one big string. It's actually made up of a bunch of different parts. And all these parts come from different places. So they could come from a system message. They could come from user input. They could come from tools. They could come from retrieval steps. They could come from the conversation history.

And so when you construct this context that you're passing into the LLM, it's really, really important to be able to control exactly what goes in there. Because that will affect what comes out. And so in order to provide this control and flexibility in this context engineering, we've started moving all of our agent orchestration over to LangGraph.

So we launched LangGraph a little over a year ago. It's an extremely low level, unopinionated framework for building agents. There's no hidden prompts. There's no hidden cognitive architectures. You can create the flow of the agent that you want. So you can do all the necessary steps to get the right context.

And then you can pass that in whatever form to the LLM. And so you have supreme control over kind of like all of it. And this control ability to build the cognitive architecture that you want is a key selling point of LangGraph as the agent orchestration framework. And of course, on top of this control, we've tried to add in functionality that doesn't get in the way of adding the right context.

So streaming, human-in-the-loop support, short-term memory and long-term memory. We don't tell you how to use these things, but we give you low level primitives so that you can build it into the agent yourself. And so this focus on controllability has really helped LangGraph stand out. And we're recommending that all complex agent orchestration things be built on top of it now.

The last belief that we have is that building agents is a team sport. So the two things I talked about so far, LangGraph and LangChain, are both aimed at developers. They're tools for engineers. But we think there are all these different areas, prompting product machine learning, that are involved in building agents.

And yes, ideally one person, the agent engineer, would have all of these assets, but it's early on. We're still figuring out what these means. And so building agents is becoming a team sport. And the way that we're helping with that, or trying to help with that, is LangSmith. So LangSmith, we think of observability, evals, and prompt engineering.

And we view this as a platform to bring everyone together to build agents as a team. So what do I mean by that? We see tracing and the observability that it provides as a really integral way for everyone, but especially product people, to see what's going on inside the agent.

So you can see all the steps that are happening. You can see the inputs and outputs. And so if you're trying to replicate a human workflow that you understand, this provides the best kind of like pane of glass into what's happening. I mentioned evals being important. This is where the machine learning knowledge comes into play.

And so we try to make it incredibly easy to build data sets and run evals both offline and online in LangSmith and provide that team functionality there. And finally, prompting. Prompting is a key part of building agents. We have a prompt hub. We have a prompt playground. The reason that all of these are in the same platform, LangSmith, is because we think building agents is a team sport, and there needs to be this platform for all these people of different backgrounds and strengths to collaborate on agents in one place.

And so that's where we are today, and I want to emphasize that agents are here. We're going to be hearing later on from a bunch of folks who have built agents, and so you'll hear about that. I also think that they've been around for a little bit. You know, people are saying 2025 is the year of agents.

I think 2024 is really when we started to see a lot of these come online. And so agents are definitely here today. We have a number of these companies speaking about how they're building agents. We'll talk with Replit next, and CodeGen has obviously been the biggest space that's been transformed, but we've seen a lot in customer support, in AI search, co-pilots.

And so agents are here. They're possible to build it, and hopefully today, hearing the stories of a lot of people who are building will show that. The thing that is happening that we see happening this year is agents that were built last year are starting to get more and more traction.

They're starting to go to production. They're starting to be used in larger scales by a lot of folks. And I think a cool stat that backs this up is if you look at some of the Lingsmith traction that we've had in terms of traces coming in. So you can see that at the start of this year, there's kind of been this influx in just trace volume.

And this speaks to the fact that agents not only are here, but they're being used consistently and providing value to folks. So those are three beliefs that we've built up over the past few years about what it's like to build agents now. So where do we think the industry is headed?

What are some beliefs we have about the future? As we see more and more agents going into production, one of the things that we're starting to believe more strongly is that AI observability is different than traditional observability. So what I mean by that is when you're dealing with agents, you're getting all of these large, unstructured, often multimodal payloads that are coming in to a platform.

And those are some technical differences from traditional observability. But also what's different is the user persona that the observability logs are being used for. They're not built for an SRE. They're built for this agent engineer persona. And that needs to bring in some of these ML concepts, some of that product concepts, some of that prompt engineering context, and provide this different type of AI observability.

And we've always had AI observability in Langsmith from traditional metrics to business metrics to more qualitative metrics. And today we're excited to launch a new series of metrics around agents. So specifically, we're launching better insight into the tools that your agents are using. So you can track the run counts of tools, the latencies, the errors.

And then we're also launching trajectory observability. So you can see which paths your agents are taking and, again, the latency and errors associated with that. And so this is available today in Langsmith if you go and send a bunch of traces, you can start to see this populate. The next belief we have is that everyone will be an agent builder.

So when we talk about this agent engineer, it combines these four different aspects. And realistically, right now, it's so early on that no one really is at the center of all of this and has all of these skills. And so, yes, we want to make it possible for people to collaborate and build agents as a team sport.

And this is Langsmith. But we also want to try to move folks who are maybe in one of these quadrants in a traditional engineering background or in a product background or in an ML background, move them more towards the center so that they can build agents. So what does that mean?

So if we think about developers who don't have a background in AI and aren't familiar with this, how can we enable them to build agents more easily? The thing that we've been building towards this, we've launched a few things over the past few months in this, is what we're calling Langraft pre-builds.

So these are common agent architectures for the variety of different agent types that we see out there. So single agents, agent swarms, supervisor agents, there's some other ones as well. We want to make it really easy for anyone who doesn't understand agents or is coming to it from an engineering background to easily get started with these common architectures.

At the next level, we want to make it possible for people who are on these product engineering teams, but maybe not developers themselves, to be more involved in building agents. So one of the coolest things that we launched, maybe a year ago at this point, is Langraft Studio. And so today we're excited to give it a facelift.

We're launching Langraft Studio V2. No more desktop apps. So you can run it if you're not on Mac anymore. And it comes with a bunch of improvements as well. So you can see all the LLM calls in a playground directly in the studio. You can build up data sets here.

You can modify prompts as well. So you can start to modify the agent. And I think most excitingly is you can pull down production traces from LangSmith into your local LangGraph Studio so that you can start to modify the agent. It will then hot reload. And then you can kind of fix these production issues that you're seeing.

And then finally, we want to make it possible for more and more people who aren't developers at all to build agents from scratch, not just on product engineering teams. And so when we think about folks at larger enterprises, there are often a number of tasks that they want to do and build agents for.

And it's tough to get kind of like engineering resources to start. And so we want to make it more and more easy for folks to build agents in a no-code way. And so today we're launching open source open agent platform. It's powered by LangGraph platform. It uses agent templates to allow people to build agents in a no-code way.

It comes with a tool server that uses MCP. It comes with RAG as a service so you can easily get started with anything related to RAG. And it contains an agent registry so that you can see all the different agents that you've created. And so this is open source.

You can check it out today. And finally, the last belief we have is that deployment of agents is the next hurdle. So it's possible to build agents. We've talked about what it looks like. Once you build an agent, you then need to deploy it. And sometimes this can be easy.

Sometimes you can stand up kind of like a traditional kind of like web server and put it behind it. But we see more and more that agents are looking a little bit different than traditional web apps. So specifically, they're often long running. We see agents -- deep research is a great example that takes 10 minutes to run.

We see agents that are taking an hour, 12 hours to run. They're often bursty in nature. So especially if you kick them off as background jobs, you might be kicking them off hundreds or thousands at a time. And they're flaky. They're flaky in a bunch of different ways. You know, the calls to the LLM might fail.

But also, you want to have human in the loop because these LLMs might not do what you expect. And so you need some statefulness in these agents to allow this human in the loop or human on the loop interaction patterns. And so we've seen these patterns crop up. We think that agents are going to become more and more long running, more and more bursty, and more and more stateful.

And so we want to help people tackle this deployment challenge. And so Langraph platform, we launched in beta about a year ago. And today we're excited to announce that it's officially generally available. So what's in Langraph platform, if you haven't checked it out, there are 30 different API endpoints that we stand up for everything from streaming to human in the loop to memory.

It scales horizontally so it can handle burstiness. It's designed for these long running workloads. And you can actually expose the agents that you deploy here as MCP servers. It also comes with a control plane where you can discover the agents that everyone at your org has deployed. You can share agents.

You can reuse these agents with templates. And then there are a few different deployment options. So we have a cloud SaaS offering as well as hybrid and then fully self-hosted options. So you can try this out if you go to Langsmith today. And if you're interested in any of the hybrid or fully self-hosted, feel free to get in touch.

So that wraps it up for the keynote. And before we go on to the next section, I want to thank a bunch of people because this is a fantastic event and I'm really grateful for a number of people who have made this possible. So Cisco customer experience is our presenting sponsor.

You'll hear from them later on. They've done a fantastic job at building some really complex agents that are transforming how they do work. And I'm excited for you all to hear more about that. We have a bunch of incredible sponsors. So I saw there was a lot of lines at the booths out there.

And I think that's in part because we have some of the most interesting agent companies in the world sponsoring this event. And so I'd highly encourage everyone to go check them out and talk to them. I think, you know, we have some ideas of what the future will look like, but so do the people here.

And so I'd encourage everyone to go check them out and talk to them later on. And then finally, I want to thank all of the speakers. We have an incredible lineup. I think everyone here is going to learn a ton. We've tried really, really hard to bring together a collection of folks who have actually built agents and put them in production so that you can hear from them and learn from them what that looks like.

And so I'm really excited to hear a lot of these talks, and I hope you all are as well. Thank you. Thank you. Thank you. Thank you. Thank you.