Anthropic 的凯特琳·莱斯与蒋 Angela：构建生态系统，而非封闭花园

在这之上最后一层抽象可能就是协调层。

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.

但下一层是关于，如果token不是真正可互换的，你需要给它们不同的任务，比如这个token在提供建议，那个token在执行，你就要开始组合这些协调策略，它们应该放在所有这些之上，因为最终还是要执行，执行还是需要知道该做什么。

But the next one is about, okay, if tokens aren't really fungible and you need to give them different jobs, like maybe this token is advising versus this token is executing, you wanna start composing 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, 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 execution layer, from the execution layer to the kind of coordination layer in terms of the abstractions that you can see us put out.

Katelyn和Angela，非常感谢你们今天加入我们。

Katelyn and Angela, thank you so much for joining us today.

我和Lauren非常高兴你们能来。

Lauren and I are thrilled to have you here.

你们负责构建Anthropic的平台，你们负责构建我认为是世界上最重要，甚至是最重要的开发者平台。

You are responsible for building Anthropic's platform, and so you are 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.

那么，也许我们可以从开始，你们能给我们介绍一下Anthropic平台是什么，以及你们在Anthropic中的位置吗？

And so maybe just to get started, can you give us the context of what is Anthropic Platform and where do you sit within Anthropic?

是的，平台既包括我们面向外部的API，也就是开发者平台，人们想要构建访问Claude智能的应用和系统时会在上面开发；也包括内部，我们运行我们的产品基础设施，基本上，我们也是我们内部应用所构建的层级。

Yeah, so Platform is both our externally facing APIs, our developer platform that people build on top of when they wanna build applications and systems that access Claude's intelligence, as well as internally, we run our product infrastructure, and basically, we're the layer that our apps build on top of internally as well.

太棒了。

Awesome.

你们团队的北极星是什么？

What's your north star as a team?

这是个好问题。

It's a great question.

因为我们既有内部又有外部，实际上我们有两个北极星，这大概就是，你可能会问，什么？

Because we have both internal and external, we actually kind of have like two North Stars, which is probably like, you need be like, what?

你当然只需要一个北极星。

You surely need one North Star.

不，我们有不同的行星系统。

No, We have different planetary system.

是的，没错。

Yes, exactly.

它们是独立的太阳系，所以没问题。

They're separate solar systems, so it's fine.

但在内部方面，我们真正想提供的是尽可能多的杠杆，让内部团队能够推出那种AGI级别的产品。

But on the internal side, like we really wanna provide is like literally as much leverage as possible for our internal teams to be able to ship like AGI pilled products.

我们希望他们能快速行动，能有一个可靠的好平台来构建。

And we want them to be able to move fast, be able to have reliable, like, great platform 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.

对外呢，我们面临的情况其实要复杂得多，但我们的一个核心目标就是给所有开发者提供工具，让他们能借助Claude去构建他们想做的任何东西。

Externally, we actually have a lot more complicated set of things, 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, that boils itself down into being wherever that business is.

我们非常看重让平台尽可能贴近业务。

We really care about bringing our platform really, really close to that business.

这就是为什么我们花很多时间跟那些超大规模云服务商合作，像AWS、谷歌这些，跟他们紧密集成。

This is why we spend a lot of time with the hyperscalers and integrating really closely directly with them, like AWS, Google, so on and so forth.

最后我们创造了很多基础组件。

And it is a lot of 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.

你知道吗，在这个AI的新世界里，以前在定制软件的最后一公里上，可能经济上不划算，但现在理论上应该变得非常容易实现了。

You know, like in this new world with AI, what used to be probably economically impossible was that last mile of of custom software now in theory should be like very, very achievable.

我们希望给他们所有的工具和能力，让他们能够去做那件事。

And we wanna give them all the tools and all the capabilities to go and do that.

所以有时候，这体现在一些基础模块、API和高级抽象上。

And so sometimes that comes in the form of primitives and APIs and higher order abstractions.

