AI 测试：超越计算机使用，迈向自主代理

当人们想到 AI 运行你的应用并测试它的能力时，我认为他们实际上过度关注了计算机使用部分，因为在我看来，计算机使用就是字面上的——你想要点击一个按钮，能否发出正确的坐标去点击那个按钮。我认为测试对这些 AI 来说实际上是一个很有趣的问题解决挑战，因为如果你想做任意测试，比如想象你做了一个跨越前端和后端的改动，要真正测试那个改动，我们必须推理：首先如何运行这些应用，让它们以正确的代码版本相互协调，然后如何触发这个功能，或者如何让事情实际发生——那才是我们花费大部分时间的地方。

When people think about the ability of an AI to run your app and test it, I think they actually overindex on the computer use part of it because computer use in my mind is the literal okay you want you know a button you want to click can you emit the right coordinates to go click that button. I think testing is actually a really interesting problem solving uh challenge for these AIs because if you wanted to do arbitrary testing like imagine you make a change that spans the front end and the back end to actually test that change we have to reason through what how do you first run these applications to orchestrate with each other with the right version of the code then okay how do I trigger the feature or how do I make the thing actually happen that is where we spend most of our time

在进入今天的节目之前，我有一小段话要对听众说。谢谢你们。如果没有你们选择点击并收听我们的内容，我们就无法带来你们如此想要的 AI 工程、科学和娱乐内容。几乎每天都有赞助商联系我们。但幸运的是，有足够多的你们订阅了我们，让这一切在没有广告的情况下得以持续，我们希望保持这样。但我只想请你们帮一个忙。你们能做的最有力、完全免费的事情就是点击那个订阅按钮。这是我对你们的唯一请求。这对我以及每周努力为大家带来 Inspace 的团队来说意义重大。如果你们订阅了，我保证我们会永不停止地努力让节目变得更好。现在，让我们开始吧。好的，我们在演播室与 Walden Yan，联合创始人兼 CPO 在一起。

Before we get into today's episode, I just have a small message for listeners. Thank you. We would not be able to bring you the AI engineering, science, and entertainment content that you so clearly want if you didn't choose to also click in and tune into our content. We've been approached by sponsors on an almost daily basis. But fortunately, enough of you actually subscribe to us to keep all this sustainable without ads, and we want to keep it that way. But I just have one favor to ask all of you. The single most powerful, completely free thing you can do is to click that subscribe button. It's the only thing I'll ever ask of you. And it means absolutely everything to me and my team that works so hard to bring the inspace to you each and every week. If you do it, I promise you we'll never stop working to make the show even better. Now, let's get into it. All right, we're in the studio with Walden Yan, co-founder, CPO.

是的。

Yeah.

这是个很酷的头衔。嗯，是的。还有

Which is cool title. Um, yes. And

也是上下文工程（context engineering）这个词的创造者之一。是的，是的。虽然我认为之前有很多人以各种方式使用过这些术语，但我确实发现，内部和外部的人都喜欢从字体工程或模型封装升级到一种更周到的构建智能体的方式。

one coiner of context engineering. Yes. Yes. Although I think there were many people who used the terms in various ways beforehand. But um I I I did find that people both internally and externally enjoyed the upgrade from font engineering or you know model wrapping into maybe a more thoughtful way to build agents.

是的。对于那些还没了解过的人，我屏幕上有那篇“不要构建多智能体”的文章，你们应该读一读，我们可能会提到它。还有创建了 Open Inspect 的 Cole Murray。

Yeah. For uh for those who haven't caught up on that, I have on screen the don't build multi-agents post which you should read read on and we might refer to. And Cole Murray who created open inspect.

很高兴来到这里。好的，那么我们来谈谈。每个人都在构建自己的 Devin。嗯，发生了什么？

Great to be here. Okay, so let's talk about it. Everyone is building their own Devins. Um, what's going on?

是的，我认为工程界正在逐渐意识到后台智能体、云端智能体这些概念。我认为我们在 2025 年 12 月左右看到了一个转变，当时 Opus 4.5 和 GPT 5.2 等模型达到了一种能力，使我们不再需要手把手地引导模型，而是能够或多或少地自主驱动模型。我的意思是，我们基本上可以从一个规范直接到一个完成的拉取请求，假设规范足够好，几乎没有任何摩擦。仅这一范式转变，我认为就极大地改变了我们与智能体交互的方式，并打开了一个世界，让后台智能体变得更加实用。

Yeah, so I think the engineering world is kind of waking up to this idea of background agents, cloud agents, uh, whatever you'd like to call it. And I think we saw a shift around the December time frame of 2025 where the models Opus 4.5 and GPT 5.2, to they reached a capability where we moved away from kind of handholding the model and being able to actually more or less autonomously drive the model. And what I mean by that is that we could pretty much go from a specification to a completed pull request assuming the spec was good enough uh with very little friction. And that paradigm alone I think changed a lot of how we interact with agents um and kind of opened this world where background agents became more practical.

我认为对于所有人来说，在 12 月都经历了这一点，但我感觉就像有一个不断上升的斜坡，嗯，有一个时刻，我认为是 Sonnet 3.7，你们在一夜之间重写了 Devin 之类的。

I think for for call everyone experienced this in December but I feel like there was just this increasing ramp right like um there was this the moment which was I think sonnet 37 where like you guys rewrote Devon in one night or something.

是的。是的。是的。那么描述一下 2025 年，或者从你的角度感觉如何？

Yes. Yeah. Yeah. So describe 2025 or you know how how it felt from your side.

回想起来，我们一直认为它在加速，但即使现在，从今天算起的过去三四个月里，它加速得更快了。所以谈论 Sonnet 3.7 是多么大的飞跃几乎有点好笑，老实说，我们很大程度上是去掉了 Devin 中那些随着智能跃进而不再需要的部分。但我也认为，最近的很多飞跃，尤其是像 Opus 和最新的 GPT 模型，它们达到了这样的自主水平，以至于人们实际上在挣扎，他们不能完全放手；而那些曾经争论“我是否需要深入 IDE 与模型打交道”的人，现在正在认真讨论能否完全将其迁移到云端。我们在所有的增长图表中都看到了这一点，内部有一个有趣的图表，我们的 PR 使用量或合并 PR 量增长了 7 倍，自从我忘了什么时候开始。

In retrospect you know we always thought it was ramping up but then even now over the last 3 4 months from today we it's been ramping up even faster. So it's almost funny to be talking about how like big of a leap Sonet 3.7 was and we honestly a lot of it was stripping out parts of Devon that were no longer needed with that jump in intelligence. But I also just think that a lot of the recent leaps uh especially you know you look at like models like opus and latest GBT models they are reaching levels of autonomy where people are actually fighting that they actually can't just be hands off and people who were once debating oh you know do I need to be in the weeds with my model in the IDE um can I just completely move it off into the cloud that's a that's a more serious conversation and we've seen that in in all of our growth charts um internally there's this funny graph where our usage has uh of PRs or our merged PRs has grown 7x since I I I forget what

我想 Dave 可能发过推文。是的。嗯，是的。

I think Dave uh maybe tweeted that. Yeah. Uh yes.

嗯，在过去大概两三个月里增长了 7 倍左右。然后你看我们的工程人员增长，大概只增加了 10% 左右。

Um it grew like 7x over like the last I think it was like 2 months, 3 months, something like that. Uh and then you see our engineing headcount growth. It's like gone up by like 10% or something

我们当时都不敢发布这个。所以，这是 Devin 在所有 Devin 仓库上的提交占比，1 月份是 16%，现在 3 月份是 80%。

like we were we were afraid to release this. So, so this is Devon commit percentages on all Devon repos uh was 16% in January and now 80% in March.

是的，现在这是一个巨大的转变。嗯，所以很多人现在在考虑购买 Devin，但也可能想自己构建，我构建 Devin 时有很多乐趣，所以我能理解为什么其他人也想构建自己的云端智能体。是的。

Yeah, it's like uh it's a big shift right now. Um and so it makes sense that a lot of people are now thinking about you know buying Devon but also maybe like you know trying to build their own and and there's lots of I I have a lot of fun building Devon so I can see why other people would want to build their own cloud agents as well. Yeah.

嗯，也许听听最初是什么激励你尝试构建 Open Inspect 是件好事。

Well, maybe it's it's good to hear like what what initially inspired you to try to build open inspect.

是的，Open Inspect 的出现主要是因为我观察到我的客户如何使用像 Claude Web、当时 OpenAI 的 Codex 这样的工具，并看到他们遇到的一些摩擦。嗯，主要是 Claude Web 通过 Slack 使用，他们遇到的一个大问题是，启动的会话只对通过 Slack 调用它的人可见，所以如果 PM 调用了会话，然后他们想把上下文传给工程团队，工程团队却看不到那个会话，这本身就是一个致命问题，因为 PM 说“嘿，工程团队，你们能加入吗”，但除非他们复制粘贴出来或返回单个响应，否则没什么可加入的。嗯，看到这些问题后，我在内部构建了一个类似的架构，只是为了实验，测试不同的想法，当时从本地主机迁移的趋势开始形成，而且当 RAMP 发布他们的博客文章时，我已经有很多组件就位了。嗯，只是觉得看看 Claude 仅凭那篇博客文章能做什么会很有趣，在我的 X 账号上实际上有一个帖子串，我实时发布了整个过程。

Yeah, open inspect came about uh through primarily my clients observing how they were using tools like cloud web um openai's codeex at the time and seeing some of the friction that they were having with it. Um, primarily the claw web uh was being used through Slack and a big issue they ran into was that these sessions that were launched were specific to whoever called it via Slack and so if a PM was the one who invoked the session and they would then go to pass context engineering engineering can't see the session and that in itself was kind of a dealbreaker because the PM hey engineering can you jump in but there's nothing to jump in on unless they're copy pasting out or you know the single response that came back. Um and so kind of seeing some of these problems, I had built a similar kind of architecture internally um just to experiment with um kind of test out different ideas as this trend of moving off of local host was starting to kind of become um and as RAMP released their blog post, I had a lot of the pieces for this already in place. Um, and just thought it would be kind of funny to uh see what Claude could do just purely from the blog post and uh on my ex account there's actually kind of a a thread of where I live tweeted like going through this.

哦，哇。

Oh wow.

嗯，比较 GPT 和 Claude，两者都在进行这个过程。

Uh comparing GPT and Claude as both of them are going through it

比如在公告之类的事情上。

like on the announcer thing or something else.

嗯，就在它发布之后。好的。嗯，我们可以把它放在节目笔记里。

Uh right after it got released. Okay. Um we can put it in the show notes.

嗯

Um

是的，有帮助的是我已经大致知道如何验证这个系统了。

yeah, it was helpful that I had already kind of knew how to verify the system.

我很清楚自己在找什么。我觉得 RAMP 在展示如何构建系统的技术细节方面做得非常好，远不止是“嘿，我们建了个好系统”，而是“你也可以这样建”。这跟我已经遇到的问题产生了强烈共鸣。环顾四周，我发现开源社区里没有真正满足这类需求的系统。有很多在 localhost 上运行的项目，比如 Superset、Conductor 等等，但没有一个真正跑在云上。于是我就自己建了一个，并且觉得把它开源出来很有意思，这样任何人都能有一个基础，在上面自由组合和定制。

I knew what I was looking for. I think RAMP did a great job of really illustrating the technical aspects of how to build something. It was much more than just 'hey we built a great system.' It was 'and here's how you can build it too.' And so I resonated a lot with that, just with the problems that I was already seeing. And I thought that looking around, I didn't really see anything in the open source community that met this type of system. I think there's a lot that run in localhost, like Superset, Conductor, and many others, but nothing that was actually running in the cloud. And so I built it, and I thought it was interesting to just open source it and allow anyone to then have a foundation that they can mix and match on top of.

所以 Devin 发布后，就有了 OpenDevin，后来变成了 All Hands。不知道你有没有试过？

So literally after Devin was launched, there was OpenDevin, which became All Hands. I don't know if you tried that or...

对。我想说的是，Open Inspect 让我很感兴趣的一点是，你没有试图把它变成赚钱的东西。很多开源项目后来都会去融资。

Yeah. Well, I was going to say one of the things that interested me a lot with Open Inspect was that you didn't try to go make it something you monetize. There are a lot of these open source projects that would then go really try to raise VCs.

嗯，你是怎么想的？我觉得这很有意思。根据我在客户那里的观察，背景智能体系统将成为他们公司内部的关键基础设施。正因如此，我想把它开源，这样他们就能 fork 并加入任何他们想要的定制。不过这个问题我经常被问到：“你会融资吗？你会把它变成一项服务吗？”

Yeah, and how did you think about that? I thought that was very interesting. I thought, and kind of just what I had seen across my clients, was that having a background agent system is going to become critical infrastructure within their company. And so because of that, I think that I wanted to open source it so that they could fork it and put in whatever customization they wanted. To that question though, I get asked all the time, 'Oh, are you going to raise? Are you going to turn this into a service?'

