composable reasoning protocol

CRP Council

CRP is the reasoning governor. Give it a decision; it assembles a council of specialist perspectives, stress-tests them against each other, and collapses to a synthesised recommendation — so agents do not settle on the first plausible answer.

Download the engine Get the skill file

What CRP does

CRP is for questions where a single answer is likely to be shallow, biased, or premature. It forces divergence, cross-pressure, reframing, collapse, and synthesis.

input

Ambiguous decision

A strategy, architecture, product, policy, or tradeoff that needs more than one perspective.

protocol

Role interference

Roles challenge, steelman, reframe, and expose contradictions instead of merely agreeing.

output

Decision-ready synthesis

The result includes recommendation, rejected options, unresolved risks, and confidence boundaries.

Wave cycle

A confirmed session traverses a fixed finite-state cycle. Each stage exists to stop the council collapsing too early.

01 // expand

Possibility surface

The council generates distinct hypotheses — mechanism, conditions, and failure point — before evaluation narrows the space.

02 // interfere

Role collision

Perspectives cross-examine each other to surface genuine tensions, hidden assumptions, and contradictions.

03 // shift

Frame shift

If the council is stuck, change the scope, objective, timeframe, stakeholder, or risk lens.

04 // collapse

Option reduction

A collapse method resolves competing positions into a workable decision path — subject to hard-constraint preconditions.

05 // synthesize

Final output

Produce a recommendation with tradeoffs, preserved dissent, confidence, and next actions.

Council sizing & collapse

Council size scales with the entropy score; the collapse method decides how competing positions resolve. Multi-perspective analysis requires entropy_score ≥ 3.

1 · LOW

1 role — narrow, well-defined questions.

2–3 · MEDIUM

2–3 roles — moderate decisions with a few trade-offs.

4–5 · HIGH

4–6 roles — complex strategic decisions.

ranked

Orders positions by explanatory strength (default).

weighted

Weights positions by confidence and evidence quality.

eliminative

Eliminates positions that fail against hard constraints.

founder_bias

Weights toward long-term viability over short-term wins.

future

Weights toward reversibility and optionality.

conflict

Surfaces unresolved tensions rather than forcing consensus.

hybrid

Combines ranked and weighted passes.

The CRP skill file

Drop the skill file into any skill-aware agent to teach it the protocol — wave mechanics, the core structural roles, the entropy threshold model, and the session lifecycle.

skill file

Composable Reasoning Protocol (CRP) Skill

A complete Markdown specification of the protocol: the four wave stages, the core roles (Operator, Skeptic, Visionary, Historian, Synthesizer), the entropy-threshold decision model, and the three-phase session lifecycle. Use it to run CRP by hand or to brief an agent before it calls the engine.

Download Skill.md

core roles

Operator
Skeptic
Visionary
Historian
Synthesizer

The Go engine

crp-go is a Go implementation of the protocol: a multi-role council runtime with diagnostic safety checks, ethical evaluation, and intelligent task routing.

FSM orchestration

Phase gates enforce the lifecycle: Initiate → Confirm → Expand → Steelman → Collapse → Synthesize.

Diagnostic mode

Missing required fields return structured errors and clarifying questions instead of a hollow analysis.

Ethics & contradictions

An ethics triad and contradiction detection run as part of the deterministic governance layer.

LLM-driven council (v1.1)

With a provider configured, the LLM selects the roster, writes hypotheses, and runs multi-round steelman debate.

Three-layer memory

Working memory (.json), an append-only audit ledger (.memory.jsonl), and distilled long-term lessons.

Provider auto-detect

Anthropic → OpenAI → Ollama. With no provider, the engine runs with no-op scaffold placeholders.

Session persistence

Sessions saved to ~/.crp/sessions/ (0600 files, 0700 dir); inspect and resume by ID.

How to use it

Build crpctl, set a provider key, write a request as JSON, and run. A bare question enters diagnostic mode; a full request needs all four sections.

# build the CLI
$ go build -o crpctl ./cmd/crpctl

# set a provider
$ export ANTHROPIC_API_KEY="sk-ant-..."

# check your environment
$ ./crpctl doctor

# validate a request without running
$ ./crpctl validate my_request.json

# run the full council
$ ./crpctl run my_request.json

// my_request.json
{
  "core_question": "Should we migrate auth to OAuth 2.0?",
  "context": {
    "background": "Three services share a 4-year-old cookie auth layer.",
    "stakes": "A failed migration breaks auth for 8,000 users.",
    "timeframe": "SOC 2 audit in 12 weeks."
  },
  "success_conditions": {
    "desired_outcome": "A go/no-go with top risks and a first step."
  },
  "constraints": {
    "hard": ["Must not break existing mobile clients."],
    "soft": ["Prefer incremental migration."]
  },
  "options": { "entropy_score": 4, "collapse_method": "weighted" }
}

Council too small? If you see collapse precondition failed: council too small for multi-perspective analysis, add "options": {"entropy_score": 4}. The auto-estimator is intentionally conservative — set the score explicitly for any decision that needs multiple viewpoints.

ANTHROPIC_API_KEY

Claude provider (model override via ANTHROPIC_MODEL, default claude-opus-4-5).

OPENAI_API_KEY

OpenAI / compatible provider (OPENAI_BASE_URL, OPENAI_MODEL).

OLLAMA_HOST

Local Ollama server, e.g. http://127.0.0.1:11434 (OLLAMA_MODEL).

CRP_SESSION_DIR

Session storage directory (default ~/.crp/sessions).

MCP transport

CRP ships an MCP-ready daemon so MCP-compatible LLM clients can drive the engine — no separate adapter project required.

cmd/crpd

Line-delimited JSON daemon

A long-running daemon that speaks line-delimited JSON — the transport CRP uses for MCP integration. Run it with go run ./cmd/crpd.

internal/mcp

Transport-only adapter

The MCP adapter is a pure transport boundary: it calls pkg/crp.Engine and owns no phase, entropy, doctrine, synthesis, or session logic.

Download the engine

Grab the compiled CRP Go engine, unzip, and build with go build -o crpctl ./cmd/crpctl.

go engine

crp-go-engine

The full council runtime: phase FSM, council expansion and interference, collapse methods, synthesis with an honesty layer, diagnostics and ethics, filesystem session memory, the LLM adapter, and both the crpctl CLI and crpd daemon.

Download .zip

in the box

cmd/crpctl — one-shot CLI
cmd/crpd — MCP daemon
pkg/crp — engine & FSM
pkg/council — roles & interference
pkg/collapse · pkg/synthesis

Ecosystem

CRP governs reasoning. Its sibling, OCR, governs the project execution that carries a decision out.

OCR Runtime

Use OCR to govern project execution around the decisions CRP produces.

ocr.html →

CmdLayer

The control plane that hosts both governed Go engines.

index.html →