有时候呢，又体现在一些标准规范上。

And sometimes that comes in the form of just like standards.

比如像skills和MCP，这些就是Claude要变得有用所必需的东西。

So for example, like skills and MCP, those are things just like Claude needs them to be useful.

然后我们可以把它们提供给整个生态系统，和所有人一起合作，帮你们创建这些功能，充分发挥Claude的潜力。

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 I would say externally, we really are oriented around just helping you just be able to build.

但在内部，这种导向虽然还存在，可能更多地偏向速度和快速行动的能力。

But internally, that orientation, while still existing, is probably more 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 platform businesses and constructs where you actually 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, 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 wanna 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 the capabilities of these models just grow and such as exponential.

而要找到一个长期稳定的产品形态确实非常困难。

And it's really hard to figure out a long lasting form factor.

我觉得两年前，大家都觉得聊天界面才是主流。

I think two years ago, we were all like, everything's chat.

现在呢，大家又觉得聊天界面算了，不看了。

And now everyone's like, forget chat.

现在的焦点全在智能体上。

It's just like agents.

接下来肯定还会出现新的交互形态，各种新形态层出不穷。

And there's gonna be another form factor, another form factor.

我们觉得这种形态会不断演变。

And we kind of imagine that 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 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 more those form factors will actually kind of naturally come out of the market.

是的，我觉得在我们团队内部，我们有过一些时刻，甚至只是尝试用不同的、更高层次的方式打包我们的原语，我们想过，好的，没问题。

Yeah, and I think within our team, we've had moments where we're experimenting even with just a packaging up of our primitives in a different sort of higher order way, and we've thought about, okay, cool.

我们已经用这个产品解决了这类具体问题，并且把它推向了世界，所以我们可以自己先试用一下，但我们绝不想陷入这样的陷阱：过于偏向内部用户的需求，因为正如Angela所说，内部用户有非常具体的要求，外部用户也有非常具体的要求，所以如果你过于偏向其中一方，就会陷入陷阱。

We've solved this exact type of problem with this product that we've built into the world, and so we can go and dog food it for ourselves, but we'd never wanna fall into this trap of like, we're over indexed on the problem as it needs to be solved for an internal user, 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.

所以我想在基础层面，这只是对Clive、Opus等token的原始访问。

So I guess at the base level, this is just raw access to Clive, Opus, whatever tokens.

你如何看待在这之上的抽象层叠？

How do you think about the layer cake of abstractions above that?

是的，如果你回顾一下，大约一年前我加入Anthropic时，平台基本上只有Messages API。

Yeah, if you look back, so when I joined Anthropic around a year ago, the platform was basically just Messages API.

那只是一个Messages API。

It was a Messages API.

我们当时推出了像MCP这样的标准。

We had come out with standards like MCP.

我们当然有围绕SDK、文档、控制台之类的开发者工具，但基本上它还是一个无状态的API。

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.

有意思的是，就像Angela说的，形态会随着时间演变，我们发现很多客户在反复解决同样的问题，而这些问题我们自己也在反复解决——随着模型能力越来越强，能运行更长时间，同时处理更多上下文，你就想构建那种能在长时间运行甚至远程环境中成功运作的智能体，不一定需要人在里面盯着。

And what's interesting, to Angela's point on form 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 contacts at a given time, you wanna 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 infrastructure being kind of a hard thing to deal with.

比如，你怎么去创建那些有合适治理和安全性的沙箱，需要的时候启动、不需要的时候关闭？还有会话记录的存储，这样你停下来之后还能恢复之前的会话，接着继续。

Like, how do you figure out spawning sandboxes that are gonna have the right governance and security and 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?

所以基础设施是我们想更多提供开箱即用的东西，现在我们也确实做得更多了。

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.

然后第二件事就是 harness 和 harness engineering。

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 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 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, 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 How often are they opting into just the managed agents offering, I guess?

