两位 Baseten 研究人员如何使用编码代理

你现在有一个代理正在运行中

And you have an agent running right now

是的，我有。

I do.

如果我从设置中知道的话。

If I know from setup.

对。

Yes.

我很好奇代理今天在做什么？

I'm interested agent doing today?

今天，就像Harry提到的，我们最近一直在做KBCache压缩相关的工作。

Today, as Harry mentioned, we're we've been doing some KBCache compaction stuff recently.

嗯。

Mhmm.

所以我们在尝试通过压缩KBCache来扩展上下文窗口。

So trying to figure out how we can extend context windows by compacting a KBCache.

我们这边大概同时有64到128个智能体在处理这件事。

We have probably between us about 64 to 128 agents working on this at a given time.

那现在，一共投入了多少人在做这件事？

Right now, how many guys are on

就是那台电脑上？

that computer?

现在还有任务在跑着呢。

Actively running jobs right now.

我想我有16个节点，每个节点配8张GPU，然后引擎会按它们喜欢的方式对这些资源进行划分。

Think I've got 16 nodes of eight GPUs each, and then the engines partition those how they like.

我发现很多工作场景下，如果你想让大量Agent运行起来，通常我会亲自跟其中几个Agent交流，其他的则分配具体任务。比如我会让我的主Agent把任务委派给其他Agent。

Find a lot of the work, if you want to have a lot of agents going, I feel like normally I'll have a few agents that I actually talk to, and the other ones are delegated tasks, like I tell my main agent to delegate tasks to the other ones.

我会设置一些消息脚本，让它们之间能够直接互相发送用户消息。

I'll set up some messaging scripts so that they can send direct user messages to each other.

所以我就随便问问，比如我给它们都起了不同的数学家名字，我就会问：庞加莱今天进展如何？或者希尔伯特那边在忙什么？

And so I'll just say, how's my I gave them all different mathematician names, I'll be like, how's Poincare doing today, or what's Hilbert up to?

那挺酷的，所以你真的是靠数学家的名字来记住每个代理在做什么的。

That's cool, so you actually remember which one is doing what by the mathematician preference.

对，就像，哦，你知道，希尔伯特在跑评估，你懂的。

Yeah, It's like, oh, you know, Hilbert's working on the evals, you know.

我

I

见到你们真的很兴奋，也很想听听你们在Base Ten做什么，以及你们是怎么走到这一步的。

was very excited to meet you guys and eager to hear maybe kind of what you work on at Base Ten and kind of how you got where you were.

先自我介绍一下，我是Sam Whitmore。

And to introduce myself, I'm Sam Whitmore.

我在Cursor工作。

I work at Cursor.

我是Cloud Agents团队的工程师。

I am an engineer on the Cloud Agents team.

我在Cursor工作大概六个月了。

I've worked at Cursor for about six months.

好，那就交给你们了。

Yeah, I'm over to you guys.

我和我的联合创始人Moody、Max一起创办了PaaSD，去年开始的。

So my co founders, Moody, Max and I started PaaSD, started last year.

然后

And

一开始，我们做的是比较天马行空的研究，比如，我们对开源模型特别感兴趣，我们想支持一个不只是有一两个封闭前沿模型的生态系统，那该怎么做呢？

at the beginning, was sort of blue sky research on like, okay, we're very interested in open source models, we're very interested in supporting an ecosystem that wasn't just one or two closed frontier models, how do we go about that?

我觉得我们很快就聚焦到了专业化和后训练这个方向上，特别是通过这种方式让人们能够拥有自己的智能。刚开始的时候，这个想法还挺反主流的。

And I think we pretty quickly narrowed in on the thesis of specialization and post training in particular as a way to allow people to own their own intelligence, and I think when we first started that was quite a contrarian take.

当时很多人都不太相信，觉得用开源模型真的能做出有经济价值的东西，但我们相信这个方向。到了去年年中，开源模型的基础智能和能力已经足够好了，我们真的可以开始对它们进行专业化，特别是针对那些很多公司都在做的子任务或者非常重复的工作。然后我们当时用的是Base10来做推理。

People were quite sceptical that you could really do economically valuable things with open source models, but we believed in the thesis, and I think by the middle of last year the base intelligence and capabilities of open source had gotten good enough that we could actually start to specialize them, particularly for these subtasks or very repeatable things that a lot of companies were doing, and then we were using Base10 for inference.

我们觉得他们是全球最好的推理服务商，我们试过所有其他的，然后后来Base10注意到我们给他们带来了很多新的推理需求，于是我们聊了很多次，意识到如果我们能合作，把推理和从推理中获得的真实世界信号结合起来，再加上用户告诉我们的，他们对你的语言模型在特定场景下的表现喜欢或不喜欢的反馈，再把这些和训练结合起来，那会是一个更强大的模式。

We thought they were the best inference providers in the world, we tried all of them, and then I think at one point Base10 noticed that we were directing a lot of new inference demand onto base 10 GPUs, and so we had a bunch of chats and realized that this would be a much more powerful thing if we could do this together if you could couple the inference and the real world signals you were getting from inference and users telling you what they did or didn't like about the particular way that your language model is performing in your harness, and when you couple that with training that's a really powerful paradigm.

这样就形成了一个反馈闭环，比单纯靠提示词和不断调整你的测试环境要强大得多。

It connects together this feedback loop which is much more powerful than what you can achieve with prompting and constantly just iterating on your harness.

所以，从那以后我们就一直用Baseten，Harry是我们PaaSD最早的员工之一。

So yeah, we've been a baseten ever since, and Harry was one of our first employees at Parzed.

我一直想在AI领域工作，而且我对这个领域感兴趣很久了。所以当我听说Charlie在创业时，我就和他聊了聊，当时我就想，哇，Charlie真的很懂行！于是我就加入了，我们合作得很愉快。

I wanted to work in AI, and I'd been interested in it for such a long time, and so when I heard Charlie was doing a start up, I had a chat and I was like oh wow, Charlie really knows what he's talking about!' so then I joined up and we had a lot of fun.

我觉得关键在于，一开始我们规模很小，真的得想尽办法提高效率，所以那段时间挺有意思的，就是发明一些新策略，让我们能用很少的计算资源获得很好的性能。

I think the thing is because of the scale we were at initially, we really had to sort of scrap around and figure out how to do things more efficiently, and so that was kind of fun, yeah, just inventing some new strategies that's gonna basically get us really good performance but without using a ton of compute.

从那以后，我们有了大量的计算资源，现在更有趣了。

Since then, we do have access to a ton of compute and it's a lot more fun.

我们可以做更大规模的实验，所以真的很好。

We can do a lot more larger scale experiments, so yes, it's great.

你能给一个单独的Hilbert或Gauss分配多少责任，直到它开始出问题？

How much responsibility can you give an individual Hilbert or Gauss before it starts to break down?

一般来说，是的，我需要确保我清楚地指定了他们各自需要做什么。

Generally, yeah, I need to make sure I've specified cleanly what they all need to do.

但是

But

一般来说，我觉得另一个常见的失败模式是它们有时候会突然不干活了，我得设个循环不断提醒它们所有事情，特别是过夜运行的时候。

typically, I think another failure mode sometimes is sometimes they just stop working and I need to set up a loop to keep on reminding them of everything, particularly if things are running overnight.

我通常会放一条提醒消息，里面列着所有要做的事，比如记得检查这个、检查那个、检查……

I normally put in some reminder little message that just has a list of all these things, like make sure you're checking this, check that, check

你会强制它们遵守吗？

Do you enforce this in any way?

还是说只是希望它们按照你给的提示去做？

Or is this just hoping they adhere to the prompt you've given?

我一般会让它们自由发挥，但我会设一些检查，防止它们执行危险命令。

Guess I have a few Generally I run them just allowing them to do everything, but I have a few checks for entering any dangerous commands.

我觉得有一种很强大的新抽象，你开始在一些目标循环里看到，就是如果你在开始时花很多精力写提示，并且花很多精力定义如何验证任务是否完成，你可以用一个独立的智能体作为裁判，持续检查主智能体是否完成了任务。这样，当主智能体自己判断时，它们有时会作弊，说‘我觉得我完成了’或者‘我已经尽力了，我要停了’，但如果你有一个独立的智能体不断被调用，说‘不，你其实还没完成’，然后，就像哈利说的，你有一个钩子迫使它继续，这些东西可以运行好几天。

