Building the future of agents with Claude

Brad Abrams 0:00 'Cause as a developer, like, my creativity ends at some point.

Alex Albert 0:04 Yeah.

Brad Abrams 0:04 I can only think of so many use cases.

Alex Albert 0:06 Right.

Brad Abrams 0:06 But the model, like, anything, anything somebody comes with, the model will figure out a way-

Alex Albert 0:11 Right

Brad Abrams 0:11 ... to go do that thing. [upbeat music]

Alex Albert 0:16 Hey, I'm Alex. I lead Claude Relations here at Anthropic. Today we're talking about building the future of agents with Claude, and I'm joined by my colleagues.

Brad Abrams 0:23 I'm Brad. I run the PM team on the Claude Developer Platform.

Katelyn Lesse 0:27 I'm Katelyn. I lead the Engineering team for the Claude Developer

Katelyn Lesse 0:30 Platform.

Alex Albert 0:30 Let's talk about the Claude Developer Platform. [chuckles]

Brad Abrams 0:32 Yeah, let's start with that.

Alex Albert 0:33 Uh, let's start with that.

Katelyn Lesse 0:34 Start there.

Alex Albert 0:34 It used to be called the Anthropic API.

Brad Abrams 0:37 Yeah.

Alex Albert 0:37 We just went through a big name change.

Brad Abrams 0:39 Yeah.

Alex Albert 0:39 Can you walk me through why we made that change, and also what this new platform is and what it encompasses?

Katelyn Lesse 0:45 Yeah, totally. So the Claude Developer Platform really encompasses our APIs, our SDKs, our documentation, all of our experiences within the console, and really everything that a developer needs to actually build on top of Claude. We're really humbled, proud to serve, um, some really awesome customers around the world who are trying to, what we like to say, raise the ceiling of intelligence-

Alex Albert 1:07 Right

Katelyn Lesse 1:07 ... um, using Claude. Um, and the platform really enables them to do that. Um, and I would say one of my favorite parts about it is the platform doesn't just serve customers, uh, externally, the platform actually serves our internal product.

Alex Albert 1:20 Mm.

Katelyn Lesse 1:20 So, um, we love telling people, like Claude Code, for example, is actually built directly on our public platform.

Alex Albert 1:27 I see.

Brad Abrams 1:28 Yeah. I mean, uh, I think when we started, we were just the Anthropic API, and very simple access to the model. But over the last year or so, we've added so many features to it. Um, we added prompt caching, we added a whole separate batch of API, uh, we added web search, a web fetch, we have this context management support, the code execution. So all these tools-

Alex Albert 1:49 Yeah.

Brad Abrams 1:49 Now, you know, now it's kind of we feel like, yeah, it's aspirationally where it's re- it's a platform now.

Alex Albert 1:54 I see. So there's just a lot more to it now.

Brad Abrams 1:56 Yeah.

Alex Albert 1:56 It's evolved in pretty drastic way over the past year, and-

Brad Abrams 1:59 Yeah. Yeah, I think so

Alex Albert 1:59 ... better naming.

Brad Abrams 2:00 Yeah.

Alex Albert 2:01 Um-

Brad Abrams 2:01 And I think that's what developers were sort of calling it anyway.

Alex Albert 2:04 Yeah. Yeah.

Brad Abrams 2:04 You know, so it's always natural to just sort of go with what developers are saying.

Alex Albert 2:07 Right. We were a little late to the game there.

Brad Abrams 2:09 No, it's okay.

Alex Albert 2:09 Developers had it right.

Katelyn Lesse 2:10 Yeah. [chuckles]

Brad Abrams 2:10 It's all-

Alex Albert 2:10 Well-

Brad Abrams 2:10 It's okay

Alex Albert 2:11 ... we've made our amends.

Brad Abrams 2:12 Yeah.

Alex Albert 2:12 Um, one of the cool things you can do now, as we're moving from the sort of chat model to maybe this more agentic future-

