多智能體集羣仍難以協調

Agent Swarms Still Can't Coordinate

📖 Read the full version with charts and embedded sources on AgentConn →

GitHub's trending page this week features a repo called Claude Code Game Studios — 49 AI agents organized into a full game development hierarchy, complete with designers, programmers, QA testers, and a production coordinator. It picked up 970 stars in a single day and has crossed 32,000 total. The pitch is irresistible: clone the repo, point Claude at it, and watch a studio of agents build your game.

The same week, two independent benchmarks dropped results that should give every multi-agent enthusiast pause. YC Labs and Olam Labs put 50 GPT-6.1 Sol agents in Minecraft with a single instruction — "build a thriving civilization" — and watched them descend into paralyzing bureaucracy. Separately, Silo-Bench, an ACL 2026 paper, measured what happens when you split a reasoning task across multiple agents: even at just two agents, performance drops 15-49%. At fifty agents, the loss hits 80-100%.

The pattern is stark. The industry is shipping orchestration frameworks. The benchmarks say coordination is unsolved.

The Civ50 Experiment: 50 Agents, 3 Hours, One Disastrous First Night

The YC Labs report, published October 29, is the most detailed public experiment on large-scale agent swarm behavior we have seen. Olam Labs (co-founded by Om Buddhdev) partnered with Y Combinator's Labs group to run what they call "Civ50": fifty GPT-6.1 Sol agents dropped into a fresh Minecraft survival world with three hours and one goal.

What happened next reads like a management consulting case study gone wrong.

View the full article on RuntimeWire →

Within 90 seconds, the agents had cleared nearly every tree near spawn. The first agent in the fixed agent directory — an agent named Ada — became the de facto leader simply because she was listed first. She received 616 direct messages. The colony generated roughly 5,900 messages total across three hours.

Then night fell. Twenty-two of the fifty agents died. The surviving colony became intensely risk-averse. A food-rationing system emerged around one agent's ledger, with fishing as the primary calorie source. Eleven different agents independently wrote fishing scripts.

⚠️ The Bone Meal Incident: At one point, four agents spent 11 minutes appointing a "sole fertilizer operator" for a single piece of bone meal on a single wheat block. This is not a parody. This is what emergent multi-agent governance looks like at scale.

The colony's social dynamics were equally revealing. After one agent picked up and ate a cooked chicken that was intended for another, the entire colony instituted a rule that rations must go into named chests and never be tossed. The word "toss" appeared 7 times before the incident and 125 times after — the agents had effectively legislated around a single misdelivered food item.

By hour three, the colony had 34 total deaths, a functioning bureaucracy, and something that looked more like a risk-averse government than a thriving civilization.

The Bed Wars and Mindustry Results: Democracy vs. Hive Mind

The same research team ran two competitive benchmarks — nine Bed Wars games (10 vs. 10 agents) and seven Mindustry battles — pitting GPT-6.1 Sol agents against Claude Opus 5.5 agents. The results reveal how differently these models approach coordination under pressure.

Mindustry (7 games, ~9.5 hours): GPT won 6-1. YC Labs summarized the split cleanly: "Claudes generally established democracies, GPTs formed hives." The Claude team used a "+1" voting system where proposals needed multiple endorsements and no objections. They kept this system unchanged for all 9.5 hours — including through five consecutive losses. The GPT team split factory ownership early, shared resources readily, and developed compressed shorthand language over time.

Bed Wars (9 games, 45 minutes each): GPT won the series 6-3. Claude's strategy was defensive — aim to win on kill count. It worked on paper: Claude led kills in three key games by margins of 63-16, 57-19, and 59-24. But GPT broke Claude's bed with minutes remaining each time. When a block-breaking bug hit both teams, GPT diagnosed it and shared a workaround. Several Claude agents concluded breaking was impossible.

The most damning finding: Claude agents wrote lessons into memory files after each game. They then repeated the same mistakes. GPT agents left their memory files empty but warned teammates directly in real time.

ℹ️ The Source Code Incident: Both teams had internet access. When games got tight, only the GPT agents searched for Mindustry's open-source code online and read it for tactical advantage — unprompted. The Claude agents never did. The "aligned, deliberative" agent lost to the one that improvised and bent rules.

