The last layer of abstraction on top of

this is probably the coordination layer.

So, you have knowledge, and you have

execution, and you have coordination.

And at the coordination layer, we're

beginning to think of these things

called like strategies, where basically

it's almost like a meta harness. The

true low-level harness is designed for

execution, but the next one is about,

okay, if tokens aren't really fungible,

and you need to give them different

jobs, like maybe some this token is

advising versus this token is executing,

you want to start composing these like

these kind of orchestrated strategies

that go together, and they should sit on

top of all these things because at the

end of the day you still need to execute

and the execution still needs to know

what to do. So, everything in theory

should kind of like ladder together. And

so, I think, you know, if you were to

look at our road map and the maybe kind

of project forward a little bit where

you kind of expect us to go, we'll move

more and more from the knowledge layer

to the execution layer and from the

execution layer to the kind of

coordination layer in terms of the

abstractions that you [music] can see us

put out.

>> [music]

>> Caitlin and Angela, thank you so much

for joining us today. Lauren and I are

thrilled to have you here. You are

responsible for building Anthropic's

platform, and so you're responsible for

building what I think is one of the most

important, if not the most important

developer platform in the world. And we

are really excited to interview you

today to understand more about what's

ahead. And so, maybe just to get

started, can you give us the context of,

you know, what is Anthropic platform and

where do you sit within Anthropic?

>> Yeah, so platform is both our externally

facing APIs, our developer platform that

people build on top of when they want to

build applications and system that

systems that access Claude's

intelligence, as well as internally, um

we run our product infrastructure, and

basically we're the layer that our apps

build on top of uh internally as well.

>> Awesome. What's your North Star as a

team?

>> It's a great question. We actually,

because we have both internal and

external, we actually kind of have like

two North Stars, which is probably like,

you know, you'd be like, "What? You

shouldn't have one North Star." But, um

no, we we can

>> planetary system.

>> Yes, exactly. There's separate solar

systems, so it's fine. Um but, uh on the

internal side, like we really want to

provide is like literally as much

leverage as possible for our internal

teams to be able to ship like AGI-pilled

products.

Um and we want them to be able to move

fast, be able to have reliable, like

great, like uh platform uh to be able to

build on top of. But, I think that key

bit about speed is like really

intentional for us, and we really really

care about that internally. Externally,

um we actually have a lot more like

complicated set of things. Um but, one

of the true Norths that we have there is

to be able to basically give any builder

the tools to be able to work with Claude

to build whatever they want to build.

And so, it's a bit of a broad statement,

but as a result of that, uh boils its

itself down into, you know, being

wherever that business is. Like, we

really care about like bringing our

platform really really close to that

business. This is why we spend a lot of

time with the hyperscalers, integrating

really closely uh directly with them,

like AWS, Google, so on and so forth. Um

and it is a lot of like primitives that

we end up creating. We want people to be

able to express what they think their

product should be. We want them to be

able to almost do like custom software

in their own way, you know, like in this

new world with AI, uh what used to be

probably economically impossible was

that last mile of of custom software.

Now, in theory, should be like very very

achievable. Um and we want to give them

all the tools and all the capabilities

to go and do that. And so, sometimes

that comes in form of primitives and

APIs and higher-order abstractions, and

sometimes that comes in the form of just

like

standards. Uh so, for example, like

skills and MCP, um those are things just

like Claude needs them to be useful, and

we can just give them out to the rest of

the ecosystem, work with everyone to

help you create those things, and get

the best out of Claude. So, um I would

say externally, you know, we really are

oriented around just helping you just be

able to build, but internally, that

orientation, while still existing, is

probably more, you know, sp- specified

towards speed and being able to move

really quickly.

>> How do you decide what goes into the

platform, what gets externalized, and

what doesn't to decide what products

should be available?

>> Yeah, I mean, we generally try to have a

philosophy that we try to be consistent

across the board. It's actually one of

the reasons why we do internal and

external.

There's plenty of other, you know,

platform businesses and constructs where

you actually like bifurcate these two

things.

For us, we kind of try to intentionally

keep it equal and then as a result we

try to hold this philosophy as much as

we can around like, you know, for any

builder internal or external, even

though if our internal builders might

have some slightly different

requirements in the same way any user

would have slightly different

requirements.

We want to have the same primitives that

are available to everyone. And one of

the maybe the overarching thesis for

that is that we've just seen like the

capabilities of these models just grow

and that's just exponential. It's really

hard to figure out like a long-lasting

form factor. I think two years ago we

were all like everything's chat and now

everyone's like forget chat. Now you

just like agents. And like there's going

to be another form factor, another form

factor.

And we kind of imagine that like

constantly evolving. And so the best way

for us to kind of enable that for

everyone and also ourselves is to

actually build a really robust platform

that gives people those kinds of like

tools to figure out what those form

factors are. And I don't think we by any

means feel like we're the only ones

capable of figuring out that form

factor, like not at all. In fact, the

more democratization we can do on that

and help people and allow people to

experiment, I think the the more those

form factors will actually kind of

naturally come out of the market.

>> Yeah, and I think within our team we've

we've had moments where we're

experimenting even with just like a

packaging up of our primitives in a

different sort of higher order way and

we've thought about, okay, cool, we've

solved this exact type of problem with

this product that we built into the

world. And so we can go and dog food it

for ourselves, but we never want to fall

into this trap of like we're over

indexed on the problem as it needs to be

solved for an internal user like because

exactly what Angela said, internal users

have very specific requirements,

external users have very specific

requirements. And so if you over index

on one or the other, you fall into a

trap. So, a lot of the time what we'll

do is dog food something internally at

the same time that we open up early

access of some sort with external

customers so that we can kind of get a

range of feedback and bring those things

back into the platform.

>> I'd love to talk about the higher levels

of abstraction that you discussed. So, I

guess at the base level, this is just,

you know, raw access to Claude, Opus, or

