claude-skills / agent-army
Orchestration · MIT · for Claude Code

agent-army

Run a fleet of autonomous Claude Code agents in parallel — one per independent chunk of work, each a full claude session in its own git worktree, coordinated by a changeable master through a command centre that lives on disk. The operation survives context limits and shift changes: any session can read the command centre and take command.

Get started → Source ↗ Visual explainer ↗
A master command centre coordinating four parallel Claude agents, each in its own git worktree, merging into one integration branch
master command centre → N agents, one per worktree → merge into one integration branch
// what it is

What agent-army does

It's the heavyweight, separate-session way to parallelise in Claude Code. Instead of one chat grinding through a backlog, you spawn N full claude processes at once — each in its own terminal window/tmux pane, its own context window, its own git worktree — and a master session coordinates them through an on-disk command centre. Because the command centre is just files on disk (outside any repo), the whole operation outlives any single chat: a fresh session can read it and take command.

It nests with its cheaper cousins

agent-army isn't a rival to subagents — it sits one level up. Each fleet agent runs its own in-session subagents to keep its context lean.

  • In-session subagents — built-in, cheap, die with your chat.
  • Workflow tool — scripted fan-out, worktree-isolated, ~10 concurrent.
  • agent-army — N full sessions, real windows, survives everything.
Nesting: one agent-army window runs a coordinator that dispatches its own subagents internally window · agent g2 (full claude session) coordinator subagent · implement subagent · test subagent · review
outer = parallelism + survival · inner = lean context per agent
// the 5 W’s & 1 H

Everything, at a glance

What it is, why it exists, when (and when not) to reach for it, who runs it, where its state lives, and how a run actually goes.

What

A parallel agent fleet

N autonomous Claude sessions, one per independent group of work, each isolated in its own git worktree and branch, coordinated by a master.

Why

Wall-clock, windows, survival

It buys three things nothing else does: N independent context windows, hours of true parallel building, and an operation that outlives any one chat. It trades ~N× the spend for that.

When

4–9 big independent seams

Use it when work is already split into 4–9 substantial, independent streams, there’s a real deadline, and a human will babysit. Not for small or coupled work — the Intake Gate routes those away.

Who

A master + its agents

A master coordinates (spawns, monitors, unblocks, reviews, assembles — writes no feature code). The agents are semi-autonomous workers, one per seam. The master is swappable mid-run.

Where

An on-disk command centre

State lives in ~/.claude/agent-army/<operation>/ — outside any repo, referenced by absolute path. Agents work in their own worktrees and PR into one integration branch.

How

Gate → launch → monitor → assemble

Run the Intake Gate, cut an integration branch, build the command centre, launch + verify each agent, monitor with two-signal health, then review and assemble one final PR.

// how it works

The operation lifecycle

Six phases, master-driven. It’s semi-autonomous — the agents build on their own, but you check in to clear blocked decisions.

01

Gather the seams

Confirm the independent groups of work and each group’s spec (an OpenSpec change or a markdown brief). One seam = one agent = one branch. Target 4–9.

02

Cut an integration branch + pick models

Branch off the agreed base; every agent PRs into it (never into main). Choose models per agent — sonnet is the cost/quality sweet spot when specs are written.

03

Create the command centre

Scaffold ~/.claude/agent-army/<operation>/ with COMMAND.md, manifest.json, and per-agent brief/status files. Give the operation a memorable codename.

04

Launch & verify

Launch one agent per seam. Verify each is actually live within ~15s — never trust the launch exit code. Each agent self-creates its worktree as step one.

$scripts/launch-agent.sh <operation> <agent>
05

Monitor (check in periodically)

Read the objective health board; locate windows; clear BLOCKED questions; relaunch by reason; stop anything idle-burning.

$scripts/fleet-status.sh <operation>
$scripts/where.sh <operation>
06

Review & assemble

When agents are PR-OPEN, review each PR two-stage (spec-compliance, then code-quality) with in-session reviewer subagents, merge into the integration branch, run CI, open one final PR, then stop the fleet and archive the command centre.

// the source of truth

Never trust a single signal

Agents stall silently at usage limits, commits lag reports, and launches lie about success. So health is two signals together: what the agent reports, and an objective probe.

  • Self-reported — the agent’s own milestone status file.
  • Objective — process alive? last commit age? transcript activity?
  • Hardened liveness — alive if the PID runs, OR a process matches the brief path, OR a cwd is under the worktree. A live agent can’t go invisible.

Status the board can report

ALIVE BLOCKED STALLED DYING DEAD IDLE-BURN DONE
STALLED (alive, no progress) → relaunch with --resume — context is fine, just frozen at a usage limit.
DYING / DEAD (context ran out) → relaunch fresh; the successor reads the continuation the agent wrote.
IDLE-BURN (done but session still alive) → stop-agent.sh it. That’s real money.
// when to use it

When agent-army — and when not

A fleet costs roughly N full sessions. The skill opens with an Intake Gate that does this maths and routes cheap work to a cheaper tool. Use this rule first.

Shape of the workUse
4–9 big independent seams, need judgement + review, span hours/days, human babysitsagent-army
Many small, mechanical, isolated tasks (rename, dep bump, header sweep)Workflow tool
A handful of independent tasks you’ll finish in one sittingIn-session subagents
Tightly coupled work (same files / ordered dependencies)Sequential
The most expensive mistake is launching a fleet you didn’t need. agent-army’s only value is buying wall-clock + independent windows + survival. If none of those is the binding constraint, it’s the wrong tool.
// get started

Install agent-army

Add the marketplace once, then install the skill. Trigger it by asking for a fleet — it always runs the Intake Gate first, so it’ll talk you out of a fleet you don’t need.

$/plugin marketplace add amjad1233/claude-skills
$/plugin install agent-army@amjad1233
Read the SKILL & scripts ↗ Visual explainer ↗
Next skill: claude-continuation →