muad-yasin/the-high-council-mcp
Public
MIT
Node 20+
MCP SERVER · CLI · BRING YOUR OWN KEYS
The High Council
A planning harness that runs one idea past several AI models from different labs, makes them argue about it on the record, and stops at a checkable result.
Nothing is resold, nothing is hosted for you, and no key ever leaves your machine.
On what this does and doesn't claim
This repo publishes the mechanism: the chains, the seat rosters, the stage order. It does not claim to produce better plans than a single good model would. That is an open question and we have not measured it. What it does, concretely, is make disagreement between models visible and recorded instead of averaged away - you can read who objected to what, who withdrew a proposal under argument, and who held their position.
From one real run
run 2026-09-11T10-06-06-899Z · four labs · three rounds · 6 of 12 proposals withdrawn
Every post is written to BOARD.md, including the ones that lost. Six of the twelve proposals on this board were withdrawn by their own authors after the other labs argued against them - half of everything proposed. The two below are the ones worth reading.
Proposal · nullable by default
Objected to by all three rival seats across the debate round.
Withdrawn by its own author
Proposal · FFI wrapper
Argued down in the same round, on the record, by the seats that read it blind.
Withdrawn by its own author
Held their position
Two of the four seats declined to sign off - on a structural requirement in the run's setup, not on whether the plan was any good. The disagreement is recorded rather than averaged away.
$0.0442
what that whole run cost - four labs, three rounds, every post recorded
How it works
A run moves through fixed stages. Which stages fire depends on the chain you pick.
01Questions
A seat reads the request and asks only the questions whose answers would change the output. You answer them, or take its stated defaults.
02Criteria
The request becomes a short list of acceptance criteria, each one a yes/no check rather than a matter of taste.
03Skeleton
An outline the other models will propose against. Names the parts, decides nothing.
04Proposals
Every lab proposes buildable parts, blind to each other.
05Debate
The labs read each other's proposals, anonymised, and post support / object / merge. Then each author replies: keep, amend, or withdraw.
06Build
One seat integrates the surviving proposals into a single document.
07Panel review
Every critic independently grades the draft against the acceptance criteria, blind. Not unanimous? It revises against the union of every objection and the panel reviews again, up to the chain's round cap.
08Handoff
A HANDOFF.md written for whoever executes the result.
Every run writes a folder: the deliverable, BOARD.md (the full debate - every post, every withdrawal), HANDOFF.md, a per-lab scoreboard, and the real token/cost accounting.
Setup
Node 20+, plus API keys for whichever labs your chain uses.
git clone https://github.com/muad-yasin/the-high-council-mcp.git
cd the-high-council-mcp
npm install
cp .env.example .env
Fill in .env with only the keys your chain needs:
ANTHROPIC_API_KEY
OPENAI_API_KEY
GOOGLE_API_KEY
MISTRAL_API_KEY
DEEPSEEK_API_KEY
GROQ_API_KEY
TOGETHER_API_KEY
COHERE_API_KEY
OPENROUTER_API_KEY
ZAI_API_KEY
XAI_API_KEY
The CLI refuses to start if any seat in the chosen chain is missing its key, rather than failing halfway through a paid run.
Quick start
Write what you want into a task file, then run a chain against it.
mkdir -p tasks
echo "What I want planned, in plain words." > tasks/your-idea.md
# see what's available and what it would cost
node src/cli.js --help
npm run dry -- --task tasks/your-idea.md --chain verify
# a real run
node src/cli.js --task tasks/your-idea.md --chain verify
verify is the cheap default: two labs, a hard two-round cap. Start there.
Or run it as an MCP server and let your client drive it:
npm run mcp
The spend cap
$5
per-run ceiling by default, checked before each paid stage
A stage that could take the run past the ceiling is never called, so the cap holds rather than reporting the overspend afterwards. A run that hits it stops cleanly and writes STOPPED-budget.md. Nothing is half-written - continue it with a higher ceiling and completed stages replay from disk for free.
node src/cli.js --task tasks/x.md --max-usd 2 # this run stops at $2
node src/cli.js --task tasks/x.md --max-usd none # no ceiling
node src/cli.js --resume runs/<id> --max-usd 10 # continue with headroom
MCP tools
Register the server with your MCP client, then drive it with these.
list_chains
Available chains with descriptions and worst-case price
write_task
Write the request the harness plans against
dry_run
Price a run before spending anything
start_run
Start a run in the background (max_usd sets its ceiling)
run_status
Stage reached, panel verdicts, scoreboard, cost, budget remaining
spend_report
What every run has cost across a window of days, derived from disk
external_prompt
The prompt a paused external stage is waiting on
prepare_stage_prompt
A self-contained bundle for a paused stage, so a driving session can dispatch it to a fresh subagent instead of authoring it inline
submit_stage
Answer a paused stage and resume
resume_run
Resume a paused run, or raise max_usd on one the cap stopped
read_run_file
Read any file from a run folder
plan_outline
Outline pass
Chains
30 chain configs live in chains/. Each one is plain JSON - the seat roster, which models fill which seat, the round cap, and whether proposals/debate/handoff stages run. They are meant to be copied and edited.
verify
Two labs, two rounds. The recommended starting point.
cheap
Small models throughout. For testing the harness itself, not for real work.
plan-debate
Five labs propose blind, debate each other's proposals anonymised, then a blind panel grades the integrated draft.
plan-auto
The full open-scope chain, every seat on a real API, runs unattended end to end.
plan-unanimous
Every critic must independently sign off on the same draft. Three rounds here means up to fifteen critic calls, not five.
mock-budget
Calls no API but carries fixture prices - watch the cap work without spending anything.
Read a chain's description field before running it; they say what they cost you in calls.
Known limits, stated plainly
The spend cap is enforced against a worst case, not a prediction: the whole prompt billed as input plus the seat's entire maxTokens budget billed as output (doubled for Anthropic seats, which may retry once). Real stages almost never cost that much, so a run can stop with headroom left. That is the intended trade - resume it with a higher ceiling.
A seat whose model has no entry in src/pricing.json is unpriced, and therefore uncapped. It contributes $0 to the running total no matter what it really costs. Check dry_run output for unpriced before trusting a ceiling.
Prices in src/pricing.json are hand-maintained list prices, last verified 2026-09-06. They are estimates, not invoices. Your provider's bill is the real number.
Chains with many labs and high round caps get expensive quickly. plan-unanimous at three rounds is fifteen critic calls; plan-auto runs several frontier models over multiple rounds. Price before you run.
A panel that signs off is not a guarantee the output is correct. It means every critic seat checked it against the stated acceptance criteria and found nothing. Criteria that are vague produce sign-offs that mean nothing - the quality of the run depends heavily on the quality of the criteria stage.
Some chains pause for human input by design. They are not stuck.
Free, public, MIT.
Clone it, bring your own keys, run it. Nothing is resold and nothing is hosted for you.
MIT. See LICENSE.