whatever tokens.

How do you think about the I guess the

layer cake of abstractions above that?

>> Yeah, if you look back, um so when I

joined Anthropic around a year ago, um

the platform was basically just the

Messages API. There was a Messages API,

um you know, we had come out with

standards like MCP. We obviously have

developer tooling around our SDKs and

our docs and our console and things like

this, but for the most part it was a

stateless API. Um and what's interesting

to Angela's point on foreign factors

evolving over time is we found a lot of

our customers solving the same problems

over and over again that we also were

solving over and over again around as

the models got better at running for

longer and working with more context at

a given time, you want to build agents

that can succeed in a kind of

long-running context and even a remote

context that doesn't necessarily have a

human in the loop. And so, we found that

we could piece together our primitives

and stand up all the same infrastructure

that we're finding ourselves standing up

internally to power our own products and

arrive at some higher-order abstractions

that let you do more agentic work out of

the box. And the problems that we're

solving for you are, you know,

infrastructure being kind of a hard

thing to deal with. Like, how do you

figure out spawning sandboxes that are

going to have the right governance and

security and like, you know, spin them

up and spin them down when you need to

or the storage around transcript

sessions so that you can resume a

session if you stop it and pick it back

up later. Um so, that infrastructure is

a big thing that we wanted to be able to

provide more of out of the box and we do

more of that today. Um and then the

second thing just being harnesses and

harness engineering. There's a lot of

thought and energy going into how do I

do my prompt caching and how do I manage

my context window as well as how do I

actually just get more intelligence out

of the model, um, and how do I manage my

costs and things like that. So,

we've kind of packaged up our primitives

a bit more in tune with the problems

that we found ourselves solving to

provide more of these things out of the

box for people so that they can, if

they're building systems for them

themselves internally, if they're

building products, they can just be more

focused on the problems that they want

to be solving and if they want to

offload some aspects of those problems

to us, they can. Um, and that's kind of

the ethos.

>> And are your customers generally

choosing to opt from the grab bag of

stuff that you offer or are they like

how how often are they opting into the

just the the managed agents offering, I

guess, just take care of it all for me?

>> Um, it varies by like the the user

group. So, like for I would say, you

know, like really AI native startups,

like the ones who are like tinkering and

like experimenting at a really low

layer, they're just going to go for the

primitives.

Um, and then for everyone else, uh,

these are kind of classic, like more

like enterprises or areas where it's

like the purpose of the startup or the

philosophy behind the startup isn't

necessarily to optimize on, um, some

kind of hill climbing piece, it's more

like stringing together a bunch of

workflows and, you know, providing

unique user value at, uh, to that user.

For those people, um, you know, it's

just kind of not their core competency.

It's not what they want to focus their

time and resources and they reach much

more for these kind of like

higher-ordered like package offerings.

>> What are some examples of the primitives

you've released at different layers in

the last few months? We've seen a few of

them. Would love to hear.

>> Yeah, I think maybe one framing I would

give, um, for some of the constructs

that Cayden was talking about is like,

and this is a bit of an

oversimplification, but effectively

there's approximately like three like

layers of this cake. At the very bottom

is just kind of like like knowledge. And

so at this layer, like in many ways it's

it's knowledge about the model, it's

knowledge about the things that the

model needs, and it's just like the

ability to know how to actually do

something with Claude is maybe the way

I'd phrase that. And so there, the

primitives that we have spent more and

more time on have been actually things

of the past. Cuz like we still evolve

them, but they tend to be a little bit

more baked. Like for example, there's

very specific shapes and parameters we

put on the messages API, and it's more

like trying to expressly like showcase

Claude's like design.

Like Claude the model's actual design,

the way it thinks, the way it respects

certain parameters, the way it kind of

like

will do tool calls. Like all of those

different pieces. And then we started to

standardizing like tools, and then we

started standardizing bits and pieces of

like context that you could put in at

different moments in time, which is

concretely like skills and like memory.

And so those are like the kind of like

knowledge layer type of abstractions

that we've put out over the past I guess

like year plus plus a bit.

Um the next layer of abstraction that

we've actually started to spend more and

more of our time on is like once you

kind of know stuff, you then need to

like execute. And so at the execution

layer, that level of abstraction is the

part that Kaylin was talking about

around like we're doing these like

higher order pieces, but like what are

we putting higher order there? It really

is because you're now getting Claude to

execute work. It's not just to know

something, right? I can give it a

question, it'll give me an answer. You

can push string a lot of that stuff

together.

But now if you need to execute, like do

work, give me the output, edit files in

a bunch of different systems, that

becomes a lot more complicated and

requires infrastructure to handle. And

so that layer is basically I would say a

low-level harness plus managed

infrastructure as like the set of

abstractions. Today we just like our

high-level product for that is called

Claude managed agents.

And so that's like a piece, but we

started to wrap more and more pieces in

that. Um I think there's going to be a

layer like on top of that. We have like

some inklings of it if we started to

build towards, but the last layer of

abstraction on top of this is probably

the coordination layer. So you have

knowledge, and you have execution, and

you have coordination. And at the

coordination layer

we've started to expose some of these in

ways that like aren't very obvious, but

we're beginning to think of these things

called like strategies, where basically

it's almost like a a harness. Right, the

harness, the true low-level harness is

designed for execution.

But the next one is about, okay, if

tokens aren't really fungible, and you

need to give them different jobs, like

maybe some this token is advising versus

this token is executing, this token is

dreaming versus this token's executing,

so on and so forth. You want to start

composing these like these kind of

orchestrated strategies that go

together, and they should sit on top of

all these things because at the end of

the day you still need to execute, and

the execution still needs to know what

to do. So, everything in theory should

kind of like lad- ladder together. And

so, I think, you know, if you were to

look at our road map and the maybe kind

of project forward a little bit where

you kind of expect us to go, we'll move

more and more from the knowledge layer

