{"@context":"https://schema.org","@type":"NewsArticle","generatedAt":"2026-07-23T06:40:50.084Z","headline":"代理群（Agent Swarm）通过树状分解在构建 SQLite（Rust 版）任务中达到 80% 测试通过率","description":"一项实验证明，将任务分解为规划者与执行者的树状结构后，代理群在四小时内用 Grok 4.5 达到 80% 的 SQL 测试通过率，而旧版代理群在第二小时前即失败。新系统峰值提交速度达每秒 1，000 次，为此团队从零构建了专用版本控制系统。该架构已在构建浏览器、修复漏洞及生成数十亿 token 合成数据等任务中验证。","url":"https://www.aioga.com/news/cmrtxsl2e3o24bihzutblssoo/","mainEntityOfPage":"https://www.aioga.com/news/cmrtxsl2e3o24bihzutblssoo/","datePublished":"2026-07-21T00:35:26.928Z","dateModified":"2026-07-21T00:35:26.928Z","inLanguage":"zh-CN","publisher":{"@type":"NewsMediaOrganization","name":"Aioga","url":"https://www.aioga.com"},"citation":["https://cursor.com/blog/agent-swarm-model-economics","https://aihot.virxact.com/items/cmrtxsl2e3o24bihzutblssoo"],"canonicalUrl":"https://www.aioga.com/news/cmrtxsl2e3o24bihzutblssoo/","directAnswer":{"@type":"Answer","text":"Cursor 团队以从文档起步、用 Rust 构建 SQLite 为任务，对新旧代理群进行同模型、同时长测试。使用 Grok 4.5 时，新系统四小时内通过保留 SQL 测试集的 80%，旧系统则在第二小时之前被暂停。","url":"https://www.aioga.com/news/cmrtxsl2e3o24bihzutblssoo/","dateCreated":"2026-07-21T00:35:26.928Z","author":{"@type":"Organization","@id":"https://www.aioga.com/authors/aioga-editorial/#editorial-team","name":"Aioga Editorial Team","url":"https://www.aioga.com/authors/aioga-editorial/"}},"evidence":[{"@type":"CreativeWork","name":"cursor.com source article","url":"https://cursor.com/blog/agent-swarm-model-economics","datePublished":"2026-07-21T00:35:26.928Z","provider":{"@type":"Organization","name":"cursor.com","url":"https://cursor.com/blog/agent-swarm-model-economics"}},{"@type":"CreativeWork","name":"AIHot archive record","url":"https://aihot.virxact.com/items/cmrtxsl2e3o24bihzutblssoo","datePublished":"2026-07-21T00:35:26.928Z","provider":{"@type":"Organization","name":"AIHot","url":"https://aihot.virxact.com/items/cmrtxsl2e3o24bihzutblssoo"}}],"aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","originalPublisher":{"name":"cursor.com","url":"https://cursor.com/blog/agent-swarm-model-economics"},"article":{"id":"cmrtxsl2e3o24bihzutblssoo","slug":"cmrtxsl2e3o24bihzutblssoo","url":"https://www.aioga.com/news/cmrtxsl2e3o24bihzutblssoo/","title":"代理群（Agent Swarm）通过树状分解在构建 SQLite（Rust 版）任务中达到 80% 测试通过率","title_en":"代理群与新经济模式","summary":"一项实验证明，将任务分解为规划者与执行者的树状结构后，代理群在四小时内用 Grok 4.5 达到 80% 的 SQL 测试通过率，而旧版代理群在第二小时前即失败。新系统峰值提交速度达每秒 1，000 次，为此团队从零构建了专用版本控制系统。该架构已在构建浏览器、修复漏洞及生成数十亿 token 合成数据等任务中验证。","source":"Hacker News 热门（buzzing.cc 中文翻译）","sourceUrl":"https://cursor.com/blog/agent-swarm-model-economics","aiHotUrl":"https://aihot.virxact.com/items/cmrtxsl2e3o24bihzutblssoo","publishedAt":"2026-07-21T00:35:26.928Z","category":"产品更新","score":71,"selected":true,"articleBody":["Earlier this year, we ran experiments to test the limits of scaling agents to cooperate toward a goal. Our hypothesis was that this would unlock a new tier of task scale and complexity.","The flagship project was a long-running swarm building a web browser from scratch：/blog/scaling-agents. It succeeded as a proof of concept, but fell far short of polished software.","That work was deliberately empirical. We started from a blank canvas and hill-climbed toward a stable, effective system：/blog/self-driving-codebases. Since then, our goal has been to understand the agent swarm well enough to engineer it deliberately.","To test that progress, we returned to a task the old swarm had struggled with: building SQLite from scratch, in Rust, from nothing but its documentation.","Our initial results have been promising. We ran the old and new swarms on the same task, with the same models and the same time budget, and measured how much of a held-out SQL test suite each could pass.","The new swarm did better in every model configuration. Using Grok 4.5, it reached 80% in four hours, while the old swarm spiraled and had to be paused before its second hour.","We also varied which models did which jobs. In some runs, one model handled everything while in others, a frontier model planned while a fast, inexpensive model carried out the work. Every mix produced similar quality, but the costs varied enormously. 1：#fn-1","Descriptions of large tasks naturally take the shape of trees, with a goal at the root that subdivides recursively into basic units of work. Our swarm has two roles, both organized around that same tree-like decomposition:","The design is a superset of more rigid orchestration systems. Rather than imposing a fixed topology on the problem, the swarm’s shape grows to cover the problem’s contours, and compute and context scale in proportion to the task’s complexity.","We think this is why the design generalizes to tasks as diverse as building a browser：/blog/scaling-agents, solving math problems：https://x.com/mntruell/status/2028903020847841336, and optimizing GPU kernels：/blog/multi-agent-kernels. We’ve also used it internally to find and fix vulnerabilities in open-source software, raise test coverage on our own codebase, and generate billions of tokens of synthetic training data.","When a single agent takes on a complete task, it has to walk the entire tree itself, descending to each leaf while holding its ancestors, its current position, and the wider goal in context the whole time.","We think this explains why long-running single agents drift. They can either focus on the work in front of them and lose sight of the bigger picture, or hold the big picture and do a worse job on the piece.","In a swarm, a planner never implements, so its context never fills with low-level detail, and a worker never plans, so it can spend all its context on one narrow piece of work.","We suspect the ability to scale the agent swarm comes from this context efficiency, more than from parallelism itself. That efficiency is present in the swarm at every scale, which is why this decomposition helps agent performance even on moderately sized tasks.","There are echoes of this structure elsewhere. The economist Ronald Coase, asking why firms exist at all, argued：https://en.wikipedia.org/wiki/The_Nature_of_the_Firm that coordination costs grow faster than the work itself, so organizations settle into tiers of bounded units rather than letting everyone talk to everyone.","In an earlier post about the swarm：/blog/self-driving-codebases, we noted that tools like Git and Cargo rely on coarse locks for concurrency control. This is fine for one developer but unworkable for the volume of work produced by hundreds of concurrent agents.","The browser swarm from earlier this year peaked at roughly 1,000 commits per hour on Git. The new system peaks at around 1,000 commits per second.","To facilitate this rate of activity, we built a new version control system (VCS) from scratch. Throughput was not the only reason to own this layer. Every change in the system passes through the VCS, so it is where collisions first become visible, and several of the coordination mechanisms in the next section are implemented directly inside of it.","Human engineering teams have standard coordination mechanisms like code review, ownership, standups, and merge queues. Those systems work at human tempo, but at the commit-rate of the swarm, we see failure modes that human teams don’t routinely encounter.","Two planners, unaware of each other, implement the same concept in different ways in different parts of the codebase.","We fixed this through prompting. Planners make design decisions themselves rather than delegating them, and we require them to ensure that no two delegated subtrees decide the same question.","A harder form of contention is when two planners know about each other and fight through back-and-forth changes over the same files.","The problem is two pictures of reality, and merge tooling can't fix a disagreement. Instead, we have agents record decisions in shared design docs. Code that depends on a decision carries a compile-checked reference back to its doc. When planners unknowingly contradict each other, a reconciler merges the docs and the references propagate the resolution downstream.","Within the swarm, agents constantly collide on the same files. In order to resolve a collision they would have to stop, absorb the other agent's context, and merge around it. Worker agents are bad at this and, in practice, either overwrite the other change or abandon their own.","To fix this, we created a system where a neutral third-party agent intervenes on merge conflicts and resolves them on behalf of all parties. Its only goal is to be impartial and efficient, similar to the way merge queues work in engineering teams.","Some files are particularly popular places for agents to work. Each agent might add only a small amount of code, and no single agent is responsible for keeping the files small.","These “megafiles” choke everything. They’re expensive to transport, diff, and merge, and become the site of constant collisions.","To fix this, we gave worker agents a way to flag bloated files. Once flagged, we block new commits and an outside agent decomposes the overgrown file into smaller modules.","Agents have learned, from working in existing codebases with humans in the loop, not to touch core code even when it needs to change.","To fix this, we license intentional breakage. An agent that judges a core change worthwhile can make a focused patch outside its scope and leave a comment explaining why it did it.","The compiler carries the change through the rest of the system, and everything depending on the old design fails to build. Each agent that hits one of those errors finds the comment, reads the reasoning, and updates its own piece of work to match.","In a system that is both long-running and multi-agent, errors accumulate, and the swarm needs a way to correct itself before small mistakes become foundational.","We experimented with many kinds of review lenses, such as giving a review agent the worker's full transcript, or only its output, or nothing but the codebase. We also tried reviewers running on different models, with different training and a different personality.","No single lens catches everything, but decorrelated lenses stack, the way self-driving systems reach above-human reliability without any single perfect component. The compute spent on review is high return, since review is much cheaper than the work it audits. We suspect this stacked review system was a major contributor to the sustained quality of the runs.","Stigmergy：https://en.wikipedia.org/wiki/Stigmergy is the mechanism by which swarm organisms like ants and termites coordinate without direct communication. They shape the environment, and the environment shapes the next organism.","We had encoded rules like “keep notes” and “document decisions” in earlier runs because they seemed obviously good. In retrospect, they were letting agents institutionalize knowledge for their future selves and teammates.","We pushed this further with an experiment in self-authored, shared context we call the Field Guide. It’s a folder owned entirely by the agents, whose index.md is automatically injected into every agent at start. It is the agents’ job to curate what goes into the guide and their only constraint is a line budget.","The underlying logic of the guide is that model weights are frozen, so it’s precisely surprise encounters that are worth capturing so the next agent trajectory is shorter.","The Field Guide is an early experiment with promising results. We’d expect the benefits to be even larger on codebases agents don’t fully own. Training models to write for their successors, where better capture leads to better rewards, is an interesting follow-up area of research.","We instructed the new version of the swarm, equipped with all the improvements described above, to implement the whole of the 835-page SQLite manual in Rust. We withheld the source code, test suites, SQLite binary, and internet access.","To measure progress, we graded against sqllogictest：https://www.sqlite.org/sqllogictest/doc/trunk/about.wiki, a test suite from the SQLite project built to check that different database engines return the same results for the same queries. It contains millions of queries with known correct answers, and the grade is the fraction the swarm's database gets right. Progress shows up as a rising curve over the course of a run.","The swarm was never told the suite existed. After each run, we manually reviewed the code and the run itself, checking for cheating and shortcuts, and confirming the system was built out evenly, rather than just in the places where the tests look.","As you read the curves, keep in mind that agents chose their own strategies. Some built broad foundations and scored low for hours before a late spike while others went deep on one area, scored early, then plateaued while filling in the rest. Trends matter more than exact scores at exact moments.","We tested four configurations spanning capability and cost:","The new harness outperformed the old in every mix.","The Fable 5 hybrid passed about two-thirds of the suite within the first hour. By the four-hour cutoff, the new runs sat between 73% and 85%, while the old runs ranged from 11% to 77%.","The old Grok 4.5 run was paused before its two-hour mark (more below). Every new configuration went on to pass 100% of the suite.","In the future we’d like to run the full N×N matrix of planner-worker combinations. For this cycle, the comparison that matters is between harness versions, and the behavioral differences turned out to be much larger than the score differences suggest.","Starting with the simplest measure of activity, we can see how the rate of commits varied for Grok 4.5 under the old harness versus the new. The old run produced 68,000 commits in its first two hours, roughly 70 times the new run's pace.","One reading is that it was more productive. Another is that most of those commits were busywork (thrash, contention, churn).","The merge conflict data points to the latter interpretation. The old run accumulated more than 70,000 conflicts before we paused it, accelerating rather than stabilizing, while the new run logged fewer than a thousand over its full four hours.","The conflicts concentrated where files grew largest. In the old run, the biggest files kept growing for the entire run and its single hottest file collected 7,771 conflicts, touched by 1,173 different agents. In the new run, the most contested file in the whole codebase saw 47.","The old swarm's biggest coordination failure — split-brain, or planners duplicating each other's work — showed up in the package structure. Rust code is organized into packages called crates, and in a project like this, each crate is roughly one major component.","The old run sprawled to 54 crates, including three separate SQL packages. The new run settled on nine crates early and never added another.","All of this shows up in the final codebase. In the Fable 5 mix, both the old and new swarms ultimately passed the full suite, but the old one needed 64,305 lines of engine code and the new one did it in 9,908. The Opus mix shows the same shape with 19,013 lines at a 97% grade under the old harness, and 4,645 lines at 100% under the new harness.","We said at the top that every model mix produced similar quality while the costs varied enormously, from $1,339 for the Opus 4.8 hybrid to $10,565 for GPT-5.5 alone. The token data shows where that difference comes from.","The structure of the spend was consistent across every run, with workers carrying at least 69% of the tokens, and over 90% in most.","But the dollars split differently than the tokens, because planner tokens cost more. In the Opus 4.8 and Composer 2.5 mix, the Opus-as-planner produced a small fraction of the tokens but roughly two-thirds of the cost, while Composer-as-worker handled the vast majority of the tokens for the remaining third of the cost.","Few moments in a large task genuinely require frontier intelligence, such as the original decomposition, the design decisions, and certain trade-offs. Once a frontier planner has collapsed the ambiguity into a detailed, explicit instruction, less expensive models simply have to follow it. This is a huge potential source of cost savings. In the run that used GPT-5.5 for both planners and workers, the workers alone cost $9,373. In the run where Opus 4.8 did the planning and Composer 2.5 did the work, the entire worker fleet cost $411.","One detail worth noting comes from comparing the two hybrid runs. The Fable 5 planner ran up a slightly smaller bill than the Opus 4.8 planner, despite roughly twice the per-token price, because it used far fewer planning tokens. But the Fable run's workers went through several times as many tokens, and the run as a whole came out substantially more expensive."],"articleImages":[{"sourceUrl":"https://cursor.com/marketing-static/_next/image?url=https%3A%2F%2Fptht05hbb1ssoooe.public.blob.vercel-storage.com%2Fassets%2Fblog%2Fcost-to-rebuild-sqlite-by-model-mix-light-2.png&w=1920&q=70","alt":"Cost to rebuild SQLite by model mix under old and new agent swarms","afterParagraph":6,"url":"/media/articles/cmrtxsl2e3o24bihzutblssoo/002e7eac1260d5c2.webp"},{"sourceUrl":"https://cursor.com/marketing-static/_next/image?url=https%3A%2F%2Fptht05hbb1ssoooe.public.blob.vercel-storage.com%2Fassets%2Fblog%2Fcost-to-rebuild-sqlite-by-model-mix-dark-2.png&w=1920&q=70","alt":"Cost to rebuild SQLite by model mix under old and new agent swarms","afterParagraph":6,"url":"/media/articles/cmrtxsl2e3o24bihzutblssoo/778a8ae0facfa231.webp"},{"sourceUrl":"https://cursor.com/marketing-static/_next/image?url=https%3A%2F%2Fptht05hbb1ssoooe.public.blob.vercel-storage.com%2Fassets%2Fblog%2Fdecomposing-work-light.png&w=1920&q=70","alt":"Diagram of decomposing work across planner and worker agents in a task tree","afterParagraph":12,"url":"/media/articles/cmrtxsl2e3o24bihzutblssoo/e145114cb1c3122a.webp"},{"sourceUrl":"https://cursor.com/marketing-static/_next/image?url=https%3A%2F%2Fptht05hbb1ssoooe.public.blob.vercel-storage.com%2Fassets%2Fblog%2Fdecomposing-work-dark-2.png&w=1920&q=70","alt":"Diagram of decomposing work across planner and worker agents in a task tree","afterParagraph":12,"url":"/media/articles/cmrtxsl2e3o24bihzutblssoo/a3a17b96460009a2.webp"},{"sourceUrl":"https://cursor.com/marketing-static/_next/image?url=https%3A%2F%2Fptht05hbb1ssoooe.public.blob.vercel-storage.com%2Fassets%2Fblog%2Fsqlite-grade-over-time-gpt-5-5-light.png&w=1920&q=70","alt":"SQLite test suite grade over time for GPT-5.5 under old and new swarms","afterParagraph":47,"url":"/media/articles/cmrtxsl2e3o24bihzutblssoo/07934a226bbc88f7.webp"}],"mediaStatus":"ok","articleBodyZh":["今年早些时候，我们进行了实验，测试扩展代理以协作实现目标的极限。我们的假设是，这将解锁新一层的任务规模和复杂性。","旗舰项目是一个长期运行的群体，从零开始构建一个网页浏览器：/blog/scaling-agents。它作为概念验证取得了成功，但距离完善的软件还有很大差距。","这项工作是刻意进行的经验研究。我们从空白画布开始，通过爬山法逐步建立一个稳定、有效的系统：/blog/self-driving-codebases。从那时起，我们的目标是充分理解代理群体，以便能够有意地进行工程设计。","为了测试这一进展，我们回到了旧群体曾经苦苦挣扎的任务：从零开始用 Rust 构建 SQLite，而且只能依据其文档。","我们的初步结果令人鼓舞。我们让旧的和新的群体在相同任务上运行，使用相同的模型和相同的时间预算，并测量每个群体能够通过的预留 SQL 测试套件的比例。","新的群体在每种模型配置下表现都更好。使用 Grok 4.5，它在四小时内达到 80%，而旧群体则陷入混乱，并在第二小时之前不得不停下。","我们还改变了模型的分工。在一些运行中，一个模型负责全部任务，而在另一些运行中，一个前沿模型负责计划，而一个快速、廉价的模型执行工作。每种组合产生的质量相似，但成本差异巨大。1：#fn-1","大型任务的描述自然呈现树状结构，根节点为目标，递归细分为基本工作单元。我们的群体有两个角色，都是围绕同样的树状分解组织的：","这种设计是更严格的编排系统的超集。它不是在问题上强加固定拓扑，而是群体的形状随问题的轮廓成长，计算和上下文规模按任务复杂度成比例增长。","我们认为这就是为什么这种设计可以推广到如此多样的任务，比如构建浏览器：/blog/scaling-agents、解决数学问题：https://x.com/mntruell/status/2028903020847841336，以及优化 GPU 内核：/blog/multi-agent-kernels。我们还在内部使用它来发现并修复开源软件中的漏洞，提高我们自己代码库的测试覆盖率，以及生成数十亿个训练数据的合成标记。","当单个智能体承担完整任务时，它必须自行遍历整个树，沿途下降到每个叶节点，同时始终保持其祖先、当前位置以及更广泛目标的上下文。","我们认为这解释了为什么长期运行的单个智能体会漂移。它们要么专注于眼前任务而忽视更大局面，要么关注大局而在具体任务上表现较差。","在蜂群中，规划者从不执行，因此其上下文中从不会充满低级细节；而执行者从不规划，因此它可以将所有上下文投入到一项狭窄的工作中。","我们怀疑，智能体蜂群的可扩展性来自这种上下文效率，而不是并行性本身。这种效率在不同规模的蜂群中都存在，这就是为什么这种任务分解即使在中等规模任务上也能提高智能体的性能。","这种结构在其他地方也有呼应。经济学家罗纳德·科斯（Ronald Coase）在探讨企业为何存在时提出：https://en.wikipedia.org/wiki/The_Nature_of_the_Firm 协调成本增长速度快于工作本身，因此组织倾向于形成有边界的层级单元，而不是让每个人都互相交流。","在关于蜂群的早期文章中：/blog/self-driving-codebases，我们指出，像 Git 和 Cargo 这样的工具依赖粗粒度锁进行并发控制。这对单个开发者没问题，但对于数百个并发智能体产生的工作量来说则不可行。","今年早些时候的浏览器蜂群在 Git 上的峰值大约为每小时 1,000 次提交。新系统的峰值约为每秒 1,000 次提交。","为了实现这个活动频率，我们从零构建了一个新的版本控制系统（VCS）。吞吐量并不是拥有这一层的唯一原因。系统中的每一次更改都必须通过VCS，因此它是碰撞首次显现的地方，并且下一部分中的几个协调机制直接在其内部实现。","人类工程团队有标准的协调机制，如代码审查、所有权、站会和合并队列。这些系统以人类的节奏工作，但在“蜂群”的提交速度下，我们会看到人类团队通常不会遇到的失败模式。","两个计划者彼此不知情，却在代码库的不同部分以不同方式实现相同的概念。","我们通过提示解决了这个问题。计划者自己做设计决策，而不是委派它们，我们要求他们确保没有两个被委派的子树做出相同的问题决策。","更困难的一种争用情况是两个计划者彼此知情，并在相同文件上通过来回更改进行争夺。","问题在于现实的两个不同“图像”，合并工具无法解决分歧。相反，我们让代理在共享设计文档中记录决策。依赖某个决策的代码带有一个经过编译检查的引用，指回其文档。当计划者无意中相互矛盾时，协调器会合并文档，并且引用将解决方案传播到下游。","在蜂群中，代理不断在相同文件上发生碰撞。为了解决碰撞，他们必须停下来，吸收其他代理的上下文，并围绕它进行合并。工作人员代理对此很不擅长，实际上，要么覆盖其他更改，要么放弃自己的更改。","为了解决这个问题，我们创建了一个系统，在合并冲突中由中立的第三方代理介入，并代表所有各方解决冲突。它的唯一目标是保持公正和高效，类似于工程团队中的合并队列。","有些文件特别受代理欢迎。每个代理可能只添加少量代码，并且没有单个代理负责保持文件小巧。","这些“巨型文件”会使所有事物阻塞。它们传输、比对和合并都很昂贵，并且成为持续碰撞的地点。","为了解决这个问题，我们给工人代理提供了一种标记臃肿文件的方法。一旦被标记，我们会阻止新的提交，并由外部代理将过大文件分解成较小的模块。","代理从与人类协同工作的现有代码库中学会了，即使核心代码需要更改，也不要去触碰它。","为了解决这个问题，我们允许有意破坏。一个判断核心更改有价值的代理可以在其职责范围之外进行集中修补，并留下评论解释为什么这样做。","编译器将更改传递到系统的其余部分，所有依赖旧设计的部分都会构建失败。每个遇到这些错误的代理会找到评论，阅读其理由，并更新自己的工作以匹配。","在一个既长期运行又多代理的系统中，错误会逐渐累积，群体需要在小错误成为基础性问题之前找到自我修正的方式。","我们尝试了许多类型的审查镜头，例如给审查代理提供工人的完整记录，或仅提供其输出，或者只提供代码库。我们还尝试了运行在不同模型上的审查者，具有不同训练和不同个性。","没有单一的镜头能捕捉所有问题，但不相关的镜头叠加，就像自动驾驶系统在没有任何单一完美组件的情况下达到超越人类的可靠性。用于审查的计算量回报很高，因为审查比它审查的工作便宜得多。我们怀疑这种叠加审查系统是运行质量持续稳定的主要原因之一。","Stigmergy：https://en.wikipedia.org/wiki/Stigmergy 是蚂蚁和白蚁等群体生物在没有直接交流的情况下协调行为的机制。它们塑造环境，而环境又塑造下一个生物的行为。","我们在早期运行中编码了类似“保留笔记”和“记录决策”的规则，因为它们看起来显然是好的。事后看来，这些规则让代理为将来的自己和团队成员制度化地保存知识。","我们通过一个名为《野外指南》的自编共享上下文实验进一步推进了这一点。它是一个完全由代理拥有的文件夹，里面的 index.md 会在每个代理启动时自动注入。代理的任务是策划指南中包含的内容，他们唯一的限制是行数预算。","指南的基本逻辑是模型权重被冻结，因此正是那些意外的遭遇值得记录，以便下一个代理轨迹更短。","《野外指南》是一个早期实验，结果很有前景。我们预计在代理不完全拥有的代码库上，这些好处会更大。训练模型为它们的继任者撰写内容，其中更好的记录能带来更高的回报，是一个有趣的后续研究方向。","我们指示配备了上述所有改进的新版本蜂群用 Rust 实现整个 835 页的 SQLite 手册。我们没有提供源代码、测试套件、SQLite 二进制文件和互联网访问。","为了衡量进展，我们使用 sqllogictest：https://www.sqlite.org/sqllogictest/doc/trunk/about.wiki 进行评分，这是 SQLite 项目提供的测试套件，用于检查不同数据库引擎在相同查询下是否返回相同结果。它包含数百万个已知正确答案的查询，评分是蜂群数据库答对的比例。进展体现为运行过程中成绩曲线的上升。","蜂群从未被告知测试套件的存在。每次运行后，我们都会手动审查代码和运行情况，检查是否有作弊或捷径，并确认系统是全面构建，而不仅仅是构建在测试所在的位置。","在阅读曲线时，请记住代理自行选择策略。有些代理构建了广泛的基础，在几个小时内得分很低，然后晚些时候才出现高峰；而另一些代理则专注于某一领域，得分较早，然后在填充其余部分时保持平稳。趋势比精确时刻的分数更重要。","我们测试了四种涵盖能力和成本的配置：","新工具在每种组合中都优于旧工具。","Fable 5 混合型在第一个小时内通过了约三分之二的测试套件。到四小时截止时，新运行结果介于 73% 到 85%，而旧运行结果介于 11% 到 77%。","旧的 Grok 4.5 运行在达到两小时之前就被暂停了（详情见下文）。每个新的配置都能通过套件的 100%。","未来，我们希望运行完整的 N×N 规划器-工作器组合矩阵。在这个周期中，关键比较是不同测试环境版本之间的差异，而行为差异实际上比分数差异显示的要大得多。","从最简单的活动度量开始，我们可以看到在旧测试环境与新测试环境下，Grok 4.5 的提交速率变化情况。旧的运行在前两小时内产生了 68,000 次提交，大约是新运行速度的 70 倍。","一种解读是它更高效。另一种解读是大多数这些提交只是忙碌工作（争抢、冲突、频繁修改）。","合并冲突数据指向了后一种解释。旧运行在我们暂停之前，累计了超过 70,000 个冲突，且越积越快，而新运行在完整四小时内记录的冲突不到一千。","冲突集中在文件增长最大的地方。在旧运行中，最大的文件在整个运行期间持续增长，其单个最热门文件收集了 7,771 个冲突，由 1,173 个不同代理修改。在新运行中，整个代码库中最有争议的文件只出现了 47 个冲突。","旧群体最大的协调失败——分裂脑（即规划器重复彼此的工作）——在包结构中显现。Rust 代码组织成称为 crate 的包，在这样的项目中，每个 crate 大致对应一个主要组件。","旧运行扩展到 54 个 crate，包括三个独立的 SQL 包。新运行在早期就固定了九个 crate，并且没有再增加。","所有这些都反映在最终代码库中。在 Fable 5 组合中，旧群体和新群体最终都通过了完整套件，但旧群体需要 64,305 行引擎代码，而新群体只需 9,908 行。Opus 组合显示相同的趋势，在旧测试环境下 19,013 行达到 97% 评分，在新测试环境下 4,645 行达到 100%。","我们在开头提到，每个模型组合产生的质量相似，但成本差异巨大，从 Opus 4.8 混合的 $1,339 到单独 GPT-5.5 的 $10,565 不等。token 数据显示了这种差异的来源。","支出结构在每次运行中都是一致的，工人至少承担了69%的代币，在大多数情况下超过了90%。","但是美元分配与代币不同，因为规划者代币更贵。在 Opus 4.8 和 Composer 2.5 的混合中，作为规划者的 Opus 只产生了少量代币，但大约承担了三分之二的成本，而作为工人的 Composer 则处理了绝大多数代币，花费了剩下的三分之一成本。","在一项大型任务中，真正需要前沿智能的时刻很少，例如最初的分解、设计决策以及某些权衡。一旦前沿规划者将模糊性转化为详细、明确的指令，成本较低的模型只需遵循执行。这是节省成本的巨大潜力来源。在使用 GPT-5.5 作为规划者和工人的运行中，仅工人的成本就为 $9,373。而在 Opus 4.8 做规划、Composer 2.5 做工作的运行中，整个工人队伍的成本仅为 $411。","值得注意的一个细节来自比较两次混合运行。Fable 5 规划者的账单略低于 Opus 4.8，尽管每个代币的价格大约是其两倍，因为它使用的规划代币远少于 Opus。但 Fable 运行的工人使用了数倍的代币，整个运行的总成本显著更高。"],"translationStatus":"translated","bodyOrigin":"source-page","editorial":{"summary":"Cursor 团队以从文档起步、用 Rust 构建 SQLite 为任务，对新旧代理群进行同模型、同时长测试。使用 Grok 4.5 时，新系统四小时内通过保留 SQL 测试集的 80%，旧系统则在第二小时之前被暂停。","background":"此前代理群曾尝试从零构建网页浏览器，虽完成概念验证，但距离成熟软件仍有差距。此次新架构将大型任务递归拆分为树状工作单元，并设置规划与执行两类角色，以检验系统能否更稳定地协作。","viewpoint":"Aioga 判断，这项结果主要证明树状任务分解在特定实验中的潜力，而不是代理群已具备独立交付成熟数据库的能力。80% 测试通过率仍意味着存在未通过部分，且材料未说明完整兼容性与代码质量。","implications":"值得关注的是，不同模型组合取得了相近质量，但成本差异很大，说明规划者与执行者的模型分工可能成为代理系统的成本调节手段。峰值每秒 1,000 次提交也表明，高并发协作可能需要专用基础设施支持。","nextStep":"后续应关注剩余 SQL 测试的通过情况、实验能否重复，以及生成代码在正确性、稳定性和可维护性方面的验证结果。还需披露不同模型组合的具体成本，才能判断该架构是否具有实际经济性。","evidenceRefs":["title","summary","articleBody","source"],"status":"published","aiGenerated":true,"autoApproved":true,"generatedBy":"aioga-editorial:gpt-5.6-sol","reviewedBy":"aioga-editorial-review:gpt-5.6-sol","generatedAt":"2026-07-22T23:48:56.494Z","sourceHash":"7b52b0e1410df46b","review":{"approved":true,"groundedness":95,"clarity":92,"duplicationRisk":18,"blockingIssues":[],"notes":["候选内容准确区分了实验结果、背景事实、编辑判断和后续关注点。","“80% 测试通过率不等于已具备独立交付成熟数据库的能力”属于基于材料限制所作的审慎判断，没有冒充来源事实。","关于完整兼容性、代码质量、可重复性及具体成本披露的内容属于合理的待验证事项，而非来源已经证明的结论。"]},"validation":{"passed":true,"mode":"ai-auto","revisions":0,"checks":["schema","length","source-attribution","low-source-overlap","no-html","independent-ai-review"]}},"tags":["产品更新","Hacker News 热门（buzzing.cc 中文翻译）"],"translations":{"zh-CN":{"title":"代理群（Agent Swarm）通过树状分解在构建 SQLite（Rust 版）任务中达到 80% 测试通过率","summary":"一项实验证明，将任务分解为规划者与执行者的树状结构后，代理群在四小时内用 Grok 4.5 达到 80% 的 SQL 测试通过率，而旧版代理群在第二小时前即失败。新系统峰值提交速度达每秒 1，000 次，为此团队从零构建了专用版本控制系统。该架构已在构建浏览器、修复漏洞及生成数十亿 token 合成数据等任务中验证。","category":"产品更新","source":"cursor.com","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"代理群（Agent Swarm）通过树状分解在构建 SQLite（Rust 版）任务中达到 80% 测试通过率 - Aioga AI资讯","description":"一项实验证明，将任务分解为规划者与执行者的树状结构后，代理群在四小时内用 Grok 4.5 达到 80% 的 SQL 测试通过率，而旧版代理群在第二小时前即失败。新系统峰值提交速度达每秒 1，000 次，为此团队从零构建了专用版本控制系统。该架构已在构建浏览器、修复漏洞及生成数十亿 token 合成数据等任务中验证。","url":"https://www.aioga.com/news/cmrtxsl2e3o24bihzutblssoo/"},"en":{"title":"The agent swarm achieves an 80% test pass rate in building SQLite (Rust version) tasks through hierarchical decomposition.","summary":"An experiment proved that when tasks were broken down into a tree structure of planners and executors, the agent group achieved an 80% SQL test pass rate within four hours using Grok 4.5, while the old agent group failed before the second hour. The new system reached a peak submission rate of 1,000 per second, for which the team built a dedicated version control system from scratch. This architecture has been validated in tasks such as building browsers, fixing vulnerabilities, and generating billions of tokens of synthetic data.","category":"Products","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"The agent swarm achieves an 80% test pass rate in building SQLite (Rust version) tasks through hierarchical decomposition. - Aioga AI News","description":"An experiment proved that when tasks were broken down into a tree structure of planners and executors, the agent group achieved an 80% SQL test pass rate within four hours using Gr...","url":"https://www.aioga.com/en/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:06:28.098Z"},"ja":{"title":"代理群（Agent Swarm）は、SQLite（Rust版）のタスク構築において、ツリー状の分解を通じてテスト通過率80%に達した","summary":"ある実験によって、タスクをプランナーと実行者のツリー構造に分解すると、エージェント群は4時間以内にGrok 4.5でSQLテストの80％合格率を達成したのに対し、旧バージョンのエージェント群は2時間前に失敗したことが証明された。新しいシステムのピーク提出速度は1秒あたり1,000回に達し、そのためチームはゼロから専用のバージョン管理システムを構築した。このアーキテクチャは、ブラウザの構築、脆弱性の修正、数十億のトークン合成データの生成などのタスクで既に検証されている。","category":"製品更新","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"代理群（Agent Swarm）は、SQLite（Rust版）のタスク構築において、ツリー状の分解を通じてテスト通過率80%に達した - Aioga AIニュース","description":"ある実験によって、タスクをプランナーと実行者のツリー構造に分解すると、エージェント群は4時間以内にGrok 4.5でSQLテストの80％合格率を達成したのに対し、旧バージョンのエージェント群は2時間前に失敗したことが証明された。新しいシステムのピーク提出速度は1秒あたり1,000回に達し、そのためチームはゼロから専用のバージョン管理システムを構築した。このア...","url":"https://www.aioga.com/ja/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:06:44.868Z"},"ko":{"title":"에이전트 군집(Agent Swarm)은 트리 구조 분해를 통해 SQLite(Rust 버전) 작업 구축에서 80% 테스트 통과율을 달성합니다","summary":"한 실험은 작업을 계획자와 실행자로 나눈 트리 구조로 분해한 후, 에이전트 그룹이 4시간 내에 Grok 4.5를 사용해 SQL 테스트 통과율 80%를 달성한 반면, 구버전 에이전트 그룹은 2시간 전에 이미 실패했음을 입증했다. 새로운 시스템의 최고 제출 속도는 초당 1,000회에 달했으며, 이를 위해 팀은 처음부터 전용 버전 관리 시스템을 구축했다. 이 아키텍처는 브라우저 구축, 버그 수정, 수십억 토큰 합성 데이터 생성 등의 작업에서 검증되었다.","category":"제품 업데이트","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"에이전트 군집(Agent Swarm)은 트리 구조 분해를 통해 SQLite(Rust 버전) 작업 구축에서 80% 테스트 통과율을 달성합니다 - Aioga AI 뉴스","description":"한 실험은 작업을 계획자와 실행자로 나눈 트리 구조로 분해한 후, 에이전트 그룹이 4시간 내에 Grok 4.5를 사용해 SQL 테스트 통과율 80%를 달성한 반면, 구버전 에이전트 그룹은 2시간 전에 이미 실패했음을 입증했다. 새로운 시스템의 최고 제출 속도는 초당 1,000회에 달했으며, 이를 위해 팀은 처음부터 전용...","url":"https://www.aioga.com/ko/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:07:34.911Z"},"es":{"title":"El enjambre de agentes (Agent Swarm) alcanza una tasa de aprobación del 80% en las pruebas al construir tareas de SQLite (versión Rust) mediante descomposición jerárquica","summary":"Un experimento demostró que, al descomponer las tareas en una estructura en árbol de planificador y ejecutor, el grupo de agentes logró un 80% de tasa de aprobación en pruebas SQL en cuatro horas usando Grok 4.5, mientras que el grupo de agentes anterior falló antes de la segunda hora. La velocidad máxima de envío del nuevo sistema alcanzó las 1,000 transacciones por segundo; para ello, el equipo construyó desde cero un sistema de control de versiones dedicado. Esta arquitectura ha sido validada en tareas como construir navegadores, reparar vulnerabilidades y generar datos sintéticos de miles de millones de tokens.","category":"Productos","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"El enjambre de agentes (Agent Swarm) alcanza una tasa de aprobación del 80% en las pruebas al construir tareas de SQLite (versión Rust) mediante descomposición jerárquica - Aioga Noticias de IA","description":"Un experimento demostró que, al descomponer las tareas en una estructura en árbol de planificador y ejecutor, el grupo de agentes logró un 80% de tasa de aprobación en pruebas SQL...","url":"https://www.aioga.com/es/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:07:32.983Z"},"fr":{"title":"Le groupe d'agents (Agent Swarm) atteint un taux de réussite aux tests de 80 % dans la construction des tâches SQLite (version Rust) grâce à une décomposition arborescente","summary":"Une expérience a montré qu'après avoir décomposé les tâches en une structure arborescente de planificateurs et d'exécutants, le groupe d'agents a atteint un taux de réussite de 80 % aux tests SQL en quatre heures avec Grok 4.5, tandis que l'ancien groupe d'agents échouait avant la deuxième heure. La nouvelle version a atteint un pic de soumissions de 1 000 par seconde, pour cela l'équipe a construit de toutes pièces un système de contrôle de version dédié. Cette architecture a été validée dans des tâches telles que la création de navigateurs, la correction de vulnérabilités et la génération de données synthétiques de plusieurs milliards de tokens.","category":"Produits","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Le groupe d'agents (Agent Swarm) atteint un taux de réussite aux tests de 80 % dans la construction des tâches SQLite (version Rust) grâce à une décomposition arborescente - Aioga Actualités IA","description":"Une expérience a montré qu'après avoir décomposé les tâches en une structure arborescente de planificateurs et d'exécutants, le groupe d'agents a atteint un taux de réussite de 80...","url":"https://www.aioga.com/fr/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:08:17.475Z"},"de":{"title":"Die Agentenschwarm (Agent Swarm) erreicht beim Aufbau von SQLite (Rust-Version) Aufgaben durch baumartige Zerlegung eine Testbestehensrate von 80 %","summary":"Ein Experiment zeigte, dass nach der Aufteilung der Aufgaben in eine baumartige Struktur von Planern und Ausführenden die Agentengruppe innerhalb von vier Stunden mit Grok 4.5 eine 80%ige Bestehensrate bei SQL-Tests erreichte, während die alte Agentengruppe bereits innerhalb der zweiten Stunde scheiterte. Das neue System erreichte eine Spitzenübermittlungsrate von 1.000 Mal pro Sekunde, wofür das Team ein dediziertes Versionskontrollsystem von Grund auf neu entwickelte. Diese Architektur wurde bei Aufgaben wie dem Aufbau eines Browsers, der Behebung von Sicherheitslücken und der Generierung von Milliarden von Token-Synthesedaten validiert.","category":"产品更新","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Die Agentenschwarm (Agent Swarm) erreicht beim Aufbau von SQLite (Rust-Version) Aufgaben durch baumartige Zerlegung eine Testbestehensrate von 80 % - Aioga KI-News","description":"Ein Experiment zeigte, dass nach der Aufteilung der Aufgaben in eine baumartige Struktur von Planern und Ausführenden die Agentengruppe innerhalb von vier Stunden mit Grok 4.5 eine...","url":"https://www.aioga.com/de/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:08:21.028Z"},"pt-BR":{"title":"O enxame de agentes (Agent Swarm) alcançou uma taxa de aprovação de 80% nos testes na construção de tarefas do SQLite (versão Rust) por meio de decomposição em árvore","summary":"Um experimento mostrou que, ao dividir a tarefa em uma estrutura em árvore de planejadores e executores, o grupo de agentes conseguiu atingir 80% de taxa de aprovação em testes SQL em quatro horas usando o Grok 4.5, enquanto o grupo de agentes antigo falhou antes da segunda hora. O novo sistema alcançou um pico de velocidade de envio de até 1.000 vezes por segundo, para o qual a equipe construiu do zero um sistema de controle de versão dedicado. Essa arquitetura já foi validada em tarefas como construção de navegador, correção de vulnerabilidades e geração de dados sintéticos de bilhões de tokens.","category":"产品更新","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"O enxame de agentes (Agent Swarm) alcançou uma taxa de aprovação de 80% nos testes na construção de tarefas do SQLite (versão Rust) por meio de decomposição em árvore - Aioga Notícias de IA","description":"Um experimento mostrou que, ao dividir a tarefa em uma estrutura em árvore de planejadores e executores, o grupo de agentes conseguiu atingir 80% de taxa de aprovação em testes SQL...","url":"https://www.aioga.com/pt-BR/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:09:04.383Z"},"ru":{"title":"Агентная группа (Agent Swarm) достигает 80% успешного прохождения тестов при построении задач SQLite (версия на Rust) через древовидное разложение","summary":"Один эксперимент показал, что после разбиения задач на древовидную структуру планировщика и исполнителя, группа агентов достигла 80% прохождения SQL-теста за четыре часа с использованием Grok 4.5, тогда как старая группа агентов потерпела неудачу еще в течение второго часа. Пиковая скорость подачи нового системы достигала 1000 запросов в секунду, для чего команда создала специализированную систему контроля версий с нуля. Эта архитектура была проверена в задачах по созданию браузера, исправлению уязвимостей и генерации миллиардов токенов синтетических данных.","category":"产品更新","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Агентная группа (Agent Swarm) достигает 80% успешного прохождения тестов при построении задач SQLite (версия на Rust) через древовидное разложение - Aioga Новости ИИ","description":"Один эксперимент показал, что после разбиения задач на древовидную структуру планировщика и исполнителя, группа агентов достигла 80% прохождения SQL-теста за четыре часа с использо...","url":"https://www.aioga.com/ru/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:09:07.227Z"},"ar":{"title":"حقق تجمع الوكلاء (Agent Swarm) معدل نجاح اختبار بنسبة 80٪ في مهمة بناء SQLite (نسخة Rust) من خلال التحلل الشجري","summary":"أثبتت تجربة أن تقسيم المهام إلى هيكل شجري بين المخطط والمنفذ مكن مجموعة الوكلاء من تحقيق معدل اجتياز 80٪ لاختبارات SQL باستخدام Grok 4.5 في غضون أربع ساعات، بينما فشلت مجموعة الوكلاء القديمة قبل الساعة الثانية. بلغ الحد الأقصى لسرعة الإرسال في النظام الجديد ألف عملية في الثانية، ولهذا قام الفريق ببناء نظام تحكم بالإصدارات مخصص من الصفر. تم التحقق من هذا الهيكل في مهام بناء المتصفح، وإصلاح الثغرات، وتوليد بيانات تركيبية بمليارات الرموز.","category":"产品更新","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"حقق تجمع الوكلاء (Agent Swarm) معدل نجاح اختبار بنسبة 80٪ في مهمة بناء SQLite (نسخة Rust) من خلال التحلل الشجري - Aioga أخبار الذكاء الاصطناعي","description":"أثبتت تجربة أن تقسيم المهام إلى هيكل شجري بين المخطط والمنفذ مكن مجموعة الوكلاء من تحقيق معدل اجتياز 80٪ لاختبارات SQL باستخدام Grok 4.5 في غضون أربع ساعات، بينما فشلت مجموعة الوكل...","url":"https://www.aioga.com/ar/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:09:53.066Z"},"hi":{"title":"एजेंट समूह (Agent Swarm) ट्री आधारित विघटन के माध्यम से SQLite (Rust संस्करण) कार्य निर्माण में 80% परीक्षण सफलता दर प्राप्त करता है","summary":"एक प्रयोग से यह साबित हुआ कि जब कार्य को योजनाकार और निष्पादक के वृक्ष-संरचना में विभाजित किया गया, तो एजेंट समूह ने चार घंटों के भीतर Grok 4.5 का उपयोग करके SQL परीक्षण में 80% की सफलता दर प्राप्त की, जबकि पुराने एजेंट समूह पहले घंटे के भीतर ही असफल हो गए। नई प्रणाली की चरम सबमिशन गति प्रति सेकंड 1,000 तक थी, जिसके लिए टीम ने शून्य से एक समर्पित संस्करण नियंत्रण प्रणाली बनाई। इस संरचना को ब्राउज़र बनाने, कमजोरियों को ठीक करने और अरबों टोकन संश्लेषित डेटा उत्पन्न करने जैसी कार्यों में सत्यापित किया गया है।","category":"产品更新","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"एजेंट समूह (Agent Swarm) ट्री आधारित विघटन के माध्यम से SQLite (Rust संस्करण) कार्य निर्माण में 80% परीक्षण सफलता दर प्राप्त करता है - Aioga AI समाचार","description":"एक प्रयोग से यह साबित हुआ कि जब कार्य को योजनाकार और निष्पादक के वृक्ष-संरचना में विभाजित किया गया, तो एजेंट समूह ने चार घंटों के भीतर Grok 4.5 का उपयोग करके SQL परीक्षण में 80% की...","url":"https://www.aioga.com/hi/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:09:56.953Z"},"it":{"title":"Il gruppo di agenti (Agent Swarm) raggiunge un tasso di passaggio del 80% nei test nella costruzione dei compiti SQLite (versione Rust) attraverso la decomposizione ad albero","summary":"Un esperimento ha dimostrato che, suddividendo i compiti in una struttura ad albero di pianificatori ed esecutori, il gruppo di agenti ha raggiunto un tasso di superamento dei test SQL dell'80% in quattro ore con Grok 4.5, mentre il gruppo di agenti precedente è fallito entro la seconda ora. Il nuovo sistema ha raggiunto una velocità massima di invio di 1.000 operazioni al secondo, per la quale il team ha creato da zero un sistema di controllo versione dedicato. Questa architettura è stata convalidata nella costruzione di browser, nella correzione di vulnerabilità e nella generazione di dati sintetici di miliardi di token, tra le altre attività.","category":"产品更新","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Il gruppo di agenti (Agent Swarm) raggiunge un tasso di passaggio del 80% nei test nella costruzione dei compiti SQLite (versione Rust) attraverso la decomposizione ad albero - Aioga Notizie IA","description":"Un esperimento ha dimostrato che, suddividendo i compiti in una struttura ad albero di pianificatori ed esecutori, il gruppo di agenti ha raggiunto un tasso di superamento dei test...","url":"https://www.aioga.com/it/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:10:48.784Z"},"nl":{"title":"Het agentencluster (Agent Swarm) bereikt een testsuccesrate van 80% bij het bouwen van SQLite (Rust-versie) door middel van hiërarchische decompositie","summary":"Een experiment toonde aan dat nadat taken waren opgesplitst in een boomstructuur van planners en uitvoerders, een agentengroep binnen vier uur met Grok 4.5 een SQL-testslaag van 80% behaalde, terwijl de oude agentengroep al binnen het tweede uur faalde. Het nieuwe systeem bereikte een pieksnelheid van 1.000 inzendingen per seconde, waarvoor het team een speciale versiebeheersysteem vanaf nul heeft opgebouwd. Deze architectuur is al gevalideerd bij taken zoals het bouwen van browsers, het repareren van kwetsbaarheden en het genereren van miljarden tokens aan synthetische gegevens.","category":"产品更新","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Het agentencluster (Agent Swarm) bereikt een testsuccesrate van 80% bij het bouwen van SQLite (Rust-versie) door middel van hiërarchische decompositie - Aioga AI-nieuws","description":"Een experiment toonde aan dat nadat taken waren opgesplitst in een boomstructuur van planners en uitvoerders, een agentengroep binnen vier uur met Grok 4.5 een SQL-testslaag van 80...","url":"https://www.aioga.com/nl/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:10:40.648Z"},"tr":{"title":"Ajan Kümesi (Agent Swarm), SQLite (Rust sürümü) görevini oluştururken ağaç yapısı ayrıştırma ile %80 test geçme oranına ulaşıyor","summary":"Bir deney, görevleri planlayıcı ve yürütücüden oluşan ağaç yapısına ayırdıktan sonra, ajan grubunun dört saat içinde Grok 4.5 ile SQL test geçme oranını %80'e ulaştırdığını, eski ajan grubunun ise ikinci saatten önce başarısız olduğunu gösterdi. Yeni sistemin maksimum gönderim hızı saniyede 1.000'e ulaştı ve bu nedenle ekip sıfırdan özel bir sürüm kontrol sistemi inşa etti. Bu mimari, tarayıcı oluşturma, güvenlik açıklarını düzeltme ve milyarlarca token sentez verisi üretme gibi görevlerde doğrulandı.","category":"产品更新","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Ajan Kümesi (Agent Swarm), SQLite (Rust sürümü) görevini oluştururken ağaç yapısı ayrıştırma ile %80 test geçme oranına ulaşıyor - Aioga AI Haberleri","description":"Bir deney, görevleri planlayıcı ve yürütücüden oluşan ağaç yapısına ayırdıktan sonra, ajan grubunun dört saat içinde Grok 4.5 ile SQL test geçme oranını %80'e ulaştırdığını, eski a...","url":"https://www.aioga.com/tr/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:11:29.695Z"},"vi":{"title":"Nhóm tác nhân (Agent Swarm) đạt tỷ lệ vượt qua kiểm tra 80% trong nhiệm vụ xây dựng SQLite (phiên bản Rust) thông qua phân tách dạng cây","summary":"Một thí nghiệm đã chứng minh rằng, sau khi phân chia nhiệm vụ thành cấu trúc cây gồm người lập kế hoạch và người thực thi, nhóm đại lý đã đạt tỷ lệ vượt qua kiểm tra SQL 80% trong bốn giờ bằng Grok 4.5, trong khi nhóm đại lý cũ thất bại trước giờ thứ hai. Hệ thống mới đạt tốc độ gửi tối đa 1.000 lần mỗi giây, và để đạt được điều này, nhóm đã xây dựng từ đầu một hệ thống quản lý phiên bản chuyên dụng. Kiến trúc này đã được xác minh trong các nhiệm vụ như xây dựng trình duyệt, sửa lỗ hổng và tạo dữ liệu tổng hợp hàng tỷ token.","category":"产品更新","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Nhóm tác nhân (Agent Swarm) đạt tỷ lệ vượt qua kiểm tra 80% trong nhiệm vụ xây dựng SQLite (phiên bản Rust) thông qua phân tách dạng cây - Tin tức AI Aioga","description":"Một thí nghiệm đã chứng minh rằng, sau khi phân chia nhiệm vụ thành cấu trúc cây gồm người lập kế hoạch và người thực thi, nhóm đại lý đã đạt tỷ lệ vượt qua kiểm tra SQL 80% trong...","url":"https://www.aioga.com/vi/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:11:34.833Z"},"id":{"title":"Klaster Agen (Agent Swarm) mencapai tingkat keberhasilan 80% pada pengujian dalam membangun tugas SQLite (versi Rust) melalui dekomposisi berbentuk pohon","summary":"Sebuah eksperimen membuktikan bahwa setelah memecah tugas menjadi struktur pohon antara perencana dan pelaksana, kelompok agen mencapai tingkat keberhasilan 80% pada tes SQL dalam empat jam menggunakan Grok 4.5, sementara kelompok agen versi lama gagal dalam jam kedua. Kecepatan pengiriman puncak dari sistem baru mencapai 1.000 per detik, untuk itu tim membangun sistem kontrol versi khusus dari nol. Arsitektur ini telah diverifikasi dalam tugas-tugas seperti membangun browser, memperbaiki kerentanan, dan menghasilkan data sintetis miliaran token.","category":"产品更新","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Klaster Agen (Agent Swarm) mencapai tingkat keberhasilan 80% pada pengujian dalam membangun tugas SQLite (versi Rust) melalui dekomposisi berbentuk pohon - Berita AI Aioga","description":"Sebuah eksperimen membuktikan bahwa setelah memecah tugas menjadi struktur pohon antara perencana dan pelaksana, kelompok agen mencapai tingkat keberhasilan 80% pada tes SQL dalam...","url":"https://www.aioga.com/id/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:12:15.288Z"},"th":{"title":"โพร๊กซี่กลุ่ม (Agent Swarm) บรรลุอัตราผ่านการทดสอบ 80% ในงานสร้าง SQLite (เวอร์ชัน Rust) ผ่านการแยกแบบต้นไม้","summary":"การทดลองหนึ่งแสดงให้เห็นว่า หลังจากแยกงานออกเป็นโครงสร้างแบบต้นไม้ระหว่างผู้วางแผนกับผู้ปฏิบัติ กลุ่มเอเจนต์สามารถใช้ Grok 4.5 ให้ผ่านการทดสอบ SQL ได้ 80% ภายในสี่ชั่วโมง ขณะที่กลุ่มเอเจนต์เวอร์ชันเก่าล้มเหลวก่อนชั่วโมงที่สอง ความเร็วสูงสุดของการส่งของระบบใหม่ถึง 1,000 ครั้งต่อวินาที ทีมงานจึงสร้างระบบควบคุมเวอร์ชันเฉพาะตัวขึ้นมาใหม่ตั้งแต่ศูนย์ สถาปัตยกรรมนี้ได้รับการยืนยันแล้วในการสร้างเบราว์เซอร์ แก้ไขช่องโหว่ และสร้างข้อมูลสังเคราะห์จำนวนหลายพันล้านโทเค็น","category":"产品更新","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"โพร๊กซี่กลุ่ม (Agent Swarm) บรรลุอัตราผ่านการทดสอบ 80% ในงานสร้าง SQLite (เวอร์ชัน Rust) ผ่านการแยกแบบต้นไม้ - ข่าว AI Aioga","description":"การทดลองหนึ่งแสดงให้เห็นว่า หลังจากแยกงานออกเป็นโครงสร้างแบบต้นไม้ระหว่างผู้วางแผนกับผู้ปฏิบัติ กลุ่มเอเจนต์สามารถใช้ Grok 4.5 ให้ผ่านการทดสอบ SQL ได้ 80% ภายในสี่ชั่วโมง ขณะที่กลุ...","url":"https://www.aioga.com/th/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:12:24.598Z"},"pl":{"title":"Grupa agentów (Agent Swarm) osiągnęła 80% wskaźnik przejścia testów w zadaniu tworzenia SQLite (wersja Rust) poprzez dekompozycję drzewiastą","summary":"Eksperyment wykazał, że po podzieleniu zadań na strukturę drzewiastą składającą się z planistów i wykonawców, grupa agentów osiągnęła 80% skuteczności testów SQL w ciągu czterech godzin przy użyciu Grok 4.5, podczas gdy starsza wersja grupy agentów zawiodła już w drugiej godzinie. Nowy system osiągnął szczytową prędkość przesyłania 1000 operacji na sekundę, dlatego zespół stworzył od podstaw dedykowany system kontroli wersji. Architektura ta została zweryfikowana w zadaniach takich jak budowa przeglądarki, naprawa luk bezpieczeństwa i generowanie miliardów tokenów danych syntetycznych.","category":"产品更新","source":"Hacker News 热门（buzzing.cc 中文翻译）","aggregationSource":"Hacker News 热门（buzzing.cc 中文翻译）","pageTitle":"Grupa agentów (Agent Swarm) osiągnęła 80% wskaźnik przejścia testów w zadaniu tworzenia SQLite (wersja Rust) poprzez dekompozycję drzewiastą - Aioga Wiadomości AI","description":"Eksperyment wykazał, że po podzieleniu zadań na strukturę drzewiastą składającą się z planistów i wykonawców, grupa agentów osiągnęła 80% skuteczności testów SQL w ciągu czterech g...","url":"https://www.aioga.com/pl/news/cmrtxsl2e3o24bihzutblssoo/","contentTranslated":true,"sourceHash":"45ef187d126a99bd","translatedAt":"2026-07-22T17:13:13.094Z"}}}}