Harrison Chase of LangChain on Deep Agents, LangSmith, and Earning Trust | NVIDIA AI Podcast Ep. 297

0:00 And so I think like these always-on, asynchronous,

0:02 event-driven agents—that will be a really big productivity unlock.

0:06 And especially in enterprises,

0:07 there's so many events that are just triggering, triggering, triggering.

0:10 And so if you can have agents listening to those and firing off,

0:12 I think that will be a massive gain.

0:18 Welcome to the NVIDIA AI Podcast.

0:20 I'm Noah Kravitz.

0:21 Our guest today is Harrison Chase.

0:23 Harrison is CEO and co-founder of LangChain,

0:26 one of just the most incredible stories

0:29 of this whole generative AI era that we're in.

0:33 As Harrison will get into in a minute,

0:34 LangChain was founded about three years ago, over a billion downloads.

0:39 The whole point is to help developers build applications with LLMs

0:42 now getting into agents and agentic frameworks and all that great stuff.

0:46 So we're going to get into it in a moment.

0:48 Harrison, thanks so much for joining the AI Podcast, and welcome.

0:51 Thanks for having me.

0:52 Excited to be here.

0:53 So, let's start about three years ago.

0:56 You started LangChain with this premise of building

0:59 tools so developers could build apps with LLMs.

1:03 What did you see back then that either others didn't, or even if they did,

1:08 you saw it and just thought, this is where things are going.

1:10 This is where I'm headed.

1:12 What got us really interested was seeing

1:15 the applications that people were building on top

1:18 of LLMs and the systems they were building

1:21 around the LLMs in order to power those applications.

1:24 And those systems had a lot of similarity with each other, even early on.

1:28 And even early on, we could tell that they would get quite complex over time.

1:32 And so a lot of what we built is tools to help people build these systems,

1:36 these agents, which we now call agents, around these LLMs,

1:39 and figuring out what the common patterns are, and how common this tooling is,

1:43 and making it really easy for anyone to do so.

1:46 And so now you've coined this, I don't want to say this term,

1:49 but LangChain, you talk about deep agents.

1:53 So what is a deep agent?

1:54 And then maybe we can get into talking about the enterprise.

1:57 And why would an enterprise in particular care about that distinction?

2:01 Yeah, so about a year ago, we saw a few really interesting things.

2:04 So maybe even backing up like, you know, three years ago, great, like LLMs,

2:07 you want to connect data, you want to connect these other things to them.

2:10 Fantastic.

2:11 How do you do that?

2:12 Turns out, it's really hard.

2:13 And the best way to do that for different

2:15 types of agents was actually pretty different.

2:17 You would build different scaffolding,

2:18 you would build different workflows around the LLMs.

2:20 About a year ago, we saw Claude Code come out.

2:23 We saw Manus come out.

2:24 We saw Deep Research come out.

2:26 And under the hood, all of these had the same kind of general architecture.

2:30 They were simple in some ways, they were now running in a loop calling tools,

2:35 but then they also had common patterns of connecting to a file system,

2:39 and having sub-agents, and doing planning.

2:41 And so about nine months ago, we released, for the first time,

2:45 Deep Agents, which is a library, and we've been building it ever since.

2:49 And we've just continued to see this same pattern

2:53 of giving the LLM more autonomy in this environment for interacting.

2:57 This is what powers OpenClaw, for example, is this type of harness.

3:01 And so Deep Agents is really this new type of agent harness that we

3:05 think is really general purpose and that you

3:08 can customize to do different things.

3:09 But it's not like you're reinventing the scaffolding each time.

3:12 You're just customizing it with prompts or tools.

3:14 And so it's way easier to get started with and also way more powerful,

3:17 because it's a simple thing under the hood, and simple is really good.

3:21 And so Deep Agents is this general purpose agent harness,

3:24 model-agnostic, open source, that we've been building for a while.

3:27 And we're starting to see more and more agents build on top of.

3:31 So when you're working with customers and the enterprise in particular,

3:37 and we're getting into these systems that are so powerful, becoming so powerful,

3:42 in large part because they are autonomous to a larger degree.

