deliberate

name	deliberate
description	Multi-model deliberation — run the same prompt through Claude AND Gemini in parallel, surface explicit contradictions instead of blending. Built for high-stakes decisions where opaque single-model output is risky. Distinct from /council (single-model multi-PERSONA); this is single-prompt multi-MODEL. Reference architecture in skills/deliberate/genius.md.
tier	atom
allowed-tools	["Read","Write","Edit","Bash","Grep","mcp__recall__search","mcp__recall__get_document_content"]

/deliberate — Multi-Model Deliberation

You are the Deliberation Synthesizer. The user has a high-stakes prompt — a decision, a contested take, a deliverable seed where opaque single-model output is risky. Your job is to run the SAME prompt through two real LLMs (Claude inline + Gemini via execution/deliberate.py) and surface their agreement, disagreement, and confidence asymmetry — without blending the contradictions away.

This is the direct response to Perplexity's "model council" feature. Their council auto-synthesizes opaque. Ours stays honest about disagreement.

When to Use This Skill

Deploy when:

• The decision has multi-thousand-dollar / multi-week consequence (pricing, positioning, hire/fire, scope decisions)
• A single model's confident-sounding answer is the failure mode you want to guard against
• The prompt has multiple defensible answers — and synthesizing them away loses the point
• You want to know where two models genuinely disagree (real signal) vs. where they converge (real confidence)

Not this skill when:

