holyclaude-cloud

 ██╗  ██╗ ██████╗ ██╗  ██╗   ██╗ ██████╗██╗      █████╗ ██╗   ██╗██████╗ ███████╗
 ██║  ██║██╔═══██╗██║  ╚██╗ ██╔╝██╔════╝██║     ██╔══██╗██║   ██║██╔══██╗██╔════╝
 ███████║██║   ██║██║   ╚████╔╝ ██║     ██║     ███████║██║   ██║██║  ██║█████╗
 ██╔══██║██║   ██║██║    ╚██╔╝  ██║     ██║     ██╔══██║██║   ██║██║  ██║██╔══╝
 ██║  ██║╚██████╔╝███████╗██║   ╚██████╗███████╗██║  ██║╚██████╔╝██████╔╝███████╗
 ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝    ╚═════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝
                              C  L  O  U  D

What it looks like in practice

/legion-start "Add JWT authentication to the API with tests and docs"

⚡ Decomposed into 4 tasks (2 parallel, estimated 18 min wall-clock)
⚡ T-001  Add JWT middleware to /api/user  →  cloud
⚡ T-002  Add /api/auth endpoint           →  cloud
⚡ T-003  Add auth integration tests       →  cloud (waiting on T-001)
⚡ T-004  Update README with auth section  →  local

✓ T-001  PR opened: github.com/you/repo/pull/12  (3 files, 89 lines)
✓ T-002  PR opened: github.com/you/repo/pull/13  (2 files, 45 lines)
↩ T-002  CI failed — re-dispatching (retry 1/2)
✓ T-002  PR opened: github.com/you/repo/pull/14  (CI passing this time)
✓ T-003  PR merged  ✅
✓ T-004  PR merged  ✅
✅ All 4 tasks merged in 22 minutes

One goal in. Merged PRs out. The orchestrator decomposed the work, routed tasks to cloud workers, an adversarial reviewer read every PR before merge, a CI failure triggered an automatic retry with the failure log as context, and the whole thing landed in dependency order.

Status: v0.4.0 — alpha

End-to-end validated on its own repo ("dogfood") plus a sandbox. Ships PRs that merge cleanly when CI passes. Brain/learning loop is live — workers accumulate experience across runs. CI re-dispatch validated end-to-end. Not yet tested on production codebases or repos with pre-commit hooks. See STATUS.md for a grade card and TROUBLESHOOTING.md for known edges.

Architecture

┌──────────────────────────────────────────────────────────────────┐
│  Layer 10: GOVERNOR     Cost cap, throttle observer, kill switch │
│  Layer 9:  RECONCILER   Dep-ordered merge, CI check, auto-heal   │
│  Layer 8:  REVIEWER     Adversarial pre-merge review + re-disp.  │
│  Layer 7:  MEDIATOR     Merge conflict resolution                │
│  Layer 6:  DISPATCHER   Local Agent vs cloud Modal — auto-route  │
│  Layer 5:  ORCHESTRATOR Decomposes plan → critic → refiner       │
│  Layer 5c: BRAIN        Write-on-finish retros, read-on-spawn    │
├──────────────────────────────────────────────────────────────────┤
│  Layers 0-4: HolyClaude (memory, browser, plugins, workflow,     │
│              team, research) — peer dependency + baked into      │
│              every cloud container                               │
└──────────────────────────────────────────────────────────────────┘

Orchestrator takes your plain-English goal, turns it into a task DAG with explicit dependencies, and runs a critic-refiner pass to audit the plan before anything dispatches.

Dispatcher routes each task — local subprocess for quick tasks or repos with large checkouts, Modal cloud container for parallelism without saturating your machine.

Reviewer is a separate Claude instance that reads every PR before merge. A critical verdict blocks and re-dispatches the worker with the review as context. A warnings verdict merges with a comment. clean merges silently.

Mediator handles merge conflicts by spawning a dedicated Claude worker on a fresh worktree with both diffs and the conflict markers as input — it resolves by intent, not by guessing which diff wins.

Reconciler merges tasks in dependency order: T-002 doesn't merge until T-001 is in. CI failures trigger a re-dispatch with the failure log attached to the next worker's prompt.

Governor watches API spend and dynamically halves the worker cap if cost exceeds max_dollars_per_hour or the rate limiter fires.

What makes this different

Most "AI coding tools" run one agent at a time. Legion runs N in parallel and coordinates them like a software team: