Runs entirely on your desk 🔒 One hard approval gate 🧾 Full audit trail

One question.
Every AI you have.
One answer you can trust.

Ask one model something hard and you get one perspective — its blind spots baked in. Gang of 8 asks all of them at once. Every AI on your machine — the claude, codex, and gemini CLIs, plus any API seats you enable — convenes as a panel, each writing independently and in parallel. Then a lead verifies the claims, overrules what's wrong by name, and assigns the real work to specialists — then ships tested files.

No API keys to start Local CLIs, own auth Offline mock backend
The panel is your machine — every seat a different origin model
claude lead · fast codex critic gemini researcher summarizer codifier · strong DeepSeek OpenRouter GLM OpenRouter Qwen OpenRouter Kimi OpenRouter
The panel model

The diversity of a committee.
The decisiveness of a single owner.

No echo chamber. Every seat writes blind, then one lead verifies against the evidence, delegates the work, and closes the loop — before anything reaches your files.

Convene the panel

All seats get the task plus pre-read project context and write their take independently and in parallel — none sees another's answer while writing.

Lead verifies & delegates

A fast lead checks claims against real evidence, adopts what's right, overrules what's wrong by name, and assigns work to specialist talents.

Best-of-N, executed

On a build, every candidate is run headless — crashers disqualified — then scored blindly by judges. The winner is a real model's code, shipped byte-for-byte.

One hard gate

Tests pass first. Then a single diff-carrying approval — create vs. overwrite — stands between the council and your real folder. Nothing crosses without your click.

Why it wins

It doesn't just talk — it builds.

Ask for working software and the council designs it, delegates the authoring, runs the tests, and fixes its own failures before anything ships.

CORE BET
🧠

Genuinely different minds, not an echo chamber

Every panelist writes in parallel, blind to the others. You get N real perspectives instead of N models agreeing with whoever spoke first — the diversity-of-intelligence bet the whole system is built on. Every contribution is tagged with the exact model that wrote it.

🗳️

Best-of-N you can trust

Candidates that crash on load are disqualified — judging by reading is blind to runtime failure. Only files that actually run get scored blindly. 🏆 winner ships unchanged.

🤝

Specialists on demand

The coder codes, the researcher researches, the critic checks. The lead recruits talents live — 🤝 code_generator ← claude — and a failed delegation is retried before falling back.

🛠️

Builds close their own loop

When RUNTESTS fails, the lead sees the real output and repairs the code — up to 3 attempts, all before promotion. A build ships passing its own tests, or says exactly why it couldn't.

HONEST BY DESIGN
🧾

Receipts, not vibes

Everything is bounded — budgets, wall-clock, depth caps — and everything is logged to a JSONL reasoning trail. Rotation is automatic but consent-gated: after three CONTINUE rounds it pauses and asks you. A run that fails says so honestly instead of dressing up a failure as an answer.

Interactive · runs in your browser

Watch a deliberation happen.

Pick a task. Watch the panel write in parallel, a crasher get disqualified, the judges score blindly, and one winner reach the promote gate — the real loop, simulated.

Give the council something hard

Choose a prompt and press Submit to the council. Nothing here calls a server — it's a faithful re-enactment of the panel → best-of-N → gate pipeline.

task › Build a responsive landing page for a local tool.
🏆 Winner shipped byte-for-byte — index.html

Highest blind score on completeness, correctness, fidelity & robustness. Credited to the model that wrote it.

🔒 promote → C:\Users\you\Desktop\tmp\index.html · CREATE new file ✓ Approved — file written
One gate. No surprises.

Work happens freely. Delivery never does.

Side effects are governed by a data-driven skill registry and a permission kernel — the kernel decides on metadata, never on hardcoded behavior.

🏗️

A sandbox with real hands

Writes, edits, test runs, staging, web lookups — all free inside the council's own scratch space. Every seat can land its work; role-gating never blocks council work.

🔒

The one gate: promote

Copying a finished file into your real folder is the only approval in the pipeline — with a diff that says whether it creates or OVERWRITES. Pick Approve all to grant a category for the session.

🎯

It lands where you said

“Read from A, save to B” delivers to B and never touches source A. No known destination? It asks where at delivery time — never up front, never assumed.

Two commands

Fully self-contained. It runs the CLIs itself.

Detection is the same PATH lookup your terminal does. Anything installed is found; anything absent is gracefully skipped. No config file, no external service.

real agents — nothing else to start
# the CLIs manage their own auth
.venv\Scripts\python cli.py serve --backend cli

# or one-shot:
.venv\Scripts\python cli.py submit "your task" --backend cli

# dashboard opens at
http://127.0.0.1:8790/
offline, deterministic — no keys at all
python -m venv .venv
.venv\Scripts\python -m pip install \
  pydantic fastapi uvicorn pytest httpx

# default mock backend — try it now
.venv\Scripts\python cli.py serve --backend mock
🔑

Which API keys do you need? None, to start.

The CLIs authenticate themselves and the model dropdowns are fed by a public, no-key catalog. Keys only add capability: a Gemini key routes the gemini seat through Google's SDK (faster on Windows, image vision, Google-grounded search); an OpenRouter key unlocks the DeepSeek / GLM / Qwen / Kimi panel seats. Absent keys degrade gracefully — they never error.

Type 1: Coordinator OS

Stop trusting one model's blind spots.

The diversity of a committee, the decisiveness of a single owner, and the receipts of an audit trail — running entirely on your desk.