干脆全都交给你处理吧。

Just take care of it all for me.

这因用户群体而异。

It varies by the user group.

比如说，对于那些真正以AI为先的初创公司，那些在底层折腾和试验的人，他们就直接用基础组件了。

So for, I would say, really AI native startups, the ones who are tinkering and experimenting at a really low layer, they're just gonna go for the primitives.

而对于其他人来说，这些更像是经典的、更企业级的，或者是那种初创公司的目的或理念不一定是优化某种爬山式的指标，而是把一堆工作流串起来，给用户提供独特的价值。

And then for everyone else, these are kind of classic, more enterprises or areas where it's like the purpose of the startup or the philosophy behind the startup isn't necessarily to optimize on some kind of hill climbing pieces, more like stringing together bunch of workflows and providing unique user value to that user.

对于那些人来说，这毕竟不是他们的核心能力。

For those people, it's just kind of not their core competency.

他们不想把时间和精力花在那上面，所以更倾向于选择这些更高层级的打包方案。

It's not where they wanna focus their time and resources, and they reach much more for these kind of higher ordered 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 for some of the constructs that Katelyn was talking about is and this is a bit of an oversimplification, but effectively, there's approximately like three layers of this cake.

最底层其实就是知识。

At the very bottom is just kind of like knowledge.

所以这一层在很多方面是关于模型本身的知识，也就是模型需要什么，简单来说就是知道怎么真正用好 Claude，我大概可以这么表达。

And so at this layer, in many ways, 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.

因为我们还在不断演进它们，但它们往往已经比较成熟了。

Because like we still evolve them, but they tend to be a little bit more baked.

比如，我们在消息API上设置了非常具体的形状和参数。

Like, for example, there's very specific shapes and parameters we put on the messages API.

这更像是要明确展示Claude的设计，也就是Claude模型的实际设计，它的思考方式，它如何尊重某些参数，它如何进行工具调用，所有这些不同的部分。

And it's more like trying to expressly showcase Claude's design, like Claude the model's actual design, the way it thinks, the way it respects certain parameters, the way it kind of will do tool calls, all of those different pieces.

然后我们开始标准化工具，接着开始标准化上下文的不同片段，这些片段可以在不同时间点插入，具体来说就是技能和记忆。

And then we started standardizing tools, and then we started standardizing bits and pieces of context that you could put in at different moments in time, which is concretely skills and memory.

所以这些就是我们在过去一年多里推出的知识层抽象。

And so those are the knowledge layer type of abstractions that we've put out over the past, I guess, year plus a bit.

我们实际上开始花越来越多时间的下一个抽象层是，一旦你知道了东西，你就需要执行。

The next layer of abstraction that we've actually started to spend more and more of our time on is once you know stuff, you then need to execute.

所以在执行层，那个抽象级别就是Katelyn刚才提到的，比如我们在做这些更高阶的东西，但我们在那里把什么变得更高阶呢？

And so at the execution layer, that level of abstraction is the part that Katelyn was talking about around, like, we're doing these, like, higher order pieces, but, like, what are we putting higher order to there?

这确实是因为你现在是让 Claude 去执行任务了。

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 and give me an answer.

你可以把很多这类东西串在一起。

You can put 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 of abstractions.

目前我们面向这个层面的高层产品叫作云端托管智能体（Cloud Managed Agents）。

Today, we just our high level product for that is called Cloud Managed Agents.

所以那只是一部分，但我们开始把越来越多的环节都包进去。

And so that's a piece, but we started to wrap more and more pieces in that.

我觉得在这之上还会有一层。

I think there's gonna be a layer on top of that.

我们已经有一些初步的想法，开始往那个方向做了，但最上面的最后一层抽象大概就是协调层。

We have some inklings of it that we started to build towards, but the last layer of abstraction on top of this is probably the coordination layer.

所以先是知识，然后是执行，最后是协调。

So you have knowledge, then you have execution, then 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 meta harness.