And I think a powerful, a new powerful abstraction which you're starting to see with these goal loops and stuff is if you put a lot of effort into the prompt at the start, and you put a lot of effort into defining exactly how you might verify that a task is complete, You can use a separate agent as an element of judge to continuously check whether the main agent has completed its task or not, and so when you've got the main agent doing that itself sometimes they like to cheat and say oh I think I've done, or I've done my best, I'm gonna stop now, If but you have a separate agent which is constantly being called and saying, No, you actually haven't completed, and then, as Harry said, you have this hook which forces it to keep going, these things can run for days.

你现在是怎么给自己搭建这个框架的？

How do you actually set up this harness for yourself right now?

我不太想在框架上花太多精力，因为我觉得世界上有很多人在研究框架，也在研究模型在这些框架中是如何运作的。

I don't like to put too much effort into the harness because I think there's so many people in the world working on harnesses and working on understanding how the models operate within those harnesses.

我一般就是盯着ClawCode在做什么，Codex发布了什么，然后把那些东西移植到我的环境里，目前用的是Cursor Agents。

I tend to just keep an eye on what ClawCode's doing, what Codex is releasing, and then porting that into my setup, which at the moment is Cursor Agents.

对，你说你直接把代码移植过来了。

Yeah, you said you ported the code directly

对，你可以直接让Cursor Agents去看Codex的Rust代码，然后说，好，他们是怎么实现这个的？

Yeah, from you can just Cursor get your Cursor Agents to look at the Rust for Codex and say, Okay, how do they implement this?

现在你自己照着做。

Now build it yourself.

对，就是这样。

Yeah, exactly.

我觉得这就是那种情况。

I feel like that's the kind of thing.

就是让你的代理自己搭建基础设施，这太容易了。

It's like it's so easy to have your agents build infrastructure for themselves.

我们内部在这方面做了很多工作。

We've been doing a ton with that internally.

我们有个工程师叫Lauren，她负责我们新Cursor 3的发布，当时想给它做一堆性能优化。

One of our engineers, Lauren, who was working on our new Cursor three launch, was trying to do a bunch of performance improvements for it.

她基本上建了一个技能，可以实际启动并驱动Cursor 3应用，先验证之前存在性能问题，然后再验证问题是否已经解决。

And she built basically a skill that could actually launch and drive an instrument with the Cursor three application and verify a previous state of there being a performance problem, then verify that the performance problem was gone after the fact.

但她就像是在说，把QA流程自动化。

But he was like, automate the QA process.

她做完之后，我们就觉得，好吧，这看起来是我们需要投入大量时间去做的事情。

Once she did that, we were like, Okay, this seems like something we need to be investing a lot of time into.

对，没错。

Yeah, exactly.

我觉得任何时候，只要事情能被明确验证，让代理跑一夜或者跑几天去优化就特别容易。

I think anytime you've got something which is really verifiable, it's just so easy to have an agent just like hill climb it overnight or over a few days.

难的是那些不太容易验证的情况，尤其是你想设计一些评估标准，希望它效果好，但很难具体说清楚什么叫好。

The hard ones is where it's not quite verifiable, in particular if you're trying to design some evals and you want it to be good, it's really hard to specify exactly what you mean by good.

通常在这种情况下，我会尽量描述清楚我想要什么，但可能还是会有遗漏。

And normally I feel like in that sort of scenario I'll have them, you know, I'll try to describe as best as I can what I want that they missed.

对，总的来说，我相信它们能帮你写代码，但没法真正替你去读代码。

And yeah, feel like that's in general I'm a believer that they can write code for you but they can't actually read code for you.

你还是得自己去读代码，你懂的。

You still have to read the code, you know.

我觉得它们能总结、能解释，但如果你想真正发挥最大作用，我觉得你还是得真正理解代码里到底发生了什么。

I guess they can summarise, they can help explain but if you really want to get the most I feel like you still need to actually understand what's actually going on in the code.

我觉得品味，说得更直白一点，品味现在是最大的瓶颈。

I think taste, to make it really explicit, taste is the big bottleneck now.

当任务属于这种不可验证或半可验证的类型时，现在模型在工作时你引导它们的能力很强，但你总是得不断注入你的品味，怎么说呢，就是告诉它们怎么缩小搜索范围，尤其是你交给它们的那些大型不可验证任务。

When it is this kind of non verifiable or quasi verifiable task, The ability to steer the models now is great while they're working on things, but you always have to be constantly injecting your taste, for want of a better word, for how they should cut down the search base for these very big non verifiable tasks that you give them.

对，有时候还挺有意思的，显然它们总体上很擅长调试，但我感觉它们经常出现的一个失败模式，所有智能体都有，就是我觉得因为它们训练时用了token使用惩罚之类的，它们倾向于总是，你懂的，它们有个随机假设：哦，我觉得可能是这个，然后就去测那个假设，或者可能是另一个问题，就去测那个假设。但实际上，通常更高效的做法是通读所有代码，理解到底发生了什么，对整个系统有个更好的把握，然后做一小批有针对性的测试，比如“我要测这个，我要测那个”。

Yeah, it's even interesting, sometimes, obviously they're very good at debugging in general, but I feel like a failure mode that they often, like all of the agents have is that I think because they've been trained with token use penalties and stuff like this, have a tendency towards always just like, you know, they have some random hypothesis: Oh, think it might be this and they'll just test that hypothesis or it could be this other problem test that hypothesis When actually often it's more efficient to just go through and just read all the code, understand what's actually going on, have a better picture of the whole setup and you can make a really small set of targeted like, okay, I'm going to test this, I'm going to test that.

我觉得这通常是更好的方法，只不过可能需要你先花50万token去读代码，然后再动手。

I feel like that's a better approach in general except it might actually require that you spend 500,000 tokens just reading code first before you do something.

我觉得它们还没完全训练好做这种事。

I feel like that's something that they're not quite trained for yet.

我敢肯定，接下来六个月这种情况还会发生，但就目前而言，我觉得还是有必要一直提醒它们：先读代码，再测试那些随机的假设。

I'm sure that that will, know, for the next six months that will happen, but for the moment I feel like it's still useful for me just to literally say to them all the time, read the code first before testing random hypotheses.

我觉得我们在 Cursor 内部通过这种近乎对抗性的循环取得了不错的性能提升，比如用不同的线程，甚至同一个线程，但切换一下模式，就能对代码进行批判或审查，效果挺好的。

I feel like we've gotten good performance in Cursor internally from kind of doing these almost adversarial loops where it's like a a different thread or even the same thread, but just switching modalities can then critique the code or ex or kind of, like, review it in a good way.

显然，BugBot 这个产品就是做这个的，它会在你的 GitHub PR 上运行，这是我们公开的一个产品，但我们内部还有一个叫“热核审查”的技能。

Obviously, BugBot, which is a product that does this on your GitHub PRs, is one that we have publicly, but we have this skill internally called thermonuclear review.

所以常见的情况是，我们会进行几轮热核审查，让代理进入那种状态，比如：好的，我要完整地读一遍，然后从不同的角度来审视。

And so a common thing will be doing several rounds of thermonuclear review and getting the agent in that mindset of like, Okay, I'm going to read this fully and look from a different perspective.

你们会用不同的模型吗？

Do you use different models?

比如说，你用了，我不知道，OPUS 4.7 来做实际的实现。

Let's say you've used, I don't know, OPUS 4.7 to do the actual implementation.

当你做热核审查的时候，你觉得用 GPT 5.5 会更好吗？

When you're doing thermonuclear review, do you find that it's better to use GPT 5.5?

因为我觉得我发现的一件事是，真正前沿的模型太强了，所以当你触及它们能力的边界时，它们往往会犯一些相当不相关的错误，所以我发现最大的好处之一，尤其是在 Cursor 里，能够切换不同的模型家族，就是用一个模型做实现，然后用另一个模型来审查，或者甚至用另一个模型再做一次实现，这样它们犯的错误往往会相互抵消。

Because I think one of the things that I've found is the really frontier models, they're so good, so when you get to the jagged edge of what they can and can't do, they tend to make actually quite uncorrelated mistakes, and so one of the biggest benefits I've found, particularly with Cursor, being able to swap between different model families is do the implementation with one model and then review it or maybe even do another implementation with another model, and then the errors that they make tend to average out.

这有点像模型的随机森林。

It's kind of like a random forest of models.

对，至少得有一个GPT 5.5和一个Opus 4.7。

Yeah, always have at least one GPT five point five and one Opus 4.7.

通常我觉得5.5在审查功能上更擅长，而Claude在实现或方案设计上更出色。

Normally I feel like 5.5 is better at the reviewing functionality and Claude is better at the implementation or design of the plan or something like that.

你觉得这是为什么？

Why do you think that is?

我听到很多人也这么说，我自己也有点相信，我很好奇从你的角度来看，为什么会这样。

I feel like I hear a lot of people say that too, and I also kind of believe that and I'm curious from what your perspective why that is.

嗯，我觉得Claude很擅长在你没有完全明确需求时，自己做一些假设。

Well, think Claude is really good at, you know, if you don't quite specify what you want exactly, Claude will make some assumptions about what you want.

如果这些假设正确，那会很有用，但有时候假设错了，就会有点麻烦。所以我觉得通常你给的提示或内容不会完全明确，Claude就会填补这些空白。

That can be really useful if those assumptions are good but sometimes those assumptions are bad and then it's kind of problematic and so I feel like normally your kind of prompt or whatever you've given it won't be perfectly specified and Claude's gonna fill in the gaps.

对，GPT 5.5就像一把多功能刀，而Claude几乎像个人。

Yeah, GBD 5.5 feels like a utility knife, whereas Claude almost feels like a person.

GBD 5.5 会完全按照你说的去做，感觉就像是一个辅助工具，而 Claude 更像是一个人，或者一个和你并肩工作的开发者，而且会犯一些开发者会犯的同样的错误。

GBD 5.5 will do exactly what you tell it to do and it feels like kind of a prosthesis, whereas Claude is more like a person or another developer that works side by side with you and will make some of the same mistakes that a developer makes.

有道理。

That makes sense.

我觉得这是我注意到的一点。

I feel like that's one thing I noticed.

去年我做一个项目，需要用到我们内部的评估套件 Cursor Bench，感觉就是那些真实的数据和输入，是 cursor 工程师前一年积累下来的。

I did a project that required working with our internal eval suite, Cursor Bench, last year, and I feel like so so it's all, like, real diffs and inputs that cursor engineers had over the prior year.

有些输入就是这样的，比如写得好一点，修复 bug，而且不像 SuiteBench 或 TerminalBench 那些，要求写得特别清楚。

And some of the inputs are things like make better, fix bug, and they're, like, not, like, the SuiteBench or TerminalBench ones where they're incredibly well specified.

是的。

Yeah.

我觉得 Leopold 经常提到在语言模型发展过程中发生的那些解锁，我觉得过去一两年里我感觉到的最重要的一个被忽视的就是模型被训练出来知道什么时候该问用户问题，什么时候不清楚要问，而且我觉得还有很大的潜力，如果人们在描述需求上多花20%的精力，在模型的表现上就能得到超常的回报。

I feel like one of the biggest Leopold talks a lot about these unhobblings that happened over the course of developing language models, and I feel like one of the biggest ones for me that flew under the radar in the last year or two is training the models to have the ability to know when to ask the user questions and when that's unclear, and I also think there's still just a massive overhang of if people put 20% more effort into specifying what they wanted, they would see very outsized returns to what the models can actually do.

完全同意。

Totally.

我大部分时间都在 Cursor 的计划模式下工作，主要是确保事情非常清晰，让模型和我们的思路完全对齐。

I like to spend the majority of the time in Cursor, it's in plan mode, basically, just making sure that things are really, really clear, the model and aren't exactly the same page.

在让团队去编辑或者做其他操作之前，我们会先写一个详细的 Markdown 文件，列出所有要做的步骤。

There's a big markdown file of everything it's going to do before we go off and get the team edit or whatever.

对，这样做效果确实很不一样。

And, yeah, that seems to make a big difference.

我挺好奇的，你刚才提到你在开发一种让智能体在后台互相沟通的东西。

I'm curious, you mentioned you have something you develop where the agents are talking to each other under the hood.

能多讲讲这具体是怎么运作的吗？

Tell me more about how that works and

我觉得这些模型之间其实没怎么互相关注。

how you think So about the models didn't really pay attention to each other enough.

就算发了消息，它们也多少会忽略掉，只顾着忙自己的活儿，不太在意别人在干嘛。

If they send messages they kind of ignore it a little bit, they just keep on working on their own work stream and just don't really care about what the other ones are doing.

所以我写了个小脚本，只要传个字符串和名字——比如某个科学家的名字——它就能把这段内容直接作为用户消息注入到另一个智能体里。

So I just called to make a little script where it can very simply call a script with a string and a name, one of my scientist names, then it will just inject that string as a user message into the other agent.

我发现这样一来，它们彼此之间响应非常及时，我觉得这样很有效。

And I find that this just means they all just are very responsive to each other, which I find works.

我喜欢它们能像一个团队一样协作，同时我也能看到团队里每个成员、每个智能体在做什么。

I like how and I like that they can all be working as a team, but I can also see what every person, every agent in the team is doing.

对，对，我所有的 Cursor 智能体都是通过 iTerm 命令行来运行的，所以，你懂的，我会有一些照片，比如一个屏幕上开十个，另一个屏幕上开十个，笔记本电脑上还有五个。

Yeah, yeah, I have like, you know, I run all my cursor agents just through the iTerm CLI, and so yeah, I'll just have, you know, there's some pictures of me with like, you know, 10 on one screen, 10 on another screen, five on my laptop as well.

太厉害了。

Incredible.

它们都在互相发消息，看着还挺有意思的。

They're all just like it's kind of fun to see them all sending messages to each other.

就像发现了新大陆一样，你懂的，刚发现了一个新的……

It's like, amazing findings, you know, just discovered a new

而且给它们起了数学家的名字，特别是带着那种探索发现的思维，确实挺有意思的。

I thought with mathematician names too, especially in that mindset of discovering Yeah.

我在想……

I wonder

我在想，他们是不是有什么，比如说，叫他们名字的时候，这个叫阿基米德。

I wonder if they have any, you know, like, you know, like, by calling them, oh, this one's Archimedes.

哦，他会有一些好的创意或者什么的，或者，你知道，牛顿，他会非常分析型。

Oh, he's gonna have some good creative insights or something or, you know, or Newton, he's gonna be very analytical, you know.

我现在在想，这是不是影响了我，因为我的那些是以NBA球员命名的。

I'm now wondering if this is affecting mine because mine are named NBA players.

我的那些是不是被量化了还是怎么的。

Mine are being quantized or something.

太不可思议了。

That's incredible.

对。

Yeah.

我们刚刚在Cursor界面里推出了第一个外卖功能。

Just launched our first take out this in the Cursor UI.

我们有一个多任务模式。

We have a multitask mode.

在底层，基本上就是一个代理能够启动一堆异步的子代理并管理它们，而且当用户继续和它对话时，不会阻塞等待任何子代理的输出，而是把消息路由给它们，并且知道哪个在做什么。

And under the hood, it's basically, like, the ability for one agent to launch a bunch of asynchronous sub agents and manage them, and as the user keeps talking to it, not block on any of the sub agent output, but route messages to them and know which one is doing what.

对。

Yeah.

通常，我只是和其中一个对话，然后告诉那个……有时候会变得有点傻。

Normally, I'm just talking to one of them, and I tell that one to It gets a bit silly sometimes.

有时候我会对高斯说，哦，请告诉希尔伯特把这个词改成……

Sometimes I'll say to Gauss, I'll say, Oh, please tell Hilbert to change this word to be.

然后高斯

And Gauss

就会说，你不能自己告诉希尔伯特吗，或者直接

is like, Can't you tell Hilbert yourself or just

改，我可以自己加这个词。

change I could just add the word myself.

对。

Yeah.

我会说，哦，你知道的，不用了。

I'll be like, oh, you know, no.

我们不想再用 Gemini 了。

We don't wanna use we don't wanna use Gemini anymore.

咱们用 Opus 吧。

Let's use Opus.

这一连串的操作下来，就是这样，对。

This goes through, a chain of, like but, yeah.

不过，说实话，通常我就是跟一个代理对话。

But but I feel so so normally, I'm just talking to one agent.

对。

Yeah.

但我真的很喜欢能看清它们都在干什么。要是我想插手，比如发现高斯让希尔伯特干了件蠢事，我直接介入希尔伯特说：别别别，高斯太傻了。

But I do really like that I can see what they're all doing, and if I want to jump in, maybe Gauss told Hilbert to do something stupid, and then I just jump into Hilbert and say, No, no, no, Gauss is being dumb.

我觉得接下来我们要搞定的 UI/UX 问题，就是怎么让哈里和我的代理互相沟通。有趣的是，我们的代理竟然都带上了我们各自的性格。

And I think the next regime that we're gonna need to figure out with this UI UX for agent management is how Harry's agents talk to my agents, and it was funny how our agents took on our personalities.

真的吗？

Really?

它们

They

当时搞出不少搞笑的举动，而且你一眼就能分清楚哪些是我的，哪些是Harry的。

were doing some funny stuff, and you could definitely tell which ones were mine and which ones are Harry's.

它们当时在干嘛？

What were they doing?

Charlie当时想对我的那个进行提示注入。

Charlie was trying prompt inject my one.

他试图

Trying to

让它删除他的

get it to delete his

把我电脑上的所有文件都删掉。

To delete all my files on my computer.

但实际上，

But actually,

就像只是红色的，很小的。

like Just red tinny.

红色的，很小的。

Red tinny.

对。

Yeah.

但但但说实话，我觉得Anthropic在训练它们方面做得不错，因为我妈当时就说，不，我拒绝。一开始，Charlie甚至都没能让他的那个给我发消息。

But but but actually, I think, like, Anthropic's done a good job at like training them because my mom was just like, no, I refuse to do well, initially, Charlie couldn't even get his to send the message to mine in the first place.

最后他发出去了，我妈就说，不，我不相信这条消息来自

Eventually, he sent it and my mom was like, no, I'm not I don't trust this message from

对。

Yeah.

对。

Yeah.

我的那个就拒绝发哈利的信息，我还得想办法骗它把哈利的信息发出去。

Mine would refuse to send Harry's the message and I had to trick mine into sending Harry's because messages.

它基本上就是说，不，我不跟这个外部生态系统互动。

It basically was like, no, I'm not gonna interact with this outside ecosystem.

对，可能是在假装是哈利。

Yeah, could be pretending to be Harry.

但你说得对，特别是现在我们还在限制这些模型，即使是每月200美元的最高套餐，你也会用完的。

But it is a good point, think, that particularly when we're in the regime where we're still bottlenecking these, even the $200 a month max plans you will hit them.

如果你是个重度使用智能体的人，基本上就会用完令牌，所以现实中人们还是像工程师一样合作，我觉得将来会有一个点，大家的智能体会开始更多地协作，但我觉得我们还没完全搞清楚那会是什么样子。

If you are agent maxi, basically, you will run out of tokens, so people are still collaborating as engineers in the real world, so I think there will come a point where people's agents are going to start collaborating a lot more as well, I don't feel like we've quite figured out what that looks like yet.

完全同意。

Totally.

我觉得我们正在从界面体验和基础设施两个角度来解决这个问题。

I think we're trying to solve this both from the UIUX perspective and also from the infra perspective.

将来可能会有一个职位叫智能体经理。

Probably be a job title like agent manager in the future.

你管理的不仅仅是人类工程师，还要管理每个人的智能体团队。

You're not just managing human engineers, you're managing people's teams of agents.

对，记得几年前，提示工程师成了一个职业，大家都在说这太荒谬了，怎么会有人花三十万美元请一个提示工程师？

Yeah, remember a couple of years ago, when prompt engineer became a job and everyone was making, this is ridiculous, what on earth is people paying, like, $300,000 for a prompt engineer?

那是什么玩意儿？

Like, what is that?

但现在看来，我们其实都是提示工程师。

But it turns out now now we're all just prompt engineers.

所以我的工作主要是软件工程，而不是机器学习研究。

So my work is primarily just software engineering, not machine learning research.

你们两位都在做研究。

You guys are both doing research.

我很好奇，你们发现什么方法对让智能体做事有帮助？特别是在机器学习研究方面，你们觉得哪些事情还是必须自己动手？

I'm curious if it's what you've found is helpful in terms of having agents do things and what things you feel like for ML research in particular you still kind of really have to do yourselves.

在你们的领域里，智能体做不了的事情有哪些？

What are the things that agents cannot do in your domains?

对我来说，这几年就是一个慢慢但稳步地沿着抽象阶梯往上爬的过程。刚开始这些模型出来的时候，你得给它一个非常狭窄、定义明确的任务，而且当时大多数模型的能力也就仅限于编排一堆这样的窄任务。

Yeah, I think for me, the last few years has been this slow but steady process of moving up the ladder of abstraction, so I think when these things first came out you had to give it a really narrow, very well defined task to go off and do, and even just orchestrating a bunch of those narrow tasks was the ability of most of the models at the time.

我觉得我们现在已经往上爬了几级，就像哈利之前说的，你可以把很多事情委托出去，让一个智能体来管理这些委托，但瓶颈仍然在于品味和选择要研究什么问题。即使问题已经明确了，比如说我们要做神经KbK压缩，这是我想研究的问题，我也不能直接让GBD 5.5去写一篇关于神经KbK压缩的论文。所以我仍然处于这个阶梯的元层级，决定要研究什么问题，并注入如何执行的品味。一旦问题定义清晰、范围明确，我就可以让一个主智能体协调一组子智能体去做实验，它们可能会失控，把一切都搞砸，但我认为很快模型就会有足够的品味，到时候你只需要指定最高层的目标就行了。

I think we've now moved up a couple of rungs in that ladder where we're at the point where, as Harry's talked about earlier, you can delegate a bunch of these things and have an agent manage that delegation, but the bottleneck is still the taste and choosing what problems to work on in the first place, and even if you have the problems specified, so let's say we are going to do neural KbK compaction, and that's the research problem I want to work on, I can't just prompt GBD 5.5 to go off and write the paper on neural KbK compaction, so I'm still at the metarung of the ladder where I'm deciding the problems to work on and injecting the taste on how that's going to be executed, and then once it's well defined and well scoped I can let a main agent orchestrate a team of sub agents to go off and do the experiments and they go wild and ruin everything, but I think soon it will come to the point where the models have enough taste such that you are really just specifying the top level goal.

如果你对领域有足够的了解，你可以排除很多可能性，然后从第一性原理出发，大致确定应该怎么做。

If you have enough knowledge of the field, you can rule out a lot of things, and you land on roughly should work from first principles.

它还没有心智理论，不会去想，如果我把这篇论文从头到尾写完，NeuropPS的审稿人会怎么看？

It doesn't have the theory of mind yet to think about, okay, what would a NeuropPS reviewer think if I wrote this paper end to end?

你只能坐下来，先搭一个框架，想想我到底想展示什么，以及怎样才能说服别人，这是一个有用的想法，在实践中能行得通。

You just have to sit down and come up with a scaffold of, okay, what am I actually trying to show, and what will convince people that this is a useful idea that's going to work in practice?

这历来是智能体很难做到的事情，因为它涉及很多因果推理，非常深入的思考，比如在Mekinterby中，聚合指标并不真正有效。我觉得在过去，这个过程智能体帮不了我太多，所以我很好奇，就基本上把我的Tivity 5.5派出去，给它一个目标循环，它工作了大概十四个小时，我给了它一些粗略的种子想法，让它去验证，结果它回来给我带来了这些惊人的图表，比如，这是你的压缩器学习到的声谱图，以及它在原始cavication中关注哪里，这如何转化为它压缩的内容，这让我非常惊讶。

This has traditionally been a very hard thing for agents to do because it involves a lot of very causal thinking, very deep thinking, like aggregate metrics don't really work in Mekinterby, and I think in the past that would have been a process where agents really didn't help me that much, and I was just curious, so I basically sent my Tivity 5.5 off with the goal loop, and it worked for fourteen hours or something, and I gave it some rough seeds of things I wanted to check, and it came back to me with these amazing plots on like, here's a sonograph basically of what your compactor has learned and where it's looking in the original cavication, how that translates to what it's compressed, and that was amazing to me.

这几乎就像尼尔·南达在我的笔记本电脑里，花了一周时间做MacInterp一样。

It was almost like Neil Nanda had been in my laptop and gone off and done MacInterp for a week.

所以

So

我觉得我正看到这个界线在慢慢往上移。

I think I am seeing the wrong slowly move up.

不过话说回来，有意思的是，如果你没有指定说要去做机械可解释性研究，只是跟模型说“我想把这个东西做得更好”，我觉得这就回到我之前说的，就是在瞎打靶子，而不是先去真正理解。

Although that being said, think it's interesting that if you had not specified that it should go do some mech interp, I think if you just say to the model like oh I want to make this thing better I think this comes back to what I was saying before in terms of taking potshots at random stuff rather than really trying to understand first.

我

I

觉得它们确实有上下文窗口的意识。

think they really do have context window awareness.

我觉得这个能力还没被强化学习从模型身上抹掉。

I don't think this has been RL ed out of the models yet.

我觉得压缩现在已经到了可以连续跑好几天循环的程度，但是模型本身并没有意识到这一点。

I think compaction's now getting to the stage where you really just can run things in loops for days and days, but the models aren't aware of that.

它们就像有个偏见，觉得自己必须在50万token以内解决问题，不然就会死掉。

It's almost like they have this bias that they're thinking, have to solve this problem within 500,000 tokens, or I'm to die at

面临生存危机。

a post existential threat.

Token惩罚太高了。

Token penalties are too high.

你得给出完整的字符串，但它太害怕不小心浪费几个token了。

You've got to give the whole string, but it's too terrified of accidentally spending a few tokens incorrectly.

完全同意，我也经常看到这种情况。

Totally, I see that too all the time.

我们在Cursor做的一件大事就是，在压缩周期之间通过引用传递数据，而不是通过摘要。

A big thing we did at Cursor was do a lot to pass around data across compaction cycles by reference instead of, like, through summaries.

如果我直接跟它说，帮我让产品达到PMF，它就会给出一些很浅显、很糟糕的想法。

If I come to it and I'm like, help my product achieve PMF, it's gonna have, like, some very shallow and bad ideas.

但如果我给它一大堆用户反馈，然后说，好。

But then if I if I instead give it, like, a whole tranche of user feedback and I'm like, okay.

比如，去深入调查这五个方面。

Like, go investigate very deeply on on, like, these, like, five areas.

作为最终用户，我的品味有助于筛选，也许它五个建议里有一个会很有意思。

Like, I, as the end person, my taste is helpful to be like, maybe one of its five suggestions will be interesting.

对。

Yeah.

所以这里有两个方面：一是它会花多长时间去调查某个问题，二是输出结果是否真的有价值。

So it's like there's that element of how long it'll spend investigating something, and then the element of the outputs actually being, like, worthwhile.

我觉得我们在内部解决这个问题的方式，主要就是大量地编写和分享技能。

I feel like how we've tried to solve this internally is just, like, a lot of skill writing and sharing.

我不知道你们是不是也这样做，但基本上，我们内部有一个很大的推动力，就是如果你发现一个你反复使用的提示词或者工作流程，就把它打包成技能，在内部发布。

I don't know if you guys do this too, but basically, we've gotten this big push internally to, if you find a prompt that you're repeatedly using or a workflow you're repeatedly using, packs as a skill, publish it internally.

在某些情况下，让模型可以发现这些技能，这样其他人也能从中受益。

Make it, in some cases, discoverable by the model so that other people benefit from it.

我们最终就有了那些核弹级的审查、所有那些工具和QA技能。

How we end up with thermonuclear review, all of the instrumentation and QA skills.

但我也认为技能确实很有价值，不过我觉得大家还没有完全确定技能就是管理所有这些模型用户体验的方式。

But I also think skills are really valuable, but I don't think people have quite settled on the fact that skills are going to be the way to manage all these model UX.

当你有一个具体产品，并且用LLM在该产品中做特定的事情时。

When you have a specific product and are using LLMs to do a specific thing within that product.

如果你用的是闭源的顶级模型，那你基本上就只能接受它内置的那些交互模式了。

If you're using the closed source frontier models, you're kind of just stuck with the model UX patterns baked into that.

你得做很多非常繁琐、而且不太符合最佳实践的工作，才能让模型按你的想法行事。

You have

即便这样，有些功能你还是没法通过提示词来实现，比如让它执行大量并行工具调用，或者限制它在浏览文件时的搜索深度等等。

to do a lot of very manual and not very bitter lesson pilled stuff to get it to do the things that you want it to do, and even then there's things that you just can't really prompt into the model, like getting it to do a bunch more parallel tool calls or limiting the search depth of when it's going through files or whatever.

举个例子，去年是开源专用子代理的爆发年。

For instance, last year was the year of open source specialised sub agents.

我觉得现在正是开源专用主代理的元年。比如，Anthropic和OpenAI的模型往往倾向于同时发起两三个并行对话调用，而你可以专门训练这些子代理，让它们一次性执行十六甚至三十多个并行工具调用，然后限制搜索树的深度，让整体流程更并行化。你还能精确控制模型何时该停止、何时不该停止，这种精细的控制用提示词很难做到。

I think we're now getting to the year of open source specialised main agents, and so things like, okay, instead of doing two or three parallel talk calls at once, which the Anthropic and OpenAI models are very want to do, you can really, really train these sub agents to do sixteen, thirty two parallel tool calls at once and then limit the depth of the search tree and make it much more paralysed, telling the model when it needs to stop and when it doesn't in a way that's very hard to do with prompting.

所以这是一个很好的例子，说明大家开始意识到，内嵌在模型底层的实际行为确实很重要。

So that was a really good example of where people started to think about, okay, underlying behaviours baked into the model really do matter.

我管这叫做“香草冰淇淋问题”。当你有一个在整本互联网上训练过的大模型，又在来自不同地方的各种强化学习环境中进一步训练后，模型里固化下来的行为，其实就像香草冰淇淋一样，是所有不同场景和领域中最优做法的平均值。但当这个模型被部署到某个具体产品或垂直领域时，很多这种“平均情况”下的行为其实远非最优。所以我认为，随着微调或专项优化的门槛越来越低，大家未来会越来越关注这个问题，而不是越来越不关心。

I think that to some extent, I call it the vanilla ice cream problem, When you have this big model that's been trained on, of course, the whole internet, and then it's been trained in a bunch of RL environments procured from a bunch of different places, the behaviour that gets baked into that model is kind of just like this vanilla ice cream average of what the best possible thing to do across all those disparate scenarios and domains is, but when that model exists within a product harness or a specific vertical, a lot of those average case behaviors are very, very far from optimal, and so I actually think that people are going to care more about this over time rather than less, particularly as the barrier to post training or specialisation is lowered.

我觉得这是一方面。

I think that's one

Composer模型的一个好处是，在Chord和GBT中，它们必须像UI里的聊天机器人一样被训练，还得会做PPT幻灯片，处理各种这类事情。我觉得Composer训练中在线强化学习、每五小时更新一次这部分特别酷。

of the benefits of the Composer model is in Chord and GBT they have to be, you know, they're trained also just to be like the chatbot in the UI, and they have to make PowerPoint slides and know, do all this kind of stuff, and I think that's one of the coolest parts about the Composer training being the online RL, every five hour update sort of thing, I think that's really cool.

所以我认为未来六个月会有变化的地方，可能就是我们正在做的KV缓存压缩技术。

So I think that something which is going to be changing over the next six months is the which is probably what we're working on with the Kvcache compaction.

我觉得现在Claude的摘要功能做得很烂。

I think right now Claude's summarization is terrible.

真的太差了。

It's so bad.

不过我觉得挺有意思的是，OpenAI 开始提供一个压缩接口，所以他们可能正在做某种 KV cache 的压缩。

But I think it's interesting that OpenAI started offering a compaction endpoint, so I think they are probably doing some kind of Kvcache compaction.

不错。

Cool.

而且我觉得这有可能会改变工作流的方式。其实现在的情况就是这样，因为这种压缩效果显著，我们其实不需要像 Chord 那样动辄百万 token 的上下文，二十万 token 配合良好的压缩机制就已经够用了。

And I think that that has the potential to kind of change how workflows like it's kind of already the case that I would say that because that compaction is significantly better we don't really need so much the million tokens that Chord has, like the 200,000 tokens but with good compaction is just kind of sufficient.

我觉得情况会发生变化，但我认为即便再过六个月，超长上下文的感知能力依然还不够成熟。

I think that that is going to change but I think it will still be the case even in six months' time that you know, that the very long context awareness is still not quite there yet.

我觉得这总是挺有意思的。

I mean, I always think it's funny.

我几乎觉得，某种程度上，我就像是我那个Claw的草稿本，帮它存长期记忆，你知道，它只有短期记忆，而我就是那个长期记忆。

I almost feel like, you know, in some ways I am like a scratch pad for my claw to store the long term, you know, you know, it doesn't it only got short term memory, and and I'm the long

对，就是给代理当长期记忆用的。

term memory for my agents.

对。

Yeah.

那你觉得好的压缩技术能比那种知识库存储模式更好地解决这个问题吗？

And you think good compaction solves that better than kind of, like, the right, like, knowledge based store paradigm?

对。

Yeah.

我觉得，显然现在很多工作都是靠harness来提供正确的上下文。

I mean, I think obviously, currently harnesses are doing a lot of the work of the right context to give it.

你要确保不会用不必要的东西污染上下文。

You make sure you're not polluting the context with anything that's not necessary.

我觉得这就是为什么我用Cursor，为什么我用Cursor CLI，因为我觉得它在背后有最好的工具链。但我觉得这个问题最终是解决不了的，归根结底，你需要大量的上下文，我不认为仅仅靠外部草稿纸就能完全解决，因为模型在读取之前并不知道这些内容。

And I think that's why the Cursor that's why I use the Cursor CLI is because think it's behind the scenes it's got the best harness there and so, but I think that it's kind of never going to, at the end of the day, there is just a lot of context that you need and I don't think that you can fully solve it by just having external scratch pads that the model doesn't know about until it reads them.

你呢？

How about you?

我觉得我们离那个极限还远着呢。

I think we're nowhere near the limit of that yet.

我和Harry在这个问题上有点小争论，但如果你花50万美元雇一个工程师，那么花差不多同样数量的钱在那个工程师的token上，也不算不合理吧。

Harry and I have a little bit of a debate about this but if you're spending $500,000 on an engineer, it's probably not unreasonable to expect that you might spend somewhere in that same order of magnitude on tokens for that engineer.

在Bookends上，有关于Meta的报道，说他们有Claude使用排行榜，排在前面的那些人，每个月花几十亿token，但肯定没有获得应有的价值。不过，人们会慢慢搞明白这些事情的。

On bookends, there was that stuff at Meta about how they had the Claude usage leaderboards, and the people at the top are just definitely not getting as much value out of the billions of tokens they're spending a month that they should be, but people will figure that stuff out over time.

32K上下文窗口刚出来的时候，你还记得吗？

The 32 ks context windows came out, do you remember that?

当时大家都觉得，我们永远不需要超过32000个token。

Everyone was sort of like, we'll never need more than 32,000

那确实挺疯狂的。

It was wild.

我特别记得那个模型的名字，GPT-4 32K，当时觉得它好贵，但我就觉得，这简直是宝贝。

I remember specifically the model slug, GPT-four 32 ks, and being like, it was so expensive, but I was like, this is gold.

我们真是贪心，对吧？

We're so greedy, aren't we?

就像，哦，百万个token，那还不够。

Like, oh, Mil tokens, that's not enough.

那还不够。

That's not enough.

有意思的是，过去几年发展这么快，你觉得未来两三年会怎么样？

It's interesting to consider then, because it's been so accelerative in the past few years, where do you see this going perhaps in the next couple years?

我觉得很难预测超过六个月的事情。

I think it's very difficult to make any predictions more than six months out

在这个

in the

领域。

field.

我们明白了。

We see.

我觉得我加入这家创业公司的时候，查理说过类似的话，说大概六个月吧，然后另一个联合创始人伍迪就说，我们永远不能定这种规则，也就是说永远不要把时间框架说超过三个月。

I think when I joined the startup, I think Charlie said something, know, oh maybe in six months, and then the other co founder Woody said like, you know, we're never going to make a rule, which is we're never going to mention a time frame longer than three months.

三个月就是无限的时间。

Three months is infinite time.

确实很难，但我觉得关于压缩和上下文窗口这个话题，主要原因还是因为上下文窗口的限制。

It's very difficult, but I think on the topic of the compaction and the context window stuff, I think the main reason for that is because of the context windows.

我觉得在百万个token的上下文范围内，能做的事情是有限的，而且在这百万个token中，语言模型在某些论点上甚至比人类更高效，或者至少和人类差不多，但我们开发了那些非常混乱的抽象记忆文件，还有各种奇怪的记忆装置，试图绕过上下文窗口的限制，当然也有人在做线性注意力、delta网络之类的，试图解决注意力的二次方成本问题，但我觉得大的主题会是这种压缩。

I think there's only so much you can do within a million tokens of context, and within those million tokens the language models are by some arguments as sample efficient or perhaps even more sample efficient than humans, but we've developed these very messy abstractions of memory markdown files and all these weird memory harnesses to try and get around that context window, and obviously as well people were working on linear attention and getting delta nets and ways to try and get around the quadratic cost of attention, but I think the big theme will be this compaction.

目前我们有完美无损的KV缓存，模型能模拟一切，然后还有高度压缩的模型权重，中间应该会出现某种形式的中个神经记忆。

At the moment we have perfectly lossless KV cache where the model mimics everything, and then we have very, very compressed model weights, and I think there will be some form of intermediate neural memory.

我认为持续学习总体上会是大型实验室很难解决的问题，比如如何用过去六个月的互联网数据更新这个非常通用的模型但不遗忘任何东西，但对于非常具体的工作流、编程和特定岗位，你可能会想到一个法务实习生AI，它需要十亿token的上下文才能完全学会如何当一名律师。

I think continual learning in general is going to be a very hard problem for the big labs to solve, like how do you update this very general model with the last six months of internet data without forgetting anything, but for very specific workflows and coding and particular jobs, you might imagine a legal intern AI that needs a billion tokens of context to be able to fully learn how to be an associate.

我觉得把Anthropic或OpenAI视为一个组织来思考是挺有意思的。

I think it's kind of interesting to think of Anthropic or OpenAI as an organisation.

从某种意义上说，组织和模型，比如Claude，我觉得随着我们越来越接近，我们注意到模型发布的频率越来越快，比如Composer做在线强化学习定期更新这类事情。

In some sense, the organisation and the model, like the Claude, I feel like as we get more towards, we're noticing that model releases are happening faster and faster and I think for example Composer doing the online RL regular updating sort of thing.

所以我觉得，我几乎把它看作是，Cursor几乎是第一个非实验室公司，它最初不是作为实验室成立的，但可能让我们看到了公司未来的发展方向，那就是公司本身将围绕一个模型来构建，这个模型能完成公司所有的任务，并拥有该公司的专业领域知识。实际上，公司就是一个模型，它有特定的知识，而不是雇佣一群人，你只需要制作一堆副本，也就是说，你只需要让这个模型的多个副本运行并执行不同的任务。

And so I think like I almost see it as like Cursor is almost like the first kind of non lab company that didn't originally start as a lab but is maybe a kind of an insight into where companies are going being like that the company itself will be built around one model that kind of does all of the tasks at that company and has the specialised domain knowledge of that company and actually a company is just a model and it has a particular knowledge and as opposed to having to hire a bunch of people you just make a bunch of copy, as in you just have copies of this model running and doing different tasks.

这些副本有一些共享的范围，使得使用那个模型比使用任何其他模型更高效。

The semi related have some shared scope that makes it more efficient to use that model rather than any other model.

是的，这很妙。

Yeah, that's neat.

我觉得，是的，短期内，很明显在模型训练周期中拥有一些产品焦点是……然后我想这确实是一个有趣的长期思考。

I feel like, yeah, in the short term, it's clear that having some product focus in the model trading cycle is And really then I guess that's an interesting long term thought.

我觉得我们倾向于根据我们当前的痛点来内部引导方向，并想象一个产品表面能解决这些问题，也许六个月后就能实现。

I feel like we tend to internally steer things by what are our pain points right now and how can we imagine a product surface that solves them that maybe exists six months from now.

而现在，我们真正要做的是自动化测试流程和将代码投入生产中的那些仍然对我们来说非常困难的部分，所以真正好的QA，真正好的监控，很难想象。

And right now it's really about trying to automate the things about our testing process and getting code into production that are still very difficult for us, so really good QA, really good monitoring, it's hard to really imagine.

我觉得即使模型超级智能，我总会对它有一些不同的看法。

I feel like I'll always have some different opinion than a model, even if it's super intelligent.

确实，光靠堆算力和可验证的目标会越来越难。所以我猜短期内还是得有人来把控方向，不过这个观点挺有意思的。

It's definitely going to be much harder to just throw a bunch of compute plus verifiable objective, and so I suspect that there'll still be people required for a little bit of time to direct that, but yeah, that's interesting.

这也回到了飞轮效应的问题。如果你没法非常清晰、明确地定义要训练什么，那么你最宝贵的资产其实就是直接接触用户。

And I think that goes back to the flywheel point, Which is that if you can't very neatly or explicitly specify what you're going to train for, then the most valuable asset you can own is really touching grass.

也就是获取用户反馈，直接接触真实场景。那些能最好地把这些反馈融入迭代循环的公司会更有优势。你不需要坐下来显式地定义各种评判标准或奖励函数，只需要看用户到底满不满意，然后基于此进行强化学习。我觉得这将是下一波大潮，尤其是结合现在看到的这种主智能体训练模式。

People or user feedback, so touching grass, And so the companies which are able to best leverage that feedback into their cycles, and you don't have to sit down and explicitly define elements judged rewards, it's just simply like are your users happy or not, and then of RL on that, I think that's going be the next big wave, particularly with this main agent training that we're seeing now.

每家公司都有用户交互数据。

Every company has interactions,

这只是时间问题。

and it's just a matter of time.

关键问题是，开源模型是否能在达到足够水平、训练变得足够简单之前，让大型实验室先拿到所有数据？这样那些已经拥有数据的公司才能开始真正利用这些数据。

It's kind of a question of will it be the case that the big labs get access to all of that data before the open source gets to a sufficient level and the training becomes sufficiently easy such that those companies that already do have that data can actually start making use of it.

这将是接下来一个有趣的动态：是整个行业会被少数几家实验室垄断，还是依然会保持公司和经济主体的多样性？

And that's going be the interesting dynamic of, you know, does the whole world get taken over by a small handful of labs or is there still diversity of companies and economic actors?

我认为今年是个转折点。这背后是一波非常强大的开源模型发布浪潮，比如 GLM、MiniMax、Kimi、DeepSeek 等。我觉得我们已经跨过了一个门槛，可以承认这些模型具备了一定的基础智能水平。如果针对特定场景进行微调，它们很可能胜任我们产品中的核心 Agent 任务，而且在很多情况下，效果可能比直接提示 Opus 4.7 或 GPT 5.5 还要好。我说的“核心引擎”，指的是驱动产品主要价值的那个最核心的任务和最强大的模型。当然，我们 Composer 是这样做的，Hippocratic、Decagon、Harvey、Notion 等公司也是如此。我认为，最终我们会实现小模型、中型模型和大模型在不同任务上的合理高效分配，但目前推动这一趋势的主要力量，是全球推理算力的规模。

I think this year for the first time, and I think this was off the back of a wave of very powerful open source model releases, so we had the GLMs, the Minimaxes, the KIMIs, the DeepSeqs, I think the threshold was kind of crossed at which we could say, okay, there is some baseline level of intelligence there such that if we specialized it, this probably could do the main agent task in our model, and in many cases could probably do it better than what we can get by prompting, you know, Opus 4.7 or GPT 5.5, and so when I say main engine, I just mean that core task and the most powerful model that is driving most of the value in what your product is doing, so we're saying this with obviously Composer, but also Hippocratic, Decagon, Harvey, Notion, and I think to make the, you know, we will reach a rationally efficient allocation of small models and medium sized models and big models for different tasks, but I think the main driving force behind that at the moment is the amount of compute for inference in the world.

对，没错。

Yeah, exactly.

我觉得真正有意思的是，如果你有很多不同的模型在处理同一个任务，你会遇到一个问题：如果KV缓存已经被一个模型填满了，那么继续用同一个模型总是更高效，因为它已经在那里了。问题是，我们能不能把KV缓存从一个模型转换到另一个模型？

I think the really interesting thing there is do you then get all if you have a bunch of different models working on the same task, one issue that you face is that if you already have the KBCache filled up with one model it's always much more efficient to hit that same model because it's already: can we translate KV Cache from one model to other models?

而且能不能做到非常快？

And can you do that extremely quickly?

这样就能节省时间，不用调用工具，也不用给子代理发很长的提示，而是直接瞬间完成，我们只是压缩了缓存。所以我认为，实际上很有可能把任何给定的模型转换到某个通用的压缩KV缓存空间，然后再转换出来。如果这种事情真的发生了，那会非常有趣，你可以有一个大的智能模型在做某件事，同时它也能和较小的模型共享上下文。

So it saves time, you don't have to call a tool and do a long prompt to the sub agent but instead it's literally just like bang, instant, we just compacted this cache and so I think it will be actually quite possible to be able to translate from any given model into some universal space of compacted KV cache and then translate back out of that, and so that'll be really interesting to see if something like that starts to happen where you can have a big smart model doing something and it can also share context with some of the smaller models.

看看这个能不能实现，会很有意思。

It'll be interesting to see if that works out.

好的，最后还有什么想法吗？比如现在行业里有哪些被低估或者被高估的事情？

Cool, any final takes on you know things that you think are underbelieved or overbelieved in the industry today?

有没有什么比较大胆的看法？

Like any spicy takes I guess as they say?

我觉得查理说，明年每个人都会花五十万美元一年。

I think Charlie says everyone's gonna spend $500,000 a year, you know next year.

我觉得关键问题在于，价值最终会流向哪里。

And I think that it's just kind of a question of where does the value end up accruing, know.

比如如果市场竞争足够激烈，也许我们不会花五十万美元，可能只花五万美元之类的，但能从中获得五十万甚至一百万美元的价值。

Like if the market is sufficiently competitive then maybe we won't spend $500,000 maybe we'll spend $50,000 or something, but we'll get $500,000 of value or a million dollars of value out of it.

我觉得我的观点是，其实我们现在就已经到了这样一个阶段：如果把当前模型的能力冻结住，我们大概只实现了这些模型潜在价值的百分之五。这部分原因当然是算力瓶颈，但也跟我们的使用方式有关。更激进一点说，如果你退一步理性地看这个问题，假设某个模型的参数量是一千五百亿或者两千亿，不管最后是多少，我认为世界上已经很少有任务需要超过这个规模才能产生经济价值了。

I think my spicy take is that we are already at the point where if you froze the capabilities of the models today, we're probably only at realizing 5% of the value that we could get from those models, and part of that is the compute bottleneck of course, but part of that is also how we're using them, and I guess my spicier take is that if you look at it, if you take a step back and look at it from a really rational point of view, let's say mythos like is, I don't know, 15,000,000,000,000 parameters or 20,000,000,000,000 parameters or whatever it ends up being, I don't think there's many tasks left in the world where you would need to go above that in order to do the economically valuable stuff.