Brad Abrams 2:20 Mm

Alex Albert 2:20 ... is building agents as part of this developer platform. Um, before we get into how we're actually doing that on, on the platform, can we talk about what even is an agent to begin with?

Brad Abrams 2:30 Yeah. I mean, agents is... It's almost sort of a buzzword, right?

Alex Albert 2:33 Yeah.

Brad Abrams 2:33 Like, everybody you talk to now is building agents, and, and whenever a industry tech term gets to that level, you know, the definition gets very gray, everything everybody builds is an agent. But Anthropic, what we really think about a agent is where the model is taking some, uh, autonomy to be able to choose what tools to call, to call those tools, to handle the results, and how to choose the next step. So, uh, as a, as a foundational research lab, like leaning into the model and be, and, and what it, its reasoning, how it decides what to do, we think that's a really important element of what an agent is.

Alex Albert 3:09 Mm. So it's kind of like the, the aspect of it being autonomous in some sense.

Brad Abrams 3:14 Yeah.

Brad Abrams 3:15 Yeah. Yeah.

Alex Albert 3:15 Charting its own course.

Brad Abrams 3:15 I mean, I think there's also re- I mean, we have customers doing really useful workflows where they're sort of predefining the path that Claude-

Alex Albert 3:23 Mm-hmm

Brad Abrams 3:23 ... should walk, and that, that is a super useful thing to do. But what's nice about the agentic thing is as the model gets better, every couple of months, you know, we release a new model, and it- with a true agentic pattern, you know, those services are just gonna get better. Where, where if you build a workflow with a lot of scaffolding in it, you kinda put bounds on the model-

Alex Albert 3:43 Mm

Brad Abrams 3:43 ... which is maybe okay in some use cases, but that means that you're- you may not take advantage of the next level of intelligence that a next model release gets.

Alex Albert 3:52 Yeah. So it seems like there's this interesting trend with agents, at least over the past 6 to 12 months-

Brad Abrams 3:57 Mm-hmm

Alex Albert 3:58 ... where, like you've said, the scaffolding

Alex Albert 4:00 has been-

Brad Abrams 4:00 Yeah

Alex Albert 4:00 ... a bit of a hindrance, and maybe we're dropping some of that.

Brad Abrams 4:03 Mm-hmm.

Alex Albert 4:03 Um, can you explain the intuitions behind that around is, is this actually the future? Is like we give less and less things to the model?

Brad Abrams 4:12 Yeah. I mean, I think over time what we're seeing is the scaffolding the model needs to be able to accomplish tasks is, is it's needing, it's needing less. As the, as the level of intelligence of the model goes up, and we have every... we believe is gonna keep going up-

Alex Albert 4:27 Yeah

Brad Abrams 4:27 ... um, that basically the model has more contextual understanding of the high level task that it's trying to accomplish, so therefore it doesn't need as many sort of guardrails.

Alex Albert 4:38 Right.

Brad Abrams 4:38 And in fact, those guardrails in some cases become some, uh, like a liability to have. Uh, we've had customers try out new models and say, "Oh, well, it's actually only just a little bit better." And then we kinda look into it with them about what's going on, and it turns out, well, yeah, they were constraining it in ways that makes it harder for them to see the intelligence of the model.

Alex Albert 4:59 Ah. Does this match what we see in the field with, like, our customers where they're also following these

Alex Albert 5:05 same trends? I know at the limit we have customers exploring all sorts of innovative techniques for managing Claude.

Katelyn Lesse 5:11 Yeah, totally. And there's actually a lot of, like, discourse about this right now, right?

Alex Albert 5:16 Mm-hmm.

Katelyn Lesse 5:16 Like, what is an agent and, and what does it need, what do you need to build? And, and there are people saying, you know, "It's just a while loop."

Alex Albert 5:22 Yeah.

Brad Abrams 5:22 Right.

Katelyn Lesse 5:22 Like, you don't have to try that hard.

