Skip to content
Back to search

fusion-fable

Fuse two frontier models into one Fable-tier answer: Opus 4.8 drafts, a second model (Opus 4.8 or GPT-5.5 via codex) checks, Opus fuses. A Claude Code skill.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/duolahypercho-fusion-fable/badge.svg)](/listings/duolahypercho-fusion-fable)

HTML

<a href="/listings/duolahypercho-fusion-fable"><img src="/api/listings/duolahypercho-fusion-fable/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

git clone https://github.com/duolahypercho/fusion-fable.git
cd fusion-fable
./install.sh

This copies the skill to `~/.claude/skills/fusion` and the slash commands to `~/.claude/commands`, then prints which panels your machine can run. Restart Claude Code (or run `/reload-skills`) afterward.

> Override the target with `CLAUDE_CONFIG_DIR=/path/to/.claude ./install.sh`.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 180 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Fusion-Fable
  2. **Fuse a panel of frontier models into one Fable-tier answer.**
  3. Fusion-Fable is a [Claude Code](https://claude.com/claude-code) skill that runs a hard question through a
  4. **panel → judge** pipeline. The same prompt is dispatched to several models *in parallel* — each answering
  5. independently with web search and bash, none seeing the others' work — and then Opus 4.8 judges every
  6. answer into a structured analysis (consensus, contradictions, partial coverage, unique insights, blind
  7. spots) and writes a final answer grounded in it.
  8. The mechanism is **independence, then synthesis**. The diversity that makes a panel beat a single model is
  9. harvested, not manufactured: running the same prompt independently yields different reasoning paths, tool
  10. calls, and sources — even two cold runs of the *same* model diverge enough that synthesizing them beats
  11. running it once. So there are no contrived "lenses" or personas; every panelist gets the task verbatim and
  12. answers it straight. Fuse **Opus 4.8 + Opus 4.8**, or **Opus 4.8 + GPT-5.5** (via the `codex` CLI), into a
  13. result better than either alone — a Fable-tier fusion.
  14. ```
  15. ┌──────────────┐
  16. ┌──▶ │ panelist 1 │ ─┐ (web + bash, independent)
  17. │ └──────────────┘ │
  18. │ ┌──────────────┐ │ ┌──────────────┐
  19. prompt ──▶ fan ─┼──▶ │ panelist 2 │ ─┼─▶ │ Opus 4.8 │ ──▶ final answer
  20. out │ └──────────────┘ │ │ (judge + │ (grounded in
  21. │ ┌──────────────┐ │ │ synthesize) │ the analysis)
  22. └──▶ │ panelist 3 │ ─┘ └──────────────┘
  23. └──────────────┘
  24. Opus 4.8 / GPT-5.5 / Gemini consensus · contradictions ·
  25. (each answers blind) partial · unique · blind spots
  26. ```
  27. Opus 4.8 **always** judges and writes the final answer — the pipeline can't be reversed, because the
  28. panelist models can't call back out to spawn Opus.
  29. ## The panels
  30. | Slug | Panel | Requires |
  31. | --- | --- | --- |
  32. | `opus4.8-4.8` | the **same prompt run twice** as 2 independent Opus 4.8 panelists → Opus judges | nothing — works everywhere |
  33. | `opus4.8-gpt5.5` | Opus 4.8 + **GPT-5.5** (codex) in parallel → Opus judges | the `codex` CLI |
  34. | `opus4.8-gpt5.5-gemini3.1pro` | Opus 4.8 + GPT-5.5 + **Gemini 3.1 Pro** in parallel → Opus judges | `codex` + `agy` CLIs |
  35. The skill auto-detects which panelist CLIs are installed and uses the richest panel available, falling
  36. back gracefully when one is missing.
  37. ## Install
  38. ```bash
  39. git clone https://github.com/duolahypercho/fusion-fable.git
  40. cd fusion-fable
  41. ./install.sh
  42. ```
  43. This copies the skill to `~/.claude/skills/fusion` and the slash commands to `~/.claude/commands`,
  44. then prints which panels your machine can run. Restart Claude Code (or run `/reload-skills`) afterward.
  45. > Override the target with `CLAUDE_CONFIG_DIR=/path/to/.claude ./install.sh`.
  46. ## Use it
  47. Three ways, all equivalent under the hood:
  48. - **Natural language** — just ask. The skill auto-triggers and picks the richest panel:
  49. > "Run this through Fusion: is it safe to `ALTER TABLE … ADD COLUMN` on a 200M-row Postgres table in prod?"
  50. - **Pinned slash commands:**
  51. ```
  52. /fusion-opus4.8 does my JWT refresh-rotation design have a replay hole?
  53. /fusion-gpt5.5 is git push --force-with-lease actually safe on a shared branch?
  54. /fusion-3 full 3-family panel (Opus 4.8 + GPT-5.5 + Gemini 3.1 Pro)
  55. ```
  56. - **Force a panel in prose** — "run the `opus4.8-gpt5.5` Fusion on …".
  57. Every run returns the same structure: a **Final answer** up top, then the audit trail —
  58. **Consensus / Contradictions / Partial coverage / Unique insights / Blind spots** — with each point
  59. attributed to the panelist that raised it, so you can see how the answer was assembled. Every run is also
  60. written to a timestamped provenance file under `~/.claude/fusion-runs/` (raw panelist answers + analysis +
  61. final answer) for auditing.
  62. ## Planning: `/fusion-plan` (iterative + OMC-integrated)
  63. `/fusion-plan` applies the panel to **planning**. Instead of one panel→judge pass it runs the panel as an
  64. **iterative loop** and plugs into the **oh-my-claudecode (OMC)** plan system end to end:
  65. 1. **Requirements** — *interactive* (you run `/fusion-plan` yourself): auto-chains OMC's `omc-plan`
  66. interview (one question at a time, explore-first, Analyst consult) → initial plan in
  67. `.omc/plans/<slug>.md`. *Non-interactive* (autonomous run, inside a sub-agent, or `--no-interview`):
  68. **no interview** — derives requirements from the existing story doc / plan context, so it never hangs
  69. waiting on an answer no one is there to give.
  70. 2. **Deepen (3 rounds, seeded)** — each round an Opus 4.8 panelist and a GPT-5.5 panelist (via `codex`)
  71. independently critique-and-improve the current plan **in parallel and blind**; Opus 4.8 judges and
  72. synthesizes one tighter plan that seeds the next round. Stops early on `NO_MATERIAL_CHANGE`.
  73. 3. **Write back** — the converged plan is written back to the same `.omc/plans/<slug>.md`, kept **concise
  74. but content-dense** (the judge compresses across rounds rather than accumulating length).
  75. 4. **Handoff** — offers the OMC quality gate (`/omc-plan --review`) → execution (`/team` or `/ralph`).
  76. ```
  77. /fusion-plan design the schema + flow for <feature>
  78. ```
  79. The panel replaces only the *plan-thinking* step; OMC owns the interview, plan format, quality gate, and
  80. execution. It works best with OMC installed; without OMC it falls back to a minimal inline interview. Like
  81. the base panel it needs the `codex` CLI for the GPT-5.5 half (otherwise it falls back to two Opus 4.8
  82. panelists per round). Reserve it for high-stakes planning — it costs an interview + ~6 panelist runs + 3
  83. judge passes.
  84. ### Optional backstop hook
  85. `hooks/fusion-plan-nudge.sh` is an optional `PreToolUse` hook (matcher `Agent|Task`). When the orchestrator
  86. is about to delegate a non-trivial *implementation* task to a sub-agent, it injects an advisory reminder to
  87. run `/fusion-plan --no-interview` on it first. It is advisory only (never blocks), de-dupes per task, and
  88. skips fusion's own panelist spawns. `install.sh` copies it to `~/.claude/hooks/` but does **not** enable it
  89. — opt in by adding it to your `settings.json` (the installer prints the snippet). Leave it off to keep
  90. planning fully manual.
  91. ## Requirements
  92. - **Claude Code**, with the session running **Opus 4.8** (panelist subagents and the judge inherit the
  93. session model — on another model the slug is nominal, not literal).
  94. - For `opus4.8-gpt5.5`: the [`codex` CLI](https://github.com/openai/codex) installed and logged in to an
  95. account with GPT-5.5 access. The runner uses `codex exec` (tested against `codex-cli` 0.139).
  96. It runs against a throwaway copy of the current repo/workdir with trusted local access so tools such as
  97. `gh`, local test runners, Docker, and SDK-managed toolchains behave like they do in your terminal without
  98. writing back to the live checkout.
  99. Each Fusion invocation uses its own temporary prompt/output directory, so concurrent runs in different
  100. Claude Code sessions do not read each other's GPT panelist artifacts.
  101. - For the 3-model panel: the **`agy`** (Antigravity) CLI installed and its keyring seeded — run `agy` once
  102. interactively to complete the Google OAuth, after which headless runs reuse that login. `run_gemini.sh`
  103. works around agy's print-mode bug (empty stdout under no TTY) by running it under a pseudo-TTY with a
  104. transcript-JSONL fallback and a hard anti-empty guard, so it never returns a silently empty answer. The
  105. pseudo-TTY is allocated by a `pty.fork()` Python helper (`_pty_run.py`) so it keeps working when the
  106. orchestrator itself runs in a socket (cmux / headless), where `script` aborts on `tcgetattr`.
  107. Only the **`opus4.8-4.8`** panel is truly zero-setup; the GPT-5.5 and Gemini panels light up once their
  108. CLIs are installed and authenticated. Note: there is no `timeout`/`gtimeout` on stock macOS, so the runners
  109. use a self-contained `perl` timeout helper (`FUSION_TIMEOUT`, default 300s per panelist).
  110. ## What's in here
  111. ```
  112. skills/fusion/
  113. SKILL.md detect → preflight → blind fan-out → judge → grounded final → save
  114. scripts/
  115. _fusion_lib.sh shared helpers: perl-based per-panelist timeout, have()
  116. _pty_run.py pty.fork() runner so agy gets a TTY even under socket stdio (cmux/headless)
  117. detect_panel.sh picks the richest available panel
  118. preflight.sh non-blocking token/call estimate + Codex cap reminder
  119. run_codex.sh runs the GPT-5.5 panelist (web + bash) with a timeout, captures its answer
  120. run_gemini.sh runs the Gemini 3.1 Pro panelist via agy (pseudo-TTY + transcript fallback)
  121. save_run.sh writes the timestamped provenance .md to ~/.claude/fusion-runs/
  122. references/
  123. panel.md why independent parallel runs (no lenses) — the panel mechanism
  124. judge_rubric.md the structured analysis + grounded final answer
  125. skills/fusion-plan/
  126. SKILL.md OMC interview → 3-round seeded panel → concise .omc/plans/ → review/execute
  127. commands/
  128. fusion-opus4.8.md /fusion-opus4.8 (pinned opus4.8-4.8 panel)
  129. fusion-gpt5.5.md /fusion-gpt5.5 (pinned opus4.8-gpt5.5 panel)
  130. fusion-3.md /fusion-3 (pinned full opus4.8-gpt5.5-gemini3.1pro panel)
  131. fusion-plan.md /fusion-plan (OMC-integrated iterative planning; reuses fusion's run_codex.sh)
  132. hooks/
  133. fusion-plan-nudge.sh optional PreToolUse backstop (not auto-enabled) — nudges /fusion-plan on spawn
  134. install.sh copies the above into ~/.claude (hook copied but left disabled)
  135. ```
  136. ## Why a panel beats one model
  137. On the DRACO deep-research benchmark, OpenRouter found that fusing model answers consistently beats the
  138. individual models — and that a meaningful chunk of the lift comes from the *synthesis step itself*, not
  139. just from mixing architectures: two independent runs of one model, synthesized, beat that model run once.
  140. Fusion-Fable implements that same independence-then-judge pipeline locally in Claude Code.
  141. ## Cost & latency
  142. A panel costs roughly N× a single answer in tokens and runs as slow as its slowest panelist. That's the
  143. deliberate trade: spend more to stop being confidently wrong where that's expensive. For quick or
  144. low-stakes questions, a single direct answer is the right call.
  145. ## License
  146. MIT — see [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.