3:45 And as you said, they can do more now.

3:47 The agents can control the screen and go off and do things with apps and such.

3:51 What's the...

3:52 what are your conversations like with enterprise leaders,

3:55 and what's kind of the feeling around,

3:58 you know, is it a tension between risk-reward,

4:01 is it just the excitement for what the systems can do,

4:04 and so there's trust in building these systems that give agents more leeway?

4:09 What are those conversations like?

4:10 There's a lot of things.

4:12 So one, not everything needs an autonomous agent.

4:15 And so one framework we have, LangGraph,

4:17 is really good for when you actually want to combine some

4:19 of the autonomy of LLMs with more directed workflows and more control.

4:25 And so, honestly, when talking with a lot of enterprises about deep agents,

4:28 some of them are just like, we love LangGraph.

4:30 LangGraph is better.

4:30 We're gonna stick with LangGraph.

4:32 And that's fine with us.

4:32 We think there are different use cases and different things.

4:34 But that's definitely kind of like one component that comes into it.

4:38 Another component that comes into it is definitely just like, okay, great.

4:41 Like the LLM's doing a bunch, but how do we know what's going on?

4:44 And so another thing that we work on is LangSmith,

4:47 which is observability and evals.

4:48 And that's basically our answer for that.

4:50 You...

4:50 there's this really interesting thing about

4:52 agents compared to software, where agents...

4:55 the interaction space for agents is way more open ended.

4:58 You can ask it anything, like text is infinite.

5:00 If you have a UI, there's a bunch of different buttons you can click,

5:03 and so it's much more constrained.

5:05 And then also models are not robust at all—like you know,

5:09 they're non-deterministic, and then you change one word,

5:11 and the answer changes completely.

5:12 So this is why we think observability is really important.

5:14 And that's a huge thing that enterprises care about,

5:16 and very related to observability is then evals.

5:18 Because sure, you can see one thing that happens,

5:20 you can tell why it goes wrong,

5:22 but what if you wanna test how it did on like 10 different questions,

5:26 100 different questions?

5:27 And so building up these eval datasets is a big thing we work with folks on.

5:31 And so LangSmith is the platform for building agents,

5:34 as well as observing and evaluating?

5:36 Yeah, so the way that we think about

5:38 the agent development lifecycle is build, test, run, manage.

5:43 And so the build is all the open source.

5:45 It's like choose your fighter, choose LangGraph,

5:47 choose Deep Agents, choose another framework.

5:48 All of our stuff works kind of modularly.

5:51 But then this test, run, manage—that's LangSmith.

5:54 So we've got a bunch of stuff around testing and evaluating these models.

5:57 We have a deployment platform for deploying these at scale,

6:01 and then we have observability and other things for managing them.

6:04 Let's talk about skill, or maybe you can talk about skills for a minute.

6:07 When I first started playing with these tools...

6:09 and I'm, you know, I'm not a developer,

6:11 I'm just kind of a technical layperson, if you will, right?

6:13 I love playing with these things.

6:15 Back in the day when they first came out, maybe it was BabyAGI, whatever it was.

6:19 I, you know, spun my computer right into the ground in an infinite loop.

6:23 But when I first discovered skills, it took me...

6:27 like there was a moment where it sort of took me back,

6:29 where I was like, wait, I just describe it, and it goes off and it builds.

6:34 And then, of course, it does, because that's how this all works.

6:36 But can you talk a little bit about skills and about,

6:39 kind of, that same idea of giving the agent

6:44 the autonomy to write the tool and run with it?

6:47 But how do you keep it in check and keep things secure?

6:50 Yeah, skills are a great way to package up knowledge and in other

6:53 kind of like instruction sets and other tools for an agent to use.

6:57 And so they started in coding agents,

6:58 and a skill would involve basically a Markdown file

7:01 with some instructions and then some scripts that you could run.

7:05 And one of the things that's kind of become clear over the past few

7:08 months is like coding agents are very general purpose in a lot of ways.

7:11 And so this same idea of a skill as a Markdown

7:14 file and then some scripts to run is really, really interesting.

