Multi-agent teams, clones, and handoffs

Parallel and specialized agents people describe when they mention multiple instances, “agents talking to each other,” or splitting “research vs execution”:

• Role separation: planner vs implementer vs reviewer—each with explicit inputs and outputs.
• Handoff packets: state summaries the next agent (or human) needs—no telepathy.
• Long-running work that survives context limits because artifacts (files, tickets, notes) carry truth.

This is about coordination discipline, not stacking models for hype.

• Mission Control and timelines make parallel runs legible—who did what, when.
• Multi-LLM and collaborative modes map to “use the right brain for the subtask.”
• Skills give each lane consistent rules (style, tools, forbidden actions).
• Approvals prevent one agent from undoing another’s destructive change.

1. Name roles in one sentence each; avoid overlapping mandates.
2. Write the handoff schema: checklist + links + open risks.
3. Single source of truth in repo or ticket—never two competing summaries.
4. Serialize writes to shared resources (one merger for the main branch).
5. Review handoffs like code reviews—bad handoffs compound.

• Branch or workspace isolation so parallel experiments do not collide.
• Identity clarity: which token or session owns which action.
• Agreement on when humans must enter the loop.

1. Pilot two roles on a toy task; measure duplicate work.
2. Add explicit stop conditions (“stop after plan approval”).
3. Introduce a reviewer pass before merge or send.
4. Log decisions that override prior agent output—audit trail.
5. Only then add parallelism where it truly saves wall time.

• “Produce a handoff block the next agent needs—nothing else.”
• “List conflicts between agent A’s plan and agent B’s edits.”
• “What single artifact should be canonical for this task?”

• Chaos test: two agents edit the same file—what prevents corruption?
• Rollback story exists for merged bad output.
• Humans can pause all automated lanes in one action.

• Duplicate work because roles were vague.
• Gossip chains of summaries—error balloons.
• Unbounded parallel API spend.
• Attribution blur: who is accountable for a bad customer email?