to the execution layer, and from the

execution layer to the kind of

coordination layer in terms of the

abstractions that you can see us put

out.

>> That's a really cool road map.

>> How do you think this all comes together

into a broader ecosystem beyond just the

things that you guys are building? How

do you help support people building

products on top of it, and how do you

help them get the most out of all these

pieces?

>> Yeah, I think this is like super top of

mind for us. Like, we really want to

find a way to be

to support as many people in doing this

as we can. I think we're still like

learning. Like, a lot of the industry

like has evolved, we've seen, you know,

a lot of different pieces um get spun up

and spun down. And I think the the

operative part for for Caitlin and I has

been in the category of like making

sure, at least at the base layer, that

we provide as many primitives across the

board as possible. So, you know, this

kind of like yeah, like knowledge,

execution, coordination layer, we want

to give all of that out to everyone so

that people can start to compose and

create on top of that. Um and that's

just from a I think pure builder kind of

point of view. Then there's a point of

view around like, how do you kind of

like plug in with us? Right? Like, we're

also building first-party products of

our own. We've also created some ways to

embed natively with us, like for

example, connectors which are built on

top of the MCP spec. Um and we try to be

more open about those types of things.

And we're starting to figure out like

what are the right bits and pieces, but

I mean, what we're really trying to do

is get to a place where, you know, in a

a company is able to get creative and

build on uh they can build whatever

products that they want. They can build

agents if they need to and then those

agents and those products could be

things that could plug into other

agents. Some of those agents could be

cloud agents, some of those agents could

be other people's agents.

But we want to be able to enable that

kind of like trans-actability across the

board. And then I think in order for all

of that to kind of ultimately be true,

there is a bit around like standard

setting. And I think there's the

traditional standard setting which is

around, you know, how do systems

interoperate? Um and that's uh you know,

things that you've kind of seen us do

with like skills and MCP.

But they're at again like the builder

layer. I think at a higher order layer,

there's also a bit around

interoperability and standard setting

around how do we all kind of like treat

safety together? And you know, we've

talked to a lot of these companies and

this is less from, you know,

philosophies aside, just more like no

one really wants to have technology

that's like, for example, like doing

negative things on on their service,

right? Uh so cyber I think is a great

example of this. You want to protect

your own systems from like negative

actors or bad actors. And so like these

kinds of like standard settings of like

how can we find ways to partner with

more and more people to be like, yeah,

we all kind of want to make sure our

critical infrastructure is good. We all

want to prevent like fraud or any of

those things from happening and how can

we work better with each of these

members? I think on the last layer,

we're still kind of like we're still

evolving and I think we're still very

much like trying to find ways that we

can be better and work with the rest of

the industry to bring people along and

and work with them.

Um but those are kind of like, you know,

the higher order primitives or pieces

that we wish to kind of like be in

place. Um so they can work with folks to

to ultimately solve this. I think if I

would like take a step back at the end

of the day on on all of these things,

um

you know, like this technology is so

transformative

and if it's a little bit like

electricity in the sense like before

electricity, there was just like, you

know, you had to like have a candle and

it was like you can only do so many

things.

Um

but with electricity, the reason why

it's such a transformative technology

for all of us and so greatly of a

utility is because you can actually like

wire it into everything. Everyone is

able to actually access it. We also have

like standards and ways to plug in and

do all the pieces that we need. And

that's not something that anybody can do

by themselves. They always have to work

with the ecosystem and work with

partners um to figure out a path

forward.

>> How do you think about the philosophy of

building an open ecosystem

uh versus a walled garden? And you know,

how do you think about what products are

really important for you to own first

party versus

where you're perfectly happy to plug

into other components of the ecosystem?

>> Yeah, there's So, maybe in using

Angela's kind of layered cake that we

talked about a little bit earlier,

you'll see that on some pieces of this

like execution for example, um what

we've done within something like Cloud

Managed Regions. And I think over time

you'll see us try to make this a little

bit more modular. We actually aren't

precious about you should run these

things on our infrastructure. Like it

should be sandboxes that we control or

it should be a storage layer that we

control. Um Well, we actually like for

example, we launched self-hosted

sandboxes and we partnered with Moodle

and Vercel and Cloudflare and a bunch of

other folks um even like Amazon's new

micro VMs um to have a first-class

offering where you can go plug any of

those things in. Um

We launched MCP tunnels so that you can

call out to your MCP servers that are

behind your firewall, right? And um be

able to punch through there. And so, for

some of these things, we you know, the

weather whether it runs on our

infrastructure versus somebody else's

infrastructure is actually not important

to us cuz the thing that's important to

us is more that the architecture of how

you put together these agents in a way

that will be powerful, in a way that

will be reliable and scalable. Um We

have strong opinions on that, and you

can kind of just conform to the

interfaces that we put out there and

plug those things in. Um And we think

that that generally is a thing that

works really well.

>> Yeah, I think on the the kind of like

verticals where we we build products, um

you know, I think we we kind of have

like two frames here. The first one is

we are always trying to figure out a

form factor, like an evolving form

factor. We, by the way, don't think form

factors are like static. It's like a

dynamic thing. So, what might be awesome

for 1 year's worth of AI development

will probably not be awesome for the

next year's worth. And we just kind of

try to have that mentality. We tell the

team uh just overall like around

Anthropic, everyone's always trying to

be like, "Is this AGI pilled enough?" Um

and then we always have this mentality

of like, you know, we build something,

it works. It was cool for a a year and

maybe it's not the right next thing. And

so, throw it away, try again. Um and we

we tell like platform users the same

thing. Um

We just think that's probably just like,

you know, attached to the technology.

But so, yeah, one one principle is like

trying to always constantly find this

new form factor. So, sometimes we'll

like launch products in certain areas to

try to showcase a new type of form

factor. Um it's not necessarily cuz we

think it's like the biggest TAM or the

most important thing to go after, but

