百万 AI Agent 能催生超级智能吗？

拉梅兹·纳姆（Ramez Naam）在我看来是目前健在的最优秀的未来学家之一。尽管他开设了 Substack 专栏（你绝对应该关注），但他写得实在太少了。因此，我一直在我的博客上转载他的文章，以鼓励他多写一些。

让我有些意外的是，拉梅兹对 AI 的态度比我预想的要怀疑得多。他当然没有轻视这项技术，但他不认同各大顶尖实验室（尤其是 Anthropic）提出的许多更为激进、更具戏剧性的论调。在这一系列的第一篇文章中，他就对“递归自我改进（RSI）是否会在不久的将来导致 AI 能力的快速腾飞”表示了怀疑：

在本文中，他对 Agent 集群（Agent Swarms）——即大量并行工作的 AI Agent——大幅提升 AI 能力的潜力表达了怀疑。近来 Agent 集群频频见诸报端，一方面是因为针对 Hugging Face 的攻击，另一方面 OpenAI 解决著名的纳维-斯托克斯（Navier-Stokes）问题也被普遍归功于大规模集群。但拉梅兹认为，并行化只是一种同样面临收益递减规律的投入要素，因此我们应该降低对 Agent 集群所能达成目标的预期。

就像他上一篇文章的情况一样，我不确定在底层模型能力——无论有没有集群——仍在以如此稳定且令人印象深刻的速度提升的情况下，这到底有多重要。但这确实是一个在智识上非常有趣的论点，而且拉梅兹非常具有说服力。

---

在我上一篇文章中，我们探讨了 AI 是否能一路自我改进到极高水平的超级智能。我的结论是：当前的反馈回路可能过于微弱，因为 AI 的改进在每一步都面临着收益递减。即使是由完全自主的 AI 承担所有研究和编码工作，也无法消除这种收益递减。 随着现实世界的参数和数据发生变化，我们应当不断修正这一结论。

但我们当时并未深入审视另一种可能性：并行运行数百万甚至数十亿个 AI 心智。它们能带来多大帮助？这就是我们本文要探讨的内容。

很多人曾建模推导过更多并行工作的 AI Agent 如何推动递归自我改进。但我们今天掌握的数据却呈现了截然不同的图景。更多 Agent 对速度很有帮助：它们可以更快地解决许多问题。但在提升 AI 智能方面的作用却没那么大。在解决更困难的问题时，多 Agent 带来的收益往往以惊人的速度衰减，甚至可能饱和。多 Agent 系统能否带来 RSI 维系自身持续运转所必需的“概念性突破”，是一个更为棘手的问题。

如果无法在 Agent 对问题的并行化处理方式上取得突破——这可能取决于机器学习问题本身的结构——那么即便拥有当今模型的数百万或数十亿个副本，也很难想象它们能在最困难的问题上取得持续突破。这些是我们所见过的最强烈的收益递减现象。当然，这些收益递减规律未来可能会发生改变。而且目前我们可参考的实验数据也少于预期。随着新证据的出现，我们需要重新校准。我将在文末列出我们应当追踪的指标，以及我对来自 Anthropic 最新发布数据的自然实验的预测。

以下是两张图的概要总结：大规模 Agent 扩展以解决更困难问题（我称之为“智能”）的实验观测结果，远远低于那些预测 AI 递归自我改进将导致智能爆炸的研究中的假设。第一张图基于 100 个并行 AI Agent 的规模。第二张图则是 10 亿个并行 AI Agent 的规模。

真实世界实验表明，并行 Agent 带来的智能提升幅度显著低于假设性 AI 模型。

外推至 10 亿个 Agent 时，假设模型中的智能提升超出真实世界实验增益曲线数个数量级。

回顾一下上一篇文章：递归自我改进（RSI）意味着 AI 的改进会反馈到下一轮 AI 研究中。其中有四项发现尤为突出：

在此我想重申一个区别：完全自动化的 AI 自我改进绝不保证会导致智能爆炸。AI 能力的收益递减会削弱这种反馈回路。并行 Agent 可以帮助自动化搜索 AI 参数空间，但在实现新的概念性突破方面看起来收效甚微。我的预期是，我们需要这类突破才能让自我改进变得可持续，更不用说迅速加速并达到真正深邃的超级智能水平了。

今天，让我们更详细地探讨并行运行数千、数百万或数十亿 AI 研究人员到底意味着什么。

在这篇文章中，我只聚焦于软件层面：即 AI 研究人员改进算法，使 AI 性能更好或运行成本更低。硬件、投资和经济增长有其自身的反馈回路，我们在上一篇文章中曾简要讨论过。在这里，我们探讨的是 AI 心智本身究竟还能多发现多少东西。

以下是核心论点及相关链接：

在《仁慈的机器》（Machines of Loving Grace）一文中，达里奥·阿莫代伊（Dario Amodei）设想了一个：

“数据中心里的天才国度”

数百万个 AI 心智，每一个在诸多领域的综合能力都超越诺贝尔奖得主，并以极高的速度运转。那将非同凡响。每个心智的智力水平是这一前提的关键组成部分。

汤姆·戴维森（Tom Davidson）和丹尼尔·埃斯（Daniel Eth）的 Forethought 论文描述了相当于“数百万顶尖人类研究人员”的情境。本杰明·托德（Benjamin Todd）的解读文章指出了“数百万名致力于 AI 研究的称职工程师”。德瓦克什·帕特尔（Dwarkesh Patel）则强调了 AI 的“庞大人口规模和完美的知识迁移能力”。

