How PRYSM routes across 27 models in under 5 ms

PRYSM’s routing engine receives a prompt and returns a routing decision in under 5 ms — before any model call happens. This post explains how it works.

The ten intent signals

The classifier scores each prompt on ten dimensions simultaneously (no sequential calls, no embedding round-trips):

code          — mentions functions, classes, algorithms, debugging
write         — mentions essays, stories, emails, creative tasks
analysis      — complex comparative reasoning, trade-off evaluation
math          — equations, proofs, numerical computation
translate     — explicit language translation request
realtime      — queries about current events, prices, today's date
simple        — short, low-complexity, conversational
multimodal    — references images, audio, or other media
reasoning     — formal logic, deductive chains, scientific reasoning
long_context — prompt exceeds ~16k tokens

Each signal produces a float in [0, 1]. The final routing decision combines signal strengths with the chosen routing mode.

Routing modes

Mode	When to use	Cost profile
`agility`	Speed and cost over quality	Cheapest model that handles the task
`balanced`	The PRYSM default	Best cost/quality tradeoff
`quality`	Critical tasks, complex reasoning	Cross-validates across multiple models

The decision logic

# Simplified pseudocode — the actual classifier uses bitfield operations
def classify_and_route(prompt: str, mode: str = "balanced", brain: dict = None) -> dict:
    signals = score_signals(prompt)
    wc = len(prompt.split())

    # Short prompts → always agility
    if wc < 8:
        mode = "agility"

    # Long analysis → quality unless overridden
    if wc > 20 and signals["analysis"] > 0.6 and mode != "agility":
        mode = "quality"

    # Select tier by mode
    if mode == "agility":
        tier = "budget"
    elif mode == "quality":
        tier = "frontier"
    else:
        tier = primary_tier(signals)   # budget | mid | premium | frontier

    # Pick the best model in the tier for the dominant signal
    model = best_model_for_signal(tier, dominant_signal(signals))

    # Apply BRAIN.md overrides (model lock, max_cost, blocked list)
    if brain:
        model = apply_brain_overrides(model, signals, brain)

    return {"model": model, "tier": tier, "signals": signals, "why": reason_string(model, signals)}

The fallback chain

If the selected provider has no API key configured, the engine falls back through providers in cost order:

DeepSeek  ($0.28/MTok) → try first
Mistral   ($0.30/MTok) → if DeepSeek unavailable
OpenAI    ($0.25+/MTok) → if Mistral unavailable
Anthropic ($3.00+/MTok) → last resort

This means a deployment with only DEEPSEEK_API_KEY still gets cost-optimized routing — it just uses DeepSeek’s full model lineup.

Dry-run: see the routing decision

from prysm import Prysm

client = Prysm()

# See the full routing decision without calling any model
preview = client.route("Write a Python function to merge two sorted lists")
print(preview["routing"]["model"])   # claude-sonnet-4.5
print(preview["routing"]["tier"])    # premium
print(preview["routing"]["why"])     # "code signal + balanced mode"
print(preview["routing"]["signals"]) # {"code": 0.92, "simple": 0.1, ...}
print(preview["estimated_cost"]["est_1k_tokens"])  # 0.003 USD

PrysmProof: cryptographic attestation of every decision

Every response includes a prysm.proof field:

resp = client.chat.completions.create(
    model="auto",
    messages=[{"role": "user", "content": "Explain quantum entanglement"}],
)
proof = resp.prysm.proof
print(proof["model"])       # gemini-3-flash
print(proof["proof_hash"])  # sha256:a1b2c3d4e5f67890
print(proof["timestamp"])   # 2026-06-13T...

The hash is sha256(request_id + timestamp + model + provider + mode + prompt_sha256 + response_sha256)[:16]. Verify offline:

is_valid = client.verify_proof(proof["request_id"], resp.choices[0].message.content)
print(is_valid)  # True

Benchmarks

Prompt type	Time to routing decision	Model selected
”What’s 2+2?” (simple)	0.8 ms	mistral-nemo
”Write a binary search” (code)	1.2 ms	claude-sonnet-4.5
”Prove P≠NP” (reasoning+analysis)	1.5 ms	deepseek-r1
50k-token document (long_context)	2.1 ms	gemini-3-flash

All measured on a single-core container, no GPU. The classifier is a pure Python bitfield operation over pre-compiled signal patterns — no embedding calls, no ML inference.

​The ten intent signals

​Routing modes

​The decision logic

​The fallback chain

​Dry-run: see the routing decision

​PrysmProof: cryptographic attestation of every decision

​Benchmarks