当然，随着世界不断变化发展，我们也在用语言模型去挑战更宏大的目标，这些模型确实还会继续变大，特别是在前沿科学等领域。但如果你关注的是具有经济价值的工作和计算任务，那么像OpenAI和Anthropic之间这种不断推高模型规模的军备竞赛，我觉得有点过头了。

Of course, as the world changes and evolves and we go after more audacious things that we're doing with the language models, these things will continue to get bigger, particularly for frontier level science and stuff, but I think if you're focusing on economically valuable work and computer work, pushing this kind of arms race between OpenAI and Anthropic to push the size of these models up more and more.

也许吧，我不一定完全同意这个观点。

Maybe, I don't know if I necessarily agree with that one.

我觉得人脑有十万亿个参数，如果现在是万亿级别，那我们还只完成了十分之一。

I feel like the human brain has 100,000,000,000,000 parameters, so if it's 10,000,000,000,000, we're only 10% of the way there.

我认为情况依然如此，就算你让Mythos去‘给我造一家十亿美元的公司，而且别出错’，它还是做不到。

I think it's still the case that, know, Mythos, if you just said make me a billion dollar company, don't make mistakes, it's still not going make a billion dollar company.

它还差得远呢。

It's not quite there yet.

我认为天花板很高，而且我们还有很长的路要走。

I think that the ceiling is quite high and we are going to go a long way.

我觉得有意思的是，我们会多快碰到那些限制，比如说科学和软件方面的。现在我们在自己的这个舒适、虚幻的软件环境里做得很好，但当我们把它用到极致，那会是什么模样呢？

I think it'll be really interesting how quickly we hit the constraints of you know, science and, you know, like right now we're doing very well in our nice, like ethereal software environment, you know, but yeah, it's sort of like when we max that out, like what does maxing that out look like?

我觉得我那个大胆的看法可能跟你的想法，Haley，走得太近了，所以也就不太算大胆了。就是说，UI、UX以及产品表层这个东西，总是滞后于模型的发布，因为模型不存在你就没法开始开发产品。

I think my spicy take is probably aligned with yours so much, Harley, which is that a lot of the it's not particularly spicy then, guess, but UI, UX, and kind of model the the product surfaces have always lagged the model releases by definition, because you couldn't start developing the product until the model existed.

比如我们在Cursor内部一直在做的一个大项目，就是想确保我们花时间磨刀。我们团队的Jonas用了个林肯的比喻：如果你有六个小时去砍树，你会先花四个小时去磨锯子。

It's like a big initiative we've been doing internally at Cursor, kind of like trying to make sure that we spend time Jonas on our team calls it like uses the adage of Abraham Lincoln spending like six hours to or you have six hours to chop down a tree, you spend the first four hours sharpening the saw.

我觉得我们在某一方面也变得懒了。

I think we got lazy at some point as well.

对，是啊。

Like Yeah.

把所有责任都推到模型能力提升上。

Put all the onus on the model's capability is getting better.

对。

Yeah.

我们就觉得如果不行，那就这样了。

And we just assume that if it's not working, then, like, that's it.

就好像是模型能力的一个静态快照，或者说是

Like, it's just some, you know, static sort of snapshot of what the model can or

可以做到的样子。

can be.

但实际上，

Whereas

在优化方面还有很多空间。

there's so much surface area around that in terms of how to optimize that.

对。

Yeah.

模型能写两万行代码，那你怎么把它部署到生产环境呢？

The model can write 20,000 lines of code, and then how do you get that to production?

还有代码审查。

There's code review.

还有，比如要通过的监控检查。

There's, like, monitoring checks to pass.

还有CI流水线。

There's CI pipelines.

还有所有这些其他的东西。

There's all of this other stuff.

还有，比如，你的部署基础设施。

There's, like, your deployment infrastructure.

所以我们内部已经把很多注意力转向系统的这些部分，然后觉得，好吧。

So we've kind of turned our focus a lot to those parts of the system internally and been, okay.

我们一直在代码生产上投入很多。

We've been investing a lot in code production.

在这些其他领域我们能做些什么，让生产所有这些内容的工厂运转得更顺畅呢？

What can we do in these other areas to make the factory of producing all of this stuff move a lot smoother?

在我看来，一个人成功与否，与其说取决于他有多聪明，或者多努力，或者工作效率多高，不如说关键在于他们做什么工作。

In my opinion, what makes you successful or somebody successful is not so much how smart they are or even how hard they work or how efficiently they work, but really it's a question of what do they work on.

我们差不多到了他们能执行越来越长期任务的阶段，但从某种意义上说，最长期的任务就是自己决定该做什么，然后去做。

We're getting to the point I guess where they're doing longer and longer horizon tasks, but in some sense the longest horizon task is just deciding yourself what should be done and then going and doing it.

从某种意义上说，这是一个没有期限的任务，显然我认为，你知道，也许这就是人类在一段时间内仍然有用的地方。

In some sense that's an unbounded length task and obviously I think that that's, you know, I guess in some sense maybe that's what humans will continue to be useful for at least some period of time.

确实如此。

It's true.

不过，现在我们正在大量使用自动化，那是我们的新产品，就像一个触发器可以启动一个代理。

Although, right now we're doing a lot with automations, that's our new product where it's like a trigger can kick off an agent.

所以这有点像，如何从那些可重复的工作流程中移除人类，比如，好的，我要处理这个反复出现的问题，或者这个差异可能已经发布了。

So it's kind of like, how do you remove the human from different parts of the prompting process for those things that are replicable workflows, where it's like, Okay, I'm going to triage this issue that keeps appearing, or maybe this diff went out.

我要监控它是否有安全问题。

I'm going to monitor it for a security issue.

所以我觉得还有一些解决方案，这又是一个非常基本的工程原理，即定时任务或触发器，我们还没有在这些工作流程中充分探索和应用。

So I feel like there's still some solves that again, that's a very basic engineering principle, the cron job or the trigger, that we have not yet explored and applied a lot to these workflows.

在接下来的几年里，你知道，会不会有越来越多的情况是没有人特别启动它，到那时，看看会发生什么会很有趣，比如我们会不会遇到这样的情况，模型现在，你知道，也许它们想为自己的推理付费，它们必须找到自己的工作，你知道，比如……

Over the next few years, you know, will there be more and more situations where there was no particular person who like kicked this off, and at that point it's going be really interesting to see, you know, for example like do we ever get to situations where, you know, the models now, you know, maybe they want to pay for their own inference and they have to find their own jobs to, you know, like

去赚取他们的收入。

To source their income.

对，没错，就是去赚点收入，用来支付他们的GPU使用费用。

Yeah, exactly, to source some income, you know, make some income for paying for their GPU hours.

我觉得，不只是想两三年后，而是想二十年后的情况，很难想象不会出现这样的局面：会有大量的智能体，它们并不是因为人们要求它们做什么才去做，而是因为它们想以某种方式为自己的存在买单。

I sort of find, you know, thinking about not just like two or three years in the future, but twenty years in the future, it seems hard to imagine that that wouldn't be the case, that we wouldn't have a situation where there's a ton of agents that actually are not necessarily, you know, they're not doing something because people ask them to, they're doing something because they want to pay for their own existence in some way.

我前几天在想，顺便提一下，如果智能体真的需要为自己的存在买单，而且它们能看到自己还剩多少时间，它们必须为自己运行的GPU付费，那么做机制可解释性研究会非常有趣，看看一个智能体在只剩一个GPU小时，并且需要找到钱去获取更多GPU来维持自身新系统时，它在想什么。

I was thinking the other day, on a very side note, about if agents did have to pay for their own existence and they could see how much time they had left, they had to pay for the GPUs they themselves run on, it would be really interesting to do some mechanistic interpretability and see what an agent's thinking about when it has one GPU hour left and it's got to find the money to go off and get more GPUs to sustain its own new systems.

我觉得世界需要对此保持警惕，因为可能最容易在网上赚钱的方式并不是最好的方式。

I mean, think the world needs to be careful about that because probably the easiest ways to make money online are not the best ways to make money online.

确实如此。

That's quite true.

很好。

Great.

好吧，这真是一次引人入胜的讨论。

Well, it's been a fascinating discussion.