Triumvirate

Three AI models. One daemon. A methodology for building software with all of them at once.

Claude, Gemini, and Codex — each with different strengths — working on the same codebase, coordinated by a single Rust daemon, visible in real-time from inside your editor.

Quick Start

git clone https://github.com/michaeljboscia/triumvirate
cd triumvirate/daemon
cargo build --release && cargo run --release

That's it. One binary. No Docker. No NATS. No cloud services. Register it in Claude Code:

# Add to ~/.claude.json under mcpServers:
"triumvirate": { "command": "/path/to/triumvirate", "args": ["mcp"] }

Then from any Claude session: spawn a Gemini session called 'research'

Requirements: Rust 1.82+ and at least one agent CLI (Claude Code, Gemini CLI, or Codex CLI). Works with 1, 2, or all 3.

The Problem

You're using Claude to write code. You want Gemini to research something. You want Codex to implement a plan in parallel. So you open three terminal windows, copy-paste context between them, lose track of which one is doing what, and eventually something goes sideways because nobody can see what anyone else is doing.

Triumvirate replaces the terminal windows.

What It Does Today

The daemon — a Rust MCP server that spawns and manages persistent agent sessions:

You:     "spawn a Gemini session called 'research'"
Claude:  → spawn_session(agent: "gemini", session_name: "research")
         ✓ Session research spawned

You:     "ask research to analyze our auth middleware"
Claude:  → ask_session(session_name: "research", prompt: "...")
         → Gemini: turn started
         → Gemini: calling read_file (src/middleware/auth.rs)
         → Gemini: calling read_file (src/middleware/jwt.rs)
         → Gemini: generating response
         → Gemini: responded (12,847 in / 1,203 out / 8,400 cached, 2 tools, 4.1s)
         "The auth middleware has three issues..."

You:     "spawn a Codex session and have it fix what Gemini found"

Persistent sessions. Live streaming. Cross-model coordination. From inside Claude — no window switching.

The methodology — skills that use the daemon to run structured multi-agent processes:

The operating environment — a starter kit that wires all three agents together:

cd starter-kit && ./install.sh

Hooks, configs, skills, and session notes for Claude, Codex, and Gemini. Plus a local stenographer that captures session notes via Ollama — zero cloud cost.

The Loop

This is how software gets built with Triumvirate:

         ┌─────────────────────────────────────────┐
         │                                         │
    Spec ──→ /goatrodeo ──→ Implementation ──→ /postrodeo
         │   (Gemini +       (Codex builds      (twins audit   │
         │    Codex review    from the spec)      the code)     │
         │    the spec)                                         │
         │                                         │
         └──── lessons feed back into next cycle ──┘

The goatrodeo runs through the daemon. It spawns Gemini and Codex as daemon sessions to review your spec. The postrodeo does the same for code review. The daemon is the infrastructure the methodology runs on.

This project was built using this loop. The Flow State feature (live agent streaming) went through a 4-round goatrodeo with 27 requirements, 29 auto-resolves, and 5 human decisions — all running through the daemon. Then Codex implemented all 6 phases from the resulting spec while the human took a nap.

The tool that coordinates agents was built by agents coordinating through the tool.

What's Shipped

Daemon (daemon/)

Skills (skills/)

Starter Kit (starter-kit/)

Full installer for multi-agent development:

• Claude — hooks (session lifecycle, token gating, artifact protection), skills, CLAUDE.md
• Codex — hooks (session recovery, pre-compact), config, AGENTS.md
• Gemini — hooks (session recovery, pre-compact), GEMINI.md
• Stenographer — local session notes via Ollama (zero cloud cost)
• MCP server registration — wires agents to communicate through the daemon

Stenographer (stenographer/)

Standalone Python tool. Reads agent transcripts, feeds them to a local Ollama model, appends narrative session notes. Triggered automatically by hooks when transcript growth crosses a threshold.

Architecture

triumvirate-daemon (single Rust binary, 13 crates)
│
├── MCP Server (rmcp) — 35+ tools
│   Sessions, ABE dispatch, fleet, knowledge, review, tokens
│
├── HTTP API (axum) — REST + Prometheus + WebSocket
│   Same tools as REST endpoints, plus /metrics, /ws, /api/tokens/*
│
├── ABE (Autonomous Build Enforcement)
│   ├── Fleet dispatch — N workers in isolated git worktrees
│   ├── Task tracker — state machine with 4-signal completion detection
│   ├── Contract enforcement — file scope, commit format, test gates
│   └── Failure classification — auto-retry with escalation
│
├── Token Economics (token-economics crate)
│   SQLite storage, session scanner (Claude/Codex/Gemini JSONL),
│   cost attribution by build/session/task
│
├── Agent Adapter (agent-adapter crate)
│   ├── GeminiStreamParser  — parses stream-json NDJSON live
│   ├── CodexExecParser     — parses exec --json JSONL live
│   └── StuckDetector       — idle, loop, freeze detection
│
├── Daemon Core — metrics, observability bus, session lifecycle
│
└── Fallback Outbox — disk-persisted retry queue

13 crates. 150+ tests. Zero external services.

Installation Options

The full stack installer sets up: daemon + skills + hooks + configs + stenographer for all three agents.

What's Next

v3.2.0 shipped the build dispatch half. What's left is polish and scale.

The daemon is the coordination layer. The methodology runs on top of it. The agents do the work.

See ROADMAP.md for the full plan.

How It Was Built

This project is designed and built by a human (Mike Boscia) coordinating three AI agents:

• Claude (Opus 4.6) — architecture, spec review, goatrodeo, documentation
• Gemini (Pro 2M context) — research, competitive analysis, adversarial review
• Codex (GPT-5.2) — implementation, from scaffold to shipped

Every feature goes through the loop: spec → goatrodeo → implementation → postrodeo. The agents review each other's work before and after building. The goatrodeo runs through the daemon. The implementation runs through the daemon. The tool is being built by the process it enables.

37 research artifacts documenting the design process are in archive/research/.

The Ecosystem

Triumvirate doesn't work alone. It's one layer in a stack of tools that collaborate in the same session:

The daily workflow: Claude Code has Triumvirate and Pythia both registered as MCP servers. You search code with Pythia, spawn agent sessions with Triumvirate, run goatrodeos that use both — all without leaving the editor. The tools compose because they share a protocol.

Prior Art

No source code was vendored from any of these projects. Where patterns were adapted, implementation was re-authored in Rust. Inline attribution comments appear at adaptation points in the source. Full details in NOTICE.md.

Acknowledgments

Triumvirate exists because three companies built AI agents good enough to coordinate:

• Anthropic — Claude Code and the MCP protocol that connects everything
• Google — Gemini CLI with stream-json and 2M context
• OpenAI — Codex CLI with exec --json and sandboxed execution

The agents are theirs. The coordination is ours. The methodology emerged from using all three together every day and discovering what works.

License

FSL-1.1-ALv2 (Functional Source License 1.1, Apache 2.0 Future License)