Agent Swarms Scale Mistakes Too. The Fix Is a Self-Verifying Loop.

TL;DR

Agent swarms have a quiet failure mode: more agents means more output and more confident mistakes at the same rate. Point 300 agents at a research job and a handful will hallucinate a number or cite a dead link, and the finished report looks identical to a perfect one. The fix is not fewer agents, it is a verify stage: a strong model checks every result against a live source, rejects what fails, and reruns it until nothing fails. Moonshot's new Kimi Work and its open-weight Kimi K2.6 are what make running that loop cheap.

The dirty secret of swarms

A swarm with no verifier has exactly one quality setting: whatever the worst agent produced. If 97 of 100 agents nail their company and 3 quietly invent a revenue figure, your report ships with three landmines that look exactly like the 97 good rows. You find out which three when it blows up in a meeting.

This is why "just add more agents" plateaus. Volume scales the output and the error count together. More hands, more mistakes, and still nobody checking. Speed was never the hard part of swarms. Trust was.

The fix: make verification a real stage

The builder behind the demo, who posts as 0xRicker, stopped treating the swarm as the finish line and made it one stage of a loop. A planner model (Opus 4.8 in their setup) writes the work and a checklist, the Kimi K2.6 swarm executes, and then the planner verifies every output against the source it claimed to use. A number that does not match gets rejected. A citation that does not resolve gets rejected. Rejected tasks go back in the queue with the reason attached and run again. The loop stops only when nothing fails.

To stress it, they pointed the loop at a job that punishes hallucination hard: research 100 EV-market companies into a comparison matrix with every figure traced to a live feed. The first verify pass rejected 12 of 100 (a revenue figure that did not match its feed, two sources that would not resolve, one empty margin field). Second pass: 3 still failed. Third pass: zero, and the loop stopped on its own. A raw swarm would have shipped those 12 and called it done. Treat the exact tally as one person's demo, but the mechanism is the point.

A swarm gives you speed. A loop gives you speed you can actually trust. The difference is the verify step.

If this sounds familiar, it is the swarm cousin of loop engineering: a loop is only as good as the gate at the end of it. There the gate was out-of-sample data; here it is a live source the claimed number has to match. Same lesson, different failure mode.

Why this is happening now: Kimi K2.6

The reason a 300-agent loop is even practical is the engine underneath. On June 12 Moonshot AI, a Beijing lab, launched Kimi Work, a local desktop agent for macOS and Windows that runs a swarm of up to 300 sub-agents, with browser automation, cron scheduling, and local file and code execution. It reportedly runs on Kimi K2.6, Moonshot's open-weight mixture-of-experts model from April that activates about 32B parameters per token, carries a 256K context window, and is documented to coordinate up to 4,000 steps.

The numbers that matter for a verify loop are cost and openness. Kimi K2.6 ranks #1 among open-weight models on Artificial Analysis (and #4 across all models they test), topped OpenRouter's weekly usage leaderboard, and matches the closed flagships on some coding benchmarks while costing a fraction per token. A verify loop reruns failed work over and over, so the per-token price of the executor is the whole budget. Cheap and open is exactly what turns "run it again until clean" from a luxury into the default.

The division of labor worth stealing

The pattern is not "use Kimi." It is the split. A strong, expensive model does the two things that need judgment: planning the work and verifying it against sources. A cheap, fast, open-weight swarm does the bulk execution. You spend your best model's tokens on the steps where being wrong is expensive, and a commodity swarm on the steps where volume is the point.

This also dissolves the false choice between "one smart agent" and "a giant swarm." The smart agent is your referee, the swarm is your workforce, and the loop is what connects them.

Where it can still go wrong

Verification is only as strong as two things: the checklist and the sources. The reason this kind of loop can be strict instead of vague is that every figure points to a real, live feed (the author wired in Binance, Yahoo Finance, the World Bank, the IMF, and live market data). Verifying then means checking the claimed number against the actual feed, not asking the model whether it feels confident. Without resolvable sources, "verify" quietly degrades into a second model guessing.

Two more caveats. The whole thing is one builder's demo, and the launch coverage notes Kimi Work only "reportedly" runs on K2.6. And a loop that reruns until clean burns compute on every failed pass, so a sloppy checklist that rejects too much can spin. The win is real, but it is not free.

Raw swarm vs self-verifying loop

• Raw swarm: runs once, hides errors in the result, quality equals the worst agent, and you audit every row by hand.
• Self-verifying loop: runs until the verify pass is clean, reruns failures automatically, quality equals the checklist, and every figure traces to a live source.

Key Takeaways

• Swarms scale errors as fast as output. A few hallucinated rows in a hundred look identical to perfect ones, so volume without verification is just faster mistakes.
• The verify stage is the whole idea. Check each output against its live source, reject and requeue failures, and stop only when nothing fails.
• Split the work by cost of being wrong. A strong model plans and verifies; a cheap open-weight swarm executes; the loop connects them.
• Open and cheap is what makes looping affordable. Kimi K2.6 being top of the open-weight pack and far cheaper than closed flagships is why rerun-until-clean is practical.
• Verification needs real sources. Strict checking requires resolvable live feeds to check against; without them, "verify" is just a second guess.

Sources: MarkTechPost: Moonshot AI launches Kimi Work, 0xRicker on X (the self-verifying loop demo), Kimi K2.6 on OpenRouter