Alex Albert 5:23 Yeah. Right.

Katelyn Lesse 5:23 And, um, I think ultimately, uh, there's a lot of, there's been a lot of evolution of frameworks that-

Alex Albert 5:30 Mm

Katelyn Lesse 5:30 ... people are putting around the model that are helping them orchestrate their agents, try to get the most out of the model. And, um, I think what, uh, the industry is maybe kind of circling around is a lot of that has become maybe too heavy-

Alex Albert 5:43 Mm

Katelyn Lesse 5:43 ... and maybe too opinionated, um, and which is why you kinda get the, the people coming back to, like, "It's just a while loop, and that is all you need." Um, and I think what we're trying to, to do there is to say-

Brad Abrams 5:55 Maybe in a lot of ways it is a while loop, but the things we can more uniquely do to help people get the most out of the model is a lot of those tools, those features, and otherwise.

Alex Albert 6:04 Mm-hmm.

Brad Abrams 6:04 And so what we wanna do is put, um, you know, frameworks and tools and platform out there that is opinionated to some extent-

Alex Albert 6:12 Mm-hmm

Brad Abrams 6:12 ... on how people should use those tools. Um, but it's not this like super heavy framework that really like, to Brad's point, gets in the way-

Alex Albert 6:20 Mm-hmm

Brad Abrams 6:20 ... of what the model's ultimately trying to do. So to strike the right balance, it's like, you know, we've, we've seen what a lot of people have tried to do, so we know we can be opinionated there, um, but we wanna be lightweight [chuckles] in the way that we're doing that-

Alex Albert 6:31 Right

Brad Abrams 6:31 ... and make sure that the real thing we're doing is helping you get the most out of the model, um, without, you know, bogging you down in some super heavy framework.

Alex Albert 6:38 Right. So would you describe part

Alex Albert 6:40 of the strategy here then as providing these auxiliary tools and things that we can give to the model-

Brad Abrams 6:47 Mm-hmm

Alex Albert 6:47 ... but we're not necessarily, like, placing the bumper-

Brad Abrams 6:51 Right

Alex Albert 6:51 ... spawn, like the model itself or-

Brad Abrams 6:52 Yeah. We think about, we think about it as like, how do you unhobble the model?

Alex Albert 6:55 Unhobble, yeah.

Brad Abrams 6:55 Like, the model already has a lot of capabilities, and in fact, I'm convinced that even if you take a current generation of models, there's way more intelligence in there than we've been able to unlock.

Alex Albert 7:04 Mm.

Brad Abrams 7:05 But anyway, that intuition is if you just give the model, like, the tools it needs, and like set it, set it free-

Alex Albert 7:12 Mm-hmm

Brad Abrams 7:12 ... let it be able to use those in the right way, um, you'll get great results.

Alex Albert 7:16 Mm.

Brad Abrams 7:16 And, and I think like a good example of that is we launched this server side, uh, web search tool and we- and web fetch tools, and it's been interesting to watch customers use those. And, you know, all we did real... I mean, it's a very minimal prompt that we have. We just give it the web search tool, and, like, all of a sudden, deep research tasks are, like, almost completely done-

Alex Albert 7:39 Mm

Brad Abrams 7:39 ... with, with just turning on that, uh, switch on the API because the model will call that tool, it'll look at its results, it'll say, consider it, and say, "Okay, maybe I need to call, you know, do these other searches."

Alex Albert 7:51 Right.

Brad Abrams 7:51 And then, "Oh, that fourth link you returned, that's the great one."

Alex Albert 7:54 Right.

Brad Abrams 7:54 It'll do a web fetch on that link and bring that data back, and really all that very autonomously on its own kind of deciding.

Alex Albert 8:01 Right. I, I think it's almost kind of like an interesting shift in, like, where the intelligence of a system is being applied.

Brad Abrams 8:07 Exactly, yeah.

Alex Albert 8:07 From like the developer having to apply their intelligence to guiding-

