A Bot Is a Chat; 300 Agents Make a System
A single agent hits a wall—the problem isn't the model, it's the shape. Grokbot handles routing, 300 Kimi K3s run as the runtime, shared memory uses a unified format, and no code is written throughout. One request goes in, one reviewed result comes out.
One Bot answers one question at a time; that's chat. Give the Bot a router, four ways of dividing work, a shared memory, and 300 Kimi Agents running in the background, and it becomes a system.
At the start of the guide, Ricker writes something blunt: “Your Grokbot is smart. It's also lonely, and loneliness is the ceiling.” When Morty reposted it, he added: Lauren Tan's bot team is essentially an “anti-chaos layer” for AI work. You throw in a messy requirement, and what comes out is a clear plan, parallel workflows, and checked output. It's not manually prompting five different agents and then stitching the results together yourself; the workflow handles the coordination in between.
One request goes in, one reviewed result comes out.
The interesting part isn't that there are more agents. It's that you no longer have to orchestrate them yourself.
Why a single Bot hits the wall
Ask a Bot to do something small, and it does a great job. Ask it to do something big—like scan the market for 80 companies and make recommendations—and you can watch it hit the wall. As it reads, it forgets what came earlier; the second half wraps up hastily, and it hands back something confident but thin.
The problem isn't the model; it's the shape. One agent, one context, one pass—everything has to be crammed in: instructions, every source it read, half-finished ideas, drafts. The bigger the task, the fuller the context, and quality starts collapsing in the second half.
On the left, one agent carries the entire scan, and by company 50 it has no room left. After that, every company is read poorly. On the right, the same job is split into 8 parts; each agent carries only 10 companies plus the shared brief, and all of them stay in their comfort zone. Same total volume, no breakdown at the end.
Splitting isn't just about saving space. An agent that only needs to compare pricing pages performs better than an agent simultaneously keeping track of the brief, the format, and 70 companies. A multi-agent system isn't a bigger brain; it's many focused brains.
Grokbot as router, Kimi K3 as runtime
The core change: don't let Grokbot answer requests directly. Every request first goes through one question—what shape is this work? Grokbot looks at the request and routes it into one of four lanes:
- Fan-out: many independent items, scanning 80 companies
- Chain: each step depends on the previous one, research → draft → edit
- Debate: judgment-type, no single answer, should we launch?
- Supervisor: long and messy, may fail, building and testing tools
The Router is just a prompt. It only requires classification, a one-line reason, and generating a brief for Kimi; it does no actual work.
grokbot · router prompt
You are a router. Never do the work yourself.
For every request, pick ONE pattern and hand off to Kimi:
FAN-OUT many independent items (scan 80 companies)
CHAIN each step needs the last (research → draft → edit)
DEBATE judgment, no single answer (should we launch?)
SUPERVISOR long, messy, may fail (build + test a tool)
Output: pattern, one-line reason, the brief for Kimi.
If unsure between two patterns, pick the simpler one.
Kimi K3 is the runtime. Inside Kimi's Agent Swarm, it can launch 300 parallel agents and run 4,000 steps. The price is one-fifth that of top models, with coding on the same level. That means this system can run daily; it isn't something you set on a pedestal for occasional use.
Shared memory and a unified format turn a crowd into a system
If agents can't see each other's work, they will duplicate effort, contradict one another, and miss things. The fix is crude but effective: shared memory. Each agent reads it before starting and writes to it after finishing. A 1M-token context can hold the brief, findings, and decisions for the entire run.
Memory has to be structured, or it just becomes noise. Three sections are enough: facts (verified facts with sources), decisions (choices and reasons), and open questions (unknowns). Each agent's first step is to read these three; its last step is to write to one of them.
The handoff between agents is where things break most easily. One returns a paragraph, the next expects a list, and the merge quietly loses half the data. The solution is equally boring but effective: all agents return the same shape.
{
"agent": "fanout-17",
"task": "pricing for company 17",
"status": "done",
"result": {},
"sources": [],
"confidence": 0.9,
"memory": {"facts": [], "open": []}
}
Status lets the supervisor see failures without reading every result. Confidence lets the merge distinguish guesses from facts. Write the format once, paste it into every template, and you never have to think about handoff again.
Plan for failure, not perfection
In a run with 300 agents, failure is guaranteed. A page fails to load, sources contradict each other, a task is partial. A single agent's failure ruins the whole game; a multi-agent system retries only the broken part.
Blind retries will fail twice in the same way. Retry with a reason—“the page didn't return pricing, try the docs site”—and it usually works. If it still fails twice, write it into open questions and mark it in the final output, rather than quietly guessing a result.
Six steps to build it, with no coding in any step
- Paste the router prompt into Grokbot. From then on, it only classifies and doesn't answer
- Store four pattern templates in Kimi's Agent Swarm
- Each template starts with “read memory” and ends with “write facts/decisions/open questions”
- Paste the handoff format, seven fields
- Use the router's output (pattern, reason, brief) as the startup prompt for the corresponding Kimi template
- Run three test requests: one broad, one deep, one judgment-type
Everything is reused. Next time you encounter a new type of work, don't build a new agent—first determine which of the four shapes it is, then send it straight into the corresponding lane.
The closing line is the most counterintuitive one in the whole piece: Don't upgrade your Bot; upgrade the shape.
Most people improve a Bot by finding a better prompt or model. That helps until you hit the wall. After the wall, the only useful thing is to change the shape of the work: one overloaded agent becomes many focused agents.
Route first, then run. The first question is always “what shape is this work?”—not “what's the answer?”
Source: Ricker's original article · Morty's tweet
发布时间: 2026-11-21 14:06