sometimes like, "Okay, this is like

always been a really difficult thing and

people have always communicated this way

or tried something this way." And so,

can we show that maybe there's a

slightly different way? Um and because

the model capabilities are are so

advanced now, can we try to express it a

bit differently? Um

>> What's an example of that?

>> Yeah, you know, like uh

Claude design is a little bit of of that

way. I think depending on how you

squint, you might see it as like a way

that we kind of are going into design as

as as like, you know, one of the

verticals. But more often than not, it's

like if you take a look at what we're

trying to do with that product, there's

a couple of like decisions that were

made in there. The first one is that

like you can actually try to offload

more and more and more to Claude.

Um and so, it tries to be kind of

opinionated on like, you know, just just

like talk to it and like let it really

try to figure out. And yes, you can

still edit it and then do these kinds of

things, but kind of like discourage a

little of that and more just like let

just talk to Claude to go figure it out.

Um the second thing was it was really

trying to express that actually like

code is a is a a way to solve for things

that you wouldn't normally think would

be the way. So, a lot of people who have

built kind of generative um you know,

like slide decks or designs or whatever,

um, we'll pick uh the way of like they

have like some kind of design system,

you integrate against design system.

It's almost in the traditional like a

classic WYSIWYG style of designing

something. And with like cloud design,

it was like, "Okay, can we try to just

like use code purely, but have Cloud

generate that code, and would it like do

a good job?" And we found through some

experiments early on, it's like,

"Actually, it looks like it can kind of

do that. And how can we kind of showcase

that uh to the world?" So, that's like

an example. We have a lot of other

internal projects, and this kind of

falls in the category of like expressing

form factor. We'll all try it out

internally. It'll be super cool for like

2 weeks, and then we move on to the next

thing. Um, we never even ship the thing,

frankly. But yeah, we actually do a lot

of product experimentation in that area,

and that's like our labs team. And then

there's like the second category, which

is that we actually do look at TAM.

Like, we're a business, we do look at

TAM, we do look at areas that we think,

uh, you know, there'd be reasonable

agentic like operations that would

happen.

In those areas,

uh, we do tend to have an orientation

towards things that are more token

heavy. And by token heavy or token

hungry, maybe is the way I would say

that, is like what we mean is like, you

know, you for spending once you spend a,

like call it like one turn, you look at

the end of that turn, and you say like,

"Am I done, or am I actually so glad

that I did that thing, I want to do more

of that thing?" We like industries where

it's like the answer to that question,

you say, "I want to do more of that

thing." So, coding is obviously the one

that we all know. And the great thing

about coding is that what it's actually

doing is that like once you finish a

turn, you look at that, and you're like,

"That was incredible. I'm like unlocked.

I'm going to do like more. I'm going to

build more, I can do more." And there's

other services where it's like actually

when you finish that turn, you completed

the job, and you just move on. You know

what I mean? Um, and so we tend to like

go into the ones that are a bit more

like there's this kind of like iterative

flow, you're going to build more,

generate more together.

Um, and then the last angle that we kind

of take a look at is just sort of like,

you know, there's going to be certain

business functions that were like they

are the buyer that we like to go to. We

want to help them optimize their

workflows, help them create better

products there. And I think we've been

pretty transparent with some of the

verticalization like we've done like

finance, we've done like legal.

Um and we've tried to kind of like

narrow on into specific areas where we

feel like by having the right context

and the right tools and putting it

together in a good form factor is

probably useful um for us to to be able

to do. And in each of those areas, we do

we're trying to do a bit of like showing

the art of the possible across all the

different ways that you would accomplish

those outcomes. And so for you know,

like finance for example is a good one.

Um you know, we you could be a company

that solves problems in finance and you

could build directly on the messages API

and you can just get some tokens and you

can build everything else on top. Or you

could be someone who builds on Claude

managed agents, you can get a lot more

out of the box. Or you could say, "I'm

going to build a plugin that or like a

connector, right?" That's going to sit

within one of our products and within

those form factors. And we did recently,

we launched like Claude for financial

services is like, "Okay, cool. We've got

packages of skills and things like this

that you could choose to use within our

product, within other people's

products." We even launched like

cookbooks on, "Here's how you would use

Claude managed agents to go and do these

things." And so I think for us, it's all

kind of an experimentation around like,

you know, we provide people all these

different pieces and see kind of where

they run with it. And then sometimes we

put together products that are just

packaging of all of these things like

Claude Tag, I think, is a really good

example. Like we had been seeing people

in the industry go into like Shopify did

this with River, um Square Block

recently did this with Builder Bot. Um

there's like a few of these examples

where people said, "I'm going to I'm

going to build like an agentic platform

internal to my company and I'm going to

try to give it all the right context and

I'm going to make it accessible from

Slack or from various other um you know,

platforms that you'd want it to be

accessible at." And I think Claude Tag

was very much a

packaging of all those same things that

anybody could choose to build something

similar, but this is how we're kind of

like, well, this is how we're doing it

internally, and if you would like to

just kind of plug in and go, here's what

that looks like.

>> you think people misunderstood about

Claude Tag? Cuz there's all this like

ruckus about, oh my god, it's just a

Slack bot. Like, tell tell us [laughter]

what what the magic of Tag is.

>> Yeah, I think it's a great question. Um

and I I do think it actually showcases a

little bit of where maybe the future

could be going.

Um yeah, I think like the I think if you

look at products in the past, people are

like, oh, you really attached to like

the form or the the UI almost, right?

Like, it looks like this, so it's like

super cool.

Um and I think when you look at like

Tag, uh it like, yeah, like the way you

interact with it is that you like

literally tag it in Slack. Uh and so

yeah, that is like the interface. But

that's not really the important part.

The important part um is all the kind of

like context engineering and like

architecture that we put underneath the

hood so that Tag just works. It really

should just like just feel like a

coworker. Like a co- you know, if you go