Brad Abrams 8:10 Right

Alex Albert 8:10 ... towards like the model now-

Brad Abrams 8:12 Right

Alex Albert 8:13 ... figuring it out.

Brad Abrams 8:13 And it's so exciting when the model does it because as a developer, like, my creativity ends at some point.

Alex Albert 8:19 Yeah.

Brad Abrams 8:19 I can only think of so many use cases.

Alex Albert 8:22 Right.

Brad Abrams 8:22 But the model, like anything, anything somebody comes with, the model will figure out a way-

Alex Albert 8:27 Right

Brad Abrams 8:27 ... to go do that thing.

Alex Albert 8:28 Right.

Brad Abrams 8:28 So it's great, great to unhobble the model.

Alex Albert 8:31 Yeah. So if I'm a developer today and I'm getting started building with

Alex Albert 8:35 the developer platform, what do you recommend? What are some best practices or ways for me to get started?

Brad Abrams 8:40 Yeah. So, um, super tactically, actually, the number one thing that we recommend right now is the Claude Code SDK.

Alex Albert 8:47 Mm-hmm.

Brad Abrams 8:47 Um-

Alex Albert 8:47 Okay

Brad Abrams 8:47 ... and what's really, really interesting about the Claude Code SDK is we essentially built an agent harness, an agentic harness, um, around the model to run that loop, right, and automate a lot of that tool calling and otherwise feature use. And obviously, originally was built for coding purposes. Um, and what, uh, the team really quickly figured out was like, actually, this is like an excellent general purpose- [chuckles]

Alex Albert 9:10 Mm-hmm

Brad Abrams 9:10 ... agentic harness. Um, and so what the SDK does is it gives people a perfect out-of-the-box solution to actually just start prototyping agents-

Alex Albert 9:19 Mm

Brad Abrams 9:20 ... um, without having to go and build, you know, the loop with all the tool calling and otherwise. It's built on top of the messages API and all those same tools that, um, we're mentioning, but it kinda gives you that really great starting place right out of the box.

Alex Albert 9:33 Right. I feel like this is a pretty common misconception, at least when I talk to developers, about the Claude Code SDK.

Brad Abrams 9:38 Mm-hmm.

Alex Albert 9:38 So like, I'm not building a coding application.

Brad Abrams 9:41 Mm-hmm, mm-hmm.

Alex Albert 9:41 Like, why would I wanna use this?

Brad Abrams 9:43 Yeah.

Alex Albert 9:43 Mm-hmm. But you can kind of remove the coding-specific-

Brad Abrams 9:47 Yeah

Alex Albert 9:47 ... parts, right?

Brad Abrams 9:48 Yeah. I mean, I think that's a great example of what we were talking about, removing scaffolding on the model. It's like once we got done removing things-

Alex Albert 9:55 Mm-hmm

Brad Abrams 9:55 ... from the Claude, from Claude Code to really unhobble the model, it turns out there was [chuckles] nothing coding left.

Alex Albert 10:00 Right.

Brad Abrams 10:01 When the, when you remove everything else, then it's just an agentic loop, and you're, you're really a minimalistic thing to give, uh, Claude access to, to a file system-

Alex Albert 10:11 Yeah

Brad Abrams 10:11 ... to a set of like Linux command line tools, um, to the ability to, you know, write code and execute that code. So those are all very generic kind of-

Alex Albert 10:21 Right

Brad Abrams 10:21 ... capabilities that turns out could solve a wide variety of problems.

Alex Albert 10:24 Right. Yeah. I feel like something I've been running up to in like my own side projects and also seeing with-

Brad Abrams 10:30 Mm-hmm

Alex Albert 10:30 ... projects within Anthropic is before the Claude Code SDK, everybody's implementing some form of managing prompt caching-

Brad Abrams 10:37 Right, right

Alex Albert 10:38 ... or some form of managing their-

Brad Abrams 10:39 Right

Alex Albert 10:39 ... tool calls and that loop.