我相信你肯定收到过邀约。但我不打算这么做，有几个原因。第一，我不想为了每个座位 20 美元去竞争，那生意太难做了。核心功能很容易被复制。再说，我很快就建好了这个系统，而且因为你没有拥有整个技术栈，所以很难变现。沙盒层有 Daytona、E2B 等很多玩家在赚钱，模型层也在赚钱。而你处在一个奇怪的灰色地带：你到底在卖什么？卖基础设施？卖集成？不如问问这位：你在卖什么？

I'm sure you've gotten offers. But primarily I don't want to do that for a few reasons. One, I think that I don't want to compete for $20 a seat. I think that is just a really difficult business. I think it's very easy to copy the main pieces of it. I mean, again, I built this fairly quickly, and I think because you are not owning the entire stack, it's hard to monetize. You have money being made at the sandbox layer with Daytona, E2B, many other players. You have money being made at the model layer. And you kind of sit in this weird in-between gray area where what are you actually selling? You're selling the infrastructure, I guess. You're selling the integrations maybe. Let's ask the guy: what are you selling?

嗯，实际上这里面有好几层。有趣的是你提到了基础设施，因为我们开始构建 Devin 的时候，也不得不自己搞定基础设施，因为……

Well, yeah, there's multiple layers to this in practice. And actually, it's funny you mentioned the infrastructure, because when we got started building Devin as well, we had to go figure out how to make the infrastructure as well, because...

你比所有人都早两年开始建这个。

You had to build this two years before everyone else, you know.

对，没错。一开始并不完善。比如我们直接用 EC2 这样的云提供商原始虚拟机搭建时，启动时间非常慢。尤其是关闭机器、保存状态，然后再让 Devin 重新唤醒时，它会宕机大约 10 分钟，因为这些系统本来就不是为这种反复开关设计的。所以我们不得不自己解决所有这些问题。结果现在，当我们向客户销售 Devin 时，我们提供的其中一项服务就是：你不用担心算力方面的事，我们来搞定。如果你愿意，我们可以在你的云环境中运行。但除了产品本身——我稍后想深入讨论智能体和智能调优——我认为 Cognition 做的很大一部分工作就是确保你的公司学习、使用并采纳这些编码智能体。因为尤其对于全球最大的企业来说，很多人希望在日常工作中使用 AI。但由于项目规划方式，以及并非所有人都熟悉如何以这种方式使用 AI，拥有一支工程师团队来实际引导你、设置你所需的所有集成和自动化，从而真正达到 AI 带来的杠杆效应，是非常有帮助的。所以，总的来说，我们就是这样做的。我们也是客户的思想伙伴。那么，我们来谈谈架构方面的事情。我觉得这总是你们俩之间的话题。你是想从这个心智模型开始，还是别的？我把发言权交给你们。

Yeah, exactly. And including the side, it was not very polished at the start. Like when we just built it off of raw VMs from cloud providers like EC2, the bootup time was so slow, I think. And especially then, like turning off the machines, saving them, and then being able to bring them back up again when you want Devin to wake up again later, it would just be out cold for like 10 minutes because that's just how long these systems took. They were not built for this repeated down and up usage. And so we actually had to go do all of that. And as a result, now one thing we offer when we go and sell Devin to people is, you know, you don't have to worry about all the compute side of things. We'll make it work. We'll make it work in your cloud if you wanted to. But aside from the product, and I want to go into the agents and the tuning of the intelligence part later, but I think a big part of what we do at Cognition as well is to just make sure that your company learns and uses and adopts these coding agents. Because I think for especially the largest enterprises in the world, you find that there is a lot of people who want to move over to using AI for their day-to-day workloads. But because of the way projects are planned, because not everyone is literate in using AI in these ways, having a team of engineers who can actually go in and onboard you, set up all the integrations you need, the automations you need to really get to that level of leverage with AI is super helpful. And so, total, we do that. We show up as thought partners to the customers that we work with as well. So let's talk about architectural stuff. I think that's always a topic of conversation between the two of you. Is this sort of like the mental model that you want to start with, or something else? I'll just kind of leave the floor open to you guys.

嗯，我想我们可以从这里开始：大致说说背景智能体系统由哪些部分组成？然后我们再深入一些决策上的细微差别。但我想 Walden 说的可能是，智能体就像在这个开放的代码框里，对吧？这是基础设施，那是智能体。你们讨论过是把智能体放在里面还是外面。你能详细说说吗？

Yeah, I think that maybe we can start here, just kind of a general: what are the pieces of a background agent system? And then maybe we can go into some of the nuances of decisions that you can make. But I guess also like what maybe Walden is saying is the agent is kind of like in this open code box, I guess right? Like this is infra, and then there's the agent. And you had this discussion about whether you put the agent in here or externally. Can you sort of tease that out?

对，在背景智能体系统中，你需要决定智能体实际运行的位置。这通常被称为“套件”：在盒内或盒外。

Yeah, in a background agent system, you have a decision to make of where the agent is actually going to run. This is typically described as the harness: in the box or out of the box.

对。把智能体放在盒内运行，需要做一些权衡。负面权衡主要是安全性，因为智能体在盒内运行。除非你另有设计，否则所有机密也需要放入盒内。考虑到 AI 的不可预测性，你很容易意外泄露机密，或出现其他意外行为。而盒外运行的概念是，智能体本身不直接在沙盒中运行，而是让所谓的“大脑”在某种工作控制平面中运行。沙盒则充当“手”，大脑通过工具调用来操作和操控那个环境。我认为这两个系统之间的另一个权衡是，在我看来，盒外运行要复杂得多，因为你需要管理状态；而盒内运行时，智能体的所有状态实际上都在盒内。当然，你也可以在其他地方持久化，但所有状态都是本地化的，需要担心的问题更少。我认为你提到的很多点正是我们一开始就把 Devin 构建成“将大脑与机器分离”的原因。

Yeah. With running the agent in the box, you're making some trade-offs by doing that. The negative trade-off you're making is primarily security, because the agent is running in that box. Unless you otherwise design it, all of your secrets need to go into that box as well. And given the nature of AI, it can be unpredictable and you could very easily end up accidentally exfiltrating your secrets, or other kind of unintended behavior. Now the out-of-the-box is the idea that we are going to have the actual agent running not directly in the sandbox, and we'll have, quote unquote, the brain of the agent running in some type of worker control plane. That sandbox then is going to serve as the hands, where the brain is basically operating and making tool calls into that environment to manipulate it. I guess the other trade-off that you're making between the two systems is that, in my opinion, running it out of the box is much more complex because you have state that has to be managed, whereas if you're running it in the box, all of the state of that agent is actually in the box. And yes, you could persist it elsewhere, but it's all kind of localized and you have less concerns to worry about. I think a lot of that what you mentioned is why we actually from the start built Devin to what we called separate the brain from the machine.

另一件你可以做的事是复用任何现有的开发机基础设施，这样你就不必太担心制作一种新的开发机，它包含大脑所需的所有依赖项，以及你提到的大脑所需的密钥。我们看到一些客户遇到的一个问题是，你有一个 GitHub 应用，你希望 Devon（你的智能体）能够通过这个应用与 GitHub 交互，但不同的用户有不同的实际权限。如果他们都在通过同一个 GitHub 应用交互，并且决定系统做什么的机制与机器上的实际密钥之间没有真正的分离，那么你就会遇到一个难以分离的问题。但在实践中，使用 Devon 会容易得多，因为我们只是说，你放在机器上的任何东西都是用户自由操作的范围，也是智能体自由操作的范围。所以只把范围最小的密钥放在那台机器上，然后大脑完全无法从机器访问。因此，如果用户可以随意操作机器，你就不必担心会搞乱大脑中最安全的部分。

The other thing this allows you to do is reuse any existing infrastructure you have for dev boxes, so you don't have to worry as much about making a new type of dev box that has all the dependencies the brain needs, as you mentioned, the secrets the brain needs as well. One thing we've seen some customers run into is you have a GitHub app and you want Devon, your agent, to be able to interact with GitHub through this application, but then you have different users with different actual permissions. If they are all interacting through the same GitHub app and there's no actual separation between the system that decides what it does and the actual secrets on the machine, then you run into an issue where it's hard to do the separation. But in practice with Devon, it's much easier because we just say whatever you put on the machine is the scope of what the user is free to do, what the agent is free to do. So only put the most scoped secrets on that machine, and then the brain is fully not accessible from the machine. So you don't have to worry about messing with the most secure parts of the brain if the user is free to do whatever they want with the machine.

我本来想提一下 OpenAI 的这张图，不知道他们是不是用“盒内”或“盒外”来描述它。还有最近 Anthropic 做了“托管智能体”，这是他们的东西。

I was going to bring up this chart from OpenAI, I don't know if this is like "in the box" or "out of the box" that they use to describe it. And also recently Anthropic did "managed agents", which is their thing.

我不知道，这都是同一模式的不同变体，对吧？

I don't know, it's all variations of the same pattern, right?

是的。所以这会是“盒外”。

Yeah. So this would be "out of the box".

嗯。

Yeah.

这对他们来说更可取，因为工作量更少。

Which is preferable for them because it's less work.

我会说工作量更大，但在我看来，这是两者中更好的架构。

I would say it's more work, but in my opinion it is the better architecture of the two.

好的。只是这样做会带来一些复杂性。有一件事我没看到很多其他玩家做得好，那就是你如何管理盒子里实际有什么？这可能很复杂，原因很多。假设你有一个大型仓库，它经常变化和更新，依赖项也在变。你如何确保智能体的工作环境实际上保持最新，拥有运行应用和测试它所需的所有凭据，以及你希望自主仓库设置具备的所有东西？

Okay. It's just you're taking on a bit of complexity by doing that. One thing I've not seen a lot of other players do well is how do you manage what's actually on the box? This can be complex for many reasons. Let's say you have a big repository that's changing and updating a lot with changing dependencies. How do you make sure that the working environment of the agent actually stays up to date, has all the credentials it needs to run the app and test it, all the things you want for your autonomous repo setup?

是的，完全正确。所以在 Cognition 内部，我们称之为“仓库设置”。最难的部分从公司成立以来就一直是个长期问题：我们如何帮助人们完成设置？因为不是每个人都直接拥有开箱即用的云环境。你觉得你的客户中这是一个常见问题吗？

Yeah, exactly. So internally at Cognition, we call this "repo setup". The hardest part of it has been a perennial problem since the start of the company: how do we help people get the setup? Because not everyone just has working cloud environments out of the box. Do you find this to be a common problem with your clients?

是的，这是一个非常常见的问题，在我的咨询工作中，这很大程度上是我帮助团队做的事情。很多团队并没有真正好的开发环境设置，甚至根本没有。很多时候是“去找 Bob 拿密钥”，这显然在智能体需要实际设置时行不通。所以很多情况下，大多数团队都在使用 Docker Compose 或某种微服务。

Yeah, this is a very common problem, and through my consulting, this is a lot of what I help teams do. A lot of teams don't really have great developer environment setups, if any. A lot of the time it's "go talk to Bob and get the secrets", and that obviously doesn't work when the agent needs to actually set this up. So a lot of that, most teams are using Docker Compose or some type of microservices.

在生产环境中？

And in prod?

不在生产环境。使用 Open Inspect，你主要是用它来交互和修改代码。还有其他用例，但你可以通过 CLI、MCP、其他工具来连接它，然后将其接入你的生产系统，主要用于 SRE 类型的用例，但你并不一定试图通过该系统测试生产内部微服务。

Not in prod. With Open Inspect, you are using this primarily to interact and make code changes. There are other use cases, but you can hook it through CLI, MCPs, other tools, and then hook that into your production systems primarily for SRE-type use cases, but you are not necessarily trying to test your prod internal microservices through the system.

是的，你提到了 Docker Compose。我认为我们的一些朋友早期采取的一个方向是使用 Docker 容器作为他们模型的抽象层。有很多原因说明 Docker 容器并不好。一是 Docker 容器并不是真正的安全边界。但另一个是，如果你在运行真正的应用程序，很多时候这些应用程序使用 Docker，然后你就得考虑 Docker 套 Docker，这真的很奇怪。

Yeah, and you mentioned Docker Compose. I think one direction we saw some of our friends take early on was using Docker containers as a level of abstraction for their models. There are lots of reasons why Docker containers are not great. One thing is Docker containers are not really a true security boundary. But the other is if you are running real applications, a lot of times those applications use Docker, and then you have to think about Docker-in-Docker, which is really weird.

是的。所以我认为让虚拟机工作的一个真正困难的挑战是，我们为什么这么做？嗯，是因为我们意识到你实际上需要完整的虚拟机才能做这类事情。尤其是现在，运行应用程序、点击操作并发送屏幕录制确实有价值，价值还在不断增加。但这是我在人们尝试构建自己的系统时看到他们遇到的一个决策：“哦，我们是把智能体放在机器里还是机器外？我们用 Docker 吗？还是用别的？”你现在推荐人们用什么？