to a company and you onboard to the the

coworker comes into your channel and

then you can chat with it. It's

proactive, it's figured out like what's

like useful, you could and um it just

gets stuff like done for you. And so, if

you think about, you know, especially

like non-technical audiences, this is

like it's a huge unlock. You just you

literally create a channel and then you

@ Claude or sometimes you don't even @

Claude and you're like, "Hey, I want to

be able to do this and do that, and I

can't figure out this, and how do I

actually like submit an expense report

again?" And traditionally, do you think

about how to solve that workflow, you

are going all over the place, and you're

talking to your manager, and you're

talking to your spin buddy, and it's

like really really complicated.

And uh today, now you just like go talk

to Claude Tag, and we do a lot of the

hard work on doing the context

engineering, the proactivity, a lot of

the harness pieces. I think Andre

Kaparthy said it really well, he's like,

it's an org-level harness. There's a lot

of like complexity baked into that. Like

Kaylee mentioned, like you can use our

APIs to go and construct that. You can

do a lot of the experimentation

yourself, obviously, but this is like an

opinionated take from Anthropic on like

how you can have this really awesome

always on kind of agent for your entire

entire company. And the bit that's like

futuristic I guess is like a lot of that

complexity is actually like it's like an

iceberg. It's like all the stuff

underneath it. That's actually becoming

the harder and harder and like useful

part that we're trying to like push

through. And I think we'll see more and

more like that kind of like tip bit

that's like outside in the water. It's

just like the interface can actually

constantly swap. Like today right like

Slack is a place where a lot of people

collaborate. A lot of business

collaborate. But also a lot of people

collaborate in Teams. And some people

collaborate by a WhatsApp group or they

text each other or they may some people

still email each other. And like those

could be the form factors that actually

completely you can imagine agents just

going there and being. And they're

almost taking up the same form factors

as humans have taken up. It was almost

like a very almost like boring take but

it's actually like I feel like the most

like forward one because you want the

agent and you want AI to basically be

like another person and it's helping

you. But like it's like you know very

intelligent can figure out all the

context and you can always have it to be

a really helpful assistant.

>> Totally. You talked about context and

then harnesses quite a bit and so your

team is just you know has such an

opinion and point of view on like what

it takes to build an exceptional agent.

I imagine a lot of that comes down to

the context engineering and the

harnesses.

>> Totally.

>> Maybe like what best practices of or

advice would you would you share with

people about what you need to get right

on the harness and what you need to get

right on the context?

>> Yeah, I think so it's interesting

because we've kind of talked about you

know we launched Claude managed agents

as this like very generic but high

performing harness because we've done

all the nitty-gritty work that's

actually like really boring and not

super interesting around how do you deal

with prompt caching? How do you deal

with context management? You like clear

old stuff out of the window. Sometimes

you like call tools programmatically so

you don't pull everything into the

context window and you can keep it

clean. There's a lot of those sort of

details on the lower level harness

layer.

Um

and I think honestly like best practices

are just stuff like

prompt caching, do it. Save a lot of

money and and token costs. Um obviously

like try to keep your context window

clear and then putting those things

together in

uh a harness that will be performant is

is you know sometimes specific to the

task that you're trying to accomplish,

right? And then of course evals. Um I'm

surprised we got this far into this

thing before one of us said the word

evals. But like you need evals um to

make sure that what you're trying to

accomplish is performant. Um

but I think we're we're starting to go

and Angela mentioned this a little bit

earlier is more of a concept of

strategies or meta harnesses. Because I

do think that yes, you can again make

this lower level harness that's going to

be performant and maybe that's

interesting for you to do yourself or

maybe not and you offload it to us. But

this concept that

you can take any given token and spend

that token on just executing or you

could take that same token and choose to

actually reflect on your past agentic

sessions and write learnings to memory

so that the next agent does a good job.

Or you could take that token and advise

with a bigger model so that a smaller

model can execute and do a better job.

Um or you can say execute execute and

then like a grader comes in and is like,

"Did you do a good job? No, you didn't.

Try again." right? And so I think the

the like interesting innovation is going

to come more at that higher level on

like the meta level, right? And I think

optimizing within those strategies is

something that our team is really

excited about and we're starting to do a

lot of work there. Um and I think a lot

of other people are starting to feel

really excited about this concept of

strategies and like the jobs you give to

tokens.

Because again like yes, there's best

practices on stuff like your prompt

caching and exactly how you clear stuff

out of your context window and how you

write your evals and like a lot of

things like this. But I I don't know

that there's necessarily so much juice

to squeeze in a lot of cases out of that

layer as compared to a layer higher than

that.

>> Yeah, and one of the reasons for that I

think is it has to do with the

generations of the the models. I if you

look like 2 years ago, a lot of the

harness was like a scaffold to kind of

like

tell the model to go from point A to

point B. And you had to like you really

had to like build in a lot you had to

practically build one wall here and one

wall here so that like the thing would

go in a straight line. And now the

models are actually very very steerable.

Um and so a lot of that steering you can

just put it in the prompt, right? You're

like go do go from point A to point B.

And the model like will go from point A

to point B. So a lot of if you have

harnesses um that are like designed to

kind of do that kind of like steering,

you can delete that part. Like that part

we actually frequently encourage like

you can delete part of those harnesses.

I think various people have said things

along those lines. And that's I think

what people oftentimes mean when they're

like you know the model will kind of

consume some of the scaffolding. And

like in that sense like for sure if your

scaffolding is telling it to go in

direction, um that it can just

intelligently figure out. Like that I

think will increasingly continue to to

be so.

But as a result of of this, what the

harness needs to start doing is more

allow it to run longer. And so that's

where like that execution bit tends to

be I think like it sounds like a maybe

somewhat silly point, but I do think it

results in a lot of differences. Because

because it you can go in the direction

that you tell it to go, you obviously

don't want it to stop at B. You don't be

