Cursor Deploys Isolated Virtual Machines to Automate 30% of Internal Code Merges

Cursor部署隔离虚拟机，实现30%内部代码合并自动化 将AI模型迁移至具备自主工具构建能力的隔离云环境中，消除了本地资源瓶颈，并实现了并行、可自我改进的软件开发。 内容详细阐述了Cursor如何摆脱本地AI的诸多限制，转向在隔离虚拟环境中运行的高自主性云端开发智能体。通过像对待人类员工入职一样对待AI入职，并引入专用的`anydev` CLI工具，Cursor使智能体能够独立搭建、测试和验证代码库。此外，利用Claude 3.5 Sonnet在GUI导航方面的元认知能力，并建立“改进工厂本身”（Work on the Factory）的自我优化循环，智能体得以在最终由人工审批之前，自主报告、修复并验证自身面临的环境摩擦问题。 Cursor 认为软件开发的瓶颈已从模型能力转移至人类工作流管理与工具供给，开发模式正从逐步指导 Agent 转向构建能够让云端 Agent 自主端到端（A 到 Z）解决任务的系统。 (0:12) 针对 AI 模型缺乏执行上下文的问题，Cursor 借鉴人类入职流程推出了 Claude 入职 Agent（cursor.com/onboard），可自主探索代码库、配置环境变量与权限并交互式启动应用 Demo。 (1:43) 为优化 Agent 开发者体验（AX）并消除云端环境从头冷启动的耗时，Cursor 自研了 anydev CLI 工具，用于辅助 Agent 管理服务、监控系统状态及处理第三方身份验证。 (3:37) Cursor 将计算机使用（Computer Use）视作全新前沿领域，借助 Claude 3.5 Sonnet 操作图形界面并自动录制端到端测试演示视频，为开发者提供高带宽的审查方式。 (5:51) 通过“Work on the Factory”（WCF）自我提升机制，Agent 会主动记录开发中的阻碍与错误，并通过批量启动二级 Agent 集群测试验证修复方案，最终提交 PR 供人类审查。 (9:52)

Cursor argues that software development bottlenecks have shifted from AI model capabilities to the infrastructure, context, and operational freedom humans provide to agents. To resolve this constraint, the team builds isolated cloud environments, specialized tooling, and automated feedback loops that allow models to run, test, and improve their own development processes. Human-Style Onboarding and the anydev CLI (1:43) Cursor observed that deploying AI models into codebases without execution context forces them to sight-read code without running tests, a constraint that would impair human engineers. To mirror human onboarding, Cursor created a Claude-powered onboarding agent (hosted at cursor.com/onboard) that explores repositories, configures environment variables, handles permissions, and interactively runs the application to produce a functional demo. To support multiple agents running concurrently in the cloud, Cursor developed the anydev CLI to eliminate idle waiting periods caused by spinning up environments from scratch. The CLI functions as an operational toolkit for agents to start background services, verify readiness, set up test accounts, and handle third-party logins, supplemented by streamlined documentation and runtime state visibility. Visual GUI Navigation and Video Reviews (5:51) Beyond text-based coding, Cursor treats direct computer use—processing raw pixels and dispatching mouse and keyboard events—as a vital capability. While code editing presents full visibility like chess, navigating graphical user interfaces resembles a video game with partial screen visibility, irreversible decisions, and potential failure states. Cursor relies on Claude 3.5 Sonnet to handle the metacognition and backtracking required for these environments. In practical workflows, such as implementing a private marketplace feature with CSV uploads, the model executes end-to-end testing and records a video demo of the interface. Cursor highlights visual recordings as a high-bandwidth review mechanism, allowing developers to inspect dynamic behavior before examining underlying source code across multiple cloud instances. Cloud Isolation and Systemic Failure Resolution (7:20) Developers interact with autonomous agents primarily through high-volume bug delegation and long-running, large-scale projects. Cursor found that running agents in isolated cloud environments creates "security through freedom," enabling broad autonomous execution without risking local environment configurations, secret leaks, or context-switching overhead. Cursor stresses that agent errors must be handled as systemic infrastructure bugs rather than isolated flukes. Because unresolved failure modes compound across an organization and degrade developer trust, engineering teams must invest in root-cause remediation to build long-term confidence in autonomous delegation. Self-Improving Workflows Through Factory Feedback (9:52) To scale autonomous software development, Cursor implemented a self-improving operational loop termed "Work on the Factory" (WCF). Agents are instructed to log friction, broken tools, or points of confusion into a central tracker, which human operators group into technical bugs, permission blocks, or procedural ignorance. To prevent brittle or flaky interventions, an agent assigned to fix an environment problem cannot simply deploy a single patch. Instead, it spins up a secondary fleet of Claude agents to validate the proposed fix across an evaluation benchmark, submitting a pull request for human sign-off only after proving stability across multiple runs. Cursor frames the progression of software automation around "building the system that builds the system," moving human engineers away from granular step-by-step guidance toward designing the environments, evaluation benchmarks, and validation fleets that allow agents to operate independently.

