The mark, in a browser tab

Auriga — Router God of Pantheon

Pantheon

Multica

mdostal.github.io/auriga

Pantheon · Router & Dispatch

Auriga

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.

View source on GitHub ↗ Read the docs ↗ Get started ↓

About

The router god of Pantheon

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.

github.com/mdostal/auriga ↗ README & architecture ↗

Plate I

The Board

Every epic Auriga is tracking, charted by status. Story count shown as apparent magnitude — the more stories, the brighter the point.

Pendingunlit — awaiting dispatch

Planningnebulous — still forming

In Progressburning — actively worked

Donefixed — settled in the chart

p1-dispatch-throughput

P1: Convert Dispatch Throughput to DONE Throughput

11 stories Pending

p2-adapter-interface

P2: Adapter‑Interface Extraction — backlogAdapter + spawnAdapter + pantheon‑v2‑l2 stub

5 stories Done

p3-auriga-ui

P3: Auriga UI — a clean, read‑only operator dashboard

4 stories Done

Plate II

Star Chart Detail

A single story, plotted with its dependencies, acceptance criteria and known risks.

Rewire cycle() and all mcaImpl.* call sites to the backlog/spawn adapter boundary

Done Complexity method · 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

Aug 1721:25 UTC−05:00

Commit 7d1d401

[p3-auriga-ui] chore: add root test:all convenience script

Aug 1721:24 UTC−05:00

Commit bcb3c18

[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 produced 9 commits 46 files changed 157 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.

Clone the repo

# requires Node 24+
git clone https://github.com/mdostal/auriga.git
cd auriga

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

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.

curl -fsSL https://mdostal.github.io/auriga/install.sh | bash

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.

View source on GitHub ↗ Full README ↗