Council of High Intelligence: multi-persona deliberation for Claude Code, Codex, Gemini CLI and OpenCode

The decision boundary the project is built around

This is not a model and not an orchestration runtime. It is a set of skill files plus an installer that gives an existing coding agent a structured way to argue with itself. The README frames the target case narrowly: questions with material downside, competing values, incomplete evidence, or an irreversible choice. Anything cheaper than that is explicitly out of scope. The README tells you to use a direct answer or primary documentation for factual lookups, and to run an experiment when the choice is cheap and reversible. It also names the anti-pattern plainly: do not convene a council to manufacture support for a preferred answer. That last line is the most useful thing in the document, because it is the failure mode that multi-agent setups invite. The intended user is someone already living in Claude Code, Codex, Gemini CLI or OpenCode who wants a second and third reasoning path without leaving the terminal. The README also asks you to write down the decision, constraints, evidence, reversibility and deadline before adding personas, and the field notes distinguish facts from inference, assumptions and unknowns. That framing is the product. The personas are downstream of it.

How the protocol enforces disagreement

The full protocol runs on a fixed round budget. Members first restate the problem, then analyze blind, then cross-examine other positions, then declare a final stance, and only then enter synthesis. The ordering matters more than the roster. Independent analysis before contact is what keeps the first positions from collapsing into the first speaker's framing, and the cross-examination round is where the README expects direct disagreement rather than polite restatement. Enforcement checks look for premature agreement, repeated claims, missing dissent and unsupported confidence. The output shape is unusual for this kind of tool: verdicts lead with what remains unresolved, and a recommendation is paired with acceptable compromises, kill criteria and one concrete next step. When the weighted tally stays split, the result returns that split instead of turning it into prose consensus. Evidence is labeled FACT, INFERENCE, ASSUMPTION or UNKNOWN, with FACT meaning directly supported by supplied or retrieved evidence and ASSUMPTION meaning required for the argument but still unverified. The README describes the 18 members as analytical instruments rather than impersonation claims, each with a grounding protocol, a method, known blind spots and a structured response contract. The counterweight column is the part worth reading closely: Aristotle against Lao Tzu on excess structure, Torvalds against Meadows on local fixes versus system consequences, Karpathy against Sutskever on empirical behavior versus frontier risk. The pairs are chosen so that one lens's blind spot is another's method.

Installing the skill in Claude Code, Codex, Gemini CLI or OpenCode

Claude Code users install it as a plugin from the marketplace, then run the command. The README gives these two lines verbatim.

/plugin marketplace add 0xNyk/council-of-high-intelligence
/plugin install council@council-of-high-intelligence

After that, the command is /council on every supported host. The README shows the three modes in one block, including the flag forms.

/council Should we open-source our agent framework?
/council --quick Should we add caching here?
/council --duo Should we use microservices or a monolith?

For Codex, Gemini CLI or OpenCode, the route is a clone plus the matching installer flag. The README shows all three flags in one block.

git clone https://github.com/0xNyk/council-of-high-intelligence.git
cd council-of-high-intelligence

./install.sh --codex-only
./install.sh --gemini-only
./install.sh --opencode-only

The README states that you should restart the target client after installation. That is the step people skip, and it is the one that decides whether the skill is picked up at all. Beyond the flags, the README does not document what install.sh writes or where, so if the command does not appear after a restart, the installer script itself is the place to look. The repository also carries per-host skill files at the top level: SKILL.md, SKILL.codex.md, SKILL.gemini.md and SKILL.opencode.md, which suggests each host gets a variant rather than one shared prompt.

Triads, duos and the mode table

Three modes are documented. Full runs independent analysis, cross-examination, a final stance and synthesis, and is meant for high stakes where competing frames need contact. Quick restates, analyzes rapidly and takes final positions, for decisions that need breadth but not a full adversarial round. Duo runs opening positions, a direct response and final statements, for when one polarity defines the decision. The mode table gives a use-when line for each, and the README repeats the guidance in prose: use --quick when cross-examination will not change the outcome, use --duo when one tension matters more than broad coverage. Named triads are the more interesting control. They select three relevant lenses without assembling the whole council, and the README lists domains including architecture, strategy, ethics, debugging, risk, shipping, product, founder, ai, ai-product, ai-safety, decision, systems, uncertainty, design, economics and bias. The README says the canonical routing table lives in SKILL.md, which means the list of domain names is not by itself enough to predict which three members you get. That is a real gap for anyone trying to reason about cost and coverage before running a session. You can also name members directly, as in the duo example with torvalds and ada. Note that the README's own example for --quick uses --triad shipping in the same line, so the flags compose.