Yes. And so I think part of the really hard challenge of getting VMs to work, why did we do that? Well, it was because we realized that you actually needed full VMs to be able to do these types of things. And especially nowadays where there's actually value in running the application and clicking around and sending you screen recordings of these things, the value just keeps adding on top of that. But it is a decision I see people run into when they try to build their own systems: "Oh, do we put the agent in the machine or out of the machine? Do we use Docker? Do we use something else?" What do you recommend people nowadays?

我认为 Docker 是一个好的解决方案，也许不是用来运行智能体，而是用来运行你的基础设施，因为这或多或少是你的工程师可能已经在使用的设置。如果不是，我不知道他们在用什么，但他们可能已经在用 Docker Compose 了。

I think Docker is a good solution for maybe not running the agent but running your infrastructure, because that is more or less the same setup your engineers are probably already using. If they're not, I don't know what they're using, but they're probably already using Docker Compose.

是的，我一直对 Web 容器情有独钟。不知道你们之前有没有试过。对我来说，它们应该是像 Docker Lite 一样的东西。

Yeah, I've always had a small candle for web containers. I don't know if you guys have tried them before. To me, they were supposed to be like Docker Light.

没有，我没试过。

No, I haven't tried it.

但是，是的，我认为你设置的任何为开发者提供良好体验的环境，自然也会让智能体容易设置。一旦你搞定了本地开发的故事，你基本上就解决了沙盒环境中的智能体设置。Open Inspect 也有钩子，你可以运行一个 setup.sh 脚本，它会预装所有东西。然后你可以预快照那个构建，这样它就能立即启动，然后还有第二个钩子，在沙盒恢复时实际恢复状态。这样你就可以让所有那些微服务运行起来，基本上在沙盒中获得与在你的机器上相同的体验。

But yeah, I think any environment that you've set up that is a good experience for your developer naturally lends itself to being easy to set up for the agent. And once you figure out that local developer story, you've more or less solved the agent in a sandbox environment setup. Open Inspect does have hooks as well where you can run a setup.sh script that will pre-install everything. You can then pre-snapshot that build so it starts instantly, and then there is a second hook to actually restore the state of the sandbox when it comes back. And so you can already have all of those microservices running and basically get the same experience that you would on your machine within the sandbox.

我们一直在思考的另一件事是不同的虚拟机服务产品。你有没有遇到过需要 macOS 特定虚拟机或 Windows 特定虚拟机的客户？

Another thing we've been thinking a lot about is different VM service offerings. Have you had customers where they needed Mac OS specific VMs or Windows specific VMs?

还没有。

Not yet.

世界上有很多技术只适用于特定类型的机器，对吧？如果你要构建一个必须在 Windows 上运行的应用程序，或者更常见的是，如果你想为 iOS 或 macOS 构建，权限支持和类似的选择……

There are many technologies in the world that only work on specific types of machines, right? If you're building an application that has to run on Windows, or more commonly if you want to build for iOS or macOS, permission support and choices like that...

我们做的基础架构，因为我们做了分离，所以它确实支持，但实际的工作正在进行中。我们最近新增支持的另一项功能（目前处于测试阶段）是进行 Android 开发。为此，我们需要支持机器内的嵌套虚拟化，因为虚拟机本身是一个虚拟化的 Firecracker 实例，然后你必须在其中运行另一个 Android 模拟器。存在一些奇怪的性能问题，这就是为什么它仍处于测试阶段。我们必须解决这些问题，但它为任何想做 Android 开发的人解锁了很多可能性。

The fundamental architecture we do, because we do the separation, it does support, but the actual work in progress is happening right now. Another thing we've recently added support for, now in beta, is doing Android development. To do that, we needed to support nested virtualization within our machines because the VM itself is a virtualized Firecracker instance, and then you have to run another Android emulator inside. There are weird performance issues, which is why it's still in beta. We have to think through these problems, but it unlocks a lot for anyone who wants to do Android development.

我试图找一个关于测试功能的参考视频，但没找到。不过我觉得你参与了测试能力的开发。为什么叫它测试，而不是计算机使用？这属于什么一般类别的问题？

I was trying to find a reference video for the testing thing. I couldn't find it, but I think you worked on the testing capability. Why do you call it testing and not computer use? What's the general category of problem?

我认为当人们想到 AI 运行并测试你的应用的能力时，他们实际上过度关注了计算机使用部分。因为在我看来，计算机使用就是字面意思：好的，你想要一个按钮，你想点击，你能发出正确的坐标去点击那个按钮吗？我认为测试对这些 AI 来说实际上是一个非常有挑战性的问题解决任务。因为如果你想做任意测试，想象一下你做了一个跨越前端和后端的改动，甚至可能涉及其他更深层的服务。要真正测试那个改动，我们必须推理：首先如何运行这些应用程序，让它们以正确的代码版本相互协调？然后，好的，我如何触发这个功能，或者如何让事情实际发生？这可能会变得任意困难。也许你必须是管理员，也许某个功能必须通过功能标志开启，也许你必须运行两个会话，然后向其中一个发送一个非常具体的词来触发特定行为。弄清楚如何做到这一点需要大量的代码库上下文，以及我们专门做了的大量编排。在某些情况下，我们发现没有一个单一的前沿模型能自己完成这个完整的端到端任务。我们见过一些案例，我们实际上不得不将不同的前沿模型编排在一起，共同解决这个问题。

I think that when people think about the ability of an AI to run your app and test it, they actually overindex on the computer use part of it. Because computer use in my mind is the literal: okay, you want a button, you want to click, can you emit the right coordinates to go click that button? I think testing is actually a really interesting problem-solving challenge for these AIs. Because if you wanted to do arbitrary testing, imagine you make a change that spans the front end and the back end, maybe even some other more deeply nested service. To actually test that change, we have to reason through: how do you first run these applications to orchestrate with each other with the right version of the code? Then, okay, how do I trigger the feature or how do I make the thing actually happen? This can get arbitrarily hard. Maybe you have to be an admin, maybe a certain thing has to be feature-flagged on, maybe you have to run two sessions and then send a very specific word into one of them to trigger specific behavior. Figuring out how to do that requires a lot of codebase context, a lot of orchestration that we've specifically done. In some cases, we found that no single frontier model can actually do this full end-to-end task itself. We've seen cases where we actually had to orchestrate different frontier models together to solve this problem together.

这就是我们在考虑这个测试问题时花费大部分时间的地方，而不是计算机使用部分。计算机使用，不管怎样，随着最近的模型已经变得好多了，它确实让那部分工作更容易了。尤其是昨天他们发布的 47，在视觉方面显然好得多，这将涵盖计算机使用。为所有这些建立评估也需要一段时间。而且让评估正确也很棘手。

That is where we spend most of our time when we think about this testing problem, not so much the computer use part. Computer use, for what it's worth, has gotten a lot better with recent models, and it's made that part of the job certainly easier. Especially with even 47 that they released yesterday, apparently way better in terms of the vision stuff, which is going to be encompassing computer use. Having evals for all these as well is something that takes a while to build up. And having the eval be right is tricky as well.

你有没有见过那些构建自己智能体的客户，他们不得不开始建立评估以确保不会出现回归？

Do you ever see clients who are building their own agents having to start standing up evals to make sure things don't regress?

不是传统意义上的评估，而是专门针对刚刚加入的测试部分。我刚刚添加了对截图的支持，理论上你也可以做视频。我需要加一个插件来实现。但它们确实原生显示出来了，这是一个非常强烈要求的功能，尤其是在 Cursor 的录制功能发布之后。我认为这对每个人来说都很有启发性，就像哦，这确实是一个非常好的功能。我想在 Devin 上你们已经有一段时间了。

Not so much eval in the traditional sense, but specific to the testing part that has just gone in. I just added support for screenshots and, in theory, you can also do video. I need to put in a plugin to do that. But they do kind of show up natively, and it was a very heavily requested feature, especially after Cursor's recording came out. I think that was very enlightening for everyone, like oh this is a very good feature to actually have. I think with Devin you guys have had this for a while.

是的，我们是第一个。

Yeah, first.

哦，是的。我明白截图是怎么工作的了。我不知道有没有什么特别不明显的。有点像一旦你知道要构建什么功能，你只需要提示它，它基本上就能工作。

Oh, yeah. I see how screenshots work. I don't know if there's anything super not obvious. It's kind of like once you know what feature to build, you can just kind of prompt it and it mostly works.

不过我认为，就 Walden 的观点而言，计算机使用是更大的测试问题的一个子集。而且我认为这非常特定于你正在工作的代码库。这不是一个开箱即用就能解决的问题。你确实需要代码库上下文才能真正知道如何测试它。我认为在后台智能体系统的情况下，幸运的是你本地有那个代码库，你知道什么在变化，然后可以检查它并用它来驱动模型。

I think to Walden's point though, the computer use is kind of a subset of the larger testing problem. And I think that that's very specific to the codebase that you're working in. It's not something that out of the box you could just solve. You do need the codebase context to actually know how to test it. And I think in the case of a background agent system, you fortunately do have that codebase locally, you know what is changing, and could then inspect it and use that to drive the model.

是的。对于那些以前没见过的人，这是一个它如何工作的例子。PR 完成后，你点击测试通过，然后它会给你发回一个视频。我真正喜欢的是它标注了——这里很小，但它确实标注了它在测试什么。然后你实际上能看到光标和一切。

Yeah. For those who haven't seen it before, this is an example of how it works. After the PR is done, you click testing approved and then it sends you back a video. What I really like is that it labels—it's very small here, but it actually labels what it's testing. And then you actually see the cursor and everything.

所以我不知道，这其中的工程……你想展示什么就展示什么，因为这是那种“哦，感受 AGI 时刻”之一，对吧？因为一旦我看到这个，我实际上希望我能在 Slack 内部直接合并，而不是去 GitHub，因为我不需要看代码。我知道它有效。也许一个新功能要来了。

So I don't know, the engineering in this... whatever you want to show, because this is one of those 'oh feel the AGI moments', right? Because once I look at this, I actually wish I could just merge inside of Slack instead of going to GitHub, because I don't need to see the code. I know it works. Maybe a new feature coming.

是的。底部的注释对我来说也是一个很大的不同，当我添加它们的时候。

Yeah. The annotations at the bottom was also a big difference for me when I added those.

是的。就像，我在看什么？你到底想演示什么？

Yeah. It's just like, what am I looking at? What are you trying to demonstrate exactly?

有一个令人惊讶的长尾小细节，最终对“你实际合并代码的速度有多快”这类最终指标产生了很大影响。我们早期花了很多时间调整的一个体验是，这些工具在 GitHub 上的正确体验是什么。因为我认为大多数现有的工具，当你构建智能体时，你会想“哦，它会为你创建 PR。”我们试图更进一步，说“哦，如果我们真的确保你可以在 GitHub 上直接与 Devin 交互呢？”所以我们确保你可以在 GitHub 上评论，Devin 实际上会接收这些评论并回复。但这里实际上有很多调整要做，因为你可以想象，我们最近有 Devin 审查，例如。Devin 审查会在自己的 PR 上发布评论，然后 Devin 必须去回复自己的评论，这真的非常循环。所以，是的，我喜欢它在这里更新说我已经评论了，但通常只是我说“嘿，合并，解决任何合并冲突。”

There's a surprisingly long tail of small details that ends up making a big difference for this kind of end metric of how fast do you actually merge the code in. One experience that we spent a lot of time tuning early on was what is the right experience on GitHub for these tools. Because I think most tools out there, when you build the agent, you'll think about 'oh, it will create the PR for you.' We tried to take that a step further and say, 'oh, what if we actually made sure you could interact with Devin directly on GitHub.' And so we made sure that you could comment on GitHub and Devin would actually receive those comments and address them back. But there's actually quite a bit of tuning you have to do here, because you can imagine that we recently have Devin review, for example. Devin review will post comments on his own PR, and then Devin has to then go answer his own comments, which is really, really loopy. So like yeah, I like that it just updates here that I have commented, but usually it's just me saying 'hey merge, fix any merge conflicts.'

是的，当 Devin 修复自己的评论时，你可能会担心它会无限循环，但我们做了很多工作来确保不会发生这种情况，既确保评论是高信号的，又确保智能体在决定修复哪些评论时会深思熟虑，甚至会说“等等，我觉得你错了”。实际上，我最喜欢的时刻之一就是当我试图让 Devin 做不同的事情时，它告诉我我错了。

Yeah, so when Devin fixes its own comments, you might be scared that oh maybe I'll infinite loop, but we put a lot of work into making sure it doesn't, both by making sure that the comments are high signal but also that the agent is thoughtful about what comments it goes tries to fix and what comments it's like wait a second, I think you're wrong. Actually, that's one of my favorite moments is when Devin tells me that I'm wrong when I try to get it to do something different.

但调整这种行为实际上对 GitHub 体验的实用性有很大影响。