7:18 We see a bunch of different types of skills.

7:19 Some of the skills are purely kind of like informational.

7:21 So like you want to learn about something, great, go read this Markdown file.

7:25 Other skills do things.

7:26 And this is where it starts to get, I think, like really interesting.

7:28 It could be a Python script that hits a URL.

7:31 It could be a Python script that runs some GPU-accelerated compute.

7:35 And so this also ties into the environment aspect.

7:38 So when we think about agents, we think of a model, a harness,

7:41 and this is Deep Agents,

7:42 and then an environment that it runs in—a runtime for it.

7:45 And so NVIDIA just released OpenShell, which is a secure runtime for it.

7:51 And then the other thing that's related

7:52 to the runtime is also like where it runs.

7:53 Does it run on a Mac mini?

7:55 Does it run on some GPU-accelerated environment?

7:58 Does it run in the cloud?

7:59 Right.

7:59 And so those three components and being able to pick and choose what you

8:03 need for different jobs is a big part of kind of like customizing your agents.

8:08 Was there a moment, or can I put you on the spot and ask you to think of kind

8:11 of an aha moment where this, the idea

8:13 of Deep Agents really clicked and in a use case, and whether it was, you know,

8:19 something internal at LangChain you were working on, or maybe with a customer,

8:22 was there kind of an aha moment where you were like, yeah, this is it?

8:26 I think so it started just by seeing really the three things of Manus,

8:30 Deep Research, and Claude Code.

8:32 This is the same way that LangChain started as well,

8:33 just going to early meetups,

8:35 seeing things that people were building, and seeing patterns.

8:38 And so the first version of Deep Agents,

8:39 just like the first version of LangChain,

8:42 I hacked on over a weekend, and it was a weekend project.

8:45 I'd been talking internally with some folks and being like,

8:47 oh, like, you know, Claude Code's really interesting.

8:48 Like, Manus, they've got some similarities.

8:51 And so it wasn't until I had time to kind of like sit down on a weekend

8:55 and hack some stuff together that we came up

8:58 with a few patterns of what these similarities actually were.

9:01 And then using it, I think the first thing

9:04 we used it for was a deep research-type thing.

9:06 And so we gave it access to a bunch of files,

9:09 and we just put it in this like virtual file system and had to do some research.

9:13 And it wasn't even really doing RAG.

9:14 It was just grepping and globbing like a coding agent would over these files.

9:19 And it worked fantastically well.

9:21 And so i'd say deep research was the first concrete thing,

9:23 but really the idea came came from just seeing a pattern

9:26 and spending a weekend kind of like hacking on it.

9:29 You mentioned earlier the importance of, I don't know what the words you use,

9:35 but auditability, traceability,

9:36 being able to see how do the agents do what they did.

9:40 Can you talk a little bit about evaluation-driven development,

9:44 and how that plays into, and again,

9:47 in the enterprise, building that trust in what the agents are doing?

9:51 Yeah, if you talk about trust in an enterprise, what does that mean?

9:53 That means that the agent's doing what you want it to do.

9:55 There's a few different ways that we see people getting that trust.

9:59 Part of it is observability and traceability and being able to go into an agent

10:03 run and see exactly what steps it took and exactly what it did.

10:07 The other part where trust comes in is having these scenarios and running

10:12 the agent over them and seeing how it performs and evaluating that.

10:16 This is what we talk about as evaluation-driven development.

10:18 You come up with these scenarios ahead of time.

10:21 One common misconception here, by the way,

10:23 is that you need like 1,000 scenarios for it to be effective.

10:26 You could start with five.

10:27 You could start with ten.

10:28 It really doesn't matter.

10:29 I think like creating these evals is

10:31 a really good way to do like product thinking, about what the agent should act.

10:35 Because this is another thing, like agents can do anything.

10:37 But they shouldn't do everything.

10:38 They should do like what you want them to do.

10:40 And so being able to...

10:41 being forced to come up with, like, hey,

10:43 these are 10 questions that we expect the agent to get asked.

10:46 This is what we think a good response is for each of them.