Cursor 团队提出，当前软件开发的核心瓶颈已从模型推理能力转移到人类如何为其提供工具、上下文与运行环境。为了释放模型的深层潜力，Cursor 改变了将智能体直接置于静态代码库的传统方式，转而为 Claude 智能体配备独立的云端计算环境，并构建了一套涵盖自动化环境配置、专用工具链、视觉验证与自演化机制的高自主性开发体系。 智能体入职：从静态审视转向动态运行 (1:43) Cursor 团队在观察人类新员工入职流程后指出，人类工程师入职时会获得专门的开发电脑、环境配置支持以及完备的项目文档；然而在传统的 AI 辅助开发中，模型通常被直接投放进包含数千行代码的陌生仓库中，在毫无运行时执行上下文的前提下进行“盲视阅读”（sight reading）。团队认为，即便是人类开发者，若被强求在无法运行或调试应用的环境下阅读代码，也会迅速受挫，因此单纯依靠模型静态阅读代码属于一种低效且容易受阻的协作模式。 针对这一痛点，Cursor 构建了基于 Claude 的公开入职智能体（部署于 cursor.com/onboard）。该智能体被引入代码仓库时的核心目标并非立即修改业务代码，而是主动探查应用的启动和运行方式：它通过与开发者交互来配置环境变量与访问权限，排查并解决复杂的本地依赖阻碍，最终拉起各项后台服务并呈现可实际交互的应用 Demo，以此为后续更深度的开发任务建立完整的运行时上下文。 优化 AX 体验：专用工具与感知原则 (3:37) 随着大量 Claude 智能体在云端并行运行，开发团队发现云端代理面临着特有的开销瓶颈——与人类开发者可以长期保持本地服务常驻不同，历史上的云端智能体在每次执行任务时都需要从零初始化环境，导致其耗费大量时间处于等待服务启动的“睡眠”状态。为了系统性优化“智能体开发者体验”（AX），Cursor 开发了名为 anydev 的专用命令行工具。该工具充当智能体的辅助中枢，支持智能体自主拉起服务、轮询等待初始化完成、检查系统健康状态、创建测试账户以及自动登录第三方平台，显著减少了空转停顿。 在此基础上，Cursor 提炼了确立智能体高度自主权的三项核心原则：其一是“赋予智能体眼睛”，确保模型能够观测到人类所见的所有界面信息、应用运行时状态变更乃至其他调试智能体的交互记录；其二是“赋予智能体工具”，在明确的安全边界内开放执行应用与网络服务的权限；其三是“提供高质量输入”，基于自回归模型的生成机制，团队将人类文档精简提炼为针对边缘案例的优质指导，并维护整洁的代码库，以从输入端确保智能体输出结果的确定性。 计算机使用与隔离：视频评审与安全自由 (5:51) 除了纯粹的代码生成，Cursor 将基于原始像素输入和键鼠模拟操作的“计算机使用”（Computer Use）视为关键前沿。团队将编写代码比作棋盘全局可见的国际象棋，而将图形用户界面（GUI）的交互比作必须面对局部视野与“单向门”抉择的视频游戏。界面中不可逆的状态与潜在的“游戏结束”风险，高度依赖模型具备高阶元认知、主动回溯以及通用推理能力，而 Claude 3.5 Sonnet 正是在此类复杂界面导航中展现出核心价值的模型。 该能力在实践中催生了“高带宽代码评审”模式。例如在构建私有市场功能时，Claude 不仅实现了支持 URL 解析与 CSV 文件上传的业务逻辑，还自动录制了端到端全流程测试的操作演示视频。开发者无需逐行比对繁复的代码补丁，只需审查视频即可迅速确认功能闭环。同时，基于独立云端沙盒的“通过自由获取安全”设计，让开发者不必担心本地配置被污染或环境变量外泄，能够毫无顾虑地将琐碎缺陷批量派发给后台智能体处理，或指派其独立攻关长周期的复杂任务。 工厂自我演进：WCF 机制与并发验证 (9:52) 为了实现从逐步人工微调向“构建能够构建系统的系统”跨越，Cursor 意识到优化智能体环境本身的工作方式与编写普通业务代码完全一致，因而将 AX 的优化迭代职责交付给智能体自身驱动。团队制定了名为“在工厂中工作”（WCF）的核心机制，强制要求所有运行中的智能体主动上报在开发中遇到的操作摩擦、工具异常或认知困惑。所有上报条目均进入中央问题记录系统，再由人类维护者进行排重，并分类归纳为技术故障、权限受阻或认知匮乏三大范畴。 针对间歇性与偶发的脆弱缺陷，Cursor 设计了严密的自动化验证协议。负责修复 AX 工具链或环境问题的智能体在提出修复方案后，系统不会采取单次试验式的直接提交，而是由该智能体自主拉起一组次级 Claude 智能体集群，在整套基准测试评估集上进行并发测试运行。只有当修复方案被验证兼具鲁棒性且完全排除偶发脆弱性后，才会向人类工程师发起最终的 Pull Request 供审查合并，以此实现工具链的自主改进闭环。 Cursor 团队强调，必须将智能体的失败视作系统性缺陷进行根除，因为残留的失误模式会在工程组织中产生负面累积效应，侵蚀开发者对自动化工具的信任；反之，彻底修复失效节点能够带来跨团队的正向复合效益。尽管该方案通过云端计算环境与多智能体自测试机制大幅提升了任务吞吐量，但系统当前依然保留了由人类工程师进行问题分类归档与最终代码合并审查的环节，在更长跨度、更高不确定性的复杂任务中如何持续维持决策鲁棒性仍是这一模式演进的关键。