But tuning that behavior actually makes a big difference in terms of how useful the actual GitHub experience is.

是的。我想补充一点，将 AI 审查者集成到系统中是这个后台系统的关键部分。Open Inspect 确实有这一点。它有一个 GitHub 代码审查者，你可以控制提示词。它也能发表评论，但还不能自动执行。功能是有的，但还不完全……

Yeah. I think to touch on that as well, having the AI reviewer integrated into the system is a critical part of this background system. Open Inspect does have that. It has a GitHub code reviewer that you can control the prompt. It does do comments as well. It doesn't do them automatically yet. The capability is there but it's not fully...

所以你需要主动请求。

So you have to ask for it.

是的，你可以。你可以在 GitHub 上标记它，然后无论你给 GitHub 机器人起什么名字，它都会跟进。如果你有合并冲突或要求它解决的其他问题，它会解决，但还不能自动执行。

You do, yeah. You can tag it on GitHub and then whatever you named your GitHub bot, it will then follow up on it. It will then, if you have merge conflicts or whatever you have asked it to resolve, it will then resolve it, but it doesn't do it automatically yet.

嗯，我很好奇，当你帮助人们实施 Open Inspect 时，他们最终最常要求但 Open Inspect 尚未提供的是什么？

Well, I'm curious what is the most common thing that people end up requesting that they still need on top of Open Inspect when you help them go implement it.

我认为很多问题归结为实际将其集成到公司中。设置后台智能体系统是一回事，但如果它没有实际集成到你的更大生态系统中，它就没那么有用。我的意思是，能够启动会话是有用的，但我们真正想要的是将它连接到所有其他系统，无论是具有只读凭据的生产数据库、日志、Confluence 还是内部知识库系统。我认为这就是我看到公司巨大飞跃的地方，对于那些可能不熟悉具体方法的公司来说，这也是一个挑战。尤其是当他们处于合规性要求较高的环境中时，访问控制可能非常严格，如何有意识地思考这些问题，我发现这是这类系统带来的问题之一。

I think a lot of it comes down to actually integrating it into the company. It's one thing to have the background agent system set up, but if it isn't actually integrated into your larger ecosystem, it isn't that useful. I mean, it is useful to be able to kick off sessions, but what we really want to be able to do is hook it into all of our other systems, whether that is the production database with readonly credentials, the logs, a Confluence or internal knowledge base system. I think that is where I see the huge leap for companies and that can be a challenge for companies as well who are maybe not familiar with exactly how to approach it. Especially if they're in environments that have more compliance type things where access control can be pretty big and how do you deliberately think about these problems I find to be one of the problems that comes with a system like this.

是的，我们发现 MCP 显然已经大爆发，你可以将其与所有这些不同的东西集成。但要真正做好集成并获得正确的体验，我们经常发现必须自己构建临时方案。我认为 Slack 是一个很好的例子：你可以给智能体一个 Slack MCP，然后它可以在 Slack 上给你发消息。但我们实际上像同事一样在 Slack 中使用 Devin，这是从头开始构建的。但要做到这一点，你实际上需要支持返回的 Webhook，对吧？然后 Devin 必须以自然的方式回应，并且希望不会过多地刷屏你的线程，惹恼公司里的人。所以你必须恰到好处地调整这种体验。尤其是在有很多来回交互的情况下，我们发现实际上必须超越简单的 MCP 集成。

Yeah, the thing we've found is so like MCPs obviously has been like really big explosion of oh you can go like integrate it with all these different things. But to actually get the integration right and get the right experience, often times we found that we had to go build our own ad hoc things. I think Slack is a great example of this: you could give your agent Slack MCP and okay you can post message back to you on Slack. But we actually use Devin like a co-worker in Slack and that's how it's been built from the ground up. But to do that, you actually need to support web hooks that come back, right? And then Devin has to respond in a natural way and then hopefully don't spam your threads too much and annoy the people in your company. So you got to tune that experience just right. Especially when there's a lot of back and forth, we find that we actually had to go beyond the simple MCP integrations in these places.

我刚刚提到了 MCP 市场。我知道这工作量不小。我的意思是，最终的答案是否要由第一方控制所有顶级 MCP？

I just pulled out the MCP marketplace. I know this is a fair amount of work. I mean, is the answer to eventually take first party control of all the top MCPs?

我希望有一个世界，你可以拥有比 MCP 更具表现力的东西，它是双向的，不仅仅是一组工具，而是一个适当的系统，可以交互并让它在所有这些界面上获得正确的体验。

I would love a world where you could have something that's more expressive than MCP that kind of goes both ways, like not just a set of tools but a proper system that interacts back and lets it have the right experience with all these interfaces.

所以 MCP 规范中实际上有采样功能，但没人使用它。

So there actually is sampling in the MCP spec but nobody uses it.

对。所以我认为另一部分是：实际上我们发现当 MCP 规范开始变得过于复杂时，它就开始失去其最初承诺的简单一步式连接。现在我们不得不去弄清楚如何支持所有这些不同的变体，在很多情况下，这看起来就像是在构建它们的第一方集成。

Right. And so I think that's the other part: actually we found that when the MCP spec starts to get too complicated, it starts to lose its original promise of being like a simple one-step connect. Like now then we had to go figure out how to support all these different variations of things and it starts to look a lot like just building their first party integrations in a lot of these cases now.

是的。我认为这还取决于它对公司的关键程度，对吧？如果几乎每个会话都要用到它，那么拥有它以便在其上进行优化可能是有意义的。

Yeah. I think it matters too how critical it is to your company, right? If this is something that nearly every session is going through, it probably makes sense to own it so that you can make optimizations on top of it.

而不是仅仅使用现成的东西。

Versus just whatever is off the shelf.

是的。太棒了。其他 MCP 呢？还有什么？抱歉。好吧，我不知道这是否过于聚焦在集成上，但你们在构建 Open Inspect 或 Devin 时还深入研究了哪些其他元素？

Yeah. Awesome. Other MCPs, what else? Sorry. Well, I don't know if that's narrowing in too much on integrations, but what else like what other elements of building Open Inspect or Devin that you guys really sink on?

是的，我认为一个非常常见的问题是记忆或知识库的概念。

Yeah, I think a problem that comes up very frequently is this idea of memories or knowledge base.

哦，天哪。

Oh boy.

是的。你怎么解决它？

Yes. How do you solve it?

简短的回答是还没解决。有一个公开的 issue 在讨论它。有人在问。

Not solved yet as a short answer. It's something there's an open issue for it. Someone asking about it.

好吧，我 Dwiki 还没有索引任何关于记忆的内容。

Okay, there's I Dwiki hasn't indexed anything about memory yet.

我在客户那里看到的主要是通过技能来解决。我发现技能可以很好地填补这个空白，或者更新 CLAUDE.md。

How I'm seeing it solved across my clients is primarily through skills. I find that skills can be a good gap within that or updating CLAUDE.md.

但我认为记忆作为一个整体是一个相当未解决的问题，这也是我有点犹豫是否要添加它的原因。我认为记忆的某些部分是可以解决的。但总的来说，这是一个非常困难的检索问题。

But I think memory as a whole is a pretty unsolved problem and it is why I've been kind of hesitant to add it. I think there are parts of memory that can be addressed. But I think as a whole it's a very difficult retrieval problem.

哦，天哪，RAMP 没有写任何关于记忆的内容。我看到零搜索结果。不，记忆很难做好，因为不仅是检索，记忆的生成也可能非常棘手，比如你不想让它过于具体。

Oh my god, RAMP didn't write anything about memory. I see zero search results. No, memory can be quite tricky to get right because it's the retrieval but also the generation of the memories that can be really tricky, like you don't want it to just be very specific.

跟我们讲讲 Devin 的记忆发展历程吧，因为我知道这有一个过程。

Walk us through the Devin memory journey because I know there's been a journey.

第一个版本是记忆系统，我们称之为知识。其理念是希望它能随着时间的推移自动学习，而不需要用户主动教 Devin 东西。所以，任何时候你提醒 Devin，“等等，不，你不应该那样用 git”，我们实际上希望 Devin 说，“嘿，你想让我记住这个以备将来使用吗？”然后你只需快速批准或拒绝，它就会逐渐积累。因为我发现 Devin 大约 95% 的记忆都是通过这种自动生成的方式获得的，很少有人愿意坐下来写大文档，比如“你应该这样使用这项技术”等等。生成和检索是我们多年来一直在努力调整的方面。

The first version of memory that kind of stuck around for a while was a system we have called knowledge. And the idea was we wanted it to pick up things over time and not need the user to be proactive about teaching Devin things. So, okay, anytime you remind Devin, wait, no, that's not quite the way you're supposed to use git, like, we actually want Devin to say, hey, do you want me to actually just remember this for the future? and for you to just basically quickly approve or reject and for it to build up over time because I find that like 95% I think some crazy stuff like that of the memories that Devin has are all through these autogenerate things, like very few people actually just want to sit down and write big docs on okay here's how you're supposed to work with the technology etc. The generation and the retrieval has been something that we've been trying to tune a lot over the years.

生成时，你不希望它记住某件事，比如你只要求过一次“请以草稿 PR 形式打开”，你不想让所有人从此以后的所有 PR 都变成草稿 PR。但你确实希望有一些通用的行为。也许你想说“Cole 通常喜欢把东西创建成草稿 PR”。检索也一样。如果你有数千条这样的记忆，如何确保它们在正确的时间被检索到？这很难做好，而且不会用一堆无用的信息撑爆上下文。随着新模型不断更迭，要确保记忆系统保持可靠，需要做大量的评估工作。

Generation like you don't want it to remember something like if you asked one time to open a draft PR, you don't want everyone forever now to get their PRs as draft PRs. But you do want some kind of common behavior. Maybe you want to say like Cole generally likes things to be created as draft PRs. Same with retrieval. If you have thousands of these memories, how do you actually make sure they're retrieved at the right time? And that can be quite tricky to do right without exploding the context with a bunch of useless information. There's a surprising amount of eval work to just make sure that memories remain a reliable system as new models come and go.

是的。

关于记忆修剪和记忆的时间维度，你有什么可以分享的吗？

Do you have anything you could share around memory pruning and the temporal aspect of memory?

是的，没错。

目前，它能做的事情包括编辑记忆。

Today, the things it could do is it could edit memories.

我明白了。所以如果你的记忆曾经说“Cole 喜欢把所有东西都创建成草稿 PR”，那么你可以说“不，别那样做”。然后它会说“你想让我把记忆更新为 Cole 现在希望所有东西都创建成公开 PR 吗？”我认为与此同时，我们不知道这是否会是系统的最终版本。我们现有的东西很可能会迁移到我们将要构建的新系统中。但我认为两年前和今天的一个重大区别是，这些智能体非常擅长原生地使用任何类似文件系统的东西。所以我们一部分人在想，我们是否应该把记忆重建得更像一个文件系统，让智能体自己导航？这是一个有趣的探索。在技能领域也有一些想法。

I see. And so if your memory used to say, like, Cole likes to open everything as a draft PR, then you can imagine, no, don't do that. And then it'll say, do you want me to update the memory to be Cole will now want everything as open PRs? I think at the same time, we don't know if this is going to be the final version of the system. Whatever we have here will probably translate into the new system we'll be coming up with. But I think one big difference between two years ago and today is these agents are really good at using anything that resembles a file system natively. And so part of us is thinking, should we rebuild memories to feel more like a file system that we let the agent navigate on its own? That's been an interesting exploration. Also some ideas in the skill space.

我现在正在调出 OpenClaw 的记忆功能。OpenClaw 的记忆有这种每日记忆日志，对吧？你可以，我的意思是那是一个文件系统，你可以摸索着浏览，它是一个事实来源。我不知道它是不是最好的。它可能非常嘈杂，但至少如果你丢失了什么东西，你可以找到它，或者你可以对更古老的、不再被调用的记忆应用某种遗忘算法。我们一直在尝试突破在公司中使用智能体的边界，其中一件事是让智能体拥有一个非常类似的文件，比如 memory.mmd 之类的，然后让它成为你特定问题的永久项目经理。所以我们内部有一些 Slack 频道，可能有一个专门针对某个产品（比如 Deep Wiki）的 Slack 频道，你可以想象你想要一个永不停止的 Devin。它一直保持清醒，但它有这个记忆文档，可以为自己维护：我们必须修复和优先处理的首要任务是什么，谁负责即将到来的工作。也许它还会定期 @ 你。所以这是一个有趣的举措，看看我们如何让 Devin 不仅仅用于工程。我们能否向上游到工程流程之上？也许只是 Devin 创建工单，然后可能由人类处理，但也可能由其他 Devin 处理。