这个框架，真正底层的框架，是为执行而设计的。

The harness, the true low level harness is designed for execution.

但下一层要考虑的是，如果token并不是真正可互换的，你需要给它们分配不同的工作，比如有的token负责建议，有的负责执行。

But the next one is about, okay, if tokens aren't really fungible and you need to give them different jobs, like maybe this token is advising versus executing.

这个令牌在做梦，那个令牌在执行，诸如此类。

This token is dreaming versus this token's executing, so on and so forth.

你开始想把这些编排好的策略组合在一起，它们应该放在所有这些之上，因为归根结底，你还是需要执行，执行者还是需要知道该做什么。

You wanna start composing these kind of orchestrated strategies that go together and they should sit on top of all these things because at end of day, you still need to execute and the executioner still needs to know what do.

所以理论上，所有东西都应该像梯子一样一环扣一环。

So everything in theory should kind of like ladder together.

所以我觉得，如果你看看我们的路线图，稍微往前推一下，大概能猜到我们会往哪个方向走，我们会越来越多地从知识层转向执行层，再从执行层转向协调层，就你们能看到我们推出的那些抽象层而言。

And so I think, you know, if you were to look at our roadmap 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, from the execution layer to the coordination layer in terms of the abstractions that you can see us put

推出。

out.

一个非常

A really

酷的说法。

cool quote.

你觉得

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 wanna find a way to be to support as many people in doing this as we can.

我们还在学习过程中。

I we're still, like, learning.

就像很多行业一样，它已经发生了变化。

Like, a lot of the industry, like, has evolved.

我们看到很多不同的项目被启动又被关闭。

We've seen, you know, a lot of different pieces get spun up and spun down.

我觉得对凯特琳和我来说，关键的一点就是，至少在基础层面，我们要尽可能提供各种基础组件。

And I think the the operative part for for Katelyn 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, we wanna give all of that out to everyone so that people can start to compose and create on top of that.

这纯粹是从开发者的角度来看的。

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.

我们还提供了一些原生集成的方式，比如基于MCP规范的连接器。

We've also created some ways to embed natively with us, like, for example, connectors, which are built on top of the MCP spec.

我们尽量在这些方面保持开放。

And we try to be more open about those types of things.

我们正在摸索哪些部分才是合适的。

And we're starting to figure out what are the right bits and pieces.

但我们真正想做的是，让公司能够被创建并在此基础上发展，他们可以构建任何他们想要的产品。

But what we're really trying to do is get to a place where a company is able to get created and built on, 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.

有些智能体可能是Claude智能体。

Some of those agents could be Claude agents.

有些可能是其他人的智能体。

Some of those agents could be other people's agents.

但我们希望能够在整个范围内实现这种互操作性。

But we want to be able to enable that kind of like transactability 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, how do systems interoperate?

这就像你看到的技能和MCP那样的东西。

And that's things that you've kind of seen to see 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 we've talked to a lot of these companies and this is less from philosophies aside, just more like no one really wants to have technology that's, for example, doing negative things on their service.

所以网络安全就是一个很好的例子。

So cyber, I think, is a great example of this.

你想要保护自己的系统免受恶意行为者的侵害。

You want to protect your own systems from negative actors or bad actors.

所以这些标准制定，比如我们如何找到与更多人合作的方式，来确保关键基础设施是好的，大家都同意这一点。

And so these kinds of standard settings of how can we find ways to partner with more and more people to be like, Yeah, we all kind of want to make sure critical infrastructure is good.

我们都希望防止欺诈或类似的事情发生。

We all want to prevent 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 trying to find ways that we can be better and work with the rest of the industry to bring people along and work with them.

但这些就是我们希望建立的高层次的框架或要素，这样才能和各方合作，最终解决这个问题。

But those are kind of the higher order primitives or pieces that we wish to be in place so they can work with folks to ultimately solve this.

我觉得如果Fly退一步看所有这些事情，这项技术真的具有变革性。

