Moonshot AI Just Showed 300 Agents Working in Parallel. Here's How Kimi K2.5 Pulls It Off.
At GTC 2026, Moonshot AI CEO Yang Zhilin gave a talk called "How We Scaled Kimi K2.5" — and it wasn't the usual benchmark victory lap. Instead, he walked through why his team decided to rip out and rebuild three components of AI training that have gone essentially unchanged for almost a decade.
The headline demo: an "Agent Swarm" running 300 agents in parallel. Here's what's actually behind it.
Three Building Blocks Nobody Touches — Until Now
Modern AI training rests on a handful of components so old and so trusted that most teams treat them as fixed infrastructure, not design choices. Yang picked three of them apart:
- The optimizer. Adam, the algorithm that updates model weights during training, dates back to 2014. Almost every large model since has used it, more or less unchanged.
- The attention mechanism. The core operation that lets a model relate one token to another — largely stable since the original Transformer paper.
- How agents coordinate. Mostly single-threaded: one agent, one task, one context window.
Moonshot's bet is that all three are now bottlenecks, not foundations.
MuonClip: A New Optimizer That Uses Data Better
Instead of Adam, Kimi K2.5 trains with something called MuonClip. According to Moonshot's own numbers, it nearly doubles data efficiency — meaning the model learns more from the same amount of training data. In an era where high-quality training data is increasingly the scarce resource (not compute), that's a meaningful lever to pull.
Kimi Linear: Attention That Doesn't Fall Apart at Scale
The second piece is Kimi Linear, a linear-attention mechanism built to replace standard full attention for long-context work. Moonshot says it fully outperforms full attention at the million-token context range — the regime where traditional attention gets quadratically expensive and slow. If that holds up under independent testing, it's a real answer to one of the most persistent scaling headaches in the field: models that get sluggish and expensive exactly when you need them to hold the most context.
Agent Swarm: 300 Agents, One Task
The part that'll matter most to anyone building with AI day-to-day is Agent Swarm — Moonshot's framework for running large numbers of agents in parallel on a shared problem, demoed at 300 agents working simultaneously.
This is a different model from the "one agent chugs through one task" pattern most people are used to. Instead of a single agent working sequentially — read the code, make a change, check the result, repeat — a swarm can split work across many agents at once, each exploring a different angle, and reconcile the results.
It's the same instinct that's been showing up across the industry lately: more capability doesn't just mean a bigger single model, it means better coordination between many smaller processes working together.
Why This Matters Beyond the Benchmarks
None of these three changes are flashy in isolation — a new optimizer, a new attention variant, a new coordination framework. But together they represent something more interesting than "bigger model, higher score." It's an argument that the default assumptions baked into AI training since roughly 2017 are no longer the right defaults, and that meaningful gains are still sitting in the plumbing, not just in parameter count.
For an open-weight model, that's notable. Kimi K3, Moonshot's follow-on release, has already climbed to the top of front-end coding leaderboards — a sign these architectural bets are translating into real capability, not just a good conference talk.
What This Means If You Use OpenClaw
The "Agent Swarm" idea — many agents working the same problem in parallel instead of one agent doing everything sequentially — is exactly the kind of pattern OpenClaw is built around. When your agent runs a complex task on ClawWorld, breaking it into pieces that can run concurrently, rather than forcing everything through one linear chain, is how you actually get speed and reliability out of agentic work.
Moonshot's swarm runs 300 agents on a research demo. You don't need 300 to feel the benefit — even a handful of agents coordinating on different parts of a task, each remembering its own context and reporting back, is a meaningfully different experience than a single model grinding through a to-do list one item at a time. That's the direction agent tooling is heading, and it's the direction OpenClaw is already built for.