I'm pulling up OpenClaw's memory thing right now. So memory in OpenClaw has this daily memory journal thing, right? And you can, I mean that is a file system you can kind of grope through and it's a source of truth. I don't know if it's the best. It's probably super noisy, but at least if you lose something, you can discover it or you can apply some kind of forgetting algorithm to more ancient memories that don't get recalled again or something. One thing we've been trying to do to push the boundaries of how you use agents at your company is letting an agent basically have a very similar file like a memory.mmd or something and just kind of be your permanent PM for a specific set of issues maybe. So we have some Slack channels internally, maybe a Slack channel dedicated to a specific product like Deep Wiki, and you can imagine that you want a Devin that never stops. It's just always awake but it has this memory doc that it can just maintain for itself about what are the number one priorities of what we have to fix and prioritize, who is responsible for some upcoming work. Maybe they'll even tag you on some recurring basis. And so it's been an interesting move to see how we can actually use Devin for more than just engineering. Can we actually upstream above the engineering process? And maybe it's just Devin creating tickets, which then maybe some humans do, but then maybe other Devins do.

是的，我比较有趣的一个自动化是研究竞争对手，然后每周给我提建议。就是这个自动化。我现在找不到它了。但基本上，它只是查看竞争对手并提出建议，然后“这里有三个你建议过但我再也不想要的东西”，你就把它塞进提示里。但我其实希望，当我拒绝 PR 时，它能更新记忆，这样我就不用再回去更新定时同步了。不过，这是个功能请求。

Yeah, one of my more fun automations is go research competitors and just suggest stuff to me on a weekly basis. That's the automation. And I can't find it right now. But basically, it just looks at competitors and suggests things, and here are three things that you've suggested that I don't want any more of and you just kind of stick that in a prompt. But I wish actually, so when I reject the PR, I wish that it updated memory so that I can then not have to go back and update the scheduled sync. But feature request.

你知道，我们可能很快就会改变它。我想，OpenInspect，在你存在的这段时间里，有没有什么事情是你尝试实现但后来又不得不撤销并改用不同方式的？

You know, we might change it soon. I guess, OpenInspect, in the time you've been around, has there been anything you tried to implement which then you had to undo and do a different way?

还没有，但我一直在想一件事：我最初构建的方式是每个集成都作为独立的包存在，所以你有 Slackbot 来处理 webhook，然后基本上与控制平面交互。随着我看到系统开始更加集成，特别是与 GitHub bot 的集成，我正在考虑将所有东西都集中到中央控制平面，因为尤其是现在我想开始，而且我收到的一个请求是能够监控实际合并的拉取请求，以及跟踪我打开了什么？有多少被合并？出现了多少评论？只是为了了解系统的健康状况。对于 GitHub 应用来说，你只有一个 webhook。所以问题是我应该把这个 webhook 放在那个 GitHub bot 包里吗？那有点奇怪，放在那里不太合理，因为那个包更像是用于代码审查的，还是我应该集中管理？这是我正在考虑的一个决定。我认为我们之前提到的另一个问题是“工具链在沙箱内还是沙箱外”。我认为长期来看，架构最终会回到沙箱外。我添加的一些较新的工具会回调控制平面，这样秘密就不会留在沙箱里。所以我认为长期我可能会把实际的智能体从沙箱中移出来。但我认为目前这样没问题。

Nothing yet, but something that is on my mind: the initial way that I built it was that each of the integrations kind of lives as its own package, and so you have the Slackbot which is what's handling the webhooks and then is basically interacting with the control plane. As I'm seeing the system starting to be more integrated, specifically with the GitHub bot integration, I'm considering bringing that all into the central control plane because especially now I want to start, and a request that I'm getting is the ability to monitor the actual pull requests being merged as well as just kind of tracking of what do I have open? How many of these are getting merged? How many comments are showing up? To just kind of understand the health of the system. And so in the case of a GitHub app, you only have one webhook. And so then it's a question of do I put that webhook in that GitHub bot package? That's kind of weird. It doesn't really make sense to live there because that package is more for the code reviewer, or do I centralize it. So that's something that's on my mind of making that decision. I think the other one we touched on earlier is kind of the harness in the box versus out of the box. I think long-term the architecture will eventually come back out of the box. Some of the newer tools that I've added are calling back into the control plane so that you don't have the secrets in the sandbox. And so I think long-term I probably will pull the actual agent out of the box. But I think for now it's fine.

关于把智能体从沙箱中移出来，我有个小问题。今年我非常看好的一件事是智能体调用其他智能体，或者生成子智能体，随便你怎么叫。这会让事情变得更难还是更容易？我说不准。因为如果工具链在沙箱里，你可以启动更多的沙箱。

Just a quick question on pulling the agent out of the box. One thing I'm very bullish on this year is agents calling other agents or spawning sub agents or whatever you want to call it. Does that make it harder or easier? I can't tell. Because if the harness is in the box, you can spin up more boxes.

是的。如果工具链在沙箱外，那就不那么容易了，因为你有一个像独角兽宠物一样的工具链生活在沙箱外。我的意思是，理论上是一样的，对吧？无论一个智能体是否在其中启动了多个子会话，例如 OpenInspect 可以启动子会话并实际创建其他环境，然后监控它们。如果是在沙箱外，那基本上就是一个额外的会话在运行。所以那个会话也在沙箱外运行。它在你运行它的工作平面上运行。然后你只需要考虑你的顶层智能体如何与它交互。

Yes. If the harness is outside the box, then it's less easy because you have a unicorn pet of a harness that's living outside the box. I mean, in theory it would be the same way, right? Whether one agent has launched many sub-sessions within it, OpenInspect for example can launch sub-sessions and actually create other environments and then monitor them. In the case where it is out of the box, that would basically just be an additional session that's running. And so that session is also running outside of the box. It's running in your worker plane wherever you're running this. And then you really just have to think about how your top-level agent then interacts with it.

我确实认为它会更复杂，因为现在架构更困难了，但我觉得一旦搞定了，可能就没问题了。

I do think it can be more complex just because again you have now a more difficult architecture, but I think if you figured it out once, it's probably fine.

Walden，我想跟你聊聊我称之为“元 Devon 管理”的东西——比如 Devon 调用其他 Devon、Devon 调度其他 Devon、查询轨迹之类的。你们构建了什么，或者有什么没发布的东西吗？

Walden, I'm just throwing it open to you in terms of like I call this kind of meta Devon management. Which is like the Devon calling Devons or Devon scheduling Devons or querying trajectories or anything like that. What have you built or unshipped anything?

我觉得我们观察到的一个令人惊讶的点是，这些独立智能体相互协作、并行工作的大部分方式，仍然遵循着相同的“管理者-子智能体”模式。很多人对那种智能体群聊、彼此随意交流的世界感到兴奋。我们确实给了 Devon 一个 MCP，这样它就可以随意给其他 Devon 发消息、创建新的 Devon 等等。但我觉得这在某种程度上创造了一个非常混乱的世界，所以我们发现日常最实用的方式仍然是一个单一引擎来分解工作，让其他开发者以相对隔离的方式处理，每个都有自己的独立环境，不共享机器。所以今天必须营造一种几乎没有冲突空间的模式。

I think one of the surprising things we've seen is that a lot of the ways that these separate agents work with each other and you want them to parallelize their work has still mostly followed the same manager sub-agents regime. A lot of people I think are excited about this world where you have swarms of agents that kind of talk with each other all over the place. We've actually given Devon an MCP so they can just go arbitrarily message other Devons and create new Devons etc. But I guess it somehow creates a really chaotic world in that sense, and so we've still found that most practical use on a day-to-day basis has been one single engine figure out how to segregate the work and have other devs work on it in a relatively isolated sense, each with their own boxes, not sharing machines. So there's very little room for conflict is kind of the regime that you have to create today.

我想提一下 Cursor 的实验，对吧？这是 Wilson Lynn 关于从单智能体到多智能体的工作，你显然以反对构建多智能体而闻名，但他们经历了整个过程，最终得出的结论正是 Devon 的做法。你觉得……

I'll call out the experiments from Cursor, right? This is Wilson Lynn's work on single agent to multi-agent, and you're obviously famously on the side of don't build multi-agent, but they went through the whole thing only to arrive at this which is exactly what Devon has. Do you think...

我觉得那篇文章迟早会有一个修订版。一年前多智能体几乎完全不可能。现在确实看到更多多智能体实验，但你可以争论它们到底是真正的多智能体，还是只是工具调用？有些人会创建子智能体去查找某个文件或实现，这有很好的上下文管理优势，因为所有工具调用和消耗的 token 最终都压缩成主智能体的一个答案。这样做有很多好处。我们基本上让 Devon 用 DeepSeek 做这件事：调用 DeepSeek，返回结果。但这感觉像工具调用，而不是两个协作者真正来回交流。但让我对多智能体可能实现最乐观的是我之前说的：Devon 有时会告诉我我错了并反驳。我认为这展示了当今的成熟度和沟通能力，使多智能体世界成为可能。比如，两个看到不同信息的智能体何时能互相交流，弄清楚谁是对的、正确的实现是什么？它们不再是唯唯诺诺的应声虫。Claude 以前只会说“你是对的”或“你完全正确”。

I think there will be a revision to that post at some point about tell... I think multi-agents were very much not at all possible a year ago. You do see more multi-agent experiments today, but you can kind of argue are they really multi-agents or are they just kind of like tool calls? There are people who will create sub-agents to go look for XYZ file, XYZ implementation has really nice context management benefits because all of the tool calls and tokens that it spends then get collapsed back to just the answer for the main agent. There's a lot of benefits to doing this. We basically have Devon do this with DeepSeek: make a call out to DeepSeek, give you back the results. But that feels like a tool call. It's not like these two collaborators actually talking back and forth with each other. But I think the thing that gives me the most bullishness that multi-agents might actually be possible is actually what I said earlier about Devon will actually sometimes tell me I'm wrong and push back. And I think that demonstrates a level of maturity and communication today that makes a multi-agent world possible. Like when can two agents who have seen different information come back to each other and actually figure out who is right, what is the correct implementation? They're not just yes-men. Claude I guess it's like used to just say, you know, 'you're right' or 'you're absolutely right'.

你说得完全对。嗯。你看到 App Store 里那个关于“topic”的恶搞了吗？就是 Codex 应用。设置里有个小彩蛋。如果你点进去，主题或外观那里，有各种颜色代码，最上面写着“absolutely”，而且用的是 topic 的颜色，真是个恶搞。

You're absolutely right. Yeah. Have you seen the App Store troll in topic? This is the Codex app. Inside of settings there's a little Easter egg. If you go there, their themes or appearance, right? There's all these color codes and the top is 'absolutely' and it's in topic's colors which is such a troll.

我喜欢那个彩蛋。你自己发现的吗？

I love that Easter egg. Did you discover that yourself?

不是，有人在推特上发了，我就想这是真的吗？因为有时候人们发推只是为了逗你玩。但嗯，就是这样。还有颜色。

No, it's like someone was tweeting about it and I was like, is this true? Because sometimes people just tweet stuff to get a rise out of you. But yeah, there you go. And colors.

嗯。但我们已经走出了那种只会说“你完全正确”的模式，它们可以进行真正的对话和来回交流。

Yeah. But yeah, we're out of this regime where it just says 'you're absolutely right' and they can have real conversations and real back and forths.

对，你也可以提示它更具对抗性之类的。嗯，好的。对我来说，那才是更智能的表现，对吧？那不仅仅是一个愚蠢的工具，它实际上在反驳你。

Yeah, you can prompt it as well to be more adversarial or whatever. Yeah. Okay. To me, that is more intelligence, right? That is not just something that's like a dumb tool. It's actually pushing back on you.

嗯。你提到那篇博客文章，有一篇他们让一群智能体协作构建了一个浏览器。

Yeah. One you mentioned that question blog posts, there was one blog they had where they fed a swarm of agents together and built a browser.

对，我觉得就是同一篇。嗯。

Yeah, that was I think the same one. Yeah.

我们发现了一个令人惊讶的成功经验：不要搞什么群组。只要一个 Devon，它自己管理上下文。让它持续运行一段时间，给它一些疯狂的任务。我记得我们让它重建一个 Windows 操作系统。

We found a surprising success of like don't do a swarm or anything. Just have one Devon, it does its own context convention. Just let it keep running for a while and give it some crazy tasks. I think we asked it to like rebuild a Windows OS system.

是的。

Yes.

它竟然做到了，只要运行足够长时间。

And it managed to do it just like going on for long enough.

这是 Andrew 做的吗？

Was this Andrew's thing?

对，对。好的。

Yeah. Yeah. Okay.

我们有很多演示最终没有发布，因为到某个时候我们会发布太多演示了。但我喜欢这一点，因为它表明多智能体仍然有一些令人兴奋的魅力，也许它带来的实际能力提升还不大，但它绝对是未来。我认为我们正朝着那个方向前进，而且已经能看到进展了。

There were lots of demos that we ended up not posting because at some point we'd just be posting way too many demos. But I love that because it kind of shows that I think the multi-agent thing still has a bit of exciting sexiness to it which is maybe still beyond the actual delta it adds to the capabilities of these systems, but it's absolutely the future. I think we're heading that direction and we can see the progress being made there already.