并行运行的 AI Agent 数量是如何代入这些论点的？在 Eth 和 Davidson 的说明性模型中，研究人员数量翻倍会产出两倍的论文。更便宜的 AI 让同样的硬件能够运行更多研究人员，而每项软件改进的寻找难度却越来越高。艾伦·陈（Alan Chan）及其同事在 2026 年发表的论文（包括 AI 先驱杰弗里·辛顿 [Geoffrey Hinton] 和约书亚·本吉奥 [Yoshua Bengio]）甚至假定增加研究人员会带来更大的效应：在软件水平保持不变的前提下，将有效研究人力翻倍会使软件改进速度提高约 2.6 倍。

这些都是关于更多研究人员能产出什么的理论假设。不断增长的 AI 研究人员数量必须持续足够快地找到改进方案，才能抵消未来取得进展时日益增加的难度。在考察了更庞大的 AI 团队实际取得了什么成果之后，我们将回过头来再审视这些假设。

与此同时，我们看到了 OpenAI 关于纳维-斯托克斯方程的发布声明：约 10,000 个 Agent 在 88 小时的并发运行中解决了一道千禧年数学难题。这让这一设想变得生动逼真——一个满是 AI 数学家的现代数据中心，正在攻克公认的难题。

我理解这种兴奋。但 Agent 的数量只告诉了我们运行了多少 AI 研究人员。我们还需要衡量这些新增的研究人员究竟做出了什么贡献。

在 MTS Live 节目中，我描述了一个难度逐步递增的 Scaling（扩展）阶梯：

• 超线性（Super-linear）： 翻倍的投入产出两倍以上的结果。收益加速递增。

• 线性（Linear）： 翻倍的投入产出两倍的结果。相互独立的作业任务通常呈现此规律。幂律指数为 1 也是相同情况。

• 幂律收益递减（Power-law diminishing returns）： 产出随投入按小于 1 的指数幂次增长。当指数为 0.5 时，产出翻倍需要四倍的投入；指数为 0.2 时，需要 32 倍；指数为 0.1 时，需要 1,024 倍。

• 对数（Logarithmic）： 投入每按乘数倍增一次，获得的边际收益保持相同。比如要再提高 5 分，可能需要再增加十倍的算力。

• 次对数（Sub-logarithmic）： 即使投入连续增加十倍，获得的收益也会越来越小。这些收益可能会不断萎缩，或在天花板处饱和。缓慢上升并不一定需要严格的硬性平台期。

并非所有的收益递减都一样。有些递减要比其他递减严峻得多。

经典的预训练 Scaling Law（扩展法则）描述了预测损失（prediction loss）呈现幂律形式的下降。在已测量的范围内，许多测试时（test-time）的分数曲线大致呈现对数形态。而一些多 Agent 的结果扁平化得更加剧烈。

让我们用数字来说明。在下图中，每条曲线在投入首次翻倍时都获得相同的收益。随后的差异便清晰可见。最严苛的几条曲线共享相同的纵轴刻度，并且每个面板都标注了其终点值。

不同的收益递减扩展模式会导致截然不同的长期结果。

为了实现失控式的 RSI，改进必须让后续的改进来得越来越快。如果软件效率的每一次进一步翻倍都需要增加固定百分比的研究量，那么 AI 研究人员数量带来的对数级收益就过于微弱，不足以维持该回路运转。次对数级扩展或遭遇瓶颈期则更为脆弱。我在本文余下部分总结的实验虽不完美，我也希望我们能拥有更多数据，但目前关于更庞大团队的最明确证据都指向了对数或次对数级的智能收益。在我们考察的假设前提下，这些增益看起来太弱了，不足以使 RSI 达成自我维系，更不用说失控加速了。

一个更大的团队在产出更好答案的能力上受到限制，至少存在三个原因，可能还不止这些。我们从以下几点谈起：

第一，协调能力。 Agent 能否有效拆解问题、管理工作流程、相互审查并整合结果？它们能否在交流关键信息的同时，不把所有时间都耗费在沟通上？一个团队既需要优秀的个人贡献者，也需要良好的项目管理。

第二，思维同质性。 这些 Agent 是在贡献有价值的新思路，还是在重复同样的套路和犯相同的错误？一百个副本可能会共享相同的盲点。只有当这些多样化的答案中有一部分是正确的时，产生更多样的答案才是有意义的。

第三，问题的结构。 有多少任务可以并行处理，又有多少必须等待早期的结果？一百万次独立的搜索可以同时运行，而连续递进的调查则无法并行。甚至弄清楚如何拆解一个概念性问题，本身就可能需要团队尚未获得的关键洞察。

更多 Agent 可能遭遇瓶颈的三个环节。

这些限制因素相互交织。一个更优秀的模型可以提供其副本此前所欠缺的思路，找到更好的分工方式，或者识别出团队此前一直忽略的解决方案。一旦有人找到了正确的方法，一项艰巨的任务可能会变得更容易并行化。这就是为什么曲线的形状至关重要，也是它为什么会发生变化的原因。

在我们进一步深入之前，先厘清两件事：速度（即 Agent 解决问题的快慢），以及集体智能（即它们能否解决更难的问题并达到新的技能水平）。我们将使用经过验证的基准测试分数作为衡量这种智能的依据。它们并非通用的 IQ 标尺。

到目前为止，增加 Agent 数量在加快执行速度方面似乎远比提升团队所能解决的问题难度级别要有效得多。

到目前为止，使用更多 Agent 为我们换来的是多得多的速度，而非额外的能力。

让我们从最理想的情况说起：一百万项独立的任务，一百万个待测试的候选对象，一百万个待搜索的区域。每个 Agent 都能分派到有用的工作，无需等待其他人，并且有可靠的方法来验证自己是否成功。

这种情况下的扩展效果可以极其出色。十个工人在一个工人完成一项任务的时间内可以完成十项任务。一次大规模搜索可能会找到小型搜索完全错过的罕见解决方案。

并行 Agent 的一个令人担忧的用途是进攻性网络安全。Lisan al-Ghaib 强调了这种可能性。虽然我不同意他关于集群智能（swarm intelligence）更宽泛的论点，但许多并行发起的攻击可能会极其强大。一个集群在同时搜索许多目标或尝试多种潜在漏洞时，可能并不需要概念上的突破。

话虽如此，渗透最安全的目标（例如操作系统和浏览器）可能需要长长的攻击链。每一步都依赖于先前的发现，才能穿透下一层防御。在这一点上，即使是在速度方面，我们也可能会遭遇收益递减或最终饱和。事实上，下面的实验之一就表明了这一点。

托比·奥德（Toby Ord）分析了 GPT-5.6 Sol 在不同基准测试中提升问题解决速度的效果及其成本。这为我们提供了一个衡量这种权衡的实用方法。总的来说，使用更多 Agent 有助于更快地完成任务，但总成本要高于使用更少 Agent 的情况。

除此之外，这种权衡还因任务类型而异。在命令行任务（Terminal-Bench）上，Ord 的

Ramez Naam is, in my opinion, one of the best futurists alive. But althoughhe has a Substack (which you should definitely follow), he doesn’t write nearly enough. So I’ve been encouraging him to write more by cross-posting his posts on my blog.

Somewhat to my surprise, Ramez has turned out to be a lot more of an AI skeptic than I would have though. He’s certainly not dismissive of the technology, but he disagrees with many of the more expansive and dramatic claims coming out of the big labs (especially Anthropic). In his first post in this series, he expressed skepticism that recursive self-improvement (RSI) would lead to a fast takeoff of AI capabilities in the near future:

In this post, he expresses skepticism about the potential for agent swarms — large numbers of AI agents working in parallel — to offer dramatic increases in AI capabilities. Agent swarms have been in the news a lot, both because of theHugging Face attack, and OpenAI’s solution of the famous Navier-Stokes problem is also widely attributed to a large swarm. But Ramez argues that parallelization is just another kind of input that suffers from diminishing returns, and that we should therefore temper our expectations about what agents swarms are able to achieve.

As was the case with his previous post, I’m not sure how much this matters, when the capabilities of the underlying models — swarm or no swarm — are still improving at such a steady and impressive rate. But it’s a very intellectually interesting argument, and Ramez can be very persuasive.

---

In my previous post, we asked whether AIs could improve themselves all the way to absurdly high levels of superintelligence. My conclusion: today’s feedback loop is probably too weak, because improving AI faces diminishing returns at every step. Even fully autonomous AIs doing all the research and coding don’t make those diminishing returns disappear. We should keep updating that conclusion as real-world parameters and data change.

But we didn’t look closely at another possibility: running millions or billions of AI minds in parallel. How much do they help? That’s what we’ll look at here.

Plenty of people have modeled how more AI agents working in parallel could fuel recursive self-improvement. But the data we have today tell a different story. More agents are useful for speed : they can solve many problems faster. They’re less useful for boosting AI intelligence. Multi-agent gains in solving harder problems often diminish incredibly quickly and may even saturate. Whether multi-agent systems can produce the conceptual breakthroughs RSI might require to become self-sustaining is the harder question.

Without breakthroughs in how well agents parallelize problems - something that may depend on the structure of machine learning problems themselves - it’s hard to see even millions or billions of copies of today’s models making repeated breakthroughs on the hardest problems. These are among the strongest diminishing returns we’ve looked at. Of course, these diminishing returns may change. And we have less experimental data to go off of today than we’d like. We’ll need to recalibrate as new evidence comes in. I’ll end with the things we should track and my predictions about a natural experiment from newly released Anthropic data.

Below is the two-image summary: The experimental observations of how large numbers of agents scale to solve harder problems (what I’m referring to as intelligence) are far far lower than the assumptions in studies that predict that AI recursive self-improvement will lead to an intelligence explosion. The first image is at the scale of 100 parallel AI agents. The second is at the scale of a billion AI parallel agents.

Real world experiments show dramatically lower intelligence gains from parallel agents than hypothetical AI models.

Extrapolated out to a billion agents, the intelligence gain in hypothetical models is orders of magnitude beyond real world experiment gain curves.

To recap the last post: recursive self-improvement (RSI) means AI improvements feeding back into the next round of AI research. Four findings stood out:

I want to reiterate a distinction here: fully automated AI self-improvement doesn’t at all guarantee an intelligence explosion. Diminishing returns in AI capabilities dampen that feedback loop. Parallel agents can help automate a search across AI parameters, but don’t look nearly as useful in making new conceptual breakthroughs. My expectation is that we’ll need those sorts of breakthroughs for self-improvement to become self-sustaining, let alone to accelerate rapidly and reach truly profound levels of superintelligence.

Today , let’s examine in much more detail what it would mean to run thousands, millions, or billions of AI researchers in parallel.

In this post I’m focusing only on software: AI researchers improving the algorithms that make AI better or cheaper to run. Hardware, investment, and economic growth have their own feedback loops, which we discussed briefly in the last post. Here, we’re asking how much more the AI minds themselves can discover.

Here’s the argument, with links:

In Machines of Loving Grace, Dario Amodei imagines a:

“country of geniuses in a datacenter”

Millions of AI minds, each more capable than a Nobel Prize winner across many fields, working at much higher speed. That would be extraordinary. The intelligence of each mind is a crucial part of the premise.

Tom Davidson and Daniel Eth’s Forethought paper describes the equivalent of “millions of top-notch human researchers.” Benjamin Todd’s explainer points to “millions of competent engineers working on AI research.” Dwarkesh Patel emphasizes AI’s “massive population size and perfect knowledge transfer.”

How does the number of AI agents running in parallel enter these arguments? In Eth and Davidson’s illustrative model, twice as many researchers produce twice as many papers. Cheaper AI lets the same hardware run more researchers, while each software improvement gets harder to find. Alan Chan and colleagues’ 2026 paper, including AI pioneers Geoffrey Hinton and Yoshua Bengio, assumes an even larger effect from adding researchers: doubling effective research labor increases the rate of software improvement by about 2.6 times , holding the software level fixed.

Those are assumptions about what more researchers produce. The growing number of AI researchers must keep finding improvements fast enough to outweigh the increasing difficulty of further progress. We’ll come back to those assumptions after looking at what larger AI teams actually achieve.

Meanwhile, we had OpenAI’s Navier–Stokes announcement: around 10,000 agents working concurrently during an 88-hour run solved a mathematics Millenium Problem. It made the idea vivid. A datacenter full of AI mathematicians, tackling a famously hard problem.

I understand the excitement. But the number of agents tells us how many AI researchers we ran. We also need to measure what those additional researchers contributed.

On MTS Live, I described a ladder of increasingly hard scaling:

• Super-linear: Twice the input produces more than twice the output. Accelerating returns.

• Linear: Twice the input produces twice the output. Independent jobs can look like this. A power-law exponent of 1 is the same case.

• Power-law diminishing returns: Output grows as input raised to a power below 1. At exponent 0.5, doubling output takes four times the input. At 0.2, it takes 32 times. At 0.1, it takes 1,024 times.

• Logarithmic: Each multiplication of input buys the same additional gain. Another five points might require another tenfold increase in compute.

• Sub-logarithmic: Even successive tenfold increases buy smaller gains. Those gains can keep shrinking, or saturate at a ceiling. A slow rise doesn’t require a hard plateau.

Not all diminishing returns are alike. Some are much harder than others.

The classic pre-training scaling laws describe power-law reductions in prediction loss. Many test-time score curves look roughly logarithmic over the measured range. Some multi-agent results flatten much more sharply.

Let’s illustrate this with numbers. In the figure below, every curve earns the same gain from the first doubling of input. The later differences then become visible. The hardest curves share a vertical scale, and each panel states its endpoint.

Different diminishing returns scaling patterns lead to very different long term results.

For runaway RSI, improvements have to make subsequent improvements arrive faster and faster. Logarithmic returns to the number of AI researchers are too weak to sustain that loop if every further doubling of software efficiency requires a fixed percentage more research. Sub-logarithmic scaling or a plateau are weaker still. The experiments I’ll summarize in the rest of this post aren’t perfect, and I wish we had more data. But the clearest larger-team evidence we have today points to logarithmic or sub-logarithmic intelligence gains. Those look too weak to make RSI self-sustaining, let alone runaway, under the assumptions we’re examining.

There are at least three reasons a larger team might be limited in its ability to produce better answers, and probably more. Let’s start with these:

First, coordination skills. Can the agents divide the problem, manage the work, check each other, and combine their results? Can they communicate what matters without spending all their time communicating? A team needs good project management as well as good individual contributors.

Second, homogeneity of thought. Are the agents contributing useful new ideas, or repeating the same approaches and mistakes? A hundred copies can share the same blind spots. More varied answers help only if some of that variety is right.

Third, the structure of the problem. How much can happen in parallel, and how much has to wait for earlier results? A million independent searches can run at once. A sequential investigation can’t. Even figuring out how to divide a conceptual problem may require an insight the team hasn’t found.

Three places where more agents can run into limits.

These limits interact. A better model can supply an idea its copies previously lacked, find a better division of labor, or recognize a solution the team had been overlooking. A difficult task may become easier to parallelize once somebody discovers the right approach. That’s why the shape of the curve matters, and why it can change.

Before we go further, let’s separate two things: speed , or how quickly agents solve a problem, and collective intelligence , or whether they can solve a harder problem and reach a new level of skill. We’ll use verified benchmark scores as evidence of that intelligence. They aren’t a universal IQ scale.

So far, adding agents seems much more effective at speeding up execution than at raising the level of problem a team can solve.

So far, using more agents buys us much more speed than extra capability.

Let’s start with the best case. A million independent jobs. A million candidates to test. A million places to search. Each agent gets useful work it can do without waiting for the others, and a reliable way to check whether it succeeded.

That can scale extremely well. Ten workers may finish ten jobs in the time one worker finishes one. A huge search may find a rare solution that a smaller search misses entirely.

One concerning use of parallel agents is offensive cybersecurity. Lisan al-Ghaib emphasizes this possibility. I disagree with his broader argument about swarm intelligence, but many attacks running in parallel could be extremely powerful. A swarm may not need a conceptual breakthrough to search many targets or try many possible vulnerabilities at once.

That said, penetrating the most secure targets, such as operating systems and browsers, can require long attack chains. Each step depends on earlier discoveries to get through another layer of defenses. Here again, we might find diminishing returns or eventual saturation, even with respect to speed. Indeed, one of the experiments below suggests that.

Toby Ord analyzed how well GPT-5.6 Sol increases the speed of solving problems on different benchmarks, and at what cost. This gives us a useful way to measure the tradeoff. In general, using more agents can help get tasks done more quickly, but at higher total cost than if you’d used fewer agents.

On top of that, the tradeoff varies by the type of task. On command-line tasks (Terminal-Bench), Ord’s analysis finds that four agents can reach the same result about 1.9 times faster , at about 2.1 times the token cost. On web research (BrowseComp), four agents can reach the same result about 2.6 times faster , at about 1.6 times the cost. I’m using the figure below to show how different tasks differ in that speed vs cost tradeoff.

More speed costs more, and the tradeoff varies by task. Based on Toby Ord’s analysis.Source.

Why the difference? Web research can often split into independent searches. A command-line task may have to change a shared environment in sequence. Some problems are simply easier to divide among agents than others.

Ord uses lambda, λ , for how speed scales with the number of agents. We’ll come back to it. At λ = 0.5, speed and total compute cost rise by the same factor. A higher λ means speed rises faster than cost.

Inspired by Toby Ord’s analysis, I applied the same approach to Anthropic’s published results on program reconstruction, or ProgramBench. Here again, more speed comes with more cost. But we also see that models within the Claude family are getting better at the speed-cost tradeoff. The newest model, Opus 5.5, gets more speedup for a smaller cost increase than Opus 5 or Fable 5.1.

With five agents, Opus 5.5 gets about 2.7 times its solo speed, compared with 2.2 times for Opus 5, and does so at lower cost. [Note: We’re using total agent runtime as a proxy for cost. Token usage and dollar costs could differ.]

Opus 5.5 gets more speedup for a smaller cost increase than older AI models.Source.

Will these speed-versus-cost gains hold up at hundreds, thousands, or millions of agents? Probably not completely, and certainly not for all tasks.

Some problems are easy to split ten ways, harder to split a hundred ways, and harder still to split among ten thousand agents. More of the work may have to wait for earlier results, and coordinating all those pieces takes work too. Smarter models can get better at this. But my best guess is that, on many problems, each further expansion will buy less speed for the added cost.

Anthropic’s formal math proof benchmark gives us one example.

On the Lean formal math task, we can compare how quickly teams reach the same score. Using Anthropic’s published checkpoints, we estimate the speed and cost of reaching 0.50. The chart starts with ten agents as the baseline.

On a math proof benchmark, the speed advantage of adding additional agents starts to taper with scale.Source.

From ten to thirty agents, speed improves faster than cost. From thirty to a hundred, cost rises faster than speed. The local speed exponent, λ, falls from about 0.75 to 0.33. The extra agents still save time, but the tradeoff gets worse.

This suggests that even speed gains can taper as we split the work among more agents, let alone gains in intelligence. More agents may add less and less as we approach the limits of how easily a problem divides into subproblems. Better coordination may push those limits outward; the task itself may still impose them.

So in speed , more agents can buy us time at some additional cost. Newer models are improving, but there are probably limits. What about intelligence?

Most arguments for superintelligence go beyond running huge numbers of today’s agents. They posit individual models becoming vastly smarter. There’s a chicken-and-egg problem here. Getting there may require conceptual breakthroughs in machine learning itself, perhaps as profound as the ideas that made modern machine learning possible, or at least as important as the Transformer and reasoning models. Parallel search may not be enough to find them. Anthropic has identified ambitious research ideas as an area where current models lag behind humans.

In the previous post, I argued that today’s measured gains from smarter models are roughly five to ten times too weak to produce a self-sustaining feedback loop. But what about running enormous numbers of our best models in parallel? Can a massive team of frontier agents that aren’t yet superintelligent invent a new architecture, a new learning method, or the idea needed to build a much smarter successor? That’s the heart of the question.

For runaway RSI, those discoveries have to overcome the diminishing returns we discussed in the last post. Here are three places they appear.

The diminishing returns a runaway research loop has to change or overcome.

The pre-training example comes from the Chinchilla scaling fit. The reinforcement-learning example comes from ScaleRL. The inference row describes the test-time math curves we discussed previously. The goal is better returns to data and compute, and gains that continue longer before flattening.

My expectation is that we’ll get easy AI improvements through work we can automate, parallelize, and search. But to get very large benefits, and runaway RSI, I expect we’ll need conceptual breakthroughs. That’s why the intelligence of each model matters so much.

Bear in mind that we’ve observed these sorts of diminishing returns in machine learning for more than thirty years. Power-law learning curves were measured in 1993. They appear to be a fundamental feature of machine learning as we know it. We shouldn’t assume they’ll be trivially changed, or that we’ll suddenly find a way to improve AI without diminishing returns. That would be a revolution. Discovering such a route might itself require far smarter minds, and we don’t know whether the mathematics of learning would permit it across the problems we care about.

That doesn’t mean there haven’t been big improvements. The transformer and reasoning models have moved the field forward enormously. But, as we saw in the previous post, a runaway feedback loop needs enough acceleration to keep outweighing the obstacles, again and again. As ideas get harder to find, we may need a faster research pace just to maintain today’s rate of progress. Anthropic’s assessment suggests that better AI tools are becoming necessary just to maintain the current pace of AI progress.

OpenAI’s GPT-5.6 Sol results provide a useful example on cybersecurity. SEC-Bench Pro tests the generation of proof-of-concept demonstrations of software vulnerabilities. This is a particular security task, not a measure of coding ability in general. The reported peak scores are approximately 71.2 with one agent, 74.3 with four, and 76.4 with sixteen.

On this cybersecurity test, sixteen times as many agents buy about 5.2 score points. The first fourfold increase adds 3.1 points; the next adds only 2.1. There’s still plenty of room below a perfect score, but the gain on this test is shrinking, even with multiplication of the number of agents. This is sub-logarithmic scaling.

On SEC-Bench Pro, each expansion buys fewer score points, showing sub-log scaling.Source.

These agents could coordinate through OpenAI’s ultra setup. This is already a test of collaboration, not just a stack of independent guesses. The points are the best reported results across different budgets, rather than an equal-compute comparison.

When OpenAI announced its Navier–Stokes result, the 10,000 agents attracted enormous excitement. Interviewing Noam Brown, Dwarkesh Patel said he was “shocked by the scale of cognitive effort” concentrated into such a short run.

But how much did those extra agents contribute? Brown, an OpenAI researcher who helped develop o1 and now works on multi-agent systems, was emphatic:

“I wouldn’t even attribute 10% of the credit to multi-agent.”

He credits the smarter underlying model. OpenAI hadn’t run the single-agent experiment needed to isolate the swarm’s contribution. Brown’s estimate is a judgment, but it directly challenges the idea that the sheer number of agents was the decisive ingredient.

Formal mathematical work seems especially analogous to the conceptual breakthroughs AI research may need. It demands a chain of valid reasoning, sometimes with a new insight that makes the whole problem tractable. Formalizing existing mathematics isn’t the same as inventing a new learning algorithm, but it’s a useful place to look.

And here we find almost no extra gain when Opus 5.5 grows from ten parallel agents to a hundred. Anthropic’s system card tests teams on 49 weighted theorem statements, checked in Lean. Each team gets 24 hours. The first tenfold expansion adds 27 score points; the next adds just two.

On these math proofs, most of the gain arrives by ten agents. This is steeply sub-logarithmic scaling, and possibly saturationSource.

These agents could communicate, share a machine and Git repository, and organize their work. The hundred-agent team even developed a hierarchy with twelve sub-leads. It could also use ten times as much aggregate agent runtime as the ten-agent team over the same day. That isn’t a measured tenfold increase in tokens, but it gives the larger team much more room to work.

We still didn’t get over the hump. This won’t necessarily stay true, but the diminishing returns are incredibly steep here, possibly pointing toward a plateau.

Opus 5.5 starts smarter than the older models and gets more speedup from parallel agents on ProgramBench. It clearly can put additional agents to useful work. So why do intelligence gains nearly stop on these math proofs? Two possibilities stand out:

• The remaining work may be hard to parallelize. Later steps depend on understanding earlier results.

• The remaining problems may need insights the model can’t find, however many copies we run. Intelligence may matter more than agent population or speed.

We haven’t isolated the cause. But a thousand copies don’t automatically supply the insight one copy is missing.

Looking at the same math results, we see something striking. Ten Opus 5.5 agents get a higher score than a hundred Fable 5.1 or Opus 5.0 agents. Opus 5.5 starts much higher than the older models. It improves substantially with ten agents, then barely improves with a hundred. But at 10 it’s already better than Fable or Opus 5’s results with a hundred agents.

Opus 5.5 starts stronger, but its team gains flatten quickly.Source.

Ten Opus 5.5 agents beat a hundred Opus 5 agents on these math proofs. They beat a hundred Fable 5.1 agents too. The stronger model does more with one-tenth as many agents.

Ten Opus 5.5 agents are able to solve problems a hundred older-model agents can’t.Source.

We saw an analogous pattern with test-time compute in the previous post. OpenAI’s internal model starts far above Astra on the curated math problems below. Even its lowest displayed result beats Astra’s highest. Changing the model gives a much bigger boost than spending more compute on Astra over the tested range.

A stronger model makes the bigger difference than more test-time compute in solving previously-unsolved math problems.Source.

A rough extrapolation of Astra’s line suggests it would need about 300 times as much compute as the internal model to match the internal model’s lowest plotted score. And that extrapolation itself is an unknown. It’s quite possible that Astra would just plateau before ever matching the OpenAI internal model’s results with far less compute.

Does adding different minds help? A study of model and persona diversity found substantial gains as diverse teams grew to eight agents. After that, the average across its tasks barely moved.

Diversity of AI models helps, but the gains flatten after eight to twelve agents.Source.

Other approaches, including X-MAS and Aitchison and colleagues’ forecasting study, find useful gains from combining different models. But none of these results demonstrates sustained improvement over many expansions of the team. The first study directly shows flattening; the others test smaller ranges.

It’s plausible that today’s models simply aren’t diverse enough. LLMs often produce strikingly similar ideas. Perhaps we need bigger changes in how these minds are trained. We’ll return to whether more deliberately different agents could change the curves.

All of the above examples show sub-logarithmic scaling , roughly the hardest kind. That said, some experiments show slightly easier diminishing returns, indicating roughly the same gain from each multiplication of parallel work. That’s logarithmic scaling. It’s better, but still steep diminishing returns. If that’s how useful research grows while each further AI improvement gets harder to find, even billions of agents don’t make a self-sustaining RSI loop look plausible.

In Ryan Greenblatt’s ARC experiment, a model generated and checked many candidate programs. More samples kept improving its score, by roughly the same amount per doubling. This is parallel search rather than a communicating research team, but it gives us a useful comparison.

Parallel search keeps improving, with logarithmic returns.Source.

A molecular-exploration study found a similar logarithmic pattern as it grew from one to 128 agents. Multiple agents explored chemical targets more effectively than one agent given the same total evaluation budget. Each agent learned as it searched.

More AI agents explore more chemical targets, with logarithmic diminishing returns.Source.

There are encouraging results from communicating teams too, including Argus on web research and Microsoft and Berkeley’s work on ARC-AGI-3. The latter finds unusually strong gains from one to five agents. Those results deserve attention; we still need to see what happens with much larger teams.

Logarithmic gains are better than the sub-logarithmic curves we saw earlier. Each tenfold expansion keeps buying the same extra increment, instead of less each time. But both shapes rise drastically more slowly than the research gains assumed in hypothetical models of self-sustaining or runaway RSI. Let’s put them side by side.

Some work can be split into independent searches or experiments. Other work needs the previous result before it can proceed. And some problems may need a higher level of intelligence or a conceptual breakthrough before we even know how to divide them. Here’s a very tentative and relatively subjective stab at which problems will scale best and worse with multiple agents. The chart runs from work that seems easiest to parallelize at the top to the hardest at the bottom. I’m sure others have many thoughts here, and that this can be much improved upon.

From work that seems easiest to parallelize to the hardest.

Will a million or a billion parallel AIs get us to self-sustaining or runaway RSI? Let’s do the math.

Hypothetical software-RSI models assume that a growing number of AI researchers produces a much larger stream of discoveries. Those discoveries make AI cheaper or more productive, allowing the next round of research to grow again.

There’s a strong case for gains in speed and for searching more of a well-defined space. Even speed gains, as we’ve seen, can taper. Intelligence is much harder to boost through parallel agents. In several experiments, peak problem-solving performance (what I’m referring to here as intelligence) rises dramatically more slowly than speed.

Here’s what three software-RSI models assume:

• Chan and colleagues (2026): doubling effective research labor produces about 2.6 times the rate of software improvement , holding the software level fixed. I find that implausible as a general assumption about adding copies of today’s AI models. The clearest large-team intelligence experiments look nothing like that.

• Eth and Davidson (2025): their illustrative team produces twice as many papers from twice as many researchers. The accelerating example assumes that the number of researchers grows faster than the work required for each further improvement.

• Tom Davidson and Tom Houlden (2025): their central exponent for parallel research effort is 0.6. Ten times the labor gives about four times the research pace. They cut that exponent in half, to 0.3, when experimental compute is held fixed and becomes a bottleneck. The benchmark reports above don’t appear to have been limited by experimental compute, so we’re using 0.6 here.

The top half of the next chart shows research-output relationships used in hypothetical RSI models where AI self-improvement can sustain itself or accelerate. The bottom half shows real-world intelligence shapes from the benchmark experiments. Those experiments show dramatically less gain from running parallel agents than the hypothetical RSI models assume.

Hypothetical research curves rise much faster than these benchmark shapes.

Let’s put these onto a single chart. We give every curve the same gain from its first expansion from one to ten agents or researchers, so we can compare their shapes.

The same starting gain, very different later returns.

Now let’s zoom in on the gap. The real-world shapes sit in a very different zone from the gains assumed in those RSI models, even when we let the math-proof curve keep rising slowly.

Zooming in makes the gap clearer. Hypothetical RSI models show much faster gains from adding more agents than empirical models based on real-world experiments.

Today’s hypothetical RSI models assume gains from additional AI researchers that we haven’t seen in these real-world experiments. Removing humans from the loop doesn’t remove shared blind spots or sequential dependencies. Adding more copies of today’s models hasn’t shown the sustained intelligence gains that may be needed for repeated conceptual breakthroughs.

I do expect better AI models to get better at spreading work across agents: dividing the problem, managing collaborators, and combining what they find. We’ve already seen progress in speed on program reconstruction. We haven’t seen a clear trend toward better multi-agent intelligence scaling in the math results. More on that in a moment.

First, an encouraging analogy: single-agent thinking-time scaling. Toby Ord’s analysis suggests that humans get more relative benefit from additional time than these AIs get from additional reasoning tokens. That may surprise people. But newer models are getting closer to the human reference on these cybersecurity tasks.

AI agents can get stuck in cognitive ruts, repeating or refining an approach that isn’t getting them far. Newer models seem to be improving at how they use extended thinking.

Newer models make better use of extra thinking tokens on these cyber tasks.Source.

This isn’t multi-agent scaling, but it’s encouraging. AIs were poor at turning more thinking into harder solved tasks, and that scaling parameter improved. They might eventually pass the human reference. That’s part of why I don’t see runaway RSI as imminent, yet think it could become more plausible as these capabilities change.

We’ve also seen new findings on helping agents escape their ruts and use more thinking time productively. The new Fork-and-Flush study periodically creates parallel branches that keep the accumulated work but start with fresh chat contexts, then continues from the best branch. It improved results across thirteen research and engineering tasks at the same compute budget. That’s a concrete research direction for using additional work more effectively.

So, have we seen a similar improvement in multi-agent scaling? For speed, sometimes. For intelligence, there’s no clear direction , so far, at least on formal math proofs. Opus 5.5 gets more speedup for a smaller cost increase on program reconstruction. But the score gains in the chart below are noisy, and newer models don’t consistently get a larger boost from additional agents.

Newer models don’t get consistently large gains from larger math-proof teams.Source.

That doesn’t mean better multi-agent scaling won’t happen. I expect the labs to work hard on coordination. Improving diversity of thought is a more open research question, but I’m sure it’s at least somewhat tractable given sufficient effort. The structure of the problem may impose the hardest limits: some discoveries have to happen before the next useful step becomes possible. We don’t yet know how much each of these constraints contributes.

Summarizing what we’ve seen, here’s an update on the conceptual limits to multi-agent scaling.

What we’ve learned so far, and where the hardest limits might be.

Frontier models share many of the same broad training ingredients: overlapping public data, related algorithms, and similar reasoning and coding exercises. So how different are these minds really?

The Artificial Hivemind study found striking similarities in models’ open-ended responses. A creativity study involving 467 people likewise found that adding AI responses eventually contributed less diversity than adding human responses. These experiments suggest that AI agents can bring less diversity of thought than an equal number of humans on these tasks, which may limit how much we get from parallel agents.

Can we make agents more different from each other? Very likely. Here are four ideas. I’m sure there are others:

• Different training experiences: vary data mixtures, curricula, reinforcement-learning environments, and reward objectives to develop strong agents that favor different useful approaches.

• Complementary specializations: combine agents trained for conjecturing, finding lemmas, searching for counterexamples, and checking proofs. Test whether their strengths combine into results no member reliably achieves alone.

• Independent proposals before discussion: let agents develop approaches before seeing one another’s answers, then exchange evidence and criticism. Test whether this reduces early convergence on the same mistake.

• Teams chosen for complementary errors: select members whose successes and failures overlap less, rather than relying only on individual benchmark rank. Measure whether the team finds more verified solutions as it grows.

As we discussed in the previous post, we’re going off of scant data here. This model could be wrong. Or newer AI versions could get sufficiently better at doing parallel work that these diminishing returns would change. If that happens, we need to be aware of it.

How would we track this? I’d propose measuring three things from new AI models across a variety of problem times. Across each task type, and especially across real world AI research, measure three parameters and track how they change as newer models arrive:

