The Deep-Decide Skill: Multi-Model AI Debate for Hard Decisions.

Most “AI for decisions” tools give you more information. That is rarely the problem. deep-decide stages a fair fight between your options instead — and it just caught a $56,000-a-year mistake that a single top model, at maximum effort, had already waved through.

The problem

When a decision is genuinely hard, you usually already have the facts. What is missing is a fair fight between the options — and an honest look at the objection you are about to overrule.

Asking a single model to “pressure-test” its own recommendation does not fix this. It brings the same blind spots to the critique that it brought to the draft.

One model interrogating itself is theater, not counsel.

What it is

deep-decide is a small, portable Claude skill that runs the fight for you. You bring a decision, the real options, and your criteria — then trigger it with deep-decide this, pressure-test this decision, or rank these options. It spins up four independent perspectives and makes each one argue the strongest honest case from its seat. Each seat must also state the assumption its whole case rests on. A final synthesis pass then ranks your options and writes down, explicitly, which objection you would be overruling if you go with the winner.

It is deliberately boring under the hood: one bundled Python script (scripts/deep_decide.py), standard library only, no frameworks, no hosted service. Keys come from your environment; if a key isn’t set, that provider simply isn’t used.

The shape of a run

Why one model is weak counsel

Good counsel comes from a diversity of intelligence. Different models are trained differently, aligned differently, and — this is the useful part — fail in different places. When Claude, GPT and Gemini each argue a seat and still land on the same answer, that agreement means something. When they disagree, the disagreement itself is the finding: it shows you exactly where your decision is fragile.

This is not a hunch. Research consistently shows that independent AI reasoners, made to disagree, produce more truthful and more reliable answers than a single model checking its own work — and that combining different model families beats any one family alone. Here is the reading list behind the design:

deep-decide turns that research into two hard rules:

• Forced dissent. Every perspective must state the key assumption behind its case and the strongest argument against itself. No seat is allowed to be only a cheerleader.
• Preserved disagreement. The synthesis ranks the options and picks a winner, but it never hides a 3–1 split behind fake consensus. The objection being overruled is written into the verdict.

How a run works

1. You state the decision freeSay “deep-decide this.” The skill restates the decision, options, and criteria back to you. If your options aren’t real alternatives, this is where that becomes obvious.
2. It shows you the bill first freeA no-cost plan: which providers, which seat runs on which model, exactly how many API calls. Nothing is spent yet.
3. You approveOnly then does --execute run.
4. Four seats argue in parallelEach on its assigned model, each filing its key assumption and counter-argument.
5. SynthesisOptions ranked, risk flagged, dissent preserved — never averaged away.
6. Everything lands on diskPer-run bundle, so you can audit any seat’s reasoning later.

# see which providers are configured (reads keys from env)
$ python3 scripts/deep_decide.py --providers

# run it for real, after the plan is approved
$ python3 scripts/deep_decide.py --execute

# the output bundle
deep-decide-runs/<slug>/
├── verdict.md        # the ranked call + overridden dissent
├── combined.md       # all four cases, side by side
├── manifest.json     # models, calls, effort — the audit trail
└── perspectives/     # operator.md · skeptic.md · finance.md · stakeholder.md

Watch a run

Press the button and watch the whole loop play out on a sample decision. The seat responses below are scripted for illustration, but the sequence — plan, approve, argue, synthesize — is exactly what the skill does.

Configuration

These are the defaults; every one of them can be overridden with an environment variable. A single API key is enough to run. The moment a second key is present, the seats spread across providers automatically — and that is where the cross-model dissent comes from.

The run that paid for itself

The reason I’m writing this up instead of leaving it in the repo: I pointed deep-decide at a final deal document. That document had already been reviewed by Claude Opus at maximum effort, with extended thinking on — and the review found nothing wrong.

The skeptic seat, arguing against the document instead of summarizing it, flagged a figure the confident single-pass review had glided over. That is the entire thesis in one anecdote.

The model didn’t need to be smarter. It needed an opponent.

Inside the verdict

Here is what a verdict.md looks like. This is a made-up example — not the real deal document — but the format is exact:

What it’s not

• It never invents a fact, number, or source. If the inputs are thin, the verdict says so instead of pretending.
• It doesn’t browse the web mid-run, and it doesn’t act on the decision. It evaluates; you decide.
• It doesn’t dress up uncertainty as confidence. A close call reads like a close call.

When to skip it

This is a tool for decisions that are expensive or slow to reverse. If the choice is cheap and easy to undo, just decide. If you haven’t done the underlying research yet, do that first — deep-decide weighs the options you give it; it doesn’t gather the facts for you. And if you only have one real option, you don’t have a decision — you have a task.

A quick pressure-test checklist

Research basis

None of the design is guesswork — every mechanism traces back to published research.

• Debate beats monologue — Du et al. 2023 (arXiv:2305.14325); Liang et al. 2023 (arXiv:2305.19118); Khan et al. 2024 (arXiv:2402.06782); Chan et al. 2023, ChatEval (arXiv:2308.07201).
• Diversity of models beats one model — Wang et al. 2024, Mixture-of-Agents (arXiv:2406.04692); Wang et al. 2022, Self-Consistency (arXiv:2203.11171); Madaan et al. 2023, Self-Refine (arXiv:2303.17651).
• Synthesis with preserved dissent — Zheng et al. 2023, LLM-as-a-Judge (arXiv:2306.05685); Gu et al. 2024, survey (arXiv:2411.15594); Guerdan et al. 2025, on why judges shouldn’t fake certainty (arXiv:2503.05965).
• Multi-agent architecture — Wu et al. 2023, AutoGen (arXiv:2308.08155); Liu et al. 2023, AgentBench (arXiv:2308.03688).

FAQ

The skill, the script, and the full reading list are on GitHub: bogdanbaciu21/skills → deep-decide. Clone it, set one key, and pressure-test the next decision you were about to make alone.