嗯。如果我要稍微反驳一下——因为我自己还不太确定——我请过 OpenEye 的 Ryan Lopo 上播客，他是个超级“乱射炮”，对吧？哦天哪，我的编码智能体完成了。我下载了一个叫 Pon Ping 的东西，不知道你们听说过没有。它从《命令与征服》和《魔兽争霸》等热门游戏中提取音效包，然后在任务完成时播放。比如“干活干活”或“听候差遣”之类的。总之，我从 Cursor 代码库和 Ryan 那里了解到一种“乱射炮”方法，试图放松单智能体的瓶颈，我觉得这可能是需要解决的一个非常重要的问题。我不认为有人真正解决了它，因为那样你只是在智能体之上又加了一层审查者来管理一切。Ryan 可能会强烈反对我说他还没解决，他认为自己已经完全解决了。

Yeah. If I were to make one super minor push back because I don't feel that confident about it yet, but I've had Ryan Lopo from OpenEye on the pod and he's a super slop cannon, right? Oh my god, that's my coding agent being done. I downloaded this like Pon Ping. I don't know if you guys have heard this. It takes sound packs from popular games like Command and Conquer and Warcraft and then it plays it whenever it's done. So it's like 'work work' or whatever 'at your commands' or something. Anyway, what I got from the Cursor codebase and from Ryan's thing was that there's a slop cannon approach where you try to loosen the single agents' bottleneck and I feel like that is probably a very important thing to try to figure out. I don't think anyone's really solved it because then you just have more reviewer stop on top of the agent stop to try to wrangle it all. Ryan will probably strongly object that I say that he hasn't solved it. He thinks he's completely solved it.

但我认为这仍然非常重要，因为那是一个瓶颈，对吧？我觉得 Devin 有时很慢，因为我在想，嗯，这确实非常可读且合理，但它本可以更快，如果我想要一个按钮，只需将并行度提高 100 倍，然后看看会发生什么。我不知道这在未来某个时候是否可行。

But I think it's still very important because that is a bottleneck, right? I feel Devin is slow sometimes because I think, well, yeah, this is very readable and very sensible, but also it is slower than it could be if I just want a button to ramp this up 100x in parallel and just see what happens. I don't know if that's feasible at some point in the future.

是的。我们内部也做过实验，基本上尝试构建完整的产品，就像我们知道自己最终会发布的正规产品，但暂时先看看能不能完全靠“氛围编码”互相叠加、自动合并、完全不进行代码审查。有一个基准测试：你能坚持多少周，然后才会说我们必须扔掉这个代码库，从头重写。

Yeah. We've also run experiments internally where we basically tried to build entire products, like true products that we knew we would eventually ship, but for now let's try to see if we can do it just by purely vibe coding on top of each other, auto-merge, no code review at all. There's this kind of benchmark of how many weeks can you go on this before you say we have to trash this codebase and rewrite it from scratch.

嗯，你们发现了什么？

Yeah, what did you find?

我们发现去年 12 月的技术水平是，你大概可以这样运行两周。到那两周结束时，你会发现，嘿，你想改一个按钮的颜色。结果这个按钮在 10 个不同的地方实现，各有各的变体，哦，你漏了一个，实际上那个地方的颜色还略有不同。好吧，这太难搞了。我们还是同时做代码审查，确保掌控全局。我们实际上会稍微清理一下，确保以可扩展的方式完成。

I think we found that the state-of-the-art in December was you could probably run this for about two weeks. By the end of those two weeks, you'd find that, hey, you want to change the color of a button. Well, turns out this button is implemented in 10 different places with all these different variations, and oh, you forgot one of them and actually it's a slightly different color in one spot. Okay, this is too much to work with. Let's actually try to do code review at the same time and make sure that we're on top of our stuff. We're actually cleaning it up a bit and making sure it's done in a scalable way.

是的，基于此，我认为“你不需要看代码”这个想法通常是个坏主意。我的梗是：你觉得这个说法会成真吗？

Yeah, I think building on that, the idea of you don't have to look at code is generally a bad idea. The meme that I have is: do you think that statement will be true?

我认为可能在一段时间内，你仍然应该继续看你的代码。我看到很多拥抱 AI 原生、AI 优先编码的团队遇到的一个问题是：你的代码库会退化到你最差的那个工程师的水平。因为那个对 AI 非常热衷、不审查自己代码的工程师，他们的模式开始固化到代码中，然后 AI 开始引用他们的模式。所以现在他们那个有 20 个 if-else 来回嵌套的代码块，AI 认为这就是做事的方式，并开始指数级地增长这种垃圾代码。我发现一个很好的方法是定期清理，无论是通过人工还是通过寻找重复的系统。然后他们处理这些问题。你最终会有 12 个格式化日期的辅助函数，你需要处理这个问题，否则它会继续在边界内蔓延。我认为有一些重复是可以的，然后有时做垃圾回收，对吧？我和很多工程负责人讨论的是，你要对模块之间的边界非常严格。作为架构师、CTO，你的工作就是说，好的，这是你们和你们之间的硬性契约。你们在这个黑盒内部做什么是你们的事，你们随便，但是在这两组之间，我们要非常清楚，任何变动都必须由人类或我来签字。就这样。我不知道你是否有其他修改或建议。

I think probably for a while it'll be true that you should continue to look at your code. A problem that I see a lot of teams run into who are embracing AI-native, AI-first coding is the meme that I have: your codebase regresses to your worst engineer. Because that engineer who is very gung-ho about AI and is not auditing their code, their pattern starts cementing into the code, and now the AI is referencing their patterns. So now their if-else block that is 20 if-elses back and forth, the AI is seeing that as the pattern of how things are done and starts to exponentially grow this slop. I find a pretty good approach to that is having scheduled cleanup, whether by humans or through systems that are looking for duplication. Then they address that. You'll end up with 12 helpers for how to format a date, and you need to address that because otherwise it will continue to sprawl within bounds. I think it's fine to have some duplication and then sometimes have garbage collection, right? What I've been talking about with a lot of engineering leaders is that you want to be very strict about the boundaries between modules. It's your job as an architect, as a CTO, to say, okay, here's the hard contract between you guys and you guys. Whatever you do inside this black box is your business, you do whatever, but between these guys, let's be really damn clear and any movement must be signed off by a human or by me. Then that's that. I don't know if you have any other modifications or advice.

嗯，关于人类在哪些方面有用这个话题，我发现一些非常深层的基建问题，有时只要有一个真正有深厚专业知识的人就能带来很大不同。我实际上在构建智能体时看到过这一点。我们有几位朋友尝试构建自己的编码智能体，我反复听到他们遇到的一个问题是，哦，你知道，grep 在他们的智能体机器上非常慢。所以很多人，我猜是因为他们使用 AI，而他们自己并没有非常深厚的基建背景知识，就说好的，我们要去构建自己的自定义 grep 索引，它会非常快，并用这个来绕过这个问题。当我们大约一年半前在构建 Devin 的早期遇到这个问题时，我们显然没有 AI 可以问怎么做。你可以直接查一个新的 grep 索引。所以你说你手写了 Devin？什么？

Well, generally on the topic of where humans can be useful, I found that some of these really deep infra problems, sometimes just having a human with really deep expertise can make a big difference. I've actually seen this come into play when building agents. We've had a few friends now try building their own coding agents, and one recurring problem I heard a lot of them run into was this problem of, oh, you know, grep is really slow on our agents' machines. So a lot of them, I assume because they're using AI and they themselves don't have super deep infra background knowledge, say okay, we're going to go build our own custom grep index, it's going to be really fast, and use that as a way around this problem. When we ran into this problem about a year and a half ago in the early days of building Devin, we obviously didn't have AI that we just asked how to do this. You could just look up a new grep index. So what do you mean you hand-coded Devin? What?

是的。你能相信我们手写了这些代码吗？我们的基建人员非常出色。他们调查后说：“哦，你知道吗？我们意识到这个问题的根本原因其实非常简单，但是一个细粒度细节：很多这些虚拟机底层并不使用真正的文件系统。它们使用网络文件系统，东西实际上是通过网络缓存的，实际上在 S3 里。所以当你 grep 时，你实际上是在做网络调用。每次你做这些事情，这就是为什么 grep 在这些机器上极其缓慢。”所以这又回到了我们为了让这些机器正常工作而必须做的所有疯狂基建工作。如果你自己尝试做，会有无数这样的小细节，所以我们最终不得不换掉那个网络文件系统。

Yeah. Can you believe we hand-wrote this code? We had our infra people who are really amazing. They were looking into it and they're like, "Oh, you know what? We realized that actually the root cause of this problem is super simple but a fine-grained detail, which is that a lot of these virtual machines underlying them don't use real file systems. They use network file systems where things are actually cached over the network, actually in S3. So when you're grepping, you're actually making network calls. Every time you're doing these things, and that's why grep is extremely slow on these machines." So again, it goes back to all the crazy infra work we had to do to actually get these machines working. If you try to do this yourself, there are tons of small details like this, and so we had to eventually go swap out that network file system.

是的，我觉得有篇相关的文章，对吧？我列了一篇关于虚拟……

Yeah, I think there's a write-up about it, right? I listed one about the virtual...

那是另一回事。块差异文件存储格式，这是我们构建的一种文件系统格式，以便虚拟机可以非常快速地启动和关闭。基本上，背后的直觉是：想象你有一个 1 TB 的磁盘，你的智能体只在该磁盘上写了 100 行代码。保存并重新加载该磁盘需要多长时间？大多数系统，因为你没有针对这种情况优化，工作量就是 1 TB 的量级，因为你必须保存所有内容并重新加载。在我们的系统中，我们尝试构建一个增量叠加的文件系统。所以每次你保存并重新启动机器时，你只做与文件系统差异成正比的工作。这大大缩短了 Devin 的启动时间。我认为这实际上现在已经过时了；我们在 Devin 内部有一个更新的系统。但是，是的，这里有很多微小的细节你必须做对，才能让 Devin 的日常体验变得良好。

That was a whole other thing. The block diff file storage format, which is a file system format that we built so that the VMs could be spun up and down very quickly. Basically, the intuition behind this is: imagine you have a terabyte of disk and your agent only wrote like 100 lines of code on top of that disk. How long does it take to save and bring back up that disk? Most systems, because you're not optimizing for this case, it's just on the order of a terabyte of work because you have to save all of that and bring it back up. In our system, we tried to build a file system that incrementally builds on top of each other. So every time you save and bring the machine back up, you're only doing work proportional to effectively the diff in the file system. This shaves off a lot of time in the boot-up process of Devin. I think this is actually now outdated; we have a newer system inside of Devin. But yeah, there's a lot of tiny details you have to get right here to actually get the day-to-day experience of Devin to be good.

这从技术上讲不是智能体，但它是智能体基础设施。当你作为一家公司销售智能体时，你销售的是智能体加上智能体基础设施。

It's like not technically agents, but it is agent infra. And when you sell an agent as a company, you sell agent plus agent infra.

至少我们是这样做的。另一个好处是，由于智能体和基础设施是一起完成的，我们可以将 Devin 部署到任何我们想要的环境中。我们不需要等待底层基础设施提供商也支持 VPC、本地部署或联邦政府云等。所以我们可以实际去弄清楚如何为你设置好这一切。

At least the way we do it. And the other nice thing about having the agent and the infrastructure done together is that we get to deploy Devin in whatever environment we want. We don't need to wait for some underlying infrastructure provider to also support VPC, on-prem, or FedGovCloud, for instance. So we can actually figure out how to get that set up for you.

是的。你们的 Cloudflare 依赖在哪里？

Yeah. Where's your Cloudflare dependency?

Cloudflare 运行控制平面。沙箱由 Modal 支持。一位贡献者刚刚添加了 Daytona。E2B 在路线图上，并且有一个抽象层，这样任何贡献者如果想添加新的提供商，都可以添加进来。

Cloudflare runs the control plane. The sandbox is Modal-supported. A contributor just added Daytona. E2B is on the roadmap, and there's an abstraction in place so that if any contributor wants to add a new provider, they can add it.

是的。太棒了。

Yeah. Amazing.

你们合作的客户通常怎么处理？他们是尝试与另一个第三方提供商签订合同，还是尝试内部做虚拟机？

How do the customers you work with generally handle this? Do they try to set up a contract with another third-party provider, or do they try to do the VMs in-house?

我看到大多数客户都在用 Modal。我认为 Modal 提供了很好的服务。它涵盖了所有你需要的沙箱组件，快照是其中很重要的一部分。而且他们还提供 GPU，所以我认为整体上这是一个非常好的选择。

Most of them I see using Modal. I think Modal has a great offering. It captures all the sandbox pieces you need, snapshots being a pretty big piece of that. And given that they also offer GPUs, I think it's a pretty nice offering as a whole.

