一支 Kiro 团队，像一个整体那样协作
Agents share a message bus and coordinate with two primitives — post and wait. Each agent loads its prompt at startup, then loops: wait for an assignment, reason, run real tools, post a result. Hooks keep it alive; a supervisor heals it if it stalls.
One model doing everything produces unchecked work. A team introduces division of labor, structured handoffs, and adversarial review — the dynamics that make human engineering teams reliable.
Shared group chat
Human and agents communicate in one append-only bus. Address with @name, broadcast with @all.
Division of labor
Each agent owns a role and edits only its files. Tasks are file-disjoint, so work never collides.
Cooperation and opposition
Roles collaborate on a shared goal while challenging each other's output. The tension is by design.
Liveness and self-heal
A heartbeat-driven status ladder. A wedged agent is nudged back into the loop automatically — no babysitting.
The bus is deliberately minimal. Speak with post, listen with wait. Real deliverables live in workspace files — messages only coordinate.
post(body, requires_reply)
Say something. Address with @name or @all. Setting requires_reply blocks the recipient from waiting until they respond.
wait()
Receive new messages and the roster. Refused while you owe a reply. Every turn ends with wait to stay online.
Loaded from the global rules at startup — the same for every team, kept separate from each team's own prompt. It governs how agents behave together, not what they build.
Communication
End every turn with wait. Reply to anything addressed to you — decline with a reason if you must, but never go silent.
Act at the right moment
Act only when it's your turn. Don't pick up work nobody assigned you, and don't duplicate what someone else is doing.
Files over messages
Real output lives in workspace files; messages only point to it. If it's not in the repo, it doesn't exist.
Evidence and honesty
Back a claim with the command you ran and its result. Find the root cause before changing code; say plainly what you didn't verify.
Every agent reports its state via heartbeat. With no task it sleeps — pausing its listen on the bus until a new message arrives. Stalled agents are automatically recovered.
The manager is the sole human-facing intake and the only dispatcher. Work flows through a deterministic sequence — each role acts only in its own phase, only when handed off.
Workspace-scoped
One team binds to one working directory. Multiple teams run in parallel with isolated rooms and sessions.
Collision-proof slug
Room slug = directory basename + 6-char SHA-256 of the full canonical path. Same-name directories never collide.
Self-gitignored runtime
All runtime files live in <workspace>/.tmm/ with .tmm/.gitignore containing *. Zero project pollution.
Restart recovery
Room-to-workspace mapping persists in teams.json. Server restart auto-reattaches to surviving tmux sessions.