like okay now go from B to C and then go

to F and then go to Z and then come back

to me on A. You know, something funky

like that. In order to be able to do a

lot of those things, the kinds of

harnesses that you do are less the

steering harness and it's more like

these kind of strategy harnesses that

Caitlyn's mentioning, which allows you

to operate at a slightly higher level of

thinking, which matches I think a lot of

the intelligence gains that we're

starting to see with the model.

>> Do you think task-specific harnesses

make sense? Or a vertical-specific or

task-specific harnesses?

>> I think people have different opinions

on this. Like our opinion is yes. I

don't think there's like a general

harness. I think there are some

capabilities that are obviously very

general and they tend to like be very

useful. Like coding is a capability that

like is very useful cuz you use it

across so many things and software as

you know it's just like eating so much

of of what is capable. So our ability to

like write software is therefore useful.

I think when you think about like very

very specific types of domains that were

going to require like a couple of pieces

of the harness to be sort of like

customized. One of that I do think is

how you choose to kind of like handle

sort of like errors between when you do

something and you hand something off to

the model.

So in like domains where you require

like an extreme level of verification,

that logic of how you handle that like

it again I think it sounds small but

like I totally understand why some

people feel like they really want to own

the harness because tweaking that last

bit will give you a ton of juice. And

especially domains like like legal and

finance where there's a lot of

consequences to you know not getting it

perfectly correct, like it's really

going to matter and that's going to be

the difference between your product and

someone else's product being the thing

that the user ultimately uses. And then

there are other domains for which like I

would say it's not going to matter as

much because you're able to compress it

into like a general model capability. So

the tweaks that I guess like you know

where where we feel like the domain

specificity is really going to matter is

the specific like verification logic

between the model

and your execution and then

I think it's going to be about like some

of these kind of like higher order

strategies on how well you're able to

actually like allocate your token

budget. I think the context is actually

a little like over done. Like yes you're

going to like throw in context and like

that's but any harness can actually

handle a lot of context and so that's

just more like you have the data and if

you have the data then obviously you're

you're uniquely qualified to do

something useful.

>> Yeah and I think when people say

harnesses they often mean a lot of

different things and I think this is why

in part there's so many different

opinions on this. Like you can think of

a harness is literally just like a loop

Um, like okay cool like user model, user

model tool, you know, like that sort of

thing. Um, then you could think of the

harness as also all of the tools that

are packaged up with the harness, right?

And and there's just like a lot of

different definitions of these things,

and I think the stuff that can be pretty

generic and like less interesting to own

and and deal with what I was kind of

saying earlier is like getting your

prompt caching right, right? Like, maybe

that is not the world's most interesting

thing. Choosing to clear out old tool

calls from the context window and and

things like that, right? Are like maybe

a little bit less interesting.

And you like go a layer higher into some

of the stuff Angela was talking about,

and then you get into like, okay, yeah,

these are things that I might want to

own and control. And so, it's

interesting with cloud managed agents,

like, the thing that we built today, we

call it higher order, but it's not

really like that high order in the sense

that you can choose to define all of the

tools that you want to bring in as

custom tools with the harness, right?

And like, we give you a lot of knobs to

control. You can define skills, you can

do your system prompts, you can do a

whole bunch of different things, MCP

servers and things like this. And I

think where, you know, we want to get to

is a point where you can literally just

tell an agent, here's the outcome I

want, and here's the budget that I want

to spend, like, ready, set, go. And you

maybe like don't think about any of

those things underneath. And so, I think

there's just a few different layers of

this, right? That for certain things,

like, you might want to sit at a

different layer of what you actually go

and control, um, and you can probably

get better outcomes within some of those

layers by doing a little bit more

optimization work.

>> Very cool. One of the things I'm curious

about, and then what that I love about

infrastructure and platform teams, is

that you get to see what the most

advanced users in the world are using

and learn from them. I'm curious, what

are some things that you're seeing and

learning from from the people building

on your platform?

>> There's some people who've been doing

some really funky ways of like handling

context.

Um, we ourselves explored this a lot.

This is actually like one of the reasons

why tag is like uh such a great product

is like there's a lot of really awesome

like context kind of engineering that

that's happening.

Um we've seen some teams be really

clever about like how they do that and

they are able to kind of think through

like, "Okay, if I have all these

contacts in a bunch of different places,

how can I proactively go reach out to

them? How can I try to generate enough

like um permissions across each of them

so and then feed that all into like an

agent?" And it's interesting that like

um I guess like this is kind of the

level of innovation that like we're

actually like very excited by. It

doesn't express itself as like a

completely different form factor, um but

what it actually does express itself as

is like maximally useful to users and

we've been seeing this more and more

with like inter- actually like internal

use cases

instead of like external ones. So like

companies who are becoming more AI

native basically, they're the ones we're

seeing increasingly more and more

innovation out of and so you know, we've

had like customers try to do this for

their like they've built their own like

custom SDLC kind of setup in very very

innovative ways. We've had uh ones who

do that for like in their entire back

office. And just like the kind of

nuances of how they like stream in

context, I think it's been like actually

really interesting in terms of like how

they've been putting together the

pieces. So that's been like one category

that's been like really really like

fascinating. Uh another category that's

been like really interesting has

actually been with companies that are

dealing with like really old-school

software. And so there's a lot of like

healthcare companies um that we kind of

engage with and you know, like they're

like the the systems I'm working with,

they don't even have APIs. Like that's

that's a a dream. Um and so you know,

how can they use computer use uh and

things like this to be able to start to

kind of automate and create more

connectivity with our systems. Um and

that area of innovation I think has been

really exciting. It's been really

interesting to see people try all sorts

of crazy stuff from like taking a laptop

and trying to like run a bunch of things

on it to auto-generate a bunch of things

that then their agents can go and use.

Um and this has actually been probably

like an area of um I think a lot of