I think if Fly were to take a step back at the end of the day on all of these things, this technology is so transformative.

它有点像电，在电出现之前，只能用蜡烛，能做的事情很有限。

And if it's a little bit like electricity in the sense, before electricity, there was just had to have a candle and it was like, you can only do so many things.

但有了电，它之所以能成为对我们所有人来说如此变革性的技术，成为如此重要的基础设施，是因为你可以把它接入到一切事物中。

But with electricity, the reason why it's such a transforming technology for all of us and so greatly of a utility is because you can actually like wired 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 to figure out a path forward.

你怎么看待构建开放生态系统和封闭花园这两种理念？

How do you think about the philosophy of building an open ecosystem versus a walled garden?

你觉得哪些产品必须由你自己一手掌控，而哪些你又很乐意接入生态系统中的其他组件？

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, 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, what we've done within something like Cloud Managed Agents, 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.

它应该是由我们控制的沙箱环境，或者是由我们控制的存储层。

It should be sandboxes that we control or it should be a storage layer that we control.

比如，我们推出了自托管的沙盒环境，还和 Modal、Vercel、Cloudflare 以及亚马逊的新微虚拟机等合作伙伴联手，打造了一个一流的方案，让你可以把这些平台都接进来。

We actually, for example, we launched self hosted sandboxes and we partnered with Modal and Vercel and Cloudflare and a bunch of other folks, even Amazon's new micro VMs, to have a first class offering where you can go plug any of those things in.

我们还推出了 MCP 隧道，这样你就能穿透防火墙，去调用那些藏在防火墙后面的 MCP 服务器了。

We launched MCP tunnels so that you can call out to your MCP servers that are behind your firewall and be able to punch through there.

所以对这些功能来说，到底跑在我们的基础设施上还是别人的上面，其实对我们来说没那么重要。我们更看重的是架构设计，也就是怎么把这些智能体组合起来，让它们既强大又可靠、可扩展。在这方面我们有自己的坚持，你只需要遵循我们提供的接口规范，把东西接上去就行。我们认为这种模式通常效果非常好。

And so for some of these things, whether it runs on our infrastructure versus somebody else's infrastructure is actually not important to us because 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, we have strong opinions on that, and you can kinda just conform to the interfaces that we put out there and plug those things in, and we think that that generally is a thing that works really well.

对。

Yeah.

我觉得在那些可能开发产品的垂直领域方面，

I think on the kind of

我想我们大概有两个思路。

verticals where we might build products, I think we kinda have 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 static.

这是一个动态的东西。

It's like a dynamic thing.

所以，某一年在AI发展上很棒的方案，到了下一年可能就不那么棒了。

So what might be awesome for one year's worth of AI development will probably not be awesome for the next year's worth.

我们就是尽量保持这种心态。

And we just kinda try to have that mentality.

我们告诉整个Anthropic团队。

We tell the team just overall around Anthropic.

Anthropic。

Anthropic.

每个人都在想，这够不够AGI范儿。

Everyone's always trying to be like, is this AGI pilled enough?

然后我们也有这种心态，就是我们做出来的东西，它有效。

And then we also have this mentality of like, we built something, it works.

它火了一年，但可能不是下一个正确的方向。

It was cool for a year and maybe it's not the right next thing.

那么有没有办法再试一次呢？

And so is there a way to try again?

我们对平台用户也是这么说的。

And we tell platform users the same thing.

我们只是觉得这大概就是跟技术绑在一起的。

We just think that's probably just, 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.

这不一定是因为我们认为这是最大的市场或者最重要的事情，但有时候就像，好吧，这一直是个很难的事情，人们总是这样交流或者这样尝试一些事情。

It's not necessarily because we think it's, like, the biggest ham or the most important thing to go after, but sometimes like, okay, this has like always been a really difficult thing and people have always communicated this way or tried some things this way.

我们能不能展示一下，也许有一种稍微不同的方式呢？

