Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Multi-Council: Five AI Models That Actually Disagree

    1

    Run high-stakes decisions through a five-model council from different labs, and see where they genuinely disagree.

    Free

    1 useSecurity scanned
    Multi-Council: Five AI Models That Actually Disagree

    Multi-Council: Five AI Models That Actually Disagree

    Example session with this skill installed

    pressure-test this: we are considering migrating our entire database from PostgreSQL to a NoSQL solution to handle upcoming scale. council this.

    • Read your context and instructions
    • Compiled the multi-council

    Five advisors on five models from five different labs answered independently. All five responded. Peer review was anonymised and cross-model.

    Council Verdict: PostgreSQL to NoSQL Migration

    Where the Council Diverged

    The verdict was never in contest — the disagreement was about what would make the migration correct.

    GLM set the bar at

    measured rather than projected load, and included whether the team can actually operate the target: resharding, compaction, failover. Gemini set a

    structural bar instead: the bottleneck must span the entire schema, not two hot tables — the only advisor to engage the word "entire" in the question. GPT set a

    workload-shape bar: key-based access, few joins, tolerance for denormalisation.

    Three different tests, and a team could pass any one of them while failing the other two.

    What Only One Advisor Saw

    Gemini alone raised geographic scale. Every other advisor equated "scale" with single-region throughput, where single-primary PostgreSQL has real physics limits for multi-region active-active writes.

    GPT alone asked for a migration plan: dual writes, CDC, backfill validation, phased cutover, rollback, and the cost of running both systems through the transition. "Extract one workload" is still a project.

    GLM alone noted that nobody steelmanned the upside — which means every advisor's "when this would be right" list was quietly built to fail.

    Where the Council Agreed, and the Blind Spot Underneath It

    All five said don't migrate, for the same core reason: this is a forecast rather than a measurement, and the usual ceiling is missing indexes, unpooled connections and N+1 queries rather than PostgreSQL itself.

    That unanimity deserves suspicion, and peer review found why. Four of the five reviewers independently flagged that every advisor had treated "NoSQL" as a single thing. DynamoDB, MongoDB and Cassandra have incompatible consistency and query models, and several now support transactions — so the recurring "you lose ACID" argument is roughly a decade out of date. The real lock-in is that data gets modelled around fixed access patterns, which makes product changes expensive, not just transactions.

    The council reached a defensible answer partly by way of an outdated argument. That is worth knowing before you repeat it to your team.

    The Recommendation

    Don't migrate on a forecast. Measure first: establish whether the ceiling is CPU, IOPS, locks, connection exhaustion or query plans. Then work the PostgreSQL ladder — pg_stat_statements, composite indexes, PgBouncer, read replicas, declarative partitioning, and Citus if writes genuinely need to scale horizontally.

    If one workload then proves unmanageable — event ingestion, telemetry, session state — move that one behind a service boundary and keep PostgreSQL as the system of record. When you do evaluate a NoSQL engine, evaluate a specific engine against your real access patterns, not the category.

    The One Thing to Do First

    Run pg_stat_statements against production and pull your ten slowest queries. Every advisor independently predicted your ceiling is there rather than in the engine. That is a claim you can falsify in an afternoon, before anyone writes a migration plan.

    Seats

    SeatModelLabTime
    gptgpt-5.6-lunaOpenAI13.8s
    geminigemini-4-argon-highGoogle37.0s
    glmglm-5.2Zhipu30.9s
    deepseekdeepseek-v4-flash-0731DeepSeek5.4s
    inklinginkling-smallThinking Machines4.8s

    5 of 5 seated. Advise round 37.5s, peer review 83.7s.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    The problem

    Ask five AI sub-agents for advice and you get one opinion wearing five hats. They share weights, training data and blind spots, so any disagreement between them was scripted by their prompts — and whatever the model cannot see, none of the five can see.

    What this does

    multi-council sends one identical, neutral question to five models from five different labs, with no assigned roles. It then anonymises the answers, has every advisor critique the others blind, and synthesises a verdict that leads with where they disagreed — because that is the part that cannot be explained by shared training data.

    It treats unanimity as a flag rather than as confidence. Five models agreeing may simply mean five models share a prior.

    How it runs

    • One question, five labs, dispatched in parallel — a full council takes about 15 seconds
    • Anonymised cross-model peer review, with the letter mapping shuffled so position carries no information
    • Divergence-first synthesis: no vote counting, no majority rule
    • A seat that fails is reported as empty, never invented

    Three rosters included

    RosterNeedsCost per run
    zero_subscriptionAn OpenRouter key onlyabout 2-3 cents
    frontierAn OpenRouter key onlyabout 9-10 cents
    referenceOpenRouter + Codex CLI + Antigravity + Z.aiabout half a cent

    Requirements — please read before installing

    You need an OPENROUTER_API_KEY. Every roster needs at least that, and nothing runs without it. The reference roster additionally expects a ChatGPT-authenticated Codex CLI, Antigravity signed in, and a Z.ai coding plan.

    Python 3.10 or newer, standard library only — there is nothing to pip install.

    You can check a roster without spending anything by running the dispatcher with --dry-run before your first real council.

    When not to use it

    Factual lookups, creation tasks, and decisions that have one obvious right answer. This is built for decisions where being wrong is expensive and the answer is genuinely uncertain.

    Licence

    MIT. Source and issues: https://github.com/michaelkpate/multi-council

    What it does

    • Frames neutral questions by scanning your workspace context (CLAUDE.md, memory/, local files) to strip out steer and bias.
    • Orchestrates multi-model councils using five distinct architectures from different labs to ensure diverse perspectives.
    • Conducts anonymous peer reviews where each model critiques the others' blind spots without knowing their identities.
    • Synthesizes divergence-first verdicts that prioritize where models disagree, as conflict reveals the most information.
    • Flags correlated errors by treating unanimity as a potential shared bias rather than a sign of certainty.

    How it works

    1. Frame: The agent generates a neutral question grounded in your specific project context and stakes.
    2. Advise: Five models receive identical prompts to commit to a firm position without hedging.
    3. Review: Responses are shuffled and anonymized; advisors then identify the strongest arguments and what the group missed.
    4. Verdict: The agent delivers a final synthesis focusing on disagreements and unique insights rather than vote-counting.

    Frameworks & tools

    This skill utilizes a dispatch script to communicate across multiple transports including openrouter, codex, agy (Antigravity), and claude_zai. It requires valid API keys for the respective labs and a local Python environment to execute the orchestrator.

    Why this beats prompting it yourself

    Prompting a single model to "be a contrarian" only produces scripted disagreement based on one set of weights. This skill forces genuine friction between different labs, catching hallucinations or biases that a single-vendor workflow would naturally overlook.

    Use cases

    • Strategic pivots where the technical or business risk of a wrong move is high.
    • Architecture reviews to find flaws in a proposed system design before implementation.
    • Policy decisions where you need to surface hidden trade-offs in team or project governance.

    Known limitations

    Not for factual lookups or tasks with one right answer. Requires at least three models to respond successfully to proceed with synthesis. Prompt length for certain transports is capped near 32,000 characters.

    Requires at least 3 models to respond. Needs OPENROUTER_API_KEY and ZAI_API_KEY. Prompt length for agy transport capped at ~32k chars. Not for factual lookups.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 25 days ago

    • Free with an Agensi account

    Requires

    OpenAI
    Google AI
    Openrouter
    Z
    Python 3.10+
    OpenRouter account and API key
    Codex CLI (reference roster only)
    Antigravity CLI (reference roster only)
    Z.ai Coding Plan (reference roster only)
    Python
    Git

    Permissions

    Terminal / Shell
    Write Files
    Read Files
    Network Access
    Environment Variables

    Allowed Hosts

    openrouter.ai
    api.openai.com
    generativelanguage.googleapis.com
    z.ai

    Terminal/Shell, Write Files and Network Access are used only to dispatch the five advisor models: each adapter shells out to its CLI or posts to the OpenRouter API, and writes solely to OS temp directories that are deleted afterwards. The skill never writes to your project. Environment Variables are read for API keys only — OPENROUTER_API_KEY, and ZAI_API_KEY if you use the reference roster.

    Listed25 days ago

    What's inside

    Frequently Asked Questions

    This skill is designed for high-stakes, subjective decisions where a single model's bias might lead you astray. It is not intended for factual queries, simple coding tasks, or problems with a single objective right answer.

    The skill includes the primary Python orchestrator script, a library of neutral-framing templates, and the dispatch configurations required to communicate with OpenRouter, Codex, Antigravity, and Claude ZAI.

    Yes, this skill requires you to have active accounts and valid API keys for the supported transports (like OpenRouter or Antigravity) to facilitate communication with the five different model labs.

    Multi Council is compatible with any AI agent environment that supports local Python execution and outbound API calls, including most CLI-based agents and MCP-enabled systems.

    If a model fails to respond due to downtime, the orchestrator requires a minimum of three successful responses from different labs to proceed with the peer review and synthesis phases.

    The synthesis report prioritizes "divergence-first" insights, meaning it highlights where models disagree and flags unanimous agreement as potential shared bias rather than absolute truth.

    New in Agents & Orchestration