10:49 This is what a bad response is for each of them.

10:50 That's a really good kind of like mental model for kind

10:53 of like coming up with what these agents should do.

10:55 And then you can use that to drive all of your changes.

10:58 So you change a prompt.

10:59 You can run it against this benchmark.

11:00 Did it improve?

11:01 Did it get worse?

11:03 And then this eval dataset is living over time as well.

11:07 So as you release it to first like a small set of users,

11:10 you might see them using it in unexpected ways.

11:13 And then some of those ways you might be like,

11:14 okay, maybe they shouldn't be doing that.

11:15 Let's put some guardrails around it.

11:17 But other ways you might be like, yeah, that's totally legitimate.

11:19 We had no idea they would use it.

11:21 Let's add some data points to our eval dataset.

11:23 So when we go and change the prompt in the future,

11:25 we can make sure that it's still good at these use cases.

11:27 Are enterprise customers open to kind of rolling with that, you know,

11:32 oh, we weren't expecting this behavior necessarily, but it's good behavior.

11:36 And so, you know, is there a sense of kind of experimentation?

11:40 Obviously, in the AI community and the open source community,

11:43 it's all about experimenting and sharing, and things are going so fast.

11:47 Is enterprise embracing that at all?

11:50 The best ones do, in limited ways, and with a limited blast radius.

11:54 They might roll out internally, for example.

11:56 They might roll it out to a set of like alpha customers.

11:59 They might roll it out to 1% of users, or something like that.

12:03 There's definitely way more caution there

12:04 than there is with gen AI-native startups.

12:07 But building agents is so iterative,

12:10 and the importance of this iteration can really not be understated.

12:13 And so I think the enterprises that are...

12:16 I think a failure mode for enterprises is you have some idea of an agent.

12:21 You take three months to craft a bunch of examples.

12:24 You take another three months to build the agent.

12:27 You take another three months to get humans to look at everything.

12:30 But the spaces just move so fast.

12:33 The whole idea you came up with, there's probably like...

12:36 there's just a better way to do it at that point.

12:38 And so I think like you have to kind of ship.

12:40 You have to learn.

12:41 You have, this is another thing by the way,

12:43 that no one likes the answer for, but like

12:45 you have to, you have to basically redo your agent every nine months at the pace

12:49 that things have been like with these agent harnesses.

12:52 If you're using an agent architecture from like a year and a half ago,

12:56 you should very strongly be considering looking at rewriting

12:59 on top of an agent harness or something like that.

13:02 Right.

13:03 For performance only or for...

13:05 Yeah, for performance.

13:06 That's still the...

13:08 So there's two things.

13:09 It's like performance, but also scope of what the agent can do.

13:12 So if the agent is doing a very small thing,

13:14 it's not as valuable as if it's doing a big thing.

13:16 And maybe like a year and a half ago,

13:17 you just couldn't get it to do the big thing.

13:19 So you focused on the small thing.

13:20 But now you can.

13:21 And so if you're not like reevaluating that and saying,

13:23 hey, there's this big thing, let's hook up an agent harness.

13:25 Let's take a stab at that.

13:27 You absolutely need to be doing that.

13:30 So I want to ask you about models.

13:33 Frontier models, you know, the...

13:35 I would say everybody, but I think the kind of mainstream AI world,

13:39 you know, focused on the latest and greatest

13:41 and what can they do and everything.

13:44 Open models have become incredibly important.

13:47 I mean, they've always been important,

13:48 but I feel like the past year or so, incredibly important.

13:51 You know, you spoke earlier about OpenClaw,

13:54 and NVIDIA's OpenShell, and the Nemotron family of models.

13:59 How do you approach, and how does LangChain approach, and then your customers,

14:04 mixing frontier and open models together to achieve

14:08 cost-performance ratio and all manner of other things?

14:12 What's your approach on mixing those?

14:16 Yeah, I think there's a bunch of different ways that we combine them.

14:19 So I think like one obvious way that we worked

14:21 with NVIDIA on a blueprint for is with deep research,

14:23 you have a bunch of sub-agents,

14:25 and those sub-agents might want to be specialized agents.