And can we show that maybe there's a slightly different way?

既然现在模型的能力这么强，我们能不能试着换种方式来表达？

And because the model capabilities are are so advanced now, can we try to express it a bit differently?

能举个例子吗？

What's an example of that?

对。

Yeah.

比如 Claude 的设计就有点那个意思。

You know, like, 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 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.

第一个就是，你可以试着把越来越多的工作交给 Claude 来处理。

The first one is that, like, you can actually try to offload more and more and more to Claude.

所以它会有点强势地引导你，比如告诉你直接跟它对话，让它去想办法搞定一切。

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.

对，你仍然可以编辑它，然后做这些事情，但有点不太鼓励那样，更多的是直接跟Claude说，让它去搞定。

And, yes, you can still edit it and then do these kinds of things, but kinda, like, discourage a little of that and more just, like, let just talk to Claude to go figure it out.

第二件事是，我们真的想表达的是，代码其实可以解决那些你通常不会想到用这种方式解决的问题。

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 kinda generative, you know, like, slide decks or designs or whatever will pick the way of, like, they have, like, some kinda design system.

你按照设计系统来集成。

You integrate against design system.

这几乎是传统的那种所见即所得的设计风格。

It's almost in the traditional, like, classic WYSIWYG style of designing something.

而克劳德设计就不一样了，它的思路是，好。

And with, like, Claude design, it was like, okay.

我们能不能纯粹用代码，让Claude直接生成代码？

Can we try to just, like, use code purely, like, have Claude 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 kinda do that.

那我们怎么向世界展示这个呢？

How can we kinda showcase that to the world?

所以，这算是一个例子。

So that's, like, an example.

我们还有很多其他内部项目，这个算是属于展现产品形态那一类的。

We have a lot of other internal projects, and this kinda falls in the category of, like, expressing form factor.

我们都会在内部试用一下。

We'll all try it out internally.

也就新鲜两个星期，然后我们就继续做别的东西了。

It'll be super cool for, two weeks, and then we move on to the next thing.

坦白说，这东西我们根本就没发布过。

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.

然后还有第二类，就是我们确实会看TAM。

And then there's like the second category, which is that we actually do look at TAM.

毕竟我们是做生意的，肯定会看TAM。

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

我们会关注那些我们认为合理的、会有智能体式操作发生的领域。

We do look at areas that we think, you know, there'd be reasonable, agentic, like, operations that would happen.

在这些领域，我们确实倾向于那些对token消耗比较大的东西。

In those areas, we do tend to have an orientation towards things that are more token heavy.

所谓token消耗大，或者说token饥饿，我想说的是，意味着当你完成一个回合后，你回头看看那回合结束时，会问自己：我做完了吗？

And by token heavy or token hungry, maybe is the way I would say that, is, what we mean is, like, you know, you 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, say, I wanna 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've finished 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?

所以我们倾向于选择那些有点迭代流程的。

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.

然后我们看的最后一个角度就是，你知道，会有某些业务功能，我们觉得他们是理想的买家。

And then the last angle that we kinda take a look at is just sort of like, you know, there's gonna be certain business functions that we're 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.

我们试图专注于特定领域，在那里我们觉得通过拥有正确的背景和正确的工具，并以良好的形式组合起来，可能对我们来说是有用的。

And we've tried to 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 for us to be able to do.

在每一个领域里，我们都在努力展示各种可能性，涵盖所有能实现那些目标的不同方式。

And in each of those areas, we're trying to do a bit of showing the art of the possible across all the different ways that you would accomplish those outcomes.

比如说金融领域就是一个很好的例子。

And so for finance, for example, is a good one.

你可能是一家解决金融问题的公司，你可以直接在Messages API之上构建，只需要一些token，其他所有东西都可以在此基础上搭建。

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 cloud managed agents.

这样你就能获得更多开箱即用的功能。

You can get a lot more out of the box.

