//DOCS Chorus

Chorus

Chorus is Punk's governed intelligence route for Mythos-level work: the class of research, analysis, coding, policy, and decision tasks that teams usually reserve for the strongest frontier models from Anthropic, Google, and OpenAI.

It gives teams one model id, punk/chorus, while Punk privately coordinates evidence, policy, verification, routing, and receipts behind the gateway.

The public promise is simple: state-of-the-art model outcomes per dollar, with a receipt.

Chorus is not answer fusion. Fusion-style APIs run a prompt through a panel of frontier models, compare the full answers, and use a judge to synthesize the final response. That is a useful reference point, and it is the right competitive bar: customers want Fable 5-class and Mythos-class quality without blindly paying for every top-tier model on every request.

Chorus takes a different path. It treats each request as an execution job: classify the work, break it into verifiable units, spend only where the answer is still uncertain, verify the result, and return a response in the caller's wire format with Punk's evidence trail attached to the run.

Frontier Target

Chorus should be evaluated against the model tier customers already trust for hardest work:

The point is not to imitate a single provider. The point is to make Punk the governed layer that can produce frontier-class outcomes from a portfolio of models, tools, verifiers, caches, artifacts, and reusable circuits.

Quick Start

Use either supported gateway wire.

OpenAI-style chat completions:

POST /v1/chat/completions

Anthropic-style messages:

POST /v1/messages

Set the model id to punk/chorus.

{
  "model": "punk/chorus",
  "messages": [
    { "role": "user", "content": "Compare these options and cite the evidence behind the recommendation." }
  ],
  "budget_limit_usd": 0.25,
  "latency_mode": "balanced",
  "quality_mode": "maximum_quality",
  "receipt_mode": "full",
  "circuit_mode": "learn",
  "chorus": {
    "requestId": "req_123",
    "workflowId": "wf_support",
    "labels": ["receipt-required"]
  }
}

The URL and response shape follow the client wire you already use. punk/chorus is the logical model id that activates the Chorus route.

Punk returns the normal run headers:

What Chorus Records

Every served Chorus run records a structured evidence trail in the Punk trace:

We expose the audit objects customers need to trust the result. We do not expose private scoring weights, routing formulas, internal prompts, or proprietary solver heuristics.

Why It Is Different From Fusion

Fusion-style model panels are prompt-level ensembles:

1. Send the whole prompt to multiple top-tier models.
2. Let each model produce a full answer.
3. Ask a judge to find consensus, contradictions, blind spots, and unique insights.
4. Write the final answer from that analysis.

Chorus is claim-level intelligence composition:

1. Compile the request into a reasoning contract.
2. Build a claim graph with dependencies and evidence requirements.
3. Route only the unresolved or high-value claims to the cheapest qualified model, tool, artifact, or verifier.
4. Verify claims independently from generation.
5. Synthesize from accepted evidence, not raw model prose.
6. Save successful routes as circuits and failed routes as negative knowledge.

That distinction matters economically. A panel pays every selected model to think about the whole task. Chorus tries to buy only the next unit of intelligence needed to reach the target confidence.

Receipt APIs

Retrieve the Chorus receipt from either receipt endpoint:

Receipts include the request id, task type, data classification, applied policy, models considered, models selected and rejected, verifier results, final confidence, cost, latency, license path, output hash, circuit candidate, and Chorus metadata.

How It Is Implemented

Chorus is implemented inside the existing Punk runtime, not as a separate service:

• @punk/chorus-core contains deterministic orchestration primitives for contracts, claim graphs, model passports, skill fingerprints, routing plans, verifiers, ledgers, receipts, circuits, negative memory, and offline comparisons.
• apps/api/src/chorus.ts adapts those primitives to gateway requests and normalizes per-request controls such as budget, latency, quality, policy, receipts, circuits, and shadow mode.
• apps/api/src/router.ts activates Chorus when model is punk/chorus, after governance checks and before the normal live-provider path.
• Chorus runs use the same Punk run ledger, auth, tenant isolation, redaction, route explanations, billing estimates, DLP, tripwire handling, and wire-specific response serializers as the rest of the gateway.
• The dashboard exposes a dedicated Chorus page and a run-detail panel for the receipt, claim graph, routing plan, verifier layer, and uncertainty summary.
• The SDK exposes PUNK_CHORUS_MODEL and punkChorusChat() for typed gateway requests, while direct HTTP clients can call either supported wire.

This keeps the product easy to integrate while making the answer auditable.

Request Controls

Compatibility aliases such as quality_mode: "best" and circuit_mode: "shadow" are accepted by the gateway, but new clients should use the canonical values above.

Dashboard

The dashboard includes:

• #/chorus for recent Chorus runs, savings, confidence, claim counts, and verifier counts.
• Run detail panels for the Chorus receipt, claim graph, route plan, and verifier layer.
• Route filtering by chorus across the existing Runs view.

Safety And Governance

Chorus inherits Punk's enterprise controls:

• tenant isolation for every run, receipt, and ledger;
• redaction before stored traces and exports;
• policy/license checks before solver selection;
• configurable budget and latency ceilings;
• no side effects from replay or shadow work;
• caveat, fallback, approval, or block for unsupported high-risk claims;
• opt-in, shape-level learning only across tenants.

Chorus should make composite intelligence more inspectable, not more opaque.