• G - Intelligence scaling: How much verified task performance does each multiplication of agents add? Measure local score gains, slopes, or exponents as appropriate. This is a task-specific proxy for collective intelligence, not a universal intelligence unit.

• λ - Speed-cost scaling: How much faster does the team reach the same result, and how much more total compute or agent-time does it use? Track the speed exponent λ over successive team-size ranges.

• N - Where gains weaken or saturate: At what team size do the score or speed curves bend, or approach a ceiling? Does the bend or onset of saturation move outward with newer models?

Track intelligence gains, the speed-cost tradeoff, and where gains weaken or saturate.

G and N answer two different questions. How much extra benchmark score does a defined team expansion buy, and how many agents can we add before those gains flatten? In the illustration below, G is the gain from one to ten agents. N is the agent count where the curve reaches its plateau. A real curve may have a gradual bend rather than a sharp plateau, or no plateau within the tested range.

One hypothetical benchmark curve. G is the added score from a specified expansion of the team; N is the agent count where gains flatten. The illustrated sharp plateau is not assumed for every real task.

Watch these parameters over time, especially G and N. Don’t stop at one to ten agents. Measure the gains from 1→10, 10→100, and 100→1,000 agents , separately, on each benchmark. A newer model might scale better over the first interval and worse over the next. We need to know whether the gains improve and whether the bend moves outward.

Three hypothetical trends for added benchmark score across model generations. Measure each expansion separately: 1 to 10, 10 to 100, and 100 to 1,000 agents. Different intervals can follow different paths.

We especially need to track these trends for actual internal AI research. Are newer models getting bigger gains from larger teams? Are those teams producing more verified discoveries and better successor models? That’s what would tell us whether massive parallel teams are getting closer to the conceptual breakthroughs RSI may need.

Anthropic has given us a concrete test to watch. Its October employment report shows research agents logging about nine hours for every human work-hour by mid-July , and nineteen by late August. The company-wide ratio reached about six.

Research agent runtime rises to about nine hours per human work-hour by mid-July and nineteen by late August. These hours include longer operation as well as parallel agents.Source.

Let’s make a generous assumption: each agent-hour is as valuable as a human research-hour , with the number of human researchers unchanged. Agents can run throughout the 168-hour week. Anthropic’s runtime ratios already count those extra operating hours against a forty-hour human week.

On that assumption, July’s nine agent-hours plus one human hour amount to ten times the labor of humans alone. August’s total is twenty times. But Anthropic already had roughly one agent-hour per human hour in April. Compared with that observed baseline, total labor grew fivefold by July and tenfold by August.

What should that do to research? Treat the added labor as parallel research effort. Davidson and Houlden’s relationships imply about 2–4 times April’s research pace by August , depending on whether experimental compute becomes a bottleneck. Applying the labor exponent used by Alan Chan and colleagues, including Geoffrey Hinton and Yoshua Bengio, gives about 25 times. Log scaling gives about twice the pace. Our sub-log shapes give only about 1.1–1.8 times.

Now translate research pace into the Epoch Capabilities Index (ECI). Suppose software research supplies half of baseline capability improvement, while the compute-growth contribution stays unchanged. Then four times the software pace means about 2.5 times the overall ECI slope , not four times. We’re already discounting the software boost. Other obstacles could reduce it further.

Allow six months from research to public release. Here’s what those assumptions imply for January and February 2027. The top group uses hypothetical RSI research relationships; the bottom group extends experimental benchmark shapes.

What different RSI models predict we should see in the pace of AI improvement (using ECI slope), six months after an AI labor increase.Source.

Why do log scaling and Davidson-Houlden’s power 0.3 nearly tie? This is only a tenfold labor increase from April to August. At that scale, both calibrations give about twice the software pace. By 100 agents and then a billion, the hypothetical power law curve pulls far ahead of the experimentally-observed log and sub-log scaling rules.

Around late May, agents were already logging about three hours per human hour: twice April’s total labor on our assumption. With a six-month lag, that earlier signal would arrive around November.

These tests have many different assumptions, including equal value per hour and treating added runtime as parallel labor. I’m open to refining them on how others think about this. In measurement, we should judge the AI pace of improvement as the rate of at which ECI score goes up over successive releases, allowing for development and publication delays.

Personally, I don’t expect to see sustained acceleration of Anthropic’s AI progress (as measured by ECI) through the first half of 2027, and certainly not one as large as these simple extrapolations from the hypothetical models of Davidson and Houlden or Chan and colleagues suggest. If anything, I expect acceleration at the low end of the sub-log scaling bar at the bottom of the chart.

I could be wrong for many reasons. Parallel search of different AI training parameters, or use of AI to code new RL environments, or gains from AIs combining existing ideas in the literature could all make a bigger difference than I expect. Or, at the next increment of AI improvement, AIs could start making much more major advances in machine learning theory that allow us to bend the scaling laws and other diminishing returns that AI faces, or to add new axis of scaling, as reasoning models did.

On the other hand, while more parallel search and recombination of existing ideas seems highly likely, they may not bring huge advantages, and the AIs we’re making today might not find conceptual breakthroughs. Atop that, ideas probably really are getting harder to find in AI, and that may chew up some or all of the increased capacity of AI to work on improving itself.

We shall see. If we see the rate of AI improvement increase significantly, I’ll update my views in proportion to what the data show.

In summary, for now, multi-agent scaling shows incredibly steep diminishing returns to model intelligence, or the ability to reach conceptual breakthroughs. I expect those sorts of breakthroughs to be necessary for major AI advances and for self-sustaining RSI, let alone a runaway intelligence explosion. And at the same time, we’re all operating on far too little real world data. The most important thing we can do now and for the months and years ahead is to rigorously collect that data, and use it to update our forecasts of the future.

---

Share