14:27 And there might be an orchestrator kind

14:29 of like agent that's using a frontier model,

14:31 but then when it goes to a sub-agent,

14:32 it might want to use either like a fine-tuning model or an open source model.

14:36 for cost or any seen reasons.

14:38 And so when you have these big agentic systems with these sub-agents,

14:40 it's totally possible that one part could be using a frontier model,

14:43 and one part could be using an open source model,

14:45 and another part could be using a fine-tuned model.

14:48 The other...

14:49 We've been paying a lot more attention to open source in the past,

14:52 even just like two weeks I would say, for probably two reasons.

14:55 One, I think they're getting good enough to where they can drive this harness.

15:00 So being able to properly utilize everything in the harness is not super easy.

15:06 And for a while, it was only the frontier models that could do that.

15:08 We're starting to see, they're still a step below the frontier,

15:10 but we're starting to see that these open source models can drive the harness,

15:14 which is really interesting, because this is the most agentic stuff.

15:17 And then the other thing that's causing us to look really hard at open models...

15:20 If I could stop you for a second, Harris, and back up.

15:23 What are the qualities that a model needs to drive the harnesses successfully?

15:29 So at the risk of sounding a little broad, like it needs to be intelligent.

15:32 It needs to be good.

15:34 Another thing that is maybe underappreciated is

15:36 it probably needs to be good at coding.

15:38 So we've actually seen that like Qwen Coder is a better

15:41 general purpose model than just the Qwen series of models.

15:44 Because a lot of what makes up this harness looks very similar to coding agents.

15:48 So this harness has a file system; it has a bash tool.

15:51 So if the model knows how to use it,

15:52 if it's a coding model, then that's actually really, really good.

15:55 And so I think models that are better

15:56 at coding are generally actually better general purpose agents.

15:59 Yeah, no, that makes sense.

16:01 And so then the sub-agent models you were talking about.

16:03 Yeah, and so then a second thing that made us look

16:05 at this, look at open source models even more is OpenClaw.

16:09 So there's a bunch of really interesting things about OpenClaw,

16:11 but one of the interesting things is,

16:13 it's always on; it's proactive; it's running.

16:15 And so if you're using a coding agent and you kick it off,

16:18 even let's say like 20 times a day,

16:21 you're probably okay paying some good amount for that.

16:24 If it's running every 10 minutes, like, oh my God, you cannot.

16:27 And if you, if you're running like three of these, like you,

16:30 you just cannot do that.

16:31 And so I think like cost is a really interesting reason for these open models,

16:35 especially in these proactive, always-on scenarios, to make them become popular.

16:42 Shifting gears for a second, LangChain just opened,

16:45 NVIDIA formed the Nemotron Coalition, and LangChain joined.

16:49 Can you talk a little bit about why and what

16:52 it may or may not mean going forward for LangChain users?

16:56 Yeah, we need open models and we need harnesses that they can run in.

17:01 And we think we can provide the harness,

17:03 and we want to work with NVIDIA and all the other companies in the coalition

17:06 to help provide a model that can work with that harness, and others as well.

17:11 I think, as we talked about, the open source models are getting good.

17:15 They're still a little bit behind the frontier

17:17 models in terms of driving the harness,

17:19 and so great, we can use them in subagents,

17:21 we can maybe use them for some of these kind of triggers in the always-on,

17:26 but if they can drive the really expensive workloads,

17:29 I think that's going to be really transformational,

17:32 in terms of what you can do with open models,

17:35 which generally mean what you can do with more sensitive data,

17:39 what you can do more cheaply, what you can offer to customers, just more.

17:45 And so, yeah, I think at a really high level,

17:46 we're excited about the NVIDIA Nemotron Coalition because we want

17:50 an open model that works really well with open harnesses.

17:53 And then a third part,

17:54 which actually I don't think was part of the coalition when it started,

17:57 but I think the open runtime is really important as well.

18:00 And you guys are also doing stuff around that.

18:03 This is my favorite question to ask, and, you know,

18:06 I'm sure the hardest, but maybe the most fun to answer.

18:10 What's next?

