Robot Teams Always Crash at Handoffs—It's Not the Model
Last month, Lauren Tan pushed 2,500 PRs into production, with bots writing and merging them themselves. After Chrome broke down her talk, he found that the problem wasn't the model—it was the few lines of text missed at every handoff.
Last month, Lauren Tan, an engineer at SpaceXAI, pushed 2,500 PRs into production. Most were written by bots, and merged by bots too. While she slept, they kept working.
When she woke up, she did only one thing: check the commits.
This process sounds like an 'AI does my job for me' story. But after Chrome broke down her talk, he pointed out a much plainer fact: what let the bot team run all night wasn't how smart the model was—it was the few lines left in the files at every handoff.
Chrome is an author focused on explaining AI to non-programmers. He wrote a long article on how to build a bot team so they can work in relay without dropping the work. The article was reposted more than 30,000 times, and the comments got pretty heated. Some said it was the most practical AI workflow they'd seen this year; others said that after reading it, they deleted their eleven bots down to only three.
Let's start with the problem.
Handoffs Are Where Things Crash
Every bot has its own memory limit. That limit is what makes the team work: one bot handles only one piece, so its head stays clear. But it also makes the handoff leaky: when a file passes from one bot to another, the reasoning behind the decisions doesn't come along.
The second bot opens the file and sees a conclusion with no derivation. What does a capable employee do when handed half a brief? Fills in the other half themselves—with plenty of confidence.
Three kinds of things leak out through that gap.
The first: a plan you rejected earlier comes back. Because the second bot doesn't know it was rejected, and it really does look like a good idea. A commenter named kuch said that writing down 'rejected plans and the reasons' is more useful than tuning prompts.
The second: the goal drifts. 'Write this up' doesn't say who it's for or why it's being written, so the bot has to guess a reader.
The third: stale facts get used as new. If the file doesn't say when a fact became true, it just keeps getting passed along.
All of these look like model errors. In fact, every one of them is a missing line in the handoff file.
There's a clip in Chrome's breakdown worth watching: at 18:53, a bot repeatedly rewrites the same piece of validation logic, so she simply turns the validation itself into a skill. At 45:16, another bot is responsible only for recording bad patterns in the docs, not rushing to fix them. These moves all revolve around one principle: write down the judgment so the next one to take over can read it.
Start with Three Bots
Chrome's advice is direct: start with three, not seven. Three that survive a month are better than seven you stop looking at by Thursday. Three is also the smallest number that can form a real handoff.
Three roles hand off in sequence:
Collector: finds materials and summarizes them, without judging what's important.
Decider: makes judgments and kills options, but doesn't produce the final output.
Producer: produces according to the brief, without inventing requirements.
Each bot gets a never-list that clearly states which things belong to someone else. Without it, the producer starts making decisions when the brief gets thin, and the decider just does the work itself because explaining takes too long.
Name: [bot name]
Owns: [one area, in one sentence]
Never: [the two or three things that belong to another bot]
Hands to: [the next bot by name]
Done means: [the exact file it leaves behind]
One commenter shared their own experience: at first they built a lot of bots, then found they didn't need nearly that many.
When do you add a fourth? When one of the three becomes boring. Boring means it has run for a week and you haven't changed it. Adding a fourth before that just means one more seam that isn't sealed.
Six Lines
The core of the whole method is here.
Before each bot finishes its work, it writes a HANDOFF.md. The next bot reads it before opening the file.
GOAL: One sentence, written for the next bot to read, not for yourself.
DECIDED: What was decided, with one sentence on why for each item.
REJECTED: What was considered and why it was thrown out. Prevents it from being proposed again next time.
DONE MEANS: What test the next stage must pass to count as complete.
SOURCE: Where the facts came from, with links and dates.
NEEDS YOU: Things that need your decision, written in one line so the bot can keep doing other work.
The third line is the one everyone skips. GOAL and DONE MEANS look useful, so people write them and stop there. REJECTED is the real time-saver: without it, the next bot looks at the same problem with the same capabilities and reaches for the same plan you've already thrown out. What you rejected on Tuesday comes back better written on Thursday.
SOURCE must include dates. A fact with a link but no date will be passed along forever and quietly become wrong.
The point of NEEDS YOU is to keep the chain from idling while waiting for you. If a bot needs your decision at 3 a.m., it writes it on this line and then keeps doing other things. You read it in the morning; only you are blocked, not the whole chain.
The Folder Is the Handoff
All the bots share the same machine. This is a security risk, and also the biggest convenience: folders are the cheapest way to hand off—no configuration, no waiting, no permissions.
The work flows like this:
/workspace/[project]/
WORKLOG.md
01-collected/
HANDOFF.md
02-decided/
HANDOFF.md
verdict.md
03-produced/
HANDOFF.md
WORKLOG.md sits at the top of the project, one line per step:
2026-10-31 09:12 | Collector | DONE | 01-collected/ | next: Decider
2026-10-31 10:40 | Decider | DONE | 02-decided/ | next: Producer
2026-10-31 11:02 | Producer | BLOCKED | needs the pricing decision in NEEDS YOU
There is only one rule: a bot starts only when its name appears after 'next:' on the previous line. It doesn't go by the schedule.
BLOCKED is a state, not a failure. A blocked bot writes one line with the reason and stops. A bot that keeps retrying will burn through a week's quota and then give you three different versions of the wrong answer.
Chrome specifically mentions that Grok Bot stores only the last twenty run records. By Thursday, the evidence from Monday's run is already gone. A self-maintained WORKLOG.md has one line per run and doesn't expire.
What to Check in the Morning
Once you have the output, read the handoff file, not just the result. Four questions, one line each:
Does the output serve the goal written in GOAL, or the one next to it?
Is there anything that conflicts with DECIDED?
Is there anything that comes from REJECTED?
Does every fact appear in SOURCE and have a date?
Return PASS, or a numbered list.
Don't edit the output yourself. A checker who changes things has an incentive to prove they were right.
You Can Build It in Five Mornings
Day 1: Create the folder, create WORKLOG.md, write one example line.
Day 2: Create the collector and the decider, and give both the same set of handoff rules. Run it once by hand, and read the HANDOFF.md written by the collector.
Day 3: Add the producer. It produces only what DECIDED says to write; anything missing goes into NEEDS YOU, and it doesn't invent things itself.
Day 4: Add a handoff check at the final stage.
Day 5: Delete one scheduled task. Look at what each scheduled task is waiting for; if it's waiting for another bot to finish, delete it—the log already has that signal. Keep timers only for when the outside world changes.
Finally
Chrome's conclusion is restrained: bot teams rarely fail at the work itself. They break in the half-second when a file moves from one memory to another, because the reasoning doesn't come along.
Six lines travel with every file, one log line says whose turn it is, and one check reads the seams rather than the output. Build these three things before you add a fourth bot, and your morning team won't surprise you.
As for those PRs that ran all night, git blame will show a string of ghosts. The comments were written by bots, the commits were made by bots, but every one can be traced back to a line in some night's HANDOFF.md.
发布时间: 2026-11-19 09:28