Everything Gets Rebuilt: The New AI Agent Stack | Harrison Chase, LangChain

**Harrison Chase** (0:00)
I think two things basically happened. The models got better, but then also, we started to discover these primitives of a harness that would really let the models do their best work. And we saw an explosion of people building agents.

**Matt Turck** (0:10)
Do you think that the models end up eating the framework layer, or do you think the framework and infra layer eats the models?

**Harrison Chase** (0:19)
I think the harness is the most important thing. The cloth models are great, but the harness is really what made that work.

**Matt Turck** (0:24)
Hi, I'm Matt Turck, welcome to The MAD Podcast. Today, my guest is Harrison Chase, co-founder and CEO of LangChain. Harrison has been one of the key figures in the rise of AI infrastructure and agents, from LangChain's early days as an open-source framework to the broader evolution of LangGraph, DeepAgent, LangSmith and AgentBuilder. This episode is a deep dive into the frontier of the AI stack. As AI moves from simple prompts to agents that can plan, use tools, write code and manage memory, the big question is what new infrastructure is required. We talk about agent runtimes, harnesses, observability and where the future of AI infra is heading. Please enjoy this great conversation with Harrison Chase.
Hey, Harrison, good to see you.

**Harrison Chase** (1:07)
Thank you for having me. I'm excited to be here.

**Matt Turck** (1:09)
So for anybody watching this on YouTube or Spotify video and who is a regular watcher of The MAD Podcast, you'll notice that we are in a different venue today. We're not in the usual studio. We are in an epic venue at the Chase Center in San Francisco. We're recording this as part of the Daytona Compute Conference today. So I thought a good place to start would be to frame the evolution of agents over the last few years. This seems that there was a huge moment, I think sometime around the holidays, December and January, when everyone kind of realized at the same time how far agents had come in just a few months. So help us maybe compare and contrast the first generation of agents compared to what we have today.

**Harrison Chase** (1:58)
Yeah, so I think a lot of the ideas behind the agents today were actually present in some of the early day stuff. The difference was the models just didn't work back then.
So LangChain came out maybe half a month or a full month before ChatGBT. And one of the main things we added at the start was this idea of running an LLM in a loop and calling tools. And there was this great paper called React, which basically said to do exactly that. And it worked for the data set that they ran it on, which was like Wikipedia question answers, but it didn't work in the real world. And then in March, I think, AutoGPT came out and that was the same thing. It ran in a loop, called tools, gave it a bunch of stuff. It really was like a precursor to open claw in a lot of ways. And then the way that I would describe the trajectory of agents since then is basically, there was this core really simple idea, just run the LLM in a loop, have it call tools, give it a prompt, give it some instructions, give it a bunch of different tools. But that didn't work really well. So people ended up building scaffolding around the models to make them do things in a more predictable and reliable way. And that's why we at LangChain, we built LangGraph, which is another framework really aimed at that graph-like workflows and giving more structure. And when you really want like super high reliability, you want to use something like that. But I think sometime in maybe like November, December with some of the newest Claude models, the models just got really good and you kind of discovered that they could actually just run in a loop. And a lot of this, this wasn't just the models, it was also the harness around the models. So what I mean by that is if you look at things that came out about a year ago, Claude code, Manus, deep research, they all had the same thing of running the model in a loop, having it call tools, it could write some code, it could read and write files.
And so I think two things basically happened. The models got better, but then also we started to discover these primitives of a harness that would really let the models do their best work. And I think over break, people basically realized that and we saw an explosion of people building agents for different things using these same core primitives.