Brad Abrams 10:41 Right, right.

Alex Albert 10:42 And now it's like, oh, just start at this base point-

Brad Abrams 10:45 Yeah

Alex Albert 10:45 ... and then build from there-

Brad Abrams 10:46 You start a little bit higher up

Alex Albert 10:47 ... and fix problems. Yeah.

Brad Abrams 10:48 Yeah, yeah, yeah.

Alex Albert 10:48 So it's like a further level of abstraction. I

Alex Albert 10:50 think that's super interesting.

Brad Abrams 10:51 Yeah. I mean, I think, I think the other really interesting to- thing to think about, especially for businesses looking at a- agents, is like, what use case to go target.

Alex Albert 10:59 Right.

Brad Abrams 11:00 So, uh, thinking beyond the technology, like, what is the actual problem to go solve? And I, I, I think, you know, we've s- we see a lot of customers and like doing a lot of things. We love all of it, but where, you know, the biggest impacts are is where the customer has thought hard about what's the business value of this.

Alex Albert 11:17 Mm.

Brad Abrams 11:17 Like, will it actually save this many engineering hours, or will it help us remove this much, uh, uh, manual work or whatnot? And being able to articulate, like, what you expect the outcome of the agent project to be, I think is really helpful in, in defining the scope, uh, of the agent.

Alex Albert 11:37 Right. And t- tying back one more time to the SDK, so it seems like-

Brad Abrams 11:41 Yeah

Alex Albert 11:41 ... it's been really, really useful for, like, individual developers like myself-

Brad Abrams 11:45 Yep, yep, yep

Alex Albert 11:45 ... you know, starting out-

Brad Abrams 11:46 Yep

Alex Albert 11:47 ... and just wanting to get hacking on something really fast. For these customers, for enterprises that are actually trying-

Brad Abrams 11:52 Right

Alex Albert 11:52 ... to get real business value-

Brad Abrams 11:54 Right

Alex Albert 11:54 ... out of these things, should they be using the SDK? Is it ready for them? Is it ready for scaled use like that?

Katelyn Lesse 12:01 Yeah. So, um, I think in a lot of ways it is. In a lot of ways, if you are in a spot where you can... Like, you can deploy that runtime. Essentially, that's what you get out of the SDK-

Alex Albert 12:12 Yeah.

Katelyn Lesse 12:12 -is an agentic loop runtime. Um, you can go and deploy that runtime wherever you want, [chuckles] whenever you're ready to do so. But I think what we're really trying to do is take the spirit of what the SDK unlocks for people, like go kind of up to that higher order abstraction where we give you the loop, we give you a lot of the tool calling in an automated way, um, and say, "How can we learn from that and give people out-of-the-box solutions that, like, at scale-"

Alex Albert 12:36 Mm-hmm.

Katelyn Lesse 12:36 -um, will really be able to solve for their use cases?" And I think that's a lot of where we're kind of trying to go with our roadmap throughout the rest of the year. Um, and one really important bit when we think about that is if the entire goal here is to help our users, like, really raise that ceiling of intelligence, get the absolute best outcome out of the models, then higher order abstractions are not just make it easier because you don't have to write all that code yourself. It's actually, like, how can we, like, really truly help you get the best outcome-

Alex Albert 13:06 Mm-hmm.

Katelyn Lesse 13:06 -because we, uh, we're in the room with research, we're in the room with inference. Like, we know how to make sure that our abstractions, our agentic loop is going to be, uh, extremely powerful-

Alex Albert 13:16 Right.

Katelyn Lesse 13:16 -and extremely good at working with Claude. Um, and the last thing that I would add in there is especially as these things get longer running, and as we provide more and more tooling to help people get at those longer running tasks, um, another big problem that our users we know are gonna keep trying to solve is, uh, observability within-

Alex Albert 13:34 Mm-hmm. Mm-hmm.