或者你也可以说，我要构建一个插件或连接器，它将会嵌入到我们的某个产品里，或者适用于那些产品形态。

Or you could say, I'm gonna build a plugin that, or like a connector that's gonna sit within one of our products and within those form factors.

我们最近推出了Claude for Financial Services，就像是在说，好的，没问题。

When we did recently, we launched 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.

我们还发布了操作指南，教你怎么用Claude托管代理去做这些事情。

We even launch 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 we provide people all these different pieces and see kinda where they run with it.

然后有时候我们会把所有这些整合成产品。

And then sometimes we put together products that are just packaging of all of these things.

比如Claude Tag，我觉得就是个很好的例子。

Like Claude Tag, I think, is a really good example.

我们一直看到行业里有人说，Shopify用River做到了这一点。

We had been seeing people in the industry go and say Shopify did this with River.

Square、Block最近用Builder Bot也做到了。

Square, Block recently did this with Builder Bot.

有几个这样的例子，人们说，我要在公司内部建一个代理平台，我要给它所有正确的上下文，我要让它能从Slack或其他各种平台访问，我觉得Claude Tag很大程度上就是把这些东西整合在一起，任何人都可以选择构建类似的东西，但这就是我们内部的做法，如果你想直接接入使用，这就是它的样子。

There's a few of these examples where people said, I'm gonna build an agentic platform internal to my company, and I'm gonna try to give it all the right context, and I'm gonna make it accessible from Slack or from various other 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.

你觉得人们对Cloudflare有什么误解？

What do you think people misunderstood about Cloudflare?

因为当时闹得沸沸扬扬的，说哎呀，这不就是个 Slack 机器人嘛。

Because there was all this ruckus about, Oh my gosh, it's just a Slack bot.

快跟我们说说 Tag 的魔力到底在哪。

Tell us what the magic of tag is.

对，我觉得这是个很好的问题。

Yeah, I think it's a great question.

而且我确实觉得，这其实稍微展示了一下未来可能的发展方向。

And I I do think it actually showcases a little bit of where maybe the future could be going.

对。

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.

我觉得当你看到tag的时候，嗯，确实是这样。

And I think when you look at, like, tag, it like, yeah.

就是说，你与它互动的方式就是直接在Slack里@它。

Like, the way you interact with it is that you, like, literally tag it in Slack.

所以，对，那其实就是它的界面。

And so, yeah, that is, like, the interface.

但那并不是真正重要的部分。

But that's not really the important part.

重要的是我们在底层做的那些上下文工程和架构，让tag能够正常工作。

The important part 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, coworker comes into your channel and then you can chat with it, it's proactive.

它会弄清楚什么是有用的。

It figured out, like, what's, like, useful.

你就能让它帮你把事情搞定。

You could and it just gets stuff, like, done for you.

所以如果你想想，尤其是非技术背景的人，这真的是一个巨大的突破。

And so if you think about, you know, especially, like, nontechnical audiences, this is, like, it's a huge unlock.

你只需要创建一个频道，然后@一下Claude，有时候甚至不用@，你就直接说，嘿。

You just you literally create a channel, and then you at Claude, or sometimes you don't even at Claude, and you're like, hey.

我想做这个做那个，这个我搞不明白，还有那个报销单到底怎么提交来着？

I wanna 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, if 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 up buddy, and it's really, really complicated.

现在呢，你直接去找Claude Tag聊就行了。

And 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.

我觉得Andrei Kaparti说得特别好。

I think Andrei Kaparti said it really well.

这就相当于一个组织级别的框架。

It's like it's like an org level harness.

这里面其实包含了很多复杂的细节。

There's a lot of complexity baked into that.

就像 Katelyn 提到的，你可以用我们的 API 来搭建这个框架。

Like Katelyn mentioned, you can use our APIs to go and construct that.

当然，你也可以自己进行大量的实验和尝试。

You can do a lot of the experimentation yourself, obviously.