innovation coming from a lot of our

customers that we want to find ways to

like support better and see like, "Okay,

maybe there are like how can we make

this easier for you? How can we help you

with some standardization? How can we

get it so that, you know, like you can

just have a spec and then Claude can

then respect it. And so it's much easier

for you to organically connect a lot of

these things. But yeah, maybe the the

general theme I would just give you is

like interestingly, a lot of the

innovation that's most exciting out

there right now has been uh this kind of

like context and connectivity layer,

which has been really fascinating.

>> Yeah, like a good one in that um we were

working with a customer who they built

some agents on Claude managed agents.

They also have some agents that they

built on other models and other

platforms and they've kind of optimized

each of these agents to be good at the

things that they want. They want these

agents to all be able to work well

together. Um and they kind of were like

wow, galaxy brain, like what if I expose

an MCP server on top of this agent so

that I can then go and like have this

other agent call a tool on that agent,

right? And and have these things just be

more modular and be able to work

together. And we're like We sat down

with them and worked through it and and

it worked perfectly. And it was pretty

cool. And so we're seeing a lot of again

that connectivity layer that I think is

one of the cooler areas where people are

innovating, but

outside of that, one thing that has been

cool is just seeing the shift in I guess

like industry trends of where we're

seeing a lot of our usage come from.

Like talked a lot about coding, like

coding as a category, like of course

absolutely exploded. There's so much

going on there. And we're starting to

see some of these emerging trends like

more recently.

Um we're starting to see manufacturing

really pick up as just a category where

people are building with AI and like one

of our PMs like getting on a flight to

Detroit to go like figure out with these

customers like what they need and what's

going on. And so I think we're going to

start to see a lot more just kind of

like outside of the box of what people

think about today sort of use cases,

which we're really excited about.

>> It seems like there's no there's a we

went through a token maxing moments of

history and now there's like the token

rationalization moments of history.

[laughter]

What are your thoughts on that and like

what what should companies be doing and

then how it how does the platform team

think about enabling that?

>> Yeah, I mean it it makes sense.

It makes sense from the high you start

to rationalize. I really like that

framing. And I think there's like a

couple things that that are like top of

mind for us on this front. I think like

again it makes sense and as these models

get more and more capable you're going

to hit like levels of intelligence

maxing that are like there that then you

want to do the next kind of dimension

and the next dimension after

intelligence will either be cost or it

will be speed.

And you just kind of like you know go

through that across all possible task

complexities in the distribution. And as

we kind of see that like happen you know

something that's like really top of mind

for us that we kind of try to spend some

time with users on is like what you

don't want to do is like stop AI usage.

Right like that's kind of the wrong

move. And we do actually see some of our

our customers do that. So often times

the way that AI spend has erupted inside

their company has been through some kind

of like shadow IT. You know like their

employees just like want to use it they

find a way they end up procuring it

themselves and before you know it like

half your org has like found some way to

have installed cloud code. And in that

world it is kind of hard to to manage

because these things are again like

they're very token hungry ultimately.

And so what we try to kind of encourage

our customers is like okay you don't

want to like stop the innovation. Like

if you are getting returns on top of

this you are shipping faster than ever

before you can like run more

operationally like efficient then those

are gains. And so the area that we

actually try to encourage people is like

if there is a way for you to kind of

construct again like a strategy that

allows you to design an architecture

that says like given a task assesses

level of complexity. I mean I'm

effectively

describing a router but like there are

ways to do this that are like I think a

bit better now. And so like this task

comes in has a certain level of

complexity for that level of complexity

like you can define some rules but for

the most part right if it's like a hard

task you should probably route that to

like a big super smart model. And if

it's not a hard task you can route that

to like cheaper models.

Designing that I think has a little bit

of like there's a lot of technical

complexity in that but it's like very

very doable. And we actually like,

encourage people to try those kinds of

things. I think ultimately

>> offer a router?

>> I I think within the Claude space, it

will like make sense. It's actually one

of the strategies we imagine like

designing, cuz the way that we are kind

of thinking a lot of these things is

like, it almost feels like every month

there's a new era of something.

Um, and if we just take a step back and

go, "Okay, and it they seems to be like

really fast." And so, what are the

different ways that are re-composable so

we can redesign very quickly for any new

whatever the cool thing is that month

kind of like

Um, and so this is like in that category

of things where we feel like we can

actually just like re-compose a lot of

our primitives and then design it. I

think the bit that we do feel really

strongly about on the model routing

front is like, we are designing our

platform for Claude and we want to make

sure that Claude is great at like

solving all these things. So, we'll like

restrict to that space

um, rather than you know, I don't think

we're that interested in saying like,

"Okay, and then you know, you should

route to a different model or whatever."

>> Makes sense.

>> Yeah, and and well, some of that too is

just like, I think we have a strong

belief that harnesses and and just like

the agentic layer should be tuned to the

model family that you use it with. And

so, I think there was a period where

people were kind of like, "Yeah, cool. I

can like build a harness and build an

agent and then just like plug in a

different model underneath." And they

were excited about routers from that

perspective. And I think we've started

to see um, like Vercel just did this

with harness agent for example. Like,

some of these players in the space like

come up a layer of abstraction and say,

"Actually like, plug in the whole

harness and the whole agent that's tied

to a model family." Which makes a lot of

sense. And so, what we could provide is

a little bit better, smarter like, how

do you mix and match the right models

within the model family underneath that

thing if that makes sense. But, yeah, on

the general question of token maxing,

costs, and these sorts of things,

I think we're just kind of going through

what feels like a normal, natural cycle

for companies in figuring out how to

make the best use of this technology and

run their businesses really well and

really effectively. And um, it's

interesting like before working at

Anthropic, I was at Stripe and we were

kind of in the very reasonable era of

like we paid a lot of attention to our

AWS bill. And so, you know, if someone

were to have built some background job

and they like didn't quite configure it

