Swarm mode
For work with enough independent parts, Anymo plans a team instead of a single agent: a commander plus specialists, executed in parallel, verified before synthesis, and watched live in the Hive view. Teams scale to a hard cap of 300 agents.
When you get a swarm
You do not pick agent counts; the planner sizes the team from the goal. "Summarize my notes" runs one agent. "Compare these three frameworks and write a recommendation" gets a small specialist set: researchers in parallel, a verifier, a synthesizer. Only goals that explicitly ask for large-scale parallel work ("audit every endpoint in this service") push the plan toward the cap. Small is the default because coordination has a cost, and the planner merges duplicate subtasks rather than spawning look-alike workers.
How a plan works
A swarm plan is a staged DAG. Stages run only after their dependencies complete, and within a stage independent assignments run in parallel:
| Stage | What happens |
|---|---|
| Plan | The commander maps specialist lanes for non-trivial work |
| Execute | Independent assignments run in parallel, bounded by the concurrency limit |
| Verify | Code, finance, research, security, and test-sensitive work gets checked by verifier agents |
| Synthesize | One agent assembles the result from compressed handoff summaries, never raw worker logs |
| Final review | A last quality pass over the assembled output |
Simple goals use the same skeleton with a single execute assignment; empty stages keep the shape without spawning fake agents.
Watching it in Hive
Toggle Hive from the chat header during a live run. Every agent is a compact chip: status dot, role, name, and the tool it is using right now. Edges animate only while data actually flows between agents. A strip across the top tracks the run: agents active and done, tool calls, elapsed time, and the current stage.
Select any node to open its notebook: what it found, what it claims, the evidence behind those claims, its budget usage, and its recent events. Progress numbers come from real scheduler metrics (completion rate, verifier pass/fail, retries, estimated tokens and cost, the critical path through unfinished stages), not from counting requests.
Budgets and the 300-agent cap
Every swarm runs under explicit ceilings:
- max agents: total planned assignments, hard-capped at 300
- max concurrency: how many run simultaneously
- max tool calls and max steps for the whole run
- max cost, optionally
Each assignment also carries its own derived budget, so one runaway worker cannot drain the run. Retries use bounded backoff, and workers fail closed: a worker that cannot proceed safely stops instead of improvising. Cancelling is cooperative and clean: pending assignments never start, running ones stop before their next model call.
Reasoning depth is role-aware by default: the commander plans at xhigh, verifiers at high, researchers and coders at xhigh, and utility workers at medium, unless you override the run's level.
Why 300 agents don't trample your files
In swarm transaction mode, workers do not write the shared workspace. Each gets an isolated overlay against a snapshot: writes become staged patches, binary outputs become artifacts, and a verifier computes patch sets and conflicts before anything merges. Only low-risk, non-conflicting changes merge automatically; overwrites, large changes, and conflicts come to you; path escapes are denied outright. The full mechanics, including Git worktree jobs for coding work, are on Worktrees and isolation.
What workers share
Workers keep private notebooks; what travels upward is a compressed handoff summary per worker. The synthesizer's context is built from those handoffs with private raw entries excluded, which is why a 50-worker run produces a coherent answer instead of a paste-up of logs. See Self-learning for the context mesh.
Try it
In the app, just describe parallel work: "research these five competitors, one report each, then a comparison". To force the swarm path headlessly:
anymo run --swarm --workspace anymo-demo \
--goal "compare three options and write a recommendation"Frequently asked questions
Will a swarm burn through my tokens?
Budgets are the defense: agent, concurrency, tool-call, step, and optional cost ceilings are set when the run starts, and per-agent budgets bound each worker. The Hive strip shows estimated token and cost totals live.
Do workers get their own approval prompts?
Workers obey the run's permission mode like any agent. Risky actions still ask; routine staged writes do not, because they only land after patch review.
Why would anyone need 300 agents?
Mostly you will not. The cap exists for embarrassingly parallel jobs, auditing hundreds of files or endpoints where each unit is independent. The planner only goes there when the goal demands it.