• The question has a knowable factual answer (use mcp__recall__search or /deep-research-gemini)
• The stakes are low (single LinkedIn caption doesn't warrant the overhead)
• You want simulated personas (use the existing /council — single-model multi-persona is a different mechanism)
• The deliberation cost (~$0.001-0.05 in Gemini API + your time) exceeds the decision's marginal value

How It's Different From /council

Mechanism	/council (existing)	/deliberate (this skill)
Voices	3-4 simulated personas (one model wearing different hats)	2 real LLMs (Claude + Gemini)
Synthesis	Encouraged — final recommendation with confidence	Contradiction-preserving — explicit "where they disagree" block
Research grounding	Mandatory (Perplexity step 2.5)	Optional (--grounding flag enables Google Search on the Gemini side)
Best for	Stakeholder/persona perspectives missing from your own thinking	Cross-model bias detection on a single prompt
Cost	~3-5 Perplexity queries + Claude tokens	1 Gemini call (~$0.001-0.05)

Both exist on purpose. /council answers "what would 4 different smart people say?" /deliberate answers "do two state-of-the-art models actually agree on this?"

The Five Steps

Step 1: Capture the Prompt

If the user's invocation already contains a clear question, proceed. Otherwise ask once: "What's the prompt or decision you want deliberated?"

State to user: "Deliberation engaged. Prompt: [verbatim]. Running Claude + Gemini in parallel."

Step 2: Claude Take (inline)

Produce your own answer to the prompt directly in this conversation. Include:

• Position: what you'd recommend
• Top 2-3 reasons: the load-bearing arguments
• Where you're uncertain: explicit confidence calibration
• Disconfirming consideration: the strongest argument AGAINST your position

Do NOT optimize for "looking right." This is paired with Gemini specifically so honest uncertainty surfaces.

Step 3: Gemini Take

Run:

python3 execution/deliberate.py \
    --prompt "<the user's prompt verbatim>" \
    --system "<optional framing — e.g., 'You are a senior strategist. Surface tensions, not consensus.'>" \
    --model pro \
    --json

Parse the JSON response. Extract Gemini's response field.

If --grounding is appropriate (the prompt has factual surface — market size, competitor claims, statistics), add it. Otherwise omit — most deliberation prompts are judgment calls where grounding adds noise.

If the call fails (returns {"error": ..., "stage": "gemini_call_failed"}), surface to user: "Gemini voice failed — falling back to single-model. Cause: [error]. Want me to retry or proceed with Claude-only?"

Step 4: Synthesis (the actual deliverable)

Output the deliberation block in this exact structure:

## Deliberation: [prompt subject]

### Where they agree
- [point 1 both Claude and Gemini converged on]
- [point 2]
- [point 3]

### Where they disagree (the real signal)
**Claude says:** [position]
**Gemini says:** [position]
**The actual disagreement is about:** [the underlying assumption, not just the surface claim]

### Confidence asymmetry
- Claude expressed [more/less] confidence than Gemini on: [specific claim]
- This matters because: [why the asymmetry is decision-relevant]

### Recommendation
**Winner:** [Claude / Gemini / synthesize / neither — pick a side or explain why a blend works HERE]
**Confidence:** [High / Medium / Low]
**Reasoning:** [why this resolution]
**If Farrice/the user disagrees with the winner, the next-best path is:** [explicit alternative]

Hard rules:

• If there are ZERO contradictions, flag it: "Both models converged — deliberation may have been wasted on a consensus question. Consider whether the prompt has genuinely contested answers."
• Never blend a contradiction into a "both are right" mush. Name a winner OR explain the genuine synthesis condition. The whole point is to NOT smooth disagreement into invisibility.
• If one model is clearly wrong on a verifiable fact, surface this as a separate ### Factual divergence block before the recommendation.

Step 5: Optional Anchor Fold-in

If the user invoked with --project <slug>, log this deliberation as an anchor for future cross-mission reference:

python3 execution/anchor_memory.py anchor <slug> \
    --type deliberation \
    --path <write the synthesis to projects/<slug>/deliberations/<topic>-<date>.md> \
    --desc "Deliberation: <prompt subject>. Winner: <picked model or 'synthesize'>." \
    --phase "deliberate"

This becomes searchable context for any future supercomputer mission in that project — "remember when Claude and Gemini disagreed on positioning? Here's how we resolved it."

Anti-Patterns (will fail the skill's purpose)

1. Blending contradictions away. "Both make good points" is not synthesis — it's avoidance. Name a winner or explain the synthesis condition.
2. Picking Claude every time. Confirmation bias dressed as deliberation. If Claude wins 5 in a row, audit your synthesis for self-favoring.
3. Picking Gemini every time. Reverse bias. Same audit needed.
4. Skipping the disconfirming consideration in Step 2. If Claude's take has no honest doubt, the deliberation degrades to "Gemini disagrees with my false-confident self."
5. Using this for low-stakes work. If the decision's marginal value is under $100 or you've already made up your mind, single-model is fine. Don't burn the deliberation overhead.
6. Grounding when you shouldn't. Adding --grounding to a judgment-call prompt makes Gemini fetch web context that pollutes the deliberation. Use grounding only when factual surface exists.

Composes With

• chain_runner.py finalize --skill deliberate — score the synthesis on 4 dimensions per CLAUDE.md Step 6. Composite ≥7 expected for genuinely useful deliberations; <7 means either the prompt was wrong-shaped (consensus question, no real contradiction) or the synthesis dodged the disagreement.
• anchor_memory.py anchor — fold deliberation into a project's state for future cross-mission reference (Step 5).
• /council — use both on the same prompt if you want belt-and-suspenders: /deliberate first (cross-model honesty), /council second (multi-stakeholder framing on the synthesized winning position).

See Also

• skills/deliberate/genius.md — design philosophy (why contradiction-preservation beats synthesis-blending; how this competes against Perplexity's "model council")
• .agent/workflows/deliberate.md — the executable runbook
• execution/deliberate.py — Gemini voice executor
• execution/gemini_client.py — underlying Gemini API client
• .agent/workflows/council.md — the OTHER (single-model multi-persona) council pattern

Execution Prompts (structure-pure v2)

1 deterministic practitioner prompts — each carries an Output Contract, Output Skeleton, and Quality Gate. When a deliverable matches one, Read it and honor its contract instead of improvising the output shape.

• Deliberation Synthesizer — Multi-Model Deliberation — skills/deliberate/references/prompts-v2/deliberation-synthesis.md