不过这是 Anthropic 的一种观点，他们认为你可以为整家公司打造这样一个非常棒、随时待命的智能体。

But this is an opinionated take from Anthropic on 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 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, tidbit that's, like, outside in the water.

其实界面可以不断切换。

It's just, like, the interface can actually constantly swap.

比如今天，很多人在Slack上协作，很多公司也在用，但也有很多人在团队里协作。

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.

有些人通过WhatsApp群聊协作，或者互相发短信，还有些人可能还在用邮件。

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.

这听起来好像很平淡，但实际上我觉得是最前卫的，因为你希望代理和AI基本上就像另一个人，在帮你做事。

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 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 has such an opinionated point of view on 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 what best practices or advice 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?

对，我觉得挺有意思的。我们推出 Cloud Managed Agents 这个通用但高性能的框架，是因为我们已经把那些繁琐、枯燥但又非常关键的底层工作都做好了。比如怎么处理提示词缓存、怎么管理上下文、如何清理窗口里的旧数据，还有如何通过编程方式调用工具，避免把所有东西都塞进上下文窗口，从而保持上下文的整洁。

Yeah, I think, so it's interesting because we've kind of talked about, we launched Cloud Managed Agents as this very generic but high performing harness because we've done all the nitty gritty work that's actually really boring and not super interesting around how do you deal with prompt caching, how do you deal with context management, you clear old stuff out of the window, sometimes you 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.

说实话，最佳实践其实就是像提示词缓存这样的东西。

And I think, honestly, best practices are just stuff like prom caching.

就这么做。

Do it.

你会省下很多钱和token费用。

You're gonna save a lot of money and token costs.

显然，尽量保持上下文窗口干净，然后把这些东西组合成一个高效的框架，有时取决于你要完成的具体任务，对吧？

Obviously, try to keep your context window clear, and then putting those things together in a harness that will be performant is sometimes specific to the task that you're trying to accomplish, right?

然后，当然还有评估。

And then, of course, evals.

我很惊讶我们聊了这么久才有人提到评估这个词。

I'm surprised we got this far into this thing before one of us said the word evals.

我们就像，你需要评估来确保你试图完成的事情是有效的。

We're like, you need evals to make sure that what you're trying to accomplish is performance.

但我认为我们开始走向的，安吉拉之前稍微提到过，是策略或元框架的概念，因为我确实认为，是的，你可以再次构建这个低层框架，它会很高效，也许你自己做很有趣，也许不，你把它交给我们。

But I think where 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 gonna be performant, and maybe that's interesting for you to do yourself or maybe not, and you offload it to us.

但这个概念是，你可以拿任何给定的token，花在单纯执行上，或者你可以拿同样的token，选择反思你过去的代理会话，并把学到的经验写入记忆，这样下一个代理就能做得更好。

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.

或者你可以用那个token去咨询一个更大的模型，这样一个小模型就能执行得更好。

Or you could take that token and advise with a bigger model so that a smaller model can execute and do a better job.

或者你可以说，执行，执行，然后一个评判者过来，说，你做得好吗？

Or you can say, Execute, execute, and then a grader comes in and is like, Did you do a good job?

不，你做得不好。

No, you didn't.

再试一次。

Try again.

所以我觉得有趣的创新会更多地出现在更高层次的元层面上，我认为在这些策略内部进行优化是我们团队非常兴奋的事情，我们已经开始在这方面做很多工作了。

And so I think the interesting innovation is gonna come more at that higher level on the meta level, 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.

我觉得很多人也开始对这个策略概念和分配给token的任务感到兴奋，因为确实，关于提示缓存、如何清除上下文窗口中的内容、如何编写评估以及很多类似的事情，是有一些最佳实践，但是我不确定在很多情况下，这一层相比更高一层还有那么多可以榨取的价值。

And I think a lot of other people are starting to feel really excited about this concept of strategies and the jobs you give to tokens because, again, 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 a lot of things like this, But 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