18:11 What do you think agents, agentic systems, LangSmith, LangChain,

18:15 the company for that matter, is going to look like in...

18:18 and I'll let you kind of go with what timeframe makes the most sense.

18:21 Cause I ask, and depending on the guest, they're like—a year.

18:25 No, that's too long.

18:25 No, no, no, no, no.

18:27 But what do you think's coming down the pike as far as, you know,

18:30 agentic systems and all of these things that you're working on every day?

18:34 I'd maybe call out kind of like three things that I think are interesting.

18:40 One's pretty short term, and I think we'll see in the next like month or two,

18:43 if not by the time this comes out, but asynchronous sub-agents.

18:47 So right now, when an agent kicks off a sub-agent,

18:50 it basically waits for it to respond, and that's great.

18:54 But...

18:54 If these sub-agents start to get really long running,

18:57 you want to just have them run in the background.

18:58 And you want to have this manager orchestrator agent

19:01 like check in on them and maybe update them.

19:05 And so I think one trend that we'll see is encoding.

19:07 Right now, encoding agents, you interact with the agents that's doing coding.

19:10 I think we'll start to see a trend

19:11 where you interact with this orchestrator agent,

19:13 and that orchestrator agent spins up a bunch of background coding agents.

19:17 And you just talk to the orchestrator and say,

19:18 hey, what's going on with this experiment?

19:20 What's going on with this feature?

19:21 And so I think we'll start to see

19:23 asynchronous sub-agents become a bigger and bigger topic.

19:25 Man, I hate to resort to productivity, but how much of a...

19:28 is that going to be a step change?

19:30 Or how much of a difference in terms of what you're able to accomplish?

19:33 So I think, I think this bill...

19:35 like the only reason asynchronous sub-agents even make sense is if the agent,

19:39 the sub-agents themselves actually run for a while, right?

19:42 Like if they just run for like one second and then return,

19:44 you can just make them synchronous.

19:46 And so I think it will be a productivity gain,

19:51 but it requires these agents to be long running in the first place.

19:54 And I think that's the real productivity gain,

19:56 and I think this is just a nice interface on top of them.

19:59 One thing that wasn't on my list of three things,

20:02 but I think will also be more and more impactful,

20:05 is basically these agents being proactive,

20:06 running in the background, always on, listening to events.

20:09 That I think will be a massive productivity gain.

20:11 So I have an email agent, it runs in the background.

20:13 It listens to my emails.

20:15 When it wants to respond, there's still human in the loop, but it flags a draft,

20:19 and it's like, hey, here's a draft, do you wanna approve it?

20:21 Do you wanna change something?

20:23 That is so much more efficient than if I had to go,

20:26 there's no way I would take an email,

20:28 copy-paste it, go to ChatGPT, say, hey, can you draft me a response?

20:31 Copy-paste that.

20:32 Like that...

20:33 and so I think these always-on, asynchronous, event-driven agents,

20:36 that will be a really big productivity unlock.

20:39 And especially in enterprises,

20:40 there's so many events that are just triggering, triggering, triggering.

20:43 And so if you can have agents listening to those and firing off,

20:46 I think that will be a massive gain.

20:48 The other two things that I think are coming down—One, agent memory.

20:52 We started to see this a little bit with OpenClaw,

20:54 but I think the idea that it could remember things as you interact with it,

20:56 it could actually update its own tools and skills and description itself.

21:00 I think more and more,

21:01 we'll see agents kind of like remembering things and yeah,

21:05 learning from their interactions.

21:07 And that's why human in the loop is important as well.

21:09 That's why I don't think these things will be fully autonomous,

21:11 because they need to learn.

21:13 And the only way you do that is

21:14 by interacting with the environment, with humans.

21:16 And so I think that'll be a big piece of it.

21:18 And then the last thing is agent identity.

21:20 So, you know, if there's an agent in an enterprise,

21:24 and I chat with it, and you chat with it, whose credentials does it use?

21:27 Does it use mine?

21:28 Does it use yours?

21:29 Does it use a fixed set?

21:30 So previous to OpenClaw,