Where the council is the wrong instrument

The README is unusually candid about this, and the honesty is the reason to trust the rest. Factual lookups do not need a council; primary documentation is faster and more accurate. Cheap reversible choices do not need one either, because the experiment is the answer. The README also warns against using a long deliberation as decoration for a decision already made, and against convening one to manufacture support. There is a subtler cost that the documentation implies without stating. Every round is tokens spent on restatement and cross-examination that a single well-formed prompt might have covered, and the fixed round budget means you cannot dial the depth down mid-session the way you can with a plain conversation. The mode flags are the only lever. There is also a verification problem: the enforcement checks look for premature agreement, repeated claims, missing dissent and unsupported confidence, but the README does not describe how those checks are implemented or how a user would audit them. If you need a guarantee that dissent was preserved rather than a prompt that asks for it, this is a prompt protocol, not a validator. Finally, the repository is Shell plus skill files, so anything you disagree with in the protocol is something you edit yourself, and your edits are yours to maintain.

How it differs from a plain multi-model comparison

The obvious alternative is asking the same question of two or three models and reading both answers, which is what most people do today, and it is genuinely cheaper. The difference is structural. Parallel answers never contact each other, so each model answers the framing you wrote rather than the framing another model challenged. The council forces a cross-examination round before final positions, which is the step that surfaces a premise you did not know you had assumed. A second alternative is a single long prompt that asks one model to argue both sides. That is cheaper still and it fails differently: one model holding both positions tends to produce a balanced-sounding synthesis with the tension already resolved, which is exactly the prose consensus the README says the weighted tally should refuse to produce. Where the council is weaker than either alternative is setup cost. The plugin path is two lines in Claude Code, but the other three hosts need a clone and an installer flag plus a client restart, and the canonical routing table lives in a separate file. If your decision does not justify that, a direct answer is the right call and the README says so.

Tracking outcomes, licence and the cost of upgrades

The README argues that a verdict is only useful if it can be checked later, and gives a concrete procedure: before acting, record the prediction, owner, review date, and the evidence that would change the recommendation. At the checkpoint, mark the result confirmed, revised, reversed or inconclusive, and do not rewrite the original rationale. That is a discipline the tool cannot enforce for you, and it is the part most users will skip. On maintenance, the last push to the default branch was on 2026-09-07, and the repository is not archived. Three releases are listed: v1.0.0 on 2026-03-30, v1.1.0 on 2026-05-21 and v1.2.0 on 2026-07-04. There is a CHANGELOG.md at the top level, so upgrade cost is legible before you pull. Because the shipped artifact is prompt text and a Shell installer, upgrades are not binary compatibility events; a new release can change how a lens reasons or how a domain routes, and that can change verdicts without any code breaking. Read the changelog before pulling if you have come to rely on a particular persona's behavior. The licence is MIT. That is permissive and places few conditions on reuse, but it also means no warranty and no support obligation, and the repository carries a SECURITY.md and CONTRIBUTING.md at the top level if you intend to send changes upstream. Nothing here is legal advice; read the LICENSE file for the actual terms.

Editorial conclusion

Adopt it if you already work inside Claude Code, Codex, Gemini CLI or OpenCode and you have a decision with real downside, competing values or irreversibility, where you want the disagreement written down rather than smoothed away. Do not adopt it for factual lookups, cheap reversible choices, or as a way to manufacture support for an answer you have already picked; the README says so directly. Before you rely on it, verify that install.sh --codex-only (or the matching flag) places the skill where your client actually reads it, and check SKILL.md for the canonical domain routing table, since the README only names the domains without mapping them to the lenses.

Frequently asked questions

Official sources

1. 0xNyk/council-of-high-intelligence on GitHub
2. License: MIT
3. Project website
4. README
5. Releases