[0:12] Alexi Robbins: setting our agents free [0:12] Alexi Robbins: Building the system that builds the system. [1:43] Alexi Robbins: sight read [3:37] Alexi Robbins: agent developer experience [3:37] Alexi Robbins: Give agents eyes [3:37] Alexi Robbins: Give agents tools [5:51] Alexi Robbins: computer use [5:51] Alexi Robbins: high-bandwidth method of reviewing the work of the agent [7:20] Alexi Robbins: security through freedom [9:52] Alexi Robbins: Work on the Factory

[0:12] Hello. [0:14] Um, okay. So, [0:16] uh, [0:17] models are getting really good. [0:19] And for more and more work, the [0:21] bottleneck is no longer the model [0:23] intelligence. [0:24] The bottleneck is humans giving the [0:26] models the tools and the contacts and [0:29] the increasingly ambitious uh, tasks and [0:32] objectives to go flex their potential. [0:34] So, um, at Cursor, we've been working on [0:37] removing that bottleneck and I'm going [0:39] to share a bit about how we've been [0:40] doing that um, and hopefully it's [0:41] helpful to some of you in in your work. [0:45] Uh, with models this good, we kind of [0:46] see the job that we have as setting our [0:48] agents free [0:49] um, safely [0:51] uh, [0:52] uh, and and having them go off and work [0:53] on bigger bigger tasks. So, we've kind [0:56] of gone through three stages of uh, the [0:58] process. The first was um, giving our [1:00] agents the tools and the context to be [1:02] more autonomous. The second is um, we [1:05] had to learn how to take advantage of [1:08] these more capable models. There's [1:09] actually a lot of work in figuring out [1:11] how to update your your sort of patterns [1:14] uh, and behaviors. [1:15] And as you do that, as you're leveraging [1:18] more more agents and uh, getting more [1:20] work done, you start to see the places [1:22] where uh, there's stress and strains and [1:24] where the agents fall over and you work [1:26] to to uh, improve that and that brings [1:28] you the third stage which is building [1:31] the system that builds the system. So, [1:33] instead of spending your day uh, hand [1:35] holding agents from task A to D, you [1:37] take that time to uh, build the system [1:40] that can solve for A to Z. [1:43] So, we started thinking about how to [1:45] make our agents more capable, how to [1:46] make them work more like we do. [1:48] Uh, we started with [1:50] uh, looking at what we do with humans to [1:52] onboard people to to uh, Cursor. So, [1:55] when a developer joins Cursor, [1:57] they get a computer. [1:59] They are uh we help them set up their [2:01] dev environment. We have a ton of [2:02] documentation, maybe too much, about how [2:04] to do all the different things that uh [2:06] developers need to do in their daily [2:08] work. Um so, we give them all this all [2:10] this context and all this material. And [2:12] and uh crucially their computer. [2:14] If you imagine if we thought [2:16] think about what the the we were doing [2:17] with the the models, we were kind of [2:19] just like throwing the onboarding [2:20] process was you throw them into a code [2:22] base and from the model's perspective, [2:24] you have that thousands of lines of code [2:26] whizzing by, you don't know like what [2:28] you're doing, you just have some task [2:29] you have to go solve, uh and it's kind [2:31] of incredible that this works as well as [2:34] it does. Um I know if like I had to work [2:37] this way and I was just sight reading [2:38] code and I couldn't test the [2:39] application, um I would also probably [2:41] frustrate and annoy uh the humans who [2:44] did have to do the testing for me. [2:46] So, um [2:49] we decided to build an onboarding agent. [2:51] And we built a a Claude onboarding [2:53] agent. Anybody can go to um [2:55] uh cursor.com/onboard. [2:57] You can put set up your repo and the [3:00] Claude onboarding agent gets to work and [3:01] it starts exploring your code base not [3:03] to make a change but to figure out how [3:05] to run it. [3:08] And this is a little bit about how it [3:09] goes. So, it's exploring, it's looking [3:11] around, [3:12] um and depending on how fast this one's [3:15] playing, you'll see it can start uh [3:17] using the app and it'll come back with a [3:18] demo. And it's not just looking to [3:20] figure out like what to run, what the [3:21] services are, um but there are sort of [3:23] these complex things it needs to do like [3:25] figure out their different environment [3:26] variables, what permissions does it [3:27] need. Um so, it's this interactive [3:30] process with with the uh developer to [3:32] make sure the services are are running [3:34] properly. [3:37] So, once we have the agents onboarded, [3:39] we realize there's still quite a bit of [3:40] work to do because you have all these [3:42] developers uh running many Claude agents [3:44] every day. So, any problems are [3:46] multiplied out across all those those [3:48] runs. And so, every time when run, they [3:51] have to start their dev environment from [3:52] scratch. When you're doing local dev, [3:53] you probably leave things running. [3:55] Um not true for the cloud cloud agents. [3:57] So, we wanted to optimize their dev ex. [3:59] They were spending a lot of time [4:00] sleeping, uh waiting for things to start [4:02] up. They didn't uh have good ways of [4:04] waiting for things, so we built an an [4:06] any dev CLI tool. [4:07] Um so, they were able to start services, [4:10] wait for the services to start, check on [4:12] statuses. They had sort of a Swiss Army [4:13] knife for things like uh creating test [4:16] accounts and signing in for services, [4:18] third-party services, things like that. [4:20] So, what we saw was uh as we made the [4:22] dev environments better, more developers [4:24] started running more cloud agents and [4:26] getting more out of it. So, there's sort [4:27] of a positive feedback loop that starts [4:29] to take place. [4:30] Um and then of course, we also had to [4:32] give them uh all the sort of [4:33] documentation that we give our our human [4:35] developers. So, we made sort of [4:37] simplified versions of this so they [4:38] could get uh when they find themselves [4:40] in sort of these edge cases or hard [4:41] problems, they have the materials there [4:43] to to lean on. [4:46] So, uh in doing this process, we sort of [4:48] derived these kind of basic principles [4:49] of autonomy. Um the first is you have to [4:52] give your agents eyes. So, everything [4:54] that you can see, the agents need to be [4:56] able to see, too. [4:57] Uh basic version of this is if, you [5:00] know, the agent's running an app, you [5:01] should be able to see that app. If you [5:03] go and make changes and you use that app [5:05] yourself and change something in the [5:06] state, the agent needs to be able to see [5:08] what you changed. Another sort of [5:09] interesting one is uh that we found is [5:12] the the agent chats where you wind up [5:14] needing to debug what happened in a [5:16] chat, and you want the agent to be able [5:17] to see the same uh the other agent's [5:19] chat uh just like you do. [5:22] Uh the next thing is giving the agents [5:23] uh tools so that they can do all the [5:25] things that you can do with sort of [5:26] reasonable security constraints. [5:28] Um [5:29] this is like, you know, basic basic one, [5:32] really important one is they should be [5:33] able to run the applications that you [5:34] can run, and they should be able to use [5:36] the services that you should you can [5:37] run. [5:38] Um [5:39] agents are auto regressive, so it is [5:41] also very important that you have a sort [5:43] of high-quality code base and and [5:46] instructions and everything else so that [5:47] uh you get high quality and high quality [5:49] out. [5:51] Um the foundational primitive we believe [5:54] for human autonomy is computer use. [5:56] Um [5:57] so the first domain where agents have [5:59] really excelled has been coding, and we [6:00] think computer use is is the next really [6:02] important domain. [6:03] Um and this is raw pixels in, mouse and [6:06] keyboard out. [6:07] Um and the Claude family of models are [6:09] really good at this. And this is this is [6:11] not the hard part of this is not [6:12] clicking in the right place. The hard [6:14] part is uh [6:16] sort of better explained is like if [6:17] coding is like chess, where you can see [6:19] all the pieces out on the board, [6:21] navigating these GUIs is more like a [6:23] video game, where you can only see a [6:24] little slice at a time. There are [6:26] one-way doors. There are game-over [6:28] states that you can get into. [6:30] Um and so you need this sort of [6:32] higher-level metacognition and [6:34] backtracking and the sort of general [6:36] general intelligence uh [6:37] uh skills that the Claude family's [6:39] really good at. So uh [6:41] uh Claude's Claude 4 7 is our computer [6:43] use model. Here's an example. It was [6:46] told to go off and build this private [6:47] marketplace feature. [6:48] Um [6:49] so it goes off and records this demo [6:51] where it's implemented all the little [6:53] pieces. We have like [6:55] uh this [6:56] URL input, and there's CSVs it needs to [6:58] add. Um [7:00] and what's great is that it's not just [7:01] using that to do its own end-to-end [7:03] testing to make sure that the changes [7:04] that it made works. You as the developer [7:07] get to uh have a really high-bandwidth [7:09] method of reviewing the work of the [7:11] agent before you get into code. And this [7:13] becomes really, really valuable when you [7:15] are running many of these agents um [7:17] simultaneously in the cloud and bouncing [7:19] between them. So that's the next thing [7:20] is once you have these autonomous agents [7:23] onboarded, you need to learn [7:25] to give them more work and give them [7:27] bigger bigger challenges to go tackle. [7:29] Um two sort of basic modes. The first is [7:33] uh you have like a lot of tasks and a [7:35] lot of bugs and issues, and you kind of [7:37] have to learn when to just uh [7:39] like stop putting those in your notes or [7:41] start stop putting them in your two [7:42] tracker and just kick off prompts. Put [7:44] them right into a prompt box and kick [7:45] them off. And when you do [7:48] uh you then have a bunch more of these [7:49] agents running and again it's great to [7:50] be able to have those demos that come [7:52] back instead of having to review lots [7:54] and lots of code. [7:55] Um and the sort of second pattern is [7:57] much bigger projects um where you can [7:59] give a cloud agent an autonomous agent [8:01] much larger units of work and have it [8:03] work for much longer. [8:07] Um one of the things we were surprised [8:08] by we kind of knew that if we made the [8:10] agents more powerful developers would do [8:13] more exciting things. [8:14] Um and we were sort of surprised by the [8:16] extent to which this was true. And um [8:18] one of the sort of really important [8:20] things was the security that the cloud [8:21] provided for for developers. [8:24] Um [8:24] there's sort of this idea of like [8:26] security through freedom which sounds [8:27] like Orwellian propaganda but uh in the [8:30] same way that you're sort of setting [8:31] your agents free to go take things on in [8:33] the cloud um on their own you also sort [8:35] of set yourself free as a developer [8:37] where you don't have to worry as much [8:39] about uh you know resource management [8:41] and context switching. Um you don't have [8:42] to worry about the agents going and [8:44] doing things that they really should not [8:45] with your environment variables. [8:47] Um [8:48] and there's there's a way in which we [8:50] were all surprised by how much more [8:52] enjoyable this made programming. [8:59] Um [9:01] really really important skills that we [9:03] we are still working on learning. Um [9:05] when the agents fail [9:07] it's really worth it to take time out to [9:10] figure out what went wrong, debug it, [9:12] and implement a fix that's again going [9:14] to be sort of multiplied out across your [9:16] whole team and your company. Um it's the [9:18] same sort of dynamic where so failure [9:20] modes if they persist make the agents [9:23] sort of continually uh [9:24] uh a compounding failure across the [9:26] entire company. Um and people don't want [9:29] to use the the agents as much and they [9:30] don't lean on them as much. But the [9:32] inverse is also true. When you invest in [9:34] them uh and you you make them work [9:35] better [9:37] everybody wants to use them more. People [9:38] are building trust with the agents. [9:40] They're finding that they can sort of [9:41] one-shot bigger and bigger tasks, and [9:43] then they want to invest more in it. [9:45] So, this is a really important change in [9:47] how you think about your work, where [9:49] you're kind of programming programming [9:50] the system. [9:52] And so, you've onboarded your agents. We [9:54] gave them the tools to make them really [9:55] powerful. [9:56] Uh we started learning how to leverage [9:59] them and scale them up, and we were [10:00] seeing where they they fell over. We [10:02] started working on this sort of loop of [10:04] how you teach them to work better. [10:06] And we realized that it does start to [10:08] feel like coding again. [10:10] Um so, of course, we thought, well, the [10:12] agents should do this. [10:16] Um we've got a few ways that we're [10:17] trying to have the agents do this. This [10:18] is uh sort of the most important one and [10:20] the one I'm going to talk about today. [10:22] Um is agents iteratively improving their [10:24] own workflows. [10:25] And so, we call this the agent [10:26] experience. There's a developer [10:27] experience. So, you have the agent [10:29] experience, and you need to care just as [10:30] much if not more about the agent [10:32] experience. [10:33] Um the way that our system works is [10:35] agents uh go about their business, and [10:37] they are told to report issues as they [10:40] come up. Um it's really just like what [10:42] we do with uh the pattern I was [10:43] describing for humans, where if you see [10:45] something wrong, say something, uh [10:47] report it, and and try to work on a fix. [10:49] All those reports are accumulated in a [10:51] system of record. It's really again very [10:53] uh [10:54] similar to how human human systems work. [10:56] Um managers will go in and review all [10:59] the issues and categorize them and [11:01] dedupe them. Um and bucket them into [11:04] their issues that can be sort of their [11:05] technical problems that can be [11:07] addressed. Then there are issues of um [11:09] permission, where the agents just don't [11:11] have access to something. Uh so, they [11:13] need to get permission. There are issues [11:15] of ignorance, where the agents need uh [11:17] they don't still know what to do, and [11:19] they need the humans to come in and tell [11:20] them what the right right right way to [11:22] solve the problem is. [11:23] Um so, then in the last step, of course, [11:26] these are then fixed by both agents and [11:28] humans. And the goal is to over time [11:30] have a less and less human involvement, [11:31] so we can have those issues that the [11:33] agent solve are solved end to end. We [11:35] don't really need to review. We can have [11:37] really high trust in their work. [11:39] Um and they have all the context that [11:40] they need, and they don't need uh [11:42] anything else from us. [11:44] So, I'm going to go through a couple [11:45] examples. So, this is our most important [11:47] skill. It's the WCF skill, [11:49] which of course stands for work on the [11:50] factory. [11:51] And you can see it's like uh [11:53] every every cloud agent gets this skill. [11:55] Um [11:56] and it's almost the exact same prompt [11:58] that I was just showing in the previous [11:59] slide. Work on the factory is the idea [12:02] that when something is annoying, broken, [12:04] or confusing, you take a moment to [12:05] report it, so we can improve the tools [12:08] and workflows, rather than just grinding [12:10] through. [12:11] Um [12:13] models a while ago would not have been [12:14] doing a very good job of this, but today [12:17] uh [12:17] they get annoyed, and they find things [12:19] broken, and they get confused, and they [12:20] like realize that, and they report it. [12:22] Um so, we get this this uh system of [12:24] record where they go and report all [12:25] those issues. [12:27] Um of course, you then have to solve the [12:29] issues, and this is its own uh really [12:31] important challenge if you want this [12:32] whole system to be sort of uh [12:33] self-improving. [12:34] And so, we were finding with these these [12:36] agent development experience problems, [12:39] having the agent just go solve them and [12:41] and try to one-shot was not that [12:42] effective, because there's a lot of [12:43] flake in those problems. [12:45] So, something only happens once in a [12:46] while. [12:47] And so, we taught it to actually have [12:49] the cloud agent that goes and solves it [12:50] kick off a bunch more cloud agents with [12:52] the change in the development [12:53] experience, and make sure that across [12:55] that sort of eval set, that there's a [12:57] robust solution. And so, then when the [12:58] problem when the solution and uh the PR [13:00] comes back to the human's review, [13:02] there's a high degree of trust that [13:03] actually this uh is is well validated [13:06] well validated well validated solution. [13:08] Um [13:10] This is slightly premature. [13:12] Um [13:16] Um [13:19] Yeah, so I think that these are both [13:20] really good examples of where there's [13:21] how these sort of skills can work as um [13:24] uh sort of background uh a garbage [13:26] collection processes or cleanup [13:27] processes in the operating system. [13:30] Um and we think that these while these [13:31] are sort of clearly applied for the the [13:33] coding domain, [13:34] in the same way we sort of speed run a [13:36] lot of AI development in coding, these [13:38] patterns are going to generalize [13:40] uh well outside of coding and to other [13:42] domains. And even if you think about it [13:44] already, cloud development experience is [13:46] not really a coding problem. There are a [13:47] lot of variables in that and very few of [13:49] them really are are just sort of coding [13:51] issues. [13:52] Um okay, so now now the thank you slide. [13:54] Um if if you'd like to talk more about [13:56] uh [13:57] self-improving identic systems, um [13:59] please talk to me. Uh you can uh find me [14:01] on on X at uh my name. Um and if you'd [14:04] like to set your agents free, you can go [14:05] to cursor.com/onboard [14:07] and have Claude onboard to your codebase [14:09] and maybe ship your next ambitious [14:11] feature. [14:12] So, thank you very much.