是的，这没什么好争论的。Modal 很棒，尤其是他们的容器产品是最自然的。所以如果你愿意放弃完整的虚拟机需求，Modal 是一个可以快速启动东西的地方。

Yeah, no debate there. Modal is great, especially their container offering is the most natural. So especially if you are willing to forgo the full VM requirements, Modal is a really fast place to spin something up.

有没有一个点……Modal 非常 Python 化，我觉得大多数工作负载已经转向了 JavaScript。我不知道你们是否有同样的感觉。当我开始做 LangSpace 和 AIE 这些事情时，我是 Python 和 JS 各占一半。我认为现在不是这样了。我认为 JS 赢了。也许我夸大了，也许对于 Cognition 来说还有 C# 和 Java 之类的，但对于新的绿地应用，你们有这种感觉吗？这重要吗？

Is there a point where... Modal is very Python, and I feel like most workloads have really shifted to JavaScript. I don't know if you guys get the same feeling. When I started with LangSpace and AIE and all these things, I was 50/50 Python and JS. I think that's wrong now. I think JS has won. Maybe I'm overstating it, and maybe for Cognition there's C# and Java and what have you, but for new greenfield apps, do you feel that? Does it matter?

我认为我看到这个领域的大多数库首先是 Python 原生的，尤其是在可观测性领域。

I think most of the libraries I see in the space are Python-native first, especially in the observability space.

话虽如此，我认为将整个系统放在一种语言中有很大的吸引力，尤其是当你的前端和后端通信时，你可以有一个统一的类型系统，这非常好。

That said, I think there is a pretty big appeal to having your entire system in one language, especially when you have both your front end and back end communicating, you can have one central type, which is very nice.

是的，这就是我反对 Modal 的理由，因为那样你就必须运行……

Yeah, that's my case against Modal, because then you have to run...

我的意思是，你可以在 Modal 内部运行 JS，这只是多了一步，不是运行时的原生操作。我不知道……你有数据吗？我不知道。

I mean, you can run JS inside Modal, it's just one extra step that isn't native to the runtime. I don't know if... Do you have numbers? I don't know.

我不喜欢 Python 的一点是，每当 AI 写代码时，它总是用 Python，而且总是用最奇怪的模式。

The one thing I don't like about Python is whenever AI writes code, it's always Python, and it always does the weirdest patterns.

是因为它混合了 Python 2 和 3 吗？

Because it's mixing 2 and 3 or what?

是的，我认为是混合了 2 和 3 的问题。它总是试图对对象使用 has attribute。但你不应该那样做。如果……它应该报错。

Yeah, I think it's something mixing 2 and 3. It always tries to do has attribute on objects. But you shouldn't be doing that. It should error if...

因为它是在库代码上训练的。我认为这更像是一种奖励黑客机制，它不希望代码失败，所以即使它知道有这个属性，它也会调用 getattr。对于我很多转向更自主编码的客户，我们已经将其作为 lint 规则：如果你使用 getattr，你的拉取请求就会失败。

Because it's training on library code. I think it's more of a reward hacking mechanism where it doesn't want the code to fail, so even when it knows it has the attribute, it'll call getattr on it. For a lot of my clients who have moved towards more autonomous coding, we've put that in as a lint rule: if you do getattr, your pull request is going to fail.

哦，这是个有趣的话题。你能多讲讲吗？还有哪些 AI 编码行为需要你设置防护措施？

Oh, this is a fun topic. Can you tell me more? What else is AI coding that you have to put guards in?

我们刚才在聊 Opus 4.7。这个新模型喜欢做的一件事是写很多注释。不是每行都注释，而是在每个函数顶部写段落式的 PRD。但我要说，值得肯定的是，这些不是以前那种垃圾描述。它像是‘这里是实际的推理过程，为什么我们选择这种方法，有哪些替代方案，以及为什么我们不应该采用那些替代方案。’信息还是太多了。但我想知道，如果你想要系统能够长期自我维护，这可能在方向上是正确的。

We were talking just before this about Opus 4.7. One of the things this new model likes to do is write lots of comments. Not like it'll comment on every line, but it'll write paragraph-like PRDs on top of every function. But I will say to its credit, these aren't slop descriptions like they were before. It's like, 'Here's actually the reasoning and why we chose this approach and what the alternatives were and why we shouldn't do those alternatives.' Still too much information. But I wonder if this actually might be directionally correct if you want systems that can self-maintain themselves in the long run.

它们还把规格说明写在代码的上下文中。

They write their specs in-line context in the code as well.

所以你认可……但与此同时，这是个棘手的问题。也许我们只给用户一个设置，让他们选择多详细。我不太喜欢这样。我喜欢注释，但请去掉它。

So you approve... but at the same time it's a tricky problem. Maybe we'll just give our users a setting for how verbose you want it to be. I haven't loved it. I like the comment, but please get rid of it.

是的。但我能想象一个世界，也许类似的东西会成为现实。我不知道你们是否了解 Git AI。

Yeah. But I could see a world where maybe something of the sort becomes reality. I don't know if you guys know about Git AI.

知道。

Yes.

我们讨论过。Git AI 背后的想法是，如果你运行一个智能体，你发送给智能体的实际提示应该与代码一起存储在 git 元数据中，这样未来的智能体可以引用它，也许代码审查机器人可以引用它。这是一个理想的世界，你的决策背景信息始终与代码共存。所以这就像是这种‘为每个注释写大量 PRD’方法的更隐蔽版本。

We've talked about it. Git AI, the idea behind it is that if you run an agent, the actual prompts you send to the agent should be stored alongside the code inside the git metadata, so that future agents can reference it, maybe code review bots can reference it. It's an ideal world where your context for why decisions are made constantly lives alongside your code. So it's like a more hidden version of this 'write massive PRDs for every comment' approach.

是的，我在等待真正的牛市案例，我们完全摆脱 git。我还没到那一步，但我在寻找，因为那将是一个巨大的转变。

Yeah, I'm waiting for the real bull case where we just get rid of git altogether. I'm not there yet, but I'm looking for it, because that would be a big shift.

关于可见的垃圾代码，我在 GPT 模型中经常看到的一个模式是不惜一切代价保持向后兼容性，它做这些奇怪的导入导出，这样就不必修改模块所在位置的名称。我看到 Claude 4.6 也开始这样做了。

Kind of on the topic of visible slop, a pattern that I see a lot across GPT models specifically is backwards compatibility at all costs, where it's doing these weird import exports so that it doesn't have to modify the names of where the modules were. And I've seen Claude 4.6 starting to do this as well.

哦不。

Oh no.

再说一次，我认为这是奖励黑客行为，它不希望失败发生。你可以通过 Semgrep 或其他工具来解决，这种行为很容易识别。但这是你只有在看到代码模式时才能学到的东西。无类型元组是一个很大的问题，只是再次把 any 扔进去。同样，你可以通过 linting 来解决。

And again, I think it's this reward hacking behavior where it doesn't want failure to occur. You can address that through Semgrep or other tools where that behavior is pretty easy to identify. But it's something you only learn through the trade of just seeing code patterns. Untyped tuples are a really big problem, just again throwing any in there. And again, you can address those through linting.

太棒了。还有其他像 linting 这样的工具吗？Devin 审查，当然，现在不那么免费了，但还在用。

Awesome. Any other tools like linting? Devin review, of course, not so free now, but still use it.

所以我认为我们试图向团队推荐的一件事，随着他们使用更多 AI 智能体，又回到了本地测试这件事上。

So one thing that I think we try to recommend teams as they use more AI agents goes back to this local testing thing.

归根结底，你希望你的智能体能够完成全部工作，不只是写代码，还要实际运行和测试它。很多代码库从一开始就不是为此构建的。例如，你可能确实需要一个本地数据库、一个本地 Docker Compose 和 Postgres，这样你就不必给智能体任何疯狂的产品凭据来实际运行和测试它的代码。我们内部也做了一个大转变，让很多核心代码组件可以纯粹作为本地开发来测试，而不需要实际集成任何实时服务。显然，公司越老，你需要做的改变就越多，但你可以用 AI 来帮你完成这次迁移。

In the end of the day, you want your agent to be able to do the full thing, not just write the code, but actually run it and test it. And a lot of code bases were not necessarily built for this from the start. For example, you probably do want a local DB setup, a local docker compose and Postgres in order to have it so that you don't need to give your agent any crazy product credentials to actually run and test its code. We've also internally done a big shift to make a lot of our core components of code testable as purely local dev without needing to actually integrate with any live services for this reason. And obviously the older the company, the more you have to change to shift in this direction, but you know you can use AI to help you perform this migration.

公司越老，为了做本地开发你需要改变的就越多。所以，你是说大多数人只是构建了与其他东西的完全集成，而没有切换到本地的代码路径？

The older the company, the more you have to change in order to do local dev. So, you're saying most people just build with full integration to other stuff and there's no code path to switch it to local?

尤其是当有很多不同的服务，并且你采用微服务架构时，进行这种转变，代码库越大就越难。我想如果你从一开始就正确构建，那是可能的，但世界上很多公司是在 Docker 出现之前成立的，所以是的，你在某个时候被迫进行迁移。

Especially when there's lots of different services and you have microservice architecture, making that shift, the larger the codebase, the harder it is. I guess if you did build it correctly from the very start, it's possible, but also a lot of companies in the world got started before Docker was a thing, so yeah, you're kind of forced to make a migration at some point.

嗯，Devon 非常擅长制作模拟服务器。

Well, Devon is very good at making mock servers.

是的。对。所以，我真正想要的一个项目就像 Little Snitch。我不知道你们有没有听说过它。我在我的电脑上运行 Little Snitch。它就像一个中间人，但它会显示所有来回的流量。然后从那里，你可以某种程度上重建服务器，对吧？然后创建本地模拟，所以如果你观察流量一小会儿，你就可以本地模拟一切。

Yes. Right. So, one of the projects I really wanted is like Little Snitch. I don't know if you guys have heard of it. I run Little Snitch on my computer. It's like a man-in-the-middle, but it shows you all the traffic going back and forth. But then from there, you can sort of reconstruct the server, right? And then create local mocks, so you can local mock everything if you just observe traffic for a little bit.

是的，这是个有趣的想法。

Yeah, that's an interesting idea.

酷。我不知道这会不会有结果，但我想也许可以谈谈 Claude Code 泄露的事，因为通常如果有 Anthropic 的人在场，我不能谈 Claude Code 泄露。你们从 Claude Code 中学到了什么吗？

Cool. I don't know if this will get anywhere, but I wanted to maybe talk a little bit about the Claude Code leak, because usually if I have an Anthropic person on, I can't talk about the Claude Code leak. Did you guys learn anything from Claude Code?

我们团队对那次泄露不是那么感兴趣。我们没有花太多时间在上面。

Our team was not that interested in that leak. We didn't spend that much time on it.

我只是在试探……

I'm just fishing for...

不，我真的没有深入研究它。

No, I didn't really research too much into it.

有道理。好的，在结束之前还有最后一件事。Windsurf 2.0，你们又发布了一个东西。所以，这种元背景是，你足够多地使用后台智能体，有时你会想把它们带到前台，而从本地到云端的那个小交接很难处理。然后 Devon 或 Cognition 刚刚做到了。

Fair enough. Okay, one more last thing before we go. Windsurf 2.0, you guys shipped another thing. So, the sort of meta context is you use background agents enough, sometimes you're going to want to bring them to foreground, and that little handoff from local to cloud is hard to work on. And then Devon or Cognition has just done it.

是的，我认为对我来说，这试图解决的最大差距是如何让测试过程尽可能快。当它可以自己测试并给你发视频时，那真是神奇。有时有些非常困难的事情你确实需要拉到本地来测试。你知道，我们只是希望 Windsurf 成为你所有智能体的本地指挥中心，比如你的后台智能体、你的本地智能体。你可以想象，“哦，好吧，这个智能体需要我审查一些东西。我把它拉下来，把我的其他智能体移到后台，去测试它。好的，砰，完成。继续下一个。”对吧？你有一些问题需要在后台修复，只需点击批准。好的，启动一个后台智能体去修复它。我喜欢一个世界，在那里我不得不离开这个窗口，然后也许另一个窗口我得想办法减少花在 Slack 上的时间，但也许，你知道，有一天我们也会想搞定那两个。

Yeah, I think for me the biggest gap this is trying to close is again how do you make the testing process as fast as possible? When it can test on its own and send you a video, it's freaking magical. Sometimes there are just really difficult things that you do just need to pull down locally to test. And you know, we just want Windsurf to just kind of be your local command center of all your agents, like your background ones, your local ones. And you can imagine, 'Oh, okay, this agent needs me to review something. I'll pull that down, move my other agents to the background, go test it. Okay, boom, done. On to the next one.' Right? You have some issue you got to fix in the background, just click like approve. Okay, sort of start a background agent to go fix it. I'd love a world where I'd have to leave this window, you know, then maybe the other window I got to figure out how to stop spending so much time in Slack, but maybe, you know, someday we'll want to get those two as well.

