driving-anu

name	driving-anu
description	Use when orchestrating agents inside anu: deciding which swarm topology fits a task, writing worker briefs, running contained (cxc) agents for unattended work, and collecting/merging results. Covers the judgment the command tables don't: when each topology pays off, how to brief a worker, the conductor/worker protocol, and the common failure modes.

Driving anu

anu turns a task into a fleet of agents in tmux panes. The command surface (swarm, mesh, box, worktrees) is in the global anu reference. This skill covers the judgment on top of it: picking the right shape and running it. The default for unattended work is contained workers (cxc) + a host conductor.

Pick the topology from the work shape

The work is…	Topology	Why
N independent subtasks that touch different files	swarm wt <n> cxc	one git worktree per agent → no write contention, merge at the end
One hard task needing decomposition + coordination	swarm star <n> cxx	a conductor decomposes and delegates; workers report back
Sequential refinement (draft → critique → polish)	swarm pipe <n> or swarm pair	each stage consumes the previous stage's output
Several approaches where you keep the best	swarm tournament <n>	rounds evaluate, prune, advance; good for "try 4 designs"
The same task over many inputs	swarm start <n> / swarm mixed	flat fan-out, no coordination overhead
Anything where you want human checkpoints	swarm pipe <n> --gated	pipeline that pauses for approval between stages; approve/reject stages with swarm gate
You need more machines than one host has	swarm mesh <n>	spreads workers across Tailscale devices

Tournament needs a quoted task and is driven with swarm tournament "<task>" [--rounds R] [--eval "criteria"], then swarm tournament score / swarm tournament status; rounds default to 2.

Default to the smallest topology that fits. Coordination has a cost; three agents that finish cleanly beat eight that deadlock on a merge.

Containment: where agents run

• Unattended / full-auto workers → cxc (Claude in a disposable VM): full autonomy, blast radius of one worktree. Edits and commits land in the real worktree; execution stays in the box.
• Keep the conductor on the host (swarm star ... with the conductor as cxx, workers cxc): contained agents cannot run host-side swarm/tmux/gh, so the thing doing the delegating must be on the host.
• No host credentials enter a box. Contained agents commit locally; push from the host afterward.

Writing a worker brief

A worker that idles or wanders was briefed badly. Every brief needs four things:

1. Scope: the exact files/dirs this worker owns. Non-overlapping with siblings.
2. Goal: the outcome in one sentence: a concrete, testable result.
3. Done-condition: how the worker knows it's finished (tests pass, file exists, function returns X).
4. Where results go: its mailbox/results path so swarm collect can find them.

Deliver briefs with swarm send agent-N "<brief>". A conductor must run the command. Describing the plan leaves the worker idle. Broadcast shared context once with swarm broadcast.

Run loop

1. Plan the topology and briefs (use /orchestrate to draft both).
2. Launch the swarm; broadcast shared context; swarm send each worker its brief.
3. Watch with swarm status / agentlog <agent> --tail; nudge an idle or off-track worker with another swarm send.
4. When workers finish, swarm collect aggregates results; review summarizes what each branch did.
5. For worktree swarms, merge with swarm merge --all or interactively via swarmx merge; swarm merge --pr opens PRs (host only, boxes have no gh auth); resolve overlaps with swarm conflicts. Push from the host.

Failure modes

• Idle workers: no brief was actually delivered. The conductor described the plan instead of running swarm send. Re-send.
• Merge pile-up: worktree workers edited overlapping files. Either the scopes overlapped (re-brief) or the task wasn't parallel to begin with (use pipe/pair).
• Contained agent "can't push": expected; boxes have no credentials. Collect and push from the host.
• Over-decomposition: if briefs are smaller than the cost of writing them, run it yourself or use a flat swarm start.
• Conductor doing the work: a star conductor should delegate, not solve. If it's coding, you wanted a flat swarm.