---
schema_version: 1
revision: "22ce5d34dbcb5a78"
id: "codex-fusion-workflows-team-guide"
title: "Fusion council decisions and evidence: team walkthrough"
---

# Fusion council decisions and evidence: team walkthrough

## Team Learning Goal

Teach Fusion as a decision workflow.

The goal is not to show every CLI flag. The goal is to teach when a hard software decision benefits from independent model disagreement, how to ask an agent for `$fusion`, and how to confirm the agent waited for council output before acting.

By the end of this section, the room should understand:

- Fusion is for expensive decisions, not tiny fixes
- Local Fusion is inspired by the panel/finalizer pattern, but is not OpenRouter Fusion
- the `$fusion` skill owns command details
- the agent should list providers, write a prompt file, run the full configured panel, wait, and read final artifacts
- partial panel output is not the answer
- failed or quota-limited providers degrade the run instead of automatically invalidating it
- the final engineering call still comes from repo evidence

## Walkthrough Depth

### Essential Walkthrough

1. State the core rule: use Fusion when disagreement improves the decision.
2. Show good and bad examples.
3. Show the local pipeline: prompt file -> panel -> finalizer -> `summary.json` / `final.md`.
4. Show the `$fusion` ask prompt.
5. Show how to confirm the agent waited.

### Expanded Walkthrough

Add:

- Local Fusion vs OpenRouter Fusion
- Fable/model-disappearance lesson
- provider terminal states
- degraded panel behavior
- artifact privacy boundary

### Deep-Dive Walkthrough

Add:

- live prompt-file build
- provider list and dry-run
- read sample `summary.json`
- extract consensus/disagreement
- exercise kickoff

## Talking Points

Opening:

> Fusion is not "ask more models because it feels fancy." Fusion is "this decision is expensive, so disagreement is worth buying."

On partial output:

> The first useful provider answer is not the council result.

On local versus hosted Fusion:

> OpenRouter Fusion is a hosted product. Local Fusion is a local CLI pattern that shells out to local provider CLIs.

On Fable:

> The Fable 5 shock is the lesson: do not make important workflows depend on one fragile model slug.

On final authority:

> Fusion advises. The repo decides.

## Live Demo Script

Use a no-edit scenario.

### 1. Choose The Decision

```text
Billing webhook duplicate-processing:
provider event id guard vs invoice lock vs processing ledger.
```

### 2. Draft A Prompt File

```bash
mkdir -p .notes/fusion
cat > .notes/fusion/billing-webhook-council.md <<'EOF'
# Fusion Prompt

## Goal

Choose the safest first implementation strategy for duplicate billing webhook processing.

## Current Evidence

- paid invoice events may arrive more than once
- current handler can process the same invoice twice
- likely files:
  - src/billing/webhook.ts
  - src/billing/idempotency.ts
  - tests/billing/webhook.test.ts

## Candidate Strategies

- provider event id guard
- invoice-level processing lock
- webhook processing ledger

## Constraints

- preserve provider contract
- avoid schema changes in first pass unless strongly justified
- preserve existing invoice state transitions

## Verification

- pnpm test billing-webhook -- --runInBand
- pnpm build

## Ask

Compare the strategies. Identify consensus, disagreement, hidden risks, missing tests,
and the first shippable slice. End with a concrete recommendation and rollback notes.
EOF
```

### 3. Preflight

```bash
fusion-high --list-providers
fusion-high --dry-run --file .notes/fusion/billing-webhook-council.md
```

### 4. Run

```bash
fusion-high --file .notes/fusion/billing-webhook-council.md
```

### 5. Confirm

Ask the agent to report:

- Fusion session
- `summary.json`
- `final.md`
- provider terminal states
- consensus
- disagreement
- chosen path
- verification

## Minimal Useful Path

If 5 minutes behind, cut:

- live run
- OpenRouter benchmark numbers
- custom configs

If 10 minutes behind, cut:

- provider terminal state details
- artifact list

If 20 minutes behind, keep only:

- when to use Fusion
- `$fusion` ask prompt
- wait for `summary.json` and `final.md`
- Local Fusion is not OpenRouter Fusion

## Boundaries With Neighboring Sections

From Section 1:

```text
Oracle PackX is for broad packed context and one expensive external review.
Fusion is for local independent model disagreement on a bounded decision.
```

From Section 5:

```text
Prompt Builder composes before launch. Fusion can consume a prompt file produced
by any deliberate composition workflow.
```

From Section 6:

```text
Section 6 compares generated implementation candidates. Fusion compares
independent critiques and strategy recommendations before implementation.
```

To Section 9:

```text
Imps are narrow one-tool agents. Fusion is a council. Do not send one-tool lookup
work to Fusion.
```

## Careful Origin Wording

Say:

```text
Local Fusion is inspired by the OpenRouter-style panel and judge/finalizer pattern.
```

Do not say:

```text
Local Fusion is OpenRouter Fusion.
```

Say:

```text
OpenRouter reported strong DRACO results for Fusion on deep research tasks.
```

Do not say:

```text
Fusion always beats a single model.
```

Say:

```text
OpenRouter cautions that Fusion should be used selectively for hard questions.
```

Do not say:

```text
Fusion replaces coding agents.
```

Say:

```text
The Fable availability change is the practical lesson about fragile single-model workflows.
```

Do not claim a precise causal story unless the cited source proves it.

## Failure Paths To Preserve

Agent skipped provider list:

```bash
fusion-high --list-providers
```

Agent used inline long prompt:

```text
Ask for a prompt file and --file.
```

Agent started implementation early:

```text
Stop and request summary.json, final.md, provider terminal states, consensus, and disagreement.
```

One provider quota-limited:

```text
Explain degraded council behavior. The run can still be useful if final artifacts exist and the missing voice is named.
```

Final answer flattened disagreement:

```text
Ask for consensus, contradictions, hidden risks, and which repo evidence decides.
```

Private artifact risk:

```text
Do not paste full session artifacts. Summarize the relevant council result.
```

## Team Checklist

Confirm the materials include:

- `$fusion` skill path
- common local source checkout
- OpenRouter inspiration boundary
- not the same product
- not for tiny fixes
- provider list first
- prompt file
- dry-run when uncertain
- full configured panel
- terminal provider states
- `summary.json`
- `final.md`
- quota non-blocking
- partial artifacts are partial
- private session store
- advisory output
- repo evidence wins
- billing webhook example
- auth/session example
- model outage fallback example

## Further References

- File: `cheatsheets/10-fusion-model-council.md`
- Exercise: `exercises/10-fusion-model-council.md`
- Skill: `skills/fusion/SKILL.md`
- Common local source checkout: `~/dev/fusion`
- OpenRouter Fusion product page: https://openrouter.ai/fusion
- OpenRouter Fusion model page: https://openrouter.ai/openrouter/fusion
- OpenRouter announcement: https://openrouter.ai/blog/announcements/fusion-beats-frontier/
- OpenRouter model-disappearance post: https://openrouter.ai/blog/tutorials/keep-your-agent-running-when-models-disappear/

## Related resources

- [Companion reference](https://lapis-fossil-vsbc.here.now/downloads/codex-power-user-workshop-2026-06-27.bundle)
- [Resource directory and portable download](/topics/codex-resources/)

## Original references

- [Portable Codex workflow resources](https://lapis-fossil-vsbc.here.now/downloads/codex-power-user-workshop-2026-06-27.bundle)