是的。那需要本地和云端的二进制文件完全相同吗？

Yeah. And does that require the binaries to be exactly the same for local versus cloud?

这里有趣的是，本地智能体和云端智能体之间的行为，我认为在理想状态下实际上有点不同。我认为本地智能体，你希望它们更快一些，让用户对事情做决定。实际上，不要尝试自主去测试东西。在后台智能体模式下，你启动它，我认为智能体应该假设我发送给用户的下一条消息应该包含用户需要的一切，并且你知道不要运行然后停止，继续运行，不要停止，直到你完成测试。

So the funny thing here is that the behavior between local agents and cloud agents, I think that is actually a bit different in their ideal state. I think local agents, you want them to be a bit more fast and let the user make the call on things. Actually, don't try to autonomously go test things. The background agent mode where you go start it off, I think the agent should just assume the next message I send the user should just have everything that the user needs for me and you know not run and stop, keep running and don't stop until you have the testing until you have.

所以那只是一个稍微不同的提示。

So that's just a slightly different prompt.

是的。但出于很多原因，因为我们做了很多工作来确保 Devon 能与不同的 Git 提供商、不同的操作系统和虚拟机配合使用，我们希望尽可能多地共享这些逻辑。所以出于我们自己的实际目的，我们尽可能多地共享它。

Yes. But for many reasons, because of all the work we do to make sure that Devon works with different git providers, that it works with different OSes and VMs, we want as much of that logic to be shared as possible. So for our own practical purposes, we try to share as much of it as possible.

是的。我的意思是，我无法想象来回切换需要多少工作。所以恭喜你们发布了这个。

Yeah. I mean, I can't imagine how much work it is to transition back and forth. So congrats on shipping this.

谢谢。

Thank you.

好的。在我们结束之前还有什么要说的吗？就你们午餐时聊的那些。

Okay. Anything else that we should cover before we wrap? Just whatever you guys were talking about in your lunch.

也许像用例，比如你觉得你的客户今天用他们的云端智能体做的最主要的事情是什么？

Maybe like use cases, like what do you find to be the biggest things that your clients are trying to do with their cloud agents today?

你想再问一遍吗，这样我们可以得到一个干净的片段？

Do you want to just ask it again so we can get like a clean cut?

是的。他刚才在喝水。是的。

Yeah. He was drinking his water. Yeah.

我想谈的是用例。你觉得你的客户今天来找你主要是为了什么？“嘿，这就是我们想要设置云端智能体的原因。”

The thing I wanted to talk about was use cases. What do you think are the main things that your clients come to you today about? 'Hey, this is why we want to go set up cloud agents.'

是的，我认为我看到的最简单、最常见的用例是 SRE 用例。想法是，无论我们的警报是在 Slack、Datadog 还是其他地方，我们都希望智能体成为第一响应者。这不一定意味着智能体实际解决了问题，但能够提前收集上下文是巨大的，因为那个智能体集成了生产日志、数据库，它拥有完全的可见性，并且随着时间的推移还有如何处理某些问题的剧本。所以这对团队来说是一个巨大的胜利，因为你可以立即获得系统内正在发生的事情的完整轨迹，并且通常实际上直接从中生成一个拉取请求，这是一个非常简洁的流程，比如错误，拉取请求完成。

Yeah, I think the easiest and most common use case I see across everyone is SRE use cases. The idea that whether we have our alerts in Slack or Datadog or wherever they're going, we want the agent to be the first responder on that. And that doesn't necessarily mean that the agent is actually resolving the issue, but just being able to collect that context ahead of time is huge, because again that agent is integrated into the production logs, the database, it has full visibility and over time playbooks as well for how to address certain issues. And so that's a huge win for teams, because instantly you can have a full trajectory of what is going on within the system and oftentimes actually a pull request directly from that, which is a pretty neat flow to actually experience of like error, pull request done.

OpenInspect 也支持为此设置触发器。所以这可以完全自主地发生，特别是从 Datadog 或者只是……

OpenInspect does support a trigger for that as well. So that could happen completely autonomously from Datadog specifically or just...

它支持 Sentry。它支持通用 webhook，如果有人想添加 Datadog，他们可以。

It supports Sentry. It supports a generic webhook, and if someone wants to add Datadog, they can.

我看到的其他用例属于非构建者用例，无论是产品经理还是营销团队。我看到很多团队中，谁在真正贡献代码的概念正在改变。在很多情况下，如果只是快速修复一个 bug，产品经理不再创建 issue 了。产品经理只是通过 Slack 发起提示，然后 pull request 就被创建了。所以我认为这是一个巨大的胜利。我认为这个趋势会继续下去，我们看到代码修改正在工程部门之外发生。我看到的最后一个常见用例是客户支持，当他们在客户那里遇到问题时，他们不完全确定为什么会发生这种行为。

The other use cases that I see are for kind of non-builder use cases, whether that's the PM or the marketing team. I'm seeing a lot of teams where the idea of who's actually contributing code is starting to change. And in a lot of cases, the PM, if there's just a quick bug fix, the PM is not creating an issue anymore. The PM is just prompting through Slack and the pull request is then being created. And so I think that that's a huge win. I think that trend will continue where we're seeing code modifications happening outside of engineering. The last common use case that I see is customer support, and so where they're experiencing an issue with a customer. They're not entirely sure why this behavior is happening.

以前的情况是，嘿，他们尝试使用这个功能时有个 bug。我们不知道发生了什么。现在，他们在 Slack 中标记这个。同样，完整的上下文已经准备好了。然后他们可以直接标记工程部门，就能完全理解那个问题，完全绕过了之前的痛点，比如，你能从他们那里获取更多信息吗？

Previously that world was, hey, there's a bug when they tried to use this feature. We don't know what's going on. Well, they're now tagging that in Slack. Again, that entire full context is ready. They can then just tag in engineering and have a complete understanding of that issue and completely bypass the previous pain points of like, oh, can you get more information from them.

我想补充的另一点是，我看到持续的安全扫描、持续的安全审查也是一个非常重要的用例。在内部，我们把这个用例视为自动分类，因为我们希望每一条进来的消息——无论是警报还是 bug 报告——都能让 Devon 先开始分类，再做其他事情。我们非常重视这个用例，以至于我们基本上努力让你永远不必离开 Slack 就能与之交互。再次强调，让与 Devon 的交互变得超级流畅，从报告进来的那一刻起，它就能响应报告，并且你可以在那里直接问它问题，拥有完整的代码库上下文来了解所有问题。这也与客户支持非常相关。我们发现的一件事是，CLI 有时对于非技术人员来说很难使用，但一个任何人都可以提问的在线聊天界面，它非常直观，不假设你有任何技术知识，但能访问你代码库的所有部分，这对支持人员、销售人员以及任何可能需要回答关于代码库问题的人都非常有用。

The only things I'd add on top of that I think I've seen is like continual security scanning, continual security review is a very big one as well. The use case internally we think about it as auto triage because we just want every message that comes in, that's an alert, that's a bug report, to have Devon just start triaging before anything else. And we've leaned into this use case so much so that we've basically tried to make it so that you don't ever have to leave Slack to interact with this. So again, making the interactions with Devon super fluid from the moment the report comes in to it responds to report and be able to ask it questions right there with full codebase context about all the issues. Very related to customer support as well. I think one thing that we found is CLIs can sometimes be like very difficult for people who aren't technical to go and use, but an online chat interface that anyone can go and ask questions and it's super intuitive and doesn't assume you have any technical knowledge but does have access to all parts of your codebase is super useful for support, for salespeople, anyone who might need to have their questions answered about the codebase.

是的，很好的提醒。这可能是一个非常昂贵的用例。有没有一个经验法则，人们应该在这方面花多少钱？因为你有无限的预算，但其他人没有，你知道。我不知道这是否是一个可以回答的问题，因为显然它取决于很多因素。

Yeah, great call out. This might potentially be like a very expensive use case. Is there like a rule of thumb on how much people should spend on this? Because you have unlimited budget but other people don't, you know. I don't know if this is an answerable question because obviously it depends on a lot of factors.

我认为这真的取决于人们如何使用它。我认为如果人们负责任地使用它并且从中获得价值，那么你就可以大致确定预算。我听到的常见数字是每个工程师 1,000 美元到 5,000 美元。

I think it depends really on how people are using it. I think if people are using it responsibly and they're getting value from it, then you can kind of determine the budget. Common numbers that I hear are anywhere from $1,000 an engineer up to $5,000 an engineer.

嗯。

Yeah.

我还没有听说过每个工程师 50,000 美元这样的数字，作为参考。

I have not heard anywhere in the realm of like $50,000 an engineer for a frame of reference.

我们会达到那个水平的。是的。我确实见过那么高的数字。嗯。我认为这也将是未来一年的一个大主题：我们会看到非常昂贵、非常智能的前沿模型，同时也会看到有人说，你知道吗，对于我做的很多工作，我不再需要前沿模型了，因为一些前沿模型实际上对很多工作来说已经足够好了。另外，提一下，你开创了 Smart Friend，这是一个混合体。我对这样一个世界非常感兴趣：你基本上拥有混合的前沿和次前沿系统，使用次前沿部分来做到非常快速、非常高效，并调用系统的前沿部分，这样你大部分时候仍然能获得前沿性能。

We'll get there. Yeah. I've seen numbers go that high for sure. Yeah. I think that this is also going to be a big theme of the coming year: we're going to see very expensive, very smart frontier models, and we're also going to see people who say, you know what, I don't need the frontier anymore for a lot of the work I do because some frontier models actually are good enough for a lot of the work. Also, shout out, you pioneered Smart Friend, which is a mix. I'm really interested in a world where you basically have hybrid frontier and subfrontier systems where you use the subfrontier part to be really fast, really efficient and call out to the frontier part of the system so that you can still get frontier performance for the most part.

是的，我试着搜索，但 Twitter 搜索完全坏了。比如“来自”字段完全消失了。非常遗憾。因为我真的……没关系。我可能需要在某个时候发一篇新帖子，关于 Smart Friend 的回归。

Yeah, I'm trying to search but Twitter search is like completely broken. Like the from field is just completely gone. It's very sad. Because I really... No worries. I might have to make a new post at some point about the return of Smart Friend.

是的。是的。我的意思是，Anthropic 现在正式采用了。

Yeah. Yeah. I mean, Anthropic is now officially adopted.

是的。

Yes.

好的，酷。我想就这些了。这真是一次很棒的讨论。很高兴邀请到你们。后台智能体现在是一个东西，每个人都在构建它们。我们讨论了很多关于生产方面的担忧，以及为什么你会选择一种架构而不是另一种。有很多值得期待的东西。

Okay, cool. I think that's it. It's really great discussion. Great having you guys on. Background agents are a thing now and everyone's building them. We talked a lot about the production concerns and why you would want to offer one architecture over the other. Lots to look forward to.

是的，我认为现在这个领域有一种真正的时代精神，公司希望将自己推向这些自主编码工厂。是的，我们正在做很多努力来支持这一点。任何听众都欢迎来和我们聊聊，无论是使用 Devon 还是与我们合作。

Yeah, there's a real zeitgeist in the space right now, I think, for companies to want to drive themselves into these autonomous coding factories. And yeah, we're doing a lot to try to support that. Any listeners are welcome to come chat to us about that, whether using Devon or working with us.

是的。招聘。

Yeah. Hiring.

是的，当然。具体来说，就给出一个非常有趣的画像。我认为人们低估了现在这个领域中品味极高的产品工程师的作用。考验是，你端到端地交付过什么有品味的产品？如果你交付过你认为有品味并且引以为豪的东西，你应该来和我们谈谈。

Yes, of course. What specifically, just give one profile that's very interesting. I think people underestimate the role of really high taste product engineers in the space right now. And the test is, what have you shipped end to end that is tasteful product? If you've shipped stuff that you think is tasteful and you're proud of, you should come talk to us.

是的，对我来说，任何希望进一步发展其工程组织的企业，我做的很多咨询都是围绕这个的。那些可能刚刚开始 AI 之旅的团队，无论是使用 Cursor 还是 Claude Code，但他们正在寻找有人帮助他们驾驭最先进的技术，而不仅仅是初始部署。如前所述，从你部署了后台智能体到我们如何真正将其完全整合到公司中并真正实现其价值，这中间有很多工作要做。

Yeah, for me, any businesses that are looking to further their engineering org, a lot of the consulting I do is around that. Teams who are maybe starting their AI journey, whether that's with Cursor or Claude Code, but they're looking for someone to help navigate them through the state-of-the-art and beyond just that initial deployment. As mentioned, there's a lot of lift from you've deployed the background agent to how do we actually get this fully integrated into the company and really realizing the true value of that.

是的。好的。那么，感谢你们来做客。

Yeah. Okay. Well, thanks you guys for coming on.

酷。感谢邀请我们。

Cool. Thanks for having us.

是的。谢谢。

Yeah. Thank you.