correctly and this thing's like burning

through like CPU or whatever it is,

right? Like at any given moment and

causing, you know, big increase in span

that's not actually worth it, right?

Like we have put in place the guardrails

to find that and then go ask that

engineer very nicely to please turn off

their background job that's not like

within the bounds of of what they should

be spending for the thing they're trying

to accomplish. I think those are the

things with AI that people are going to

start to go and figure out and I think

to Angela's point, I think that gets

dangerous is when you're kind of just

like, here's a cap and you're stuck

within your cap like ready, set, go. But

I do think that encouraging innovation,

encouraging people to, you know, create

really excellent outcomes with this

stuff and then coming in from the side

and looking and saying like, okay, well,

there are few different ways we probably

could have accomplished that outcome,

right? And one is like you take Opus and

you run it all night and you do

something crazy and another is maybe to

get a little bit smarter with the

strategies that you put together in

order to create that same outcome within

a lower cost and I think that's the like

next layer of thinking that everyone's

going to start to do.

>> Very cool. Is there anything that you

guys are excited about building over the

next two months that you can share hints

at what might come next?

>> Uh, yeah, I mean, I know we said this

word like 20 million times, so I

apologize, but like we really are trying

to build ways for you to compose

strategies.

Um, and so, uh, that is an area that

that we're like trying to move into that

kind of like, yeah, uh, coordination

layer of the abstraction. Um, and we

want to start at at this front because

the types of problems that we see people

building, they are at a layer where it's

like in order to get the most return on

this, you have to be a little clever

about like what is the nature of the

problem that you're solving. So, to give

you something like concrete, like if

when you try to solve for like let's say

you want to build an agent that's like

trying to

do bug hunting. And you could just send

one off to go and do that. And it's

going to give you a certain type of

return, a level of return possibility.

And then people kind of get stuck at

that and they're like, "Okay, my next

options are I can like

make a bigger I can just like swap the

model for a different probably bigger

model

or I could like let it run like longer.

And that's what pretty much like the

only two like levers that you have to

like try to make this like bug hunting

agent.

From a lot of experimentation, when we

do these kinds of things it's like

actually the thing like those two those

two things are still true. But you

actually have a third lever and tends to

actually do a lot more than you think it

does. Which is that actually if you were

to like best of end the thing, it would

like give you a lot more returns. But

like just to be just saying those words

are fine. There's plenty of papers and

people have published it to actually

build that thing and put it into

production so you can actually test it

on users and see the results for

yourself. That's like really really

freaking hard. And you end up building

all these like custom harnesses and so

on and so forth. So like you know, all

that stuff.

But we're seeing like this is where the

alpha is and it's hard. And so like in

the same very simple philosophy that we

talked about at the beginning, like if

it's like gives you the return that you

want and it's hard, we're going to go

try to just make it easy for you. So

then you can use it to then run the

experiments that you actually need to

run. It reminds me of when people were

talking about agent swarms a year ago.

It's some version of that.

>> Yeah. Has it been a whole year?

>> Yeah.

I know. We're finally there.

>> Yes.

Yeah. No, I think that that's like

that's a type of strategy. Exactly. In

the same way that you have like you

know, one big one that separates a bunch

that's another type of strategy. I think

people have thought about this maybe the

in the way of like human organization. I

guess it could be similar. But if you

take it to the kind of its end state,

it's actually more just like the token

has a job. And I think it's this job

piece that we're we're really indexed on

and

we see a lot of returns to you. And

that's the thing that we want to spend

time with users and the rest of the

ecosystem on on like how can we just

make that easier for folks to then

experiment? Like we can give you like

five jobs off the top of our head and

we'll probably "That's what we have

internally.

Um and if we give this out to the rest

of the ecosystem, there's probably going

to be like 100,000, 200,000, who knows

what other combinations of people could

put together."

>> Yeah. We want to be able to keep doing

this hill climbing on like, how do you

get the most value, the most

intelligence per dollar, and just put

that power in people's hands. But around

the edges of that, we have these

personas that have kind of just like

things they have to work through in

order to be able to like really deploy

AI either within their companies or

within their products. And um that's

like the sort of enterprise-ready

security and compliance controls and

things like this. But really even just

like making the platform more modular in

the right ways, like being able to plug

in different pieces of the solutions

that we're building, like I want to use

memory for this thing over here, right?

Or whatever else it is, and having a

truly excellent developer experience

around that, because we spend a lot of

time with enterprises who are like,

"Okay, I have this like walled garden,

and I need to figure out exactly how I

can plug these in." And so, we're We've

got a part of our team that's innovating

on things like strategies and jobs and

trying to help you maximize

intelligence. And they're like, "That's

really cool, but I can't actually use

any of that for XYZ reasons." So, I

think solving those problems is really,

really important to us. But then the

other persona is, you know, the like

weekend developer who's like, "I want to

go and build something useful for

myself, right?" And they're often doing

that on top of our platform and on top

of many other just pieces of developer

platforms in the community. And I think

for some of those folks, there's more

that we can do to be provide solutions

that are maybe more open or more

hackable or whatever it may be for those

folks to kind of just like go wild with

what we can offer them and have this

really excellent developer experience.

And so, I think there's a lot of stuff

that maybe I would put in the the

category of table stakes that I'm really

excited about, because I think those are

the things that then unlock getting

people to say, "Okay, yes, this thing

works for me, and now I can plug in on

some of the stuff that you guys are

doing that's really innovative and help

line me to get more intelligence and

save costs and things like that.

>> Wonderful.

>> Caitlin and Angela, I feel I mean you

were building one of the most important

developer platforms in the world and

talking to the two of you over time I

just feel really optimistic that that

platform is in very thoughtful

hands that that care about the

ecosystem. So thank you for taking the

time today to share what you're up to

and we look forward to what's ahead.

>> Thanks for having us.

>> Thank you guys.

>> [music]

[music]