Katelyn Lesse 13:34 -those longer running tasks. Um, and so that's, that's one of the most common things that comes up for folks is, you know, I, I have these long-running tasks, I'm trying to get, um, these really great outcomes. But, um, you know, I might need to do some steering, or I might need to tune my prompt, or I might need to think about tool calling a little differently. And, um, that's something that we know we can give people that observability through the platform over time-

Alex Albert 13:58 Mm-hmm. Mm-hmm.

Katelyn Lesse 13:58 -and that's another big area of focus for us.

Alex Albert 14:00 Hmm. Okay. That's really interesting. I mean, this has been a huge issue that's starting to come to a head with agents right now-

Brad Abrams 14:07 I think so.

Alex Albert 14:07 -especially as you trust them to go work in some, you know, other application-

Brad Abrams 14:11 Yeah. Yeah.

Alex Albert 14:11 -in the background. How do you make sure they're actually doing the right thing?

Brad Abrams 14:14 Yeah. Yeah.

Alex Albert 14:14 And then if you're deploying them.

Brad Abrams 14:16 Yeah. How do you audit it? Like if we're-

Alex Albert 14:18 Yeah.

Brad Abrams 14:18 -gonna give some level of autonomy to the system, there needs to be a way to audit it and, like, make sure the right things are happening so that you can tune things and whatnot. So I think observability is really, really a key piece of this.

Alex Albert 14:30 And putting a pin there that I wanna ask a question on, just like the future

Alex Albert 14:35 of how-

Brad Abrams 14:35 Hmm.

Alex Albert 14:35 -we're gonna address that. Um, before I do, uh, is there other tools that exist right now that folks should be aware of when they're getting started with the developer platform? Things have... you've found helpful or useful?

Brad Abrams 14:48 Yeah. I mean, I think there's a c- so we mentioned, uh, web search and web fetch. Uh, I think an-another big thing that we're seeing is, um, customers, m- uh, have to do... right now have to do a lot of work to manage the context window. So by default, Claude has 200k tokens of context. We have a mil-million token available now in beta on Sonnet, which is great, but even a million, there's a limit there. Uh, and what, what many customers have told us is that, um, they get better outputs, higher intelligence if they, uh, even use a smaller part of the context. And so we've done... We have a, a couple of cool features that are just coming out to help developers manage that context.

Alex Albert 15:31 Hmm.

Brad Abrams 15:31 So in these agentic loops, a lot of times you're doing ten, 15, 100 tool calls, and you edit this file or look up data in this database or, uh, you know, send this email, and each of those tool calls takes up like a, you know, 100, 200, 1,000 tokens.

Alex Albert 15:49 Right.

Brad Abrams 15:49 Uh, and so we have this cool feature that lets you, uh, lets the model actually remove some of the older tool calls that are not needed anymore.

Alex Albert 15:57 Interesting.

Brad Abrams 15:58 Uh, and that give, that gives just, just like you, if you declutter your desk and declutter your notebook-

Alex Albert 16:03 Yeah.

Brad Abrams 16:03 -like, you can focus a little bit better. So if you declutter the prompt, actually, the model can actually focus a little bit better.

Alex Albert 16:09 Oh, interesting. So okay, we're removing unnecessary context.

Brad Abrams 16:12 Mm-hmm.

Alex Albert 16:12 Is there a risk that we remove necessary context?

Brad Abrams 16:15 Yeah.

Alex Albert 16:15 How does that work?

Brad Abrams 16:16 Yeah, yeah. Yeah, yeah. So, um, we have some, some guardrails and some-

Alex Albert 16:20 Okay.

Brad Abrams 16:20 -bounds around it, so you don't... But g-the general rule is if you, um, remo- we try to remove the tools that are, like, several turns back.

Alex Albert 16:29 Okay.

Brad Abrams 16:29 That the model's already made decisions based on those tools. But if you... AI was playing with it, uh, recently, and r-I removed the tools that it was just called-

Alex Albert 16:38 Mm.

