OpenPrism
Many diverse model voices, split and recombined into one judged answer.
OpenPrism sends your prompt to a panel of different models in parallel, then a
judge model reconciles their answers. The judge runs an explicit pass over them
(consensus, contradictions, gaps, blind spots) and writes one response that beats any
single model's. It's the OpenRouter "Fusion" pattern as
a small, self-hostable tool.
Works with Claude Code, opencode, Cursor, Windsurf, Gemini CLI, and Codex, or
anything that speaks MCP. It runs on models you already have: any model configured in
opencode (75+ providers, recommended, no extra keys), or your
own OpenAI-compatible provider keys.
Why it works
- Diversity beats raw strength. Independent models from different houses catch
different things, and a judge that reconciles them does better than any single model
on open-ended problems.
- Parallel panel. Wall-clock is about the slowest panelist, not the sum, so a
fourth model adds almost no latency.
- Use it deliberately. A call costs roughly the slowest model plus the judge.
Point it at hard questions (research, architecture, ambiguous trade-offs), not
routine work.
- Diversity is counted by model family, not by raw count. OpenPrism picks default
panels by family (Anthropic, OpenAI, Google, Qwen, GLM, Kimi, MiniMax, and so on),
so two models from the same maker don't count as two voices. Every run is graded:
full (all panelists answered, at least OPENPRISM_MIN_FAMILIES distinct families),
degraded (a panelist failed but the family floor still holds), or stop (fewer
than the floor answered, i.e. a single-family monoculture). The grade always prints,
and OPENPRISM_STRICT=1 refuses a stop outright.
How it works
┌──────────── panel (parallel) ────────────┐
prompt ───▶ │ model A model B model C model D │ ──▶ judge ──▶ answer
└───────────────────────────────────────────┘ (reconcile +
(different providers / houses) synthesize)
Two backends decide where panel calls go (set with OPENPRISM_BACKEND):
| Backend | Models from | Use |
|---|
opencode (default, recommended) | every provider/model authed in opencode, discovered live, nothing hardcoded, no keys in OpenPrism | easiest; just opencode auth login your providers |
direct | your own OpenAI-compatible provider keys (.env / providers.json) | when you don't run opencode |
Two modes:
- research (default). Fusion-style synthesis. This is the mode with measured
benchmark benefit.
- code. Code is verifiable, so blending prose is wrong. Each model produces a
candidate, then the judge picks the strongest one and repairs it (best-of-N) and
adds a
Verify by: line. v1 does not auto-run the tests yet.
Install
Pick whichever fits. All of them work on Linux, macOS, Windows, and WSL.
A. Claude Code marketplace (simplest):
/plugin marketplace add ba1lly/OpenPrism
/plugin install openprism@openprism
B. Any MCP host via uvx (needs uv; no clone, no venv).
Generate the config for your host with the built-in wizard:
uvx openprism init --host opencode
# ...or --host cursor | windsurf | gemini | codex | claude-code
It prints (or --writes) the MCP config block, launching the server via
uvx --from openprism openprism-mcp (the published
PyPI package). For the latest GitHub branch use
--git; to pin a tag use --ref v0.1.0.
C. From source (for development):
git clone https://github.com/ba1lly/OpenPrism && cd OpenPrism
./install.sh # Linux / macOS / WSL (Windows: ./install.ps1)
The installer creates a venv, installs OpenPrism, seeds .env, and prints host config.
To point a host at this checkout, run openprism init --host <h> --local.
Then add a provider key to .env (direct backend), or set
OPENPRISM_BACKEND=opencode to use opencode's providers with no keys here.
Judge options
OPENPRISM_JUDGE_BACKEND | OPENPRISM_JUDGE_MODEL | Notes |
|---|
claude-code (default) | alias, e.g. opus | claude -p headless via a Claude Max plan |
anthropic-api | opus or a model id | metered Anthropic API key |
opencode | provider/model ref | routes the judge through opencode too |
Usage (CLI)