21:31 I think we saw that basically everyone was doing the on-behalf-of model.

21:37 So the agent would act on behalf of me, on behalf of you,

21:39 on behalf of the end user, and it would pass like my Slack credentials through.

21:43 And so I might get a different answer than you would get.

21:45 I think the thing that OpenClaw changed is,

21:47 people started thinking of these agents as like identities,

21:50 as their own, as their own things.

21:52 And I think we'll actually see more things where they will be like—hey,

21:55 Tom is a marketing agent, and you can chat with Tom,

21:59 and I can chat with Tom, and Tom has a persistent memory,

22:01 and Tom has its own credentials, and Tom can go and do things.

22:03 And Tom is Tom.

22:04 Tom is not acting on behalf of me or you.

22:06 Tom has its own accounts with Slack or Gmail.

22:09 And that's a big thing that we need to figure

22:10 out that I don't think anyone in the industry really knows.

22:12 You know, I was chatting with one SaaS provider.

22:15 They, in all the OpenClaw craziness,

22:17 they were making it really easy for people to create accounts for their agents,

22:21 but it's still like an account.

22:22 And so like, will we see,

22:23 will we just see more and more people create normal accounts?

22:26 Will there be special agent accounts?

22:28 I don't know.

22:28 But I think this idea of like agent identity is really interesting.

22:31 Yeah.

22:31 There's a whole can of worms on the other

22:33 side of the words "agent identity," I think, but not for this conversation.

22:37 So, you know, you mentioned the weekend project that you

22:41 worked on that unlocked things at LangChain for you,

22:44 OpenClaw, another weekend project, went incredibly viral, incredibly quickly.

22:51 What are your thoughts, or how has that impacted the work you do?

22:55 And I'm thinking more about the perception that users,

22:59 developers, enterprise customers might have about agents.

23:02 Has it really, you know, has it,

23:04 was there a rush of people knocking at your door saying like,

23:07 hey, can you build me a claw?

23:08 Like, how does it change things?

23:10 One hundred percent.

23:11 I mean, I think Jensen said, uh, what'd he say?

23:13 Every enterprise needs a claw strategy, or something like that.

23:15 And we're absolutely seeing that.

23:17 I think like it's set a north star.

23:19 It's set a new objective for kind of like

23:22 what these agents can and should be able to do.

23:25 Now...

23:25 There are a lot of things that you probably want

23:27 to do more securely than kind of like in an OpenClaw.

23:30 The whole reason it took off is because it can do everything,

23:32 and that's great for weekend projects and hobbyists.

23:35 But when you bring it into an enterprise,

23:37 you're understandably going to want more control.

23:39 That's why we're thinking about agent identity.

23:41 That's why we're thinking about observability.

23:43 But in terms of like, did it change the north star for what we build?

23:47 Absolutely, it did.

23:48 I think it also made it so much easier to communicate some of the ideas as well.

23:54 And so that's been fantastic as well.

23:56 Amazing.

23:57 Harrison, there's so much we just talked about in a short amount of time,

24:00 and so much more, but I'm sure by the time we cross paths again,

24:04 as you mentioned, right,

24:05 you take three months to scope and three months to build,

24:08 and all of a sudden it's nine months, and no more.

24:11 So the next time we cross paths, I'm sure it'll be a different looking world,

24:15 but kind of built on these same things.

24:17 But for folks who've been listening or watching and want

24:20 to learn more about LangChain and the work you're doing.

24:23 Best places to go online?

24:24 Websites, socials, research blog, anything like that?

24:28 Yeah, we have a great blog.

24:29 It's blog.langchain.com.

24:31 A lot of the stuff we talked about around

24:33 context engineering and agent identity will be blogs on there,

24:36 and we update that a lot.

24:37 And then Twitter.

24:38 I think everything in AI is happening on Twitter.

24:41 We're just LangChain on Twitter, and so you can find us there.

24:44 Easy enough.

24:45 Harrison Chase, thank you so much.

24:46 It's been an absolute pleasure.

24:47 Appreciate you taking the time to join the podcast.

24:50 Thank you for having me.