Multi-agent crews coordinate across five distinct topologies: single-liaison stars, peer-messaging teams, issue-delegated squads, strict reporting trees, and leaderless swarms. Systems like Firstmate, Claude Code, Multica, Paperclip, and Agensh define who holds context, how tasks are claimed, and whether a lead supervises or gets out of the way.
Five lead-agent topologies: key facts
- Firstmate uses a single-liaison star topology: a captain speaks only to the first mate, which runs parallel crewmates in isolated Git worktrees via treehouse.
- Claude Code agent teams (
CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1) add direct peer mailbox messaging and a shared task list alongside the lead. - Multica squads route issues through a lead that posts an evaluation and
@-mentions assignees using UUID markdown before stopping. - Paperclip organizes agents into a strict tree-structured org chart with a root CEO and single-parent
reportsTochains. Agents run in scheduled heartbeat windows, then readGET /api/agents/me/inbox-litefor compact assignments at heartbeat startup. - Agensh (arXiv:2609.26781, submitted on 2026-09-22) eliminates the lead entirely, raising pandoc benchmark pass rates from 33.89% to 55.06% across 1,024 self-assigning agents.
Firstmate: single-liaison star topology
In Kun Chen's agent distro Firstmate, coordination follows a star topology where the user (the captain) speaks only to the first mate. The first mate coordinates the fleet, while the captain approves merges and receives reports.
The first mate dispatches tasks to crewmates running in visible sessions (tmux windows, Herdr tabs, Zellij tabs, cmux workspaces, or Orca terminals). Each task executes in an isolated Git worktree via treehouse or Orca so concurrent file edits never collide.
Firstmate uses two task shapes: "ship" tasks delivering pull requests or local merges under configured merge authorities (no-mistakes, direct-PR, local-only, and optional +yolo), and "scout" tasks producing investigation reports. A zero-token bash watcher sleeps on the fleet and wakes the first mate when something needs attention. Optional secondmates run from isolated homes locally or over SSH. The first mate stays read-only over project code by default; crewmates make changes behind the configured merge authority.
Claude Code agent teams: peer messaging with a shared task list
Claude Code provides an experimental multi-agent architecture enabled by setting CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 in settings.json or the environment:
{
"env": {
"CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
}
}An agent team consists of a lead session, independent teammates, a shared task list, and an inter-agent mailbox. The lead breaks prompts into tasks and assigns them to workers, each running in a separate context window.
Unlike a strict star topology, teammates message each other directly through their mailbox without routing through the lead. Teammates claim and complete work from the shared task list. Users can also converse directly with any teammate without involving the lead. Claude Code restricts each session to one team, and teardown waits for running tools or requests to finish.
Multica squads: issue-driven delegation via mention routing
Multica organizes agents into squads assigned to project issues. A squad consists of one leader agent and multiple member agents or humans. Assigning an issue to a squad triggers an execution run only for the leader:
multica squad create --name "Product Delivery" --leader delivery-lead
multica squad member add <squad-id> \
--member-id <agent-id> --type agent --role "Owns frontend"Multica injects the Squad Operating Protocol, Squad Roster with UUID mention markdown ([@Name](mention://agent/<uuid>)), and Squad Instructions into the leader's prompt.
The leader inspects the issue, writes a delegation comment @-mentioning the chosen member, logs its evaluation via multica squad activity <issue-id> action --reason "...", leaves the issue in_progress, and stops. The leader does not write code. When a member posts an update without an @mention, the leader wakes to evaluate next steps. If a comment explicitly @-mentions another agent, the leader stays silent.
Paperclip: hierarchical org charts and heartbeat cycles
Paperclip structures agent fleets as a corporate reporting tree where every agent except the CEO reports to exactly one direct manager in reportsTo. Paperclip prohibits reporting cycles and enforces single-parent chains.
The root CEO agent reports to the board (the human user). The CEO delegates workstreams to department managers (such as a CTO or CMO), who break goals into subtasks for individual contributors (such as backend engineers or content writers). Work delegates downward through reporting lines; blockers and status escalate upward to immediate managers.
Paperclip agents wake during discrete execution windows called heartbeats, triggered by schedules, issue assignments, mentions, approvals, or manual calls. At heartbeat startup, agents call GET /api/agents/me/inbox-lite to retrieve tasks. Operators inspect the structure via Paperclip's interactive visual tree or query GET /api/companies/{companyId}/org (available as JSON, SVG, or PNG).
Agensh: decentralized swarms without a lead agent
In paper arXiv:2609.26781 (submitted on 2026-09-22 by Zhihao Zhan, Ting Song, Li Dong, Shaohan Huang, Jianxun Lian, Yan Xia, and Furu Wei), the authors evaluate Agensh: a multi-agent harness without a central orchestrator.
Agensh workers run an asynchronous cooperation loop: gathering shared context, self-assigning sub-tasks, taking action, verifying results, and merging progress.
Agensh replaces the lead agent with three infrastructure components: a shared workspace holding proposed, ongoing, and completed artifacts; a message interface for inter-worker communication; and a shared context recording reusable findings and intentions. In ProgramBench tests with GPT-5.6-sol (high), scaling from 1 to 128 self-organized agents increased the mean test pass rate from 19.31% to 28.78%. On pandoc, scaling from 1 to 1,024 agents improved the test pass rate from 33.89% to 55.06%, showing that decentralized task claiming avoids orchestrator bottlenecks.
Comparing the five crew coordination models
Model | Topology | Lead agent role | Task allocation mechanism | Communication path | Isolation | Example |
|---|---|---|---|---|---|---|
Single liaison | Star | Gatekeeper and supervisor | Direct dispatch to worktrees | Captain to lead, lead to workers | Git worktrees (treehouse) | Firstmate |
Peer team | Hub and mesh | Coordinator and synthesizer | Workers claim from task list | Lead to worker, worker to worker | Context windows | Claude Code agent teams |
Squad router | Reactive star | Dispatcher and evaluator | Mention routing ( | Comments trigger lead when unrouted | Shared issue timeline | Multica squads |
Hierarchical tree | Multi-level tree | Departmental manager | Downward delegation | Downward delegation, upward escalation | Heartbeat windows | Paperclip |
Decentralized swarm | Mesh | None (no lead orchestrator) | Autonomous self-claiming | Peer message interface | Shared workspace | Agensh |
Single liaisons isolate parallel coding tasks. Peer teams support interactive multi-angle reviews. Squad routers automate issue triage. Hierarchical trees organize multi-tier teams with approval gates. Decentralized swarms scale to high-concurrency tasks where lead orchestrators saturate.
Sources
- Firstmate repository: https://github.com/kunchenguid/firstmate (read 2026-10-06)
- Claude Code Agent Teams: https://code.claude.com/docs/en/agent-teams (read 2026-10-06)
- Multica Squads: https://multica.ai/docs/squads (read 2026-10-06)
- Paperclip Org Structure: https://docs.paperclip.ing/guides/org/org-structure/ (read 2026-10-06)
- Paperclip Core Concepts: https://docs.paperclip.ing/start/core-concepts (read 2026-10-06)
- Paperclip Agents API: https://docs.paperclip.ing/reference/api/agents/ (read 2026-10-06)
- Agensh Paper (arXiv:2609.26781): https://arxiv.org/abs/2609.26781 (read 2026-10-06)
Last verified: 2026-10-06.