Brad Abrams 16:39 -and it's, "Oh, my tool results are gone. I don't know what to do."

Alex Albert 16:41 Right.

Brad Abrams 16:41 And then the... but the mo- the Sonnet doesn't give up. Like, it's like, "I'm just gonna call this tool again."

Alex Albert 16:45 Yeah.

Brad Abrams 16:46 You know?

Alex Albert 16:46 Yeah, yeah, yeah.

Brad Abrams 16:46 Um, but yeah. So generally, we have put some bounds on that because of that experience. So we, we do preserve the most recent set of tools.

Alex Albert 16:53 I see. Okay.

Brad Abrams 16:54 And then the other cool thing we do is, um, tombstone it. So by that we mean when we remove the tool calls, we put a note in there to the model and say, "Oh, the tool results for this search call are, were, were here."

Alex Albert 17:07 Oh, okay.

Brad Abrams 17:08 "And they've been removed."

Alex Albert 17:09 So model's not completely-

Brad Abrams 17:10 Yeah.

Alex Albert 17:10 -like memory wiped.

Brad Abrams 17:11 Exactly.

Alex Albert 17:12 Right. Yeah.

Brad Abrams 17:12 I, I think we found the model does better if we just give it a little more context about what is happening.

Alex Albert 17:17 Right.

Brad Abrams 17:18 Um, and, and so that's a, that's a key feature.

Alex Albert 17:21 Right.

Brad Abrams 17:21 Um, and th-the other one is this, like, um, [lip smack] kind of agentic memory, uh, feature that we've added. Uh, and there we, we have seen that the model, um, does... Like right now, if you give a task to the model, say a deep research task or, or play Pokémon or whatnot, like the model does about the same every time it runs. Um, but if you give a human a task, like the fifth time the human does a task, like they do it like way better.

Alex Albert 17:51 Right. Right.

Brad Abrams 17:52 Because they've learned, "Okay, if I'm gonna do this search, okay, probably the Wikipedia site is better than this other site-"

Alex Albert 17:58 Yes.

Brad Abrams 17:58 -or whatever. Like they learn which things, so they get better over time. So we've given this memory tool to the model now so that the model can actually take some notes while it's going and say, "Oh, like I realize that this website maybe isn't the right one."

Alex Albert 18:13 Mm-hmm.

Brad Abrams 18:13 "Or if I'm doing a search, it should be like this," or, "If I'm looking up, I should use this database, not that database," or whatnot. And it, it makes those notes, and then when it's stumped, it can actually go back and review its notes and say, "Okay," like, "Oh, I'm starting this task. Let me go read the notes."

Alex Albert 18:30 So I can figure it out. Cool. So we're handling all of that for the developers.

Brad Abrams 18:34 Yeah. Yeah. Well, we're giving the model like this core capability to do memory, and right now we're letting the developer manage the memory.

Alex Albert 18:41 Okay.

Brad Abrams 18:42 'Cause, you know, different developers, like they might wanna store it in some cloud storage or they might wanna store it somewhere else. So we're letting developers figure out exactly where to store the memory. That way they have more control over that.

Alex Albert 18:52 Right.

Brad Abrams 18:53 Um, but-

Alex Albert 18:54 By exposing the tool

Brad Abrams 18:55 But expose the tool.

Alex Albert 18:56 I see.

Brad Abrams 18:56 Yeah, expose the tool.

Alex Albert 18:57 So going back again to, to a roadmap question

Alex Albert 19:00 here. So it sounds like there's a ton of new features that we've recently launched. There's a lot of momentum, and now there's other offerings as well, like the Claude Code SDK-

Brad Abrams 19:07 Mm-hmm

Alex Albert 19:07 ... and things coming out soon. Um, what are you most excited about, Katelyn? What's the, what's the future looking like here in the next six to twelve months?

