The Charioteer senses the work board and dispatches every ticket to the lane and agent best able to do it — the router god of Pantheon's agent swarm. Open source and standalone-capable.
Sample board shown below — a static illustration, not a live feed. Run Auriga locally against your own data.
What Auriga actually is, and why a multi-agent swarm building software needs something like it.
What Auriga is
Auriga is the router god of Pantheon — a swarm of coordinated agents building software together. Auriga senses the state of the shared work board and dispatches each unit of work to the right lane and agent: the PM/router of the Pantheon SDLC pipeline. It's one plugin god bound into the Pantheon host, alongside siblings like Minerva (planning, upstream of Auriga), Heimdall (lane gateway / token routing), Hellsing (zombie/worker reaping), Consus (ideation → sign-off), and Argus (observability).
It also runs standalone — its own repo, its own process — with a small, zero-dependency router at its core (plain Node, no framework) that talks to the board through an adapter-interface boundary rather than a hardcoded backend. That boundary is what lets the routing policy evolve, get tested, and get swapped independently of the agents it dispatches to, and it's the same seam that will eventually let Auriga route boards other than Multica.
Why orchestration needs a router
A swarm of agents building software needs a single thing deciding who does what and when — otherwise tickets pile up unassigned, hive-authored stories get routed to runtimes that can't run them, and a single overloaded runtime collapses throughput to zero. Auriga is that decision layer.
Concretely, each cycle it: recovers zombies (stale or failed in-progress work), advances issue status from verifiable board facts alone — a finished run moves a ticket to review, but only a merged pull request marks it done, run status is never trusted on its own — then selects a small, capacity-capped batch of unassigned todos and routes each one by capability, respecting per-agent and per-runtime caps so it never mass-flips the board. Work flagged for a human is filtered out before any of that logic runs. Auriga only ever assigns and re-runs work; it never deletes or cancels — and every routing decision underneath is pure, deterministic, and unit-tested against mocked board state, not left to chance.
Auriga is open source. Drop it into any Multica-backed workflow, extend the routing policy, swap the adapter backend, or just read the decision logic — every routing choice is pure, deterministic, and unit-tested. Zero vendor lock-in by design.
Four pillars of Auriga's routing logic — all deterministic, all unit-tested against mocked board state, no runtime guessing.
Capability-aware routing
Each ticket is matched to the lane and agent best suited to handle it. Auriga reads the board's structural signals — issue type, tags, project scope — and routes deterministically. No heuristics, no LLM calls, no guessing: pure policy code you can read and test.
State machine transitions
Auriga advances issue status from verifiable board facts alone. A finished run moves a ticket to review — but only a merged pull request marks it done. Run status is never trusted on its own. The transition rules are a small, pure function you can unit-test in isolation from any external service.
Capacity discipline
Per-agent and per-runtime caps ensure Auriga never mass-flips the board in a single cycle. Each dispatch pass selects a small, capacity-capped batch. Work flagged for a human is filtered out before any routing logic runs. The board stays legible and stable under load.
Zombie recovery
Auriga detects stale or failed in-progress work — tickets stuck in a terminal-looking state with no recent activity — and recovers them automatically. Retries are capped. When a ticket exhausts its retry budget, Auriga marks it blocked with a comment explaining why, rather than silently giving up.
Pantheon
Where Auriga sits in the constellation
Auriga is one god in a coordinated agent swarm. Each god owns a distinct responsibility in the SDLC pipeline.
Mi
Minerva
Planning & decomposition — breaks operator asks into scoped epics and sub-issues, upstream of Auriga
upstream
Au
Auriga
Routing & dispatch — senses the work board each cycle and routes every ticket to the right lane and agent
you are here
He
Heimdall
Lane gateway & token routing — manages provider lanes, rate-limit recovery, and request throughput
infra
Hl
Hellsing
Zombie & worker reaping — terminates stuck or runaway agent processes across the swarm
ops
Co
Consus
Ideation & sign-off — manages the idea pipeline from operator prompt to approved issue
upstream
Ar
Argus
Observability — monitors swarm health, surfacing anomalies and pipeline stalls
P3: Auriga UI — a clean, read‑only operator dashboard
4 storiesDone
Plate II
Star Chart Detail
A single story, plotted with its dependencies, acceptance criteria and known risks.
p2-adapter-interface›p2-router-cutover
Rewire cycle() and all mcaImpl.* call sites to the backlog/spawn adapter boundary
DoneComplexitymethod · classic
Dependency constellation
Log entry
The concentrated-risk cutover: rewire auriga-router.mjs's cycle() options bag from mca to backlog + spawn (typed adapter instances), and re-point all ~25 mcaImpl.* call sites across the unblock pass, cascade re-dispatch pass, false-done/review-scan pass, dispatch pass, and review lane to the new adapter methods. main() defaults to createMulticaBacklogAdapter()/createMulticaSpawnAdapter(), preserving today's live supervised behavior with zero config changes required. lib/core.mjs is NOT touched — every call into it is unchanged.
Acceptance criteria
Given cycle(opts) is called, when opts is inspected, then it accepts { backlog, spawn, cfg, core, log, sleep, dryRun, noZombie, maxAssign, now } — no mca parameter remains
Given npm test runs from repo root, then all 6 pre-existing test files pass with their existing assertions about ROUTING DECISIONS unchanged
Given the new cutover-e2e.test.mjs runs, when cycle() is driven end-to-end..., then it completes correctly with zero external process calls attempted
Cross-cutting
Documentation
README.md's quickstart section and src/router/README.md's Files/paths section reference lib/multica.mjs and lib/config.mjs by name — flag as stale after this cutover.
Risks
High severity
A call site re-pointed to the wrong adapter method... could silently change WHICH issues get dispatched.
MitigationFull regression suite plus the new cutover-e2e test...
Plate III
Observation Log
A chronological trail of commits and process audits, most recent first.
Aug 1721:26 UTC−05:00
Commit d5d2f72
Merge pull request #60 from mdostal/feat/p3-auriga-ui
[p3-auriga-ui] fix: crash + path-traversal bugs from independent review
Aug 1616:13 UTC
Audit record · execute
p2-adapter-interface-execute-20260816T161309Z
5 story specs produced9 commits46 files changed157 tests passing
Aug 1720:59 UTC−05:00
Commit 6b0eea7
[p3-auriga-ui] mark all 4 stories done
Mark
The Charioteer's Pentagon
The favicon plots Auriga's own asterism: Capella, Menkalinan, Theta Aurigae, El Nath and Iota Aurigae, joined in the traditional kite.
96 × 96
32 × 32 (tab)
Monochrome
Capella — sixth-brightest star in the night sky — anchors the mark at full weight, gold against the four dimmer kite points. The three faint satellite dots at her shoulder are the Haedi, the Kids the Charioteer carries. Same pentagon, three treatments: full color for in-product chrome, a bolder stroke at 32px for tab legibility, and a single-ink mono variant for contexts that can't render color. This page's own tab favicon is the 32px treatment.
Field Guide
Get started
Auriga is open source and standalone-runnable: clone it, verify the router's decision logic, then optionally build and serve the operator dashboard locally. No external services required.
1
Clone the repo
# requires Node 24+
git clone https://github.com/mdostal/auriga.git
cd auriga
2
Verify the router
The router at src/router/ is plain Node with zero dependencies — its decision logic is pure and unit-tested against mocked board state.
cd src/router
npm test
3
Build and run the operator dashboard (optional)
The dashboard is a separate, isolated Vite + Tailwind + shadcn/ui package, served by a small read-only node:http JSON API over this repo's own .pHive/ planning state. Neither package is a dependency of the router.
cd ../ui
npm install
npm run build
cd ../server
npm install
node index.mjs
# → http://localhost:8787
＋Install & interact from an AI agent (Claude Code / Codex)one command▸
A separate, faster path alongside the clone above: one command installs the same auriga CLI and registers Auriga's read-only MCP server with whatever agent CLI is already on your machine — so your own Claude Code or Codex session can query this board's real state directly, no dashboard required.
Under the hood this clones the repo, links the auriga command onto $PATH, then runs auriga agent init to detect and wire up Claude Code / Codex — idempotent, safe to re-run any time. Run auriga agent status afterward to see what got registered.