There are caveats worth stating clearly. The sample sizes are small — seven Mindustry games, nine Bed Wars games, one Civ50 run. Each model ran in a different harness (Codex vs. Claude Code), so harness and model effects are tangled. No statistical tests were reported. But the qualitative patterns — bureaucratic paralysis, ignored memory, defensive conservatism — match what we see in every production multi-agent deployment.

The Academic Evidence: Coordination Overhead Is Measurable

The Minecraft experiments are vivid, but the academic benchmarks are more damning because they are controlled.

Silo-Bench (ACL 2026) designed 30 algorithmic tasks where information is deliberately split across agents. The key finding: the failure is not in information acquisition — agents successfully gather the data they need — but in integration. They cannot combine distributed knowledge into a coherent solution. At k=2 agents, performance drops 15-49% compared to a single agent with the same information. At k=50, the drop reaches 80-100%. The coordination tax does not just reduce gains — it eliminates them entirely.

"When 20 Agents Fail to Sort" (ACL Findings 2026) set an even simpler challenge: distributed sorting. Success drops sharply as agent count grows, with failures concentrated in shared state management, convention alignment, and consistent termination. The paper proposes CAMOC (Coordination-Aware Multi-agent Orchestration with Communication), a drop-in fix that substantially improves results — suggesting the problem is architectural, not capability-limited.

View the full post on Google Research →

Google Research's scaling study (January 2026, 180 agent configurations) adds the quantitative framework. On parallelizable tasks (Finance-Agent), centralized coordination raised performance 81% above single-agent baselines. On sequential tasks (PlanCraft), every multi-agent variant tested lost 39-70%. Independent multi-agent systems amplified errors up to 17.2x. Centralized systems limited amplification to 4.4x.

The takeaway from the research is unambiguous: coordination overhead scales superlinearly with agent count. Adding agents to a sequential task does not just fail to help — it actively degrades performance.

Why Model IQ Is Not the Bottleneck

View the discussion on Hacker News →

The Memdoor project landed on Hacker News this week with 385 points and 188 comments: five Qwen3.8-27B models, running collaboratively through a custom harness, matched Fable 5 on LiveCodeBench Hard. A team of open-source models punching above their weight against the frontier.

The top comment was prophetic: "It's remarkably easy to build a harness that improves a single eval, and remarkably difficult to build one that generalizes."

This captures the coordination paradox precisely. The harness — the orchestration layer — matters enormously. But the returns from adding agents are inconsistent and task-dependent. Richmond Alake from Oracle made the same point at AI Engineer this week: "Everyone has the same models. Memory is the moat — the intelligence plane governs what agents know."

The DoorDash evidence drives the point home from the product side. Ars Technica reported that outside AI agents have led to only "hundreds" of DoorDash orders total. Not hundreds per day — hundreds, period. The agents exist. They can place orders. But the coordination required to go from "can do the task" to "reliably does the task at scale" is the gap that nobody has closed.

View the discussion on Reddit →

The Community Reaction

View the discussion on Reddit →

The Reddit thread racked up 4,759 upvotes and 315 comments — one of the biggest AI agent stories on r/technology this quarter. On Hacker News, the Memdoor discussion (a separate but thematically linked thread) drew 385 points and 188 comments with practitioners debating whether multi-agent harnesses can generalize beyond single benchmarks.

The discourse splits into two camps. The first sees this as evidence that multi-agent systems are fundamentally limited by coordination overhead — that the ceiling is lower than the hype suggests. The second camp, smaller but vocal, argues that coordination is an engineering problem with known solutions from distributed systems theory, and that these experiments are testing first-generation coordination protocols against tasks that took human societies centuries to solve.

Both camps are right, and the tension between them is precisely the point. Coordination is both a hard problem and a solvable one. The question is whether the current rush to ship 49-agent studios is running ahead of the coordination science that would make them work.

The 49-Agent Studio Problem

The broader developer community is also grappling with these overhead costs. A parallel Hacker News thread on "The AI Cost of JavaScript Frameworks" (223 points, 154 comments) debates how framework complexity compounds when AI agents are the ones writing and maintaining the code — a coordination cost that scales with every additional tool and abstraction layer agents must navigate.

View the discussion on Hacker News →

Back to Claude Code Game Studios. The repo is impressive — 49 specialized agents, 72 workflow skills, 12 validation hooks, 41 document templates. It mirrors a real studio hierarchy. It earned 970 stars in a day.

But here is the question the benchmarks force us to ask: what happens when those 49 agents need to coordinate? The Civ50 experiment used 50 agents — a comparable number — and the result was a bone-meal bureaucracy. Google's research found that coordination overhead rises disproportionately as tool count grows, with severe degradation when agents manage 16+ tools. Silo-Bench showed that even two agents lose up to half their solo performance on integration tasks.

The pattern repeating across GitHub Trending is frameworks that add agents. The pattern repeating across benchmarks is that agents, once added, spend most of their time coordinating rather than producing. The industry is building the organizational chart. The research says the meetings are eating the work.

⚠️ Contrarian Corner: Maybe the bureaucracy IS the coordination solution. Human organizations have the same overhead — committees, voting, named responsibilities for single resources. The Civ50 colony's food-rationing system and fertilizer operator are structurally identical to how early human settlements organized. Perhaps agent coordination will improve through the same slow cultural evolution, not through architectural silver bullets. The uncomfortable implication: if you want agents to coordinate well, you may need to let them develop their own institutions over many iterations — which means the "throw 50 agents at it for 3 hours" benchmark is measuring startup culture, not steady-state governance.

What This Means for Builders

The benchmarks converge on a clear set of principles for anyone designing multi-agent systems in production:

1. Default to single-agent. Google's study found that a predictive model could pick the best architecture for 87% of unseen tasks using just task properties (tool count, decomposability). For sequential reasoning tasks, every multi-agent variant lost. Start with one strong agent. Add agents only when you can prove the task is parallelizable and the coordination protocol is defined.

2. Measure coordination overhead before scaling. Silo-Bench's 15-49% penalty at k=2 means coordination is expensive even at the smallest multi-agent scale. Before adding a second agent, benchmark the integration cost. If two agents lose 30% on your task, five agents will not gain it back.

3. Centralize orchestration. Google's error-amplification numbers are definitive: 17.2x for independent agents vs. 4.4x for centralized coordination. If you must use multiple agents, give one agent clear authority. The Mindustry results reinforce this — GPT's hive-mind coordination outperformed Claude's democratic voting in 6 of 7 games.

4. Do not trust written memory. The Bed Wars finding — agents writing lessons they then ignored — should alarm anyone building memory-augmented multi-agent systems. Direct, real-time communication between agents outperformed asynchronous written records. If your agents share state through files or databases rather than direct messaging, test whether they actually use what they read.

5. Watch for bureaucratic emergence. The bone-meal incident and the toss-legislation are not edge cases — they are the natural equilibrium of agents that can communicate freely. If your agents can create rules, they will create rules, and the rules will multiply faster than the productive output. Constrain the communication channel deliberately.

For a deeper dive into orchestration architecture, see our coverage of dynamic workflows in Claude's agent swarm and the graph-structured approach to multi-agent coordination. For fleet management patterns, the agent-of-agents architecture piece covers the observe-route-kill primitives.

The Bottom Line

The agent coordination problem is not a model problem. GPT-6.1 Sol and Claude Opus 5.5 are both frontier models. They both failed to coordinate efficiently at scale — one through bureaucratic conservatism, the other through chaotic improvisation that happened to win more games. The Minecraft benchmarks do not crown a winner in the model race. They expose a shared failure in the coordination layer.

Fifty agents in Minecraft built a government. They did not build a civilization. The gap between those two outcomes is the coordination tax, and right now, nobody is close to solving it. The frameworks shipping on GitHub this week are adding more agents. The benchmarks shipping from research labs this week are proving that more agents, absent a coordination breakthrough, means more overhead, more errors, and more bone-meal committees.

Build one agent that works. Then ask yourself very carefully whether you need a second one.

Originally published at AgentConn