Katelyn Lesse 19:15 Yeah. So we talked a little bit about these higher orders of abstraction where we can, um, really just make it, uh, as, as simple as possible for you to get the absolute best outcomes out of Claude. Um, and we wanna pair that with the observability that we talked about, um, so that you can really like, you know, see the data and take those insights from those longer running tasks. Um, and if you combine these things together and start to think about some of the capabilities like memory that Brad just talked about, you can really start to see this flywheel where over time, we're not just able to help you get the best outcomes out of Claude, but we can help you get self-improving and continuously-

Brad Abrams 19:50 Mm. Mm-hmm

Katelyn Lesse 19:50 ... improving outcomes out of Claude. And that to me is kind of the, the like galaxy brain magic of the roadmap, is get to a point where, um, you know, we, we have people coming to us, they're building on Claude, they're, they have their tasks, they know what they're trying to do, um, and they get these like really like aha moments where over time it's getting better and better and better. Um, and you know, that is... that's kind of the biggest thing that in everything that we're doing, we're trying to make sure we're going after.

Alex Albert 20:17 That's awesome.

Brad Abrams 20:19 Yeah, I mean, I guess I'd have to say I'm a- I, I'm always excited about model launches.

Alex Albert 20:23 Yeah.

Brad Abrams 20:23 Like, it's like Christmas, like what, how, what will, will it, what will be possible now? So I love playing with the model launches as they come out, just unlocks more use cases. Some use cases that, you know, we've been working hard on and, and trying to improve, which is satisfying to see, but also some things, oh, we had no idea the model would be able to do this thing.

Alex Albert 20:41 Right.

Brad Abrams 20:41 You know, now it draws ASCII pictures so much better.

Alex Albert 20:45 Yeah [laughs] .

Brad Abrams 20:45 Or what, you know, whatever.

Alex Albert 20:46 The important things [laughs] .

Brad Abrams 20:47 The very important things. But beyond that, the other thing I'm really excited about is, um, we're, we're in the early stages of giving Claude a computer. You know, I think about if we, uh, hire an employee here at Anthropic, and we, we welcome them, "Here's your first day," but we don't give them a computer.

Alex Albert 21:03 Yeah.

Brad Abrams 21:03 Like, they would not be very successful [laughs] at Anthropic.

Alex Albert 21:07 Right.

Brad Abrams 21:07 So like right now, essentially everybody u- is using Claude and, and it doesn't have a computer. So I'm, I'm really excited about giving Claude a computer, and I... you see like the very baby steps of that-

Alex Albert 21:17 Mm-hmm

Brad Abrams 21:18 ... with the code execution tool-

Alex Albert 21:19 Mm-hmm

Brad Abrams 21:20 ... uh, where the, the model can write code, execute it on the VM, and get the results back. So like it can like zoom in on images or take a, a Excel spreadsheet and create like amazing data analysis with charts and graphs, and that's just the baby step. Like, what if it had a persistent computer-

Alex Albert 21:39 Right

Brad Abrams 21:39 ... that was always there and it could like organize the files in there the way it needed-

Alex Albert 21:44 Yeah

Brad Abrams 21:44 ... and get the tools set up the way it wanted and, um, I just think there's a lot of headroom-

Alex Albert 21:49 Right

Brad Abrams 21:49 ... to, to that scenario.

Alex Albert 21:50 Yeah. And I guess that all ties back into this unhobbling piece too.

Brad Abrams 21:53 Exactly. Exactly.

Alex Albert 21:55 Just more and more tools-

Brad Abrams 21:55 It's all about unhobbling the model

Alex Albert 21:56 ... and more things for Claude to do.

Brad Abrams 21:57 That's exactly. Just give, give Claude the tools.

Alex Albert 21:59 Yeah.

Brad Abrams 21:59 Yeah.

Alex Albert 22:00 Well, I'm excited for that future. Thanks so much for this conversation.

Brad Abrams 22:03 All right, cool.

Katelyn Lesse 22:03 Thanks.

Alex Albert 22:03 Yeah, thank you. [outro music]