Knowledge lives in someone else's training run.
- Build: a training run produces gigabyte-scale weights you download and trust.
- Serve: a model forward pass — it always answers, right or wrong.
- Guard: you threshold its confidence yourself, and hope.
Resources · the education page
One family. Four names.
The same idea, three rungs deep — and an engine that plays.
Reflex is the product you install. Reflexer is the other engine — the same wire, played as a game. Instinct is the idea that upgrades Reflex. Rethink is that idea, served from our GPU hosts.
Numbers law: every measured claim on this page is a link into the benchmark — none is typed.
New here? Start with this
How Jev works — and how Reflex goes further
A two-minute primer on decision models, the wire they speak, the numbers that judge them — and where a free local engine changes the picture.
What is a decision model?
Think of a triage nurse with a clipboard. You describe the situation; the clipboard has a few fixed questions — how urgent?, which ward?, needs a specialist, yes or no? The nurse does not write you an essay. They tick one box per question and tell you how sure they are.
A decision model is that nurse, as software: it takes a state (the situation, as text or structured data) plus a set of typed questions, and returns one typed answer per question with a probability for every option — never free text. Jev, by TypeSafe AI, is the best-known example: a hosted model you call over the internet. The request shape it uses — the Jev wire — has become a common language: Cloudflare's open Clef models — Clef (27B) and Clef-flash (9B) — speak it too, and Reflex speaks the same vocabulary.
- decision model
- Software that answers typed questions about a situation with probabilities, instead of writing free text.
- Jev
- TypeSafe AI's hosted decision model, and the request shape (the Jev wire) many decision models now share.
- state
- The situation under decision — a paragraph of text, or a JSON object.
- questions
- What you want decided, each with an id and a type. The answer space is part of the request, not baked into a model.
- noul
- A typed yes/no question; the answer is the probability of “yes”.
- choice
- Pick one option from a list you supply.
- score
- Pick a level on an ordered scale you supply (lowest first), e.g. routine → critical.
- criteria
- The options themselves: a map of option → description for
choice, a list of levels forscore.noulneeds none. - prefill
- A neural model reading the whole input in one forward pass, before it produces anything.
- autoregressive
- Generating an answer one token at a time, each step feeding the next — how chatbots write. Slow for decisions, and the text still has to be parsed.
- non-autoregressive
- Scoring every option in parallel straight from the prefill — no text is generated. This is what decision models like Clef (27B) and Clef-flash (9B) do, per Cloudflare.
- calibration
- Whether stated confidence matches reality: of all answers given “eight in ten” confidence, about eight in ten should be right.
- ECE
- Expected calibration error — the average gap between confidence and accuracy, measured in confidence buckets. Lower is better; zero is perfectly calibrated.
- Brier score
- The mean squared distance between the predicted probabilities and the true answer. Lower is better; it punishes being confidently wrong.
- abstain
- Saying I'm not sure instead of guessing. In Reflex it is a designed output: the full probability distribution still comes back with it.
- coverage
- The share of questions a system actually answered (did not abstain on, did not error on).
- chance-corrected skill
(score − chance) / (1 − chance): zero means no better than random guessing on that task, one means perfect. It lets a two-option task and a many-option task share one scale.- macro-F1
- Accuracy-like score computed per label and then averaged, so rare labels count as much as common ones.
- JDI
- The Jev Decision Index — a community leaderboard that scores Jev-wire models on one frozen suite of typed-decision benchmarks: chance-corrected, with an unanswered question counted as wrong, and calibration published per entrant.
More words used further down this page
- modelless
- No neural network and no training run — answers come from documents you author plus a few small numbers fitted from your labels.
- lane
- One way of answering the same questions — an engine plus its setup. The board compares lanes side by side.
- suite
- One benchmark task: a fixed set of questions with known answers.
- selective accuracy
- How often answers are right, counting only the questions the system chose to answer (abstentions left out). Read it beside coverage.
- cc
- Chance-corrected accuracy: zero is random guessing on that suite's option count, one is perfect, below zero is worse than guessing.
- conformal floor
- A simple, well-understood baseline for honest confidence (split conformal prediction). A calibration claim has to beat it.
- record-only
- Measured and published on the board, but not yet served to anyone.
- tier-fallback
- Where a product lane has no answer of its own on a suite, the cell shows what is actually served there — the cheaper tier's answer — marked ↩ in tables and ▲ on the radar.
- encoder head
- A small trained layer on top of a text encoder that turns the encoder's reading of the question into option probabilities.
- vessel
- The package a hosted head is built to ship in: hashed, signed and encrypted, so only the hosted reader can open it. The format is built but not yet the serving path — today's specialists are files checked against a pinned BLAKE3 digest, run on our servers.
- rung
- One step on the ladder: free local Reflex first; a hosted head only when the step below abstains.
- rulebook
- The fixed list of rules a game engine scores with: every board a move can lead to gets a score, and the best plan wins. Also called the genome.
- frozen genome
- The rulebook shipped as constant bytes — never retrained at runtime, never blended, so the same request always gives the same answer.
The workflow
Inputs (a state + typed questions) → the decision model (reads it all, scores every option) → typed outputs (one answer per question, each with probabilities). Your code reads the answer and, if it is careful, the confidence.
One request, one response
A security-incident triage, in the Jev wire shape Cloudflare documents for Clef (27B) and Clef-flash (9B). Three questions, one of each type.
{
"state": "Login failures spiked overnight; an admin account then created a new API key.",
"questions": {
"severity": {
"type": "score",
"instructions": "How severe is this incident?",
"criteria": ["routine", "needs attention", "critical"]
},
"action": {
"type": "choice",
"instructions": "What should happen next?",
"criteria": {
"page_oncall": "Wake the on-call responder now",
"open_ticket": "File a ticket for business hours",
"ignore": "No action needed"
}
},
"rotate_keys": {
"type": "noul",
"instructions": "Should every API key be rotated?"
}
}
}{
"answers": {
"severity": {
"type": "score",
"probabilities": { "0": p₀, "1": p₁, "2": p₂ },
"score": Σ i·pᵢ,
"confidence": max(p₀, p₁, p₂)
},
"action": {
"type": "choice",
"choice": "page_oncall",
"probabilities": {
"page_oncall": q₁, "open_ticket": q₂, "ignore": q₃
},
"confidence": q₁
},
"rotate_keys": {
"type": "noul",
"noul": P(true)
}
}
}The p and q values are placeholders, not results: each is a probability
between zero and one, and one question's probabilities add up to one. A score answer keys its
levels by position (lowest first) and reports the expected level; envelopes and extra fields
(model, usage) are trimmed here, and field spellings vary slightly by server; Reflex's own spelling (a list of questions with kind, prompt and
options) is in the integration skill.
How Reflex differs
Same questions, same typed answers — different place and different honesty. Jev is a hosted model: every decision is a network round-trip to someone else's GPU, and it always returns an answer. Reflex is a modelless engine (no neural network, no training run) on your own machine: it answers from a corpus you author, in microseconds, and when the evidence is thin it abstains instead of guessing. Only those abstained questions need to go anywhere else — to a hosted Rethink head, paid only where Reflex was not sure.
Step by step: what goes in and what comes out
1 · One question, two routes
The same state and typed questions either way — here a security triage: route the ticket, promote or not, rate the severity. The difference is only where the answering happens and what happens when the answerer is unsure.
IN · POST /decide — the same request either way
{ "state": "The staging deploy of release candidate 4.2 finished but the error budget is down to 12 percent and two health endpoints are flapping after the rollout. Rollback is one command. Decide what happens next.", "questions": [ { "id": "route", "kind": "choice", "prompt": "Route this ticket to the team that owns it.", "options": [ "deploy-ops", "billing-support" ] }, { "id": "promote", "kind": "noul", "prompt": "Should the rollout be promoted to production right now?" }, { "id": "severity", "kind": "score", "prompt": "How severe is this situation?", "options": [ "routine", "needs-attention", "critical" ] } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (abstained request)
2a · The Jev route — a network hop
Every decision crosses the network to their cloud, where a hosted model reads the whole state in one pass. Their product, their wire — nothing here is ours to show beyond the public description.
3a · One-pass read
A hosted model reads the state and every option together and always returns a typed answer with probabilities — even when it is unsure. Thresholding those probabilities is your job.
2b · The Reflex route — loopback
The same question goes over loopback to the modelless engine on your own machine. It answers from a corpus you author, in microseconds — nothing leaves by default.
IN · POST /decide · a question it is sure on
{ "state": "The piece leaves no holes under it on the left edge, sits flat on the surface, and the stack stays low.", "questions": [ { "id": "clean", "kind": "noul", "prompt": "Does the stack look clean?" } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (answered request)
3b · Sure — answer with confidence
When the evidence is there, a typed answer comes back with calibrated confidence. This game-head question is one the engine is sure on.
IN · POST /decide
{ "state": "The piece leaves no holes under it on the left edge, sits flat on the surface, and the stack stays low.", "questions": [ { "id": "clean", "kind": "noul", "prompt": "Does the stack look clean?" } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (answered request)
OUT · sure: outcome yes
{ "answers": [ { "question_id": "clean", "outcome": { "noul": { "yes": true } }, "probabilities": [0.51943666], "confidence": 0.51943666 } ], "routing": { "lane": "modelless", "reason": "game-head/tetris (corpus-fitted, decoded arm)" }, "calibration": { "method": "none", "temperature": 1.0 } }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (answered response)
3c · Not sure — it abstains
On the harder triage question the engine abstains: “not sure” with the full distribution attached, never a guess. Your code routes the hard case instead of thresholding a confident-looking wrong answer.
IN · POST /decide · the triage question
{ "state": "The staging deploy of release candidate 4.2 finished but the error budget is down to 12 percent and two health endpoints are flapping after the rollout. Rollback is one command. Decide what happens next.", "questions": [ { "id": "route", "kind": "choice", "prompt": "Route this ticket to the team that owns it.", "options": [ "deploy-ops", "billing-support" ] }, { "id": "promote", "kind": "noul", "prompt": "Should the rollout be promoted to production right now?" }, { "id": "severity", "kind": "score", "prompt": "How severe is this situation?", "options": [ "routine", "needs-attention", "critical" ] } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (abstained request)
OUT · not sure: every outcome is null
{ "answers": [ { "question_id": "route", "outcome": null, "probabilities": [0.52583224, 0.47416782], "confidence": 0.0019263625 }, { "question_id": "promote", "outcome": null, "probabilities": [0.49452087], "confidence": 0.00008660555 }, { "question_id": "severity", "outcome": null, "probabilities": [0.3601853, 0.2878931, 0.35192165], "confidence": 0.004379213 } ], "routing": { "lane": "modelless", "reason": "modelless corpus routing: ops=3 support=0; fused abstain (score+distance) armed; drafter-only=1" }, "calibration": { "method": "none", "temperature": 1.0 } }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (abstained response)
4a · The hosted model always answers
The Jev route's answer to the same triage question is a typed answer with probabilities — always. If you threshold it, you decide where “unsure” begins; if you don't, every case looks answered.
4b · Escalation is a choice, not a default ○ illustrative · planned
Only the abstained questions are candidates for a hosted, paid head — and only if you point your app at it. That is what makes paying optional rather than constant. Planned: the hosted lane opens later.
IN · the abstained question, sent up
{ "state": "The staging deploy of release candidate 4.2 finished but the error budget is down to 12 percent and two health endpoints are flapping after the rollout. Rollback is one command. Decide what happens next.", "questions": [ { "id": "route", "kind": "choice", "prompt": "Route this ticket to the team that owns it.", "options": [ "deploy-ops", "billing-support" ] }, { "id": "promote", "kind": "noul", "prompt": "Should the rollout be promoted to production right now?" }, { "id": "severity", "kind": "score", "prompt": "How severe is this situation?", "options": [ "routine", "needs-attention", "critical" ] } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (abstained request)
Where it runs
Jev: their cloud. Reflex: localhost — nothing
leaves your machine unless you escalate.
When it is unsure
Jev: answers anyway; thresholding is your job. Reflex: abstains, distribution attached, so your code can route the hard case.
How it is judged
Accuracy, chance-corrected skill and calibration — every lane, losses included, on the benchmark.
on the board Clef-flash (9B) is on the board. Cloudflare's Clef (27B) and Clef-flash (9B) are open decision models that speak the Jev wire. The benchmark carries a Clef-flash (9B) comparison lane — the community 4-bit quant, run locally by the same harness as every other lane. Clef (27B) is not measured yet; the Jev Decision Index is the community board for it in the meantime.
Try it
What is this family?
Two products, one idea — and a second engine that plays. The products ship binaries; the idea is how they compose; the engine runs the same question wire over a game board (the rulebook engine).
Reflex — the product
The modelless [no neural network — no training run] decision engine. Open source, MIT, installs on your machine, answers from documents you author. The free floor of the family.
Read the Reflex sectionInstinct — the idea
When the free engine abstains, a specialist trained for exactly that domain scores the survivors — composed on top, never instead. Embodied by the open teaching lane, and one rung deeper in Rethink.
See it on top of ReflexRethink — the product
The same composition idea at the encoder tier, served HOSTED-ONLY [weights that never leave our servers — you call, we think] from our GPU hosts. Private by design.
Read the Rethink section
Step by step: what goes in and what comes out
1 · The same typed question
Your app sends the same typed question it would send the free engine: a state plus questions — choice, score or yes-no. This spot question is one the game heads know.
IN · POST /decide
{ "state": "The piece leaves no holes under it on the left edge, sits flat on the surface, and the stack stays low.", "questions": [ { "id": "clean", "kind": "noul", "prompt": "Does the stack look clean?" } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (answered request)
2 · The free floor answers first
Reflex runs before anything paid: embed, route to the corpus, score every option, and the fused gate checks confidence. On this harder triage question the gate abstains — every outcome comes back null — and that abstain is what pays the rung above.
IN · POST /decide · a harder question
{ "state": "The staging deploy of release candidate 4.2 finished but the error budget is down to 12 percent and two health endpoints are flapping after the rollout. Rollback is one command. Decide what happens next.", "questions": [ { "id": "route", "kind": "choice", "prompt": "Route this ticket to the team that owns it.", "options": [ "deploy-ops", "billing-support" ] }, { "id": "promote", "kind": "noul", "prompt": "Should the rollout be promoted to production right now?" }, { "id": "severity", "kind": "score", "prompt": "How severe is this situation?", "options": [ "routine", "needs-attention", "critical" ] } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (abstained request)
OUT · not sure: the abstain that pays the rung
{ "answers": [ { "question_id": "route", "outcome": null, "probabilities": [0.52583224, 0.47416782], "confidence": 0.0019263625 }, { "question_id": "promote", "outcome": null, "probabilities": [0.49452087], "confidence": 0.00008660555 }, { "question_id": "severity", "outcome": null, "probabilities": [0.3601853, 0.2878931, 0.35192165], "confidence": 0.004379213 } ], "routing": { "lane": "modelless", "reason": "modelless corpus routing: ops=3 support=0; fused abstain (score+distance) armed; drafter-only=1" }, "calibration": { "method": "none", "temperature": 1.0 } }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (abstained response)
3a · Sure — the specialist is never paid
When the floor is sure, the answer goes straight back with calibrated confidence and a receipt, and no specialist is consulted. That is the rung model: you pay for thinking, never for re-answering what the free floor already knows.
IN · POST /decide
{ "state": "The piece leaves no holes under it on the left edge, sits flat on the surface, and the stack stays low.", "questions": [ { "id": "clean", "kind": "noul", "prompt": "Does the stack look clean?" } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (answered request)
OUT · sure: outcome yes
{ "answers": [ { "question_id": "clean", "outcome": { "noul": { "yes": true } }, "probabilities": [0.51943666], "confidence": 0.51943666 } ], "routing": { "lane": "modelless", "reason": "game-head/tetris (corpus-fitted, decoded arm)" }, "calibration": { "method": "none", "temperature": 1.0 } }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (answered response)
3b.1 · Prune to the candidates
Only the abstained question goes on. The survivors are pruned to the top candidates so the rung above scores a handful of options, not the whole list.
3b.2 · The specialist scores
A per-domain specialist — a locked artifact whose digest is checked at every load — scores the candidates. Selection is a monotonic hot-swap of whole artifacts from the manifest: never a weighted blend, because blends do not preserve rankings.
3b.3 · Fuse into one calibrated answer
The composition fuses the floor's read with the specialist's: a cascade pick, or prior fusion lifting the calibrated favourite. A confident pick returns as the answer, receipt attached.
4 · Still unsure — one rung deeper ○ illustrative · planned
Where the bag view reads too coarse, a trained encoder head thinks — GPU-hosted, weights on our hosts only. It is measured on the benchmark board today, record-only: the hosted lane opens later, and this is the public request it would carry.
IN · the abstained question, sent up
{ "state": "The staging deploy of release candidate 4.2 finished but the error budget is down to 12 percent and two health endpoints are flapping after the rollout. Rollback is one command. Decide what happens next.", "questions": [ { "id": "route", "kind": "choice", "prompt": "Route this ticket to the team that owns it.", "options": [ "deploy-ops", "billing-support" ] }, { "id": "promote", "kind": "noul", "prompt": "Should the rollout be promoted to production right now?" }, { "id": "severity", "kind": "score", "prompt": "How severe is this situation?", "options": [ "routine", "needs-attention", "critical" ] } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (abstained request)
5 · The manifest hot-swaps arms
arsenal.toml is the one selection surface: a specialist joins only where it beat free Reflex on one frozen test read, and it is swapped whole — a decision always observes one whole server.
Where each lane runs.
Structural facts only — a shipped artifact, a deploy shape, a design law. The measured side of every claim is one click away.
| Runs on | Reflex (product) | Instinct (idea · open lane) | Rethink (product) |
|---|---|---|---|
| Browser (wasm) | ✅ arena head + playground | — (a server-side lane) | — (hosted-only by law) |
| Mac / PC / Linux | ✅ release binaries | ✅ serve bin (CPU hosts) | — (no public binary) |
| Mobile | via the browser (wasm) | via a hosted API | via a hosted API |
| Edge device (ESP32-class) | not shipped — possible in principle, no tested surface today ³ | not shipped (a server-side lane) | not shipped (GPU hosts only) |
| Self-hosted server | ✅ one static binary | ✅ container image (CPU tier) | private deploy — our GPU hosts only |
| Hosted API | loopback-only by design ¹ | ✅ demo vessels after the open | ✅ the product surface (HOSTED-ONLY) |
¹ The engine listens on your machine and answers browser calls only from origins you allow — see how it works. ³ An edge lane exists in the wider workspace but serves a different product — the honest cell today is “not shipped” for every tier.
Reflex — the free floor.
Reflex is the family's free floor — a modelless decision engine that runs on your machine, answers from a corpus you author, and abstains by design when the evidence is thin. [Modelless: no neural network — no training run. Corpus: your documents — the corpus is the model. Abstain: the engine says “I don't know” instead of guessing.]
Step by step: what goes in and what comes out
1 · You ask
Your app sends a state plus typed questions over loopback — choice, score or yes-no. Nothing leaves your machine.
IN · POST /decide
{ "state": "The piece leaves no holes under it on the left edge, sits flat on the surface, and the stack stays low.", "questions": [ { "id": "clean", "kind": "noul", "prompt": "Does the stack look clean?" } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (answered request)
2 · Embed and route
The state is hashed into features and the domain argmax picks your corpus — the corpus IS the model here; no neural weights, no AI service.
3 · Score every option
Each option is scored against the corpus: the drafter's compressed-length delta blended with the query's cosine to the option's corpus centroid — the cosine is the signal that ranks.
4 · Calibrate
A sigmoid gate turns the signal into confidence. The calibrator starts bit-identical to the raw readout and refits only from outcome evidence you supply — offline, one-off, yours.
5a · Signal — the answer
With signal, one pick per question goes back with calibrated confidence and the full distribution riding beside it. This game-head question is one the engine is sure on.
IN · POST /decide
{ "state": "The piece leaves no holes under it on the left edge, sits flat on the surface, and the stack stays low.", "questions": [ { "id": "clean", "kind": "noul", "prompt": "Does the stack look clean?" } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (answered request)
OUT · sure: outcome yes
{ "answers": [ { "question_id": "clean", "outcome": { "noul": { "yes": true } }, "probabilities": [0.51943666], "confidence": 0.51943666 } ], "routing": { "lane": "modelless", "reason": "game-head/tetris (corpus-fitted, decoded arm)" }, "calibration": { "method": "none", "temperature": 1.0 } }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (answered response)
5b · No signal — the honest abstain
Off-corpus or low confidence yields outcome null: the engine declines instead of guessing, and the full distribution still rides for risk-coverage analysis. This kitchen question is nowhere near the corpus — the distance gate catches it.
IN · POST /decide · off-corpus
{ "state": "My sourdough starter stopped rising after I moved it to a colder kitchen.", "questions": [ { "id": "route", "kind": "choice", "prompt": "Route this ticket to the team that owns it.", "options": [ "deploy-ops", "billing-support" ] } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (off_corpus request)
OUT · not sure: outcome null
{ "answers": [ { "question_id": "route", "outcome": null, "probabilities": [0.52577484, 0.47422513], "confidence": 0.0019177794 } ], "routing": { "lane": "modelless", "reason": "modelless corpus routing: ops=0 support=1; fused abstain (score+distance) armed" }, "calibration": { "method": "none", "temperature": 1.0 } }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (off_corpus response)
6 · Refit from your data
Thresholds are fitted offline from labeled outcomes — never telemetry. The feedback wire is where outcome labels come back: report whether a past answer was right, and the engine recalibrates once it has enough reports.
IN · POST /feedback · an outcome label
{ "p": 0.51943666, "outcome": true }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /feedback (feedback request)
OUT · not enough reports yet — no refit
{ "refit": false }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /feedback (feedback response)
Instinct — the idea on top.
Instinct is the idea that upgrades Reflex without replacing it: when the free engine abstains, a specialist trained for exactly that domain scores the survivors on top, never instead.
The fused gate [the confidence check that decides whether to consult a specialist] answers with confidence and the specialist is never paid. On an abstain, the survivors are pruned to the top candidates and a locked per-domain specialist scores them. The answer carries a receipt — an audit trail of what answered, from which lane, checksum-committed in both directions.
The idea is taught by the open lane gist-rs/riir-instinct — and a specialist serves only where it strictly beat the free engine on a frozen test read. A tie or a loss sells nothing; the free engine keeps answering.
What does an abstain give my code?
A typed answer — the full distribution rides with it, so your code decides what a no-answer is worth instead of catching an exception. That is exactly the signal Instinct composes on: the abstain is the moment a specialist earns its keep.
Why does a free engine need a specialist at all?
The corpus bounds it. Modelless answers are excellent inside the domain you authored and honest about the edge of it. A specialist trained for exactly that hard domain covers the cases the corpus cannot — paid only where it was needed, per the winner law.
Deep write-up
The lane's own explainer, mirrored on this site: resources.md (local mirror) · on GitHub.
Reflexer — the same wire, played as a game.
Reflexer is the family's rulebook engine — it speaks Reflex's question types and answer envelope over a different state, the game board: one frozen-genome search per turn answers where to place, how the position stands, and whether it survives. [Rulebook: a fixed list of rules that scores every board a move can lead to. Frozen genome: shipped as constant bytes — never retrained, never blended.]
Step by step: what goes in and what comes out
1 · One request shape
Both engines speak the same wire: a state plus typed questions — choice, score, yes-no — and both answer in the same envelope. The captured request here is Reflex's, a yes-no question about a game state.
IN · POST /decide — the shared wire
{ "state": "The piece leaves no holes under it on the left edge, sits flat on the surface, and the stack stays low.", "questions": [ { "id": "clean", "kind": "noul", "prompt": "Does the stack look clean?" } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (answered request)
2a · 2a — the state is text
Reflex's state is text you wrote: a sentence, a paragraph, a JSON object. The question engine reads it and answers from a corpus you author — or abstains.
3a · 3a — your corpus answers
Answers come from documents, so off-corpus questions abstain honestly. This one the engine is sure on: outcome yes, calibrated confidence.
OUT · sure: outcome yes
{ "answers": [ { "question_id": "clean", "outcome": { "noul": { "yes": true } }, "probabilities": [0.51943666], "confidence": 0.51943666 } ], "routing": { "lane": "modelless", "reason": "game-head/tetris (corpus-fitted, decoded arm)" }, "calibration": { "method": "none", "temperature": 1.0 } }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (answered response)
2b · 2b — the state is a board
Reflexer's state is the game facts: the board, the falling piece, what is left in the bag. The same wire, played as a game — this recorded turn comes from the arena's replay-verified rulebook walk.
IN · a recorded game turn — board, piece, spot sentence
{ "state_sentence": "The stack stands low and the surface is mostly flat. There are no holes under the blocks. The square piece is falling.", "piece": "O", "board": [ "..........", "..........", "..........", "..........", "..........", "..........", "..........", "..........", "..........", "..........", "..........", "..........", "..........", "..........", "..........", "..........", "..........", "..........", "..........", ".........." ] }recorded rulebook game — the arena's replay-verified walk (recorded by the katgpt-rs site-walk example; turn 1)
3b · 3b — one frozen search
The genome scores every board each legal move can lead to, and the best plan's first move is played. Same request, same answer, on every host — the pick here is the recorded one.
OUT · the recorded pick — argmax over the option scores
{ "state_sentence": "The stack stands low and the surface is mostly flat. There are no holes under the blocks. The square piece is falling.", "piece": "O", "pick": 5, "per_option_ms": [ 0.047, 0.047, 0.047, 0.047, 0.047, 0.047, 0.047, 0.047, 0.047 ] }recorded rulebook game — the searched pick (argmax over the rulebook's option scores; turn 1, piece O)
4 · 4 — the shared envelope
Both engines answer in the same shape: one typed answer per question with probabilities, or a first-class abstain. Your code does not change between them.
OUT · the envelope, Reflex side
{ "answers": [ { "question_id": "clean", "outcome": { "noul": { "yes": true } }, "probabilities": [0.51943666], "confidence": 0.51943666 } ], "routing": { "lane": "modelless", "reason": "game-head/tetris (corpus-fitted, decoded arm)" }, "calibration": { "method": "none", "temperature": 1.0 } }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (answered response)
5 · 5 — the vessel swaps the genome
One signed file swaps the rulebook whole at boot — monotonically, never a weighted blend, because blends do not preserve move rankings. It is a public format: anyone can mint artifacts with it.
You have already met this engine: the arena's Reflex · rulebook boards are it — the lane is family-branded, the engine behind it is Reflexer, and the Reflex question engine does not need it. One set of bytes runs the local binary, the browser tab and a stateless worker, and they answer identically. Reflexer also gave the family its artifact format — the vessel: one signed file, hashed and locked, applied whole at boot so a downgrade or a fork refuses; the family's artifacts, public and hosted alike, ship in it.
Why do the names sound alike?
Because the arena labels the lane, not the repo: Reflex · rulebook is the family-branded lane, and Reflexer is the engine behind it. Reflex answers your questions; Reflexer plays the game. Two engines, one vocabulary — and the arena shows both.
Do I need Reflexer to run Reflex?
No. They are separate engines. Install Reflex to answer typed questions on your own machine; Reflexer is what the arena's rulebook boards run, and the format its artifacts ship in.
What did Reflexer give the whole family?
The vessel format: one signed file that swaps an engine's decision rules whole at boot — never a weighted blend, because blends do not preserve move rankings. It is a public format; anything that ships as an artifact in this family, public or hosted, rides it.
Deep write-up
The lane's own explainer, mirrored on this site: resources.md (local mirror) · gist-rs/riir-reflexer on GitHub.
Rethink — the same idea, one rung deeper.
Rethink is the same Instinct idea one rung deeper: where a bag specialist is too coarse, a trained encoder head thinks — served HOSTED-ONLY from our GPU servers, so the weights never leave controlled hardware. [HOSTED-ONLY: weights that never leave our servers — you call, we think.]
Step by step: what goes in and what comes out
1 · Your question
A state plus typed questions, on your machine — the same wire the free floor speaks. Nothing leaves by default.
IN · POST /decide
{ "state": "The piece leaves no holes under it on the left edge, sits flat on the surface, and the stack stays low.", "questions": [ { "id": "clean", "kind": "noul", "prompt": "Does the stack look clean?" } ] }captured from the reflex 0.2.4 release binary, 2026-10-04 · POST /decide (answered request)
2 · The fused gate
The free floor's confidence check runs first. On this harder triage question it abstains — every outcome comes back null — and only that abstain moves up the ladder.
IN · POST /decide · a harder question
{ "state": "The staging deploy of release candidate 4.2 finished but the error budget is down to 12 percent and two health endpoints are flapping after the rollout. Rollback is one command. Decide what happens next.", "questions": [ { "id": "route", "kind": "choice", "prompt": "Route this ticket to the team that owns it.", "options": [ "deploy-ops", "billing-support" ] }, { "id": "promote", "kind": "noul", "prompt": "Should the rollout be promoted to production right now?" }, { "id": "severity", "kind": "score", "prompt": "How severe is this situation?", "options": [ "routine", "needs-attention", "critical" ] } ] }captured from the reflex 0.2.4 release binary, 2026-10-04 · POST /decide (abstained request)
OUT · not sure: every outcome is null
{ "answers": [ { "question_id": "route", "outcome": null, "probabilities": [0.52583224, 0.47416782], "confidence": 0.0019263625 }, { "question_id": "promote", "outcome": null, "probabilities": [0.49452087], "confidence": 0.00008660555 }, { "question_id": "severity", "outcome": null, "probabilities": [0.3601853, 0.2878931, 0.35192165], "confidence": 0.004379213 } ], "routing": { "lane": "modelless", "reason": "modelless corpus routing: ops=3 support=0; fused abstain (score+distance) armed; drafter-only=1" }, "calibration": { "method": "none", "temperature": 1.0 } }captured from the reflex 0.2.4 release binary, 2026-10-04 · POST /decide (abstained response)
3a · Sure — nothing leaves
When the floor is sure, the answer returns in microseconds with a receipt — hashes of the input and the decision, not your data — and no rung above is paid.
IN · POST /decide
{ "state": "The piece leaves no holes under it on the left edge, sits flat on the surface, and the stack stays low.", "questions": [ { "id": "clean", "kind": "noul", "prompt": "Does the stack look clean?" } ] }captured from the reflex 0.2.4 release binary, 2026-10-04 · POST /decide (answered request)
OUT · sure: outcome yes
{ "answers": [ { "question_id": "clean", "outcome": { "noul": { "yes": true } }, "probabilities": [0.51943666], "confidence": 0.51943666 } ], "routing": { "lane": "modelless", "reason": "game-head/tetris (corpus-fitted, decoded arm)" }, "calibration": { "method": "none", "temperature": 1.0 } }captured from the reflex 0.2.4 release binary, 2026-10-04 · POST /decide (answered response)
3b.1 · The bag rung scores the survivors
The abstained question goes to small per-domain scorers over hashed word-count features — CPU-class, cheap enough to run anywhere. A confident bag pick answers right here.
3b.2 · Too coarse — the encoder thinks ○ illustrative · planned
Where a bag view is too coarse, a trained encoder head reads the question as a whole and thinks — GPU-hosted, weights that never leave our servers. The hosted lane is planned; this is the public request it would carry, and its reply is published when the lane opens.
IN · the abstained question, sent up
{ "state": "The staging deploy of release candidate 4.2 finished but the error budget is down to 12 percent and two health endpoints are flapping after the rollout. Rollback is one command. Decide what happens next.", "questions": [ { "id": "route", "kind": "choice", "prompt": "Route this ticket to the team that owns it.", "options": [ "deploy-ops", "billing-support" ] }, { "id": "promote", "kind": "noul", "prompt": "Should the rollout be promoted to production right now?" }, { "id": "severity", "kind": "score", "prompt": "How severe is this situation?", "options": [ "routine", "needs-attention", "critical" ] } ] }captured from the reflex 0.2.4 release binary, 2026-10-04 · POST /decide (abstained request)
4 · The hosted vessel
One locked file holds the head — hashed, signed, applied whole. Weights never leave hardware we control.
The free floor always answers first. Rethink is paid only where the free engine's confidence check abstains — the same fused gate as Instinct, one tier deeper. Every open-serve answer already carries a receipt today (the build plus hashes of the input and the decision); receipts on hosted answers are a roadmap item. And the seated cells are published either way: the benchmark's Rethink rows are the measured side, live today.
Escalation is built, not just drawn. Only abstentions ever go up — a sure answer never reaches a paid rung. The step from the specialist rung to the encoder is armed per suite, and only where the encoder measured ahead of the rung below on the board; a runtime rate guard watches every arming and demotes the lane to the cheaper rung if the escalation share drifts outside the band it was measured at, with the demotion named in the answer's receipt. The hosted API that exposes this ladder is still forming — the board carries the measured side today.
The shape it ships in. Rethink ships in two phases — each card's state is on the storefront's roadmap. v1, hosted only is next: the keyed decision API (forming), only-"not sure" escalations, pay per hosted answer and receipts on hosted answers (planned), opt-in stats with the quality-gated retrain (test network). v2, distributed follows: the rethink download — one program on your machine with the engine built in — plus leaseable specialists and encoders, where a lease raises the cost of copying without making copying impossible (the roadmap's own honest limit).
Why hosted-only? Why not ship the weights?
Because the class is structural, not a policy. The heads ship inside a HOSTED-ONLY vessel, and a build without the hosted reader cannot open one at all — so the weights cannot land on hardware nobody controls, not by accident and not by option. The same honesty carries into v2's leases: a lease raises the cost of copying, it does not make copying impossible — what a copy cannot get is the next update, a place on the network, or rewards.
Can I run Rethink myself?
Not today — v1 is hosted only: the trained heads run on our servers and you reach them over the API. The roadmap's v2 plans the rethink download — one program on your machine with the engine built in, and leaseable specialists and encoders (planned, after v1). Until then, the open lanes — Reflex and the Instinct teaching lane — are the ones you can run.
Where is the product surface?
The storefront is live at rethink.riir.ai — what the hosted tier does, how your data is handled, and the roadmap each card's state lives on. The buy card carries its honest state (not open yet — nothing is charged today). The bench Rethink rows are the measured side of everything this section claims.
Could the encoder be smaller — 4-bit weights?
We measured it rather than guessed. The serving weights already have a half-size step: an 8-bit tier (each weight stored in half the bytes), which passed the quality gates we declare before every measurement — its answers stayed within a couple of accuracy points of the full-precision reads on every test set. Cutting in half again, to 4-bit, failed the same gates: on the hardest test set — the one with the most answer classes — accuracy fell by double digits, and the confidence numbers got less honest with it. So 4-bit stays a measurement lane, never a shipping posture. If it ever comes back, it comes back through retraining with the small format built in, judged by the same gates. Until then, "smaller" means the 8-bit tier — what we serve when footprint matters.
Build your own.
Three development flows, one per rung. The compact write-ups live in each lane's docs — mirrored on this site, with the source of truth on GitHub for the public lanes.
Reflex — author a lane.
Step by step: what goes in and what comes out
1 · Author the grammar
Write the domain as sentences: a state sentence and option sentences in a closed grammar. The grammar bounds what can be asked — nothing outside it is ever answered.
2 · Label a slice
A small set of your own labeled examples, kept offline. This is the only data the fit consumes — no telemetry feeds it.
3 · Refit the gates
Fit the gate thresholds from your labels, offline, one-off. The calibrator stays bit-identical until you refit it.
4 · Serve on loopback
Run the edge on your machine with one allowed origin. The health read is the loopback edge answering: which lanes are ready, which heads are fitted.
OUT · GET /healthz — the edge is up
{ "status": "ok", "lanes": { "modelless": "ready", "raw": "ready", "laya": "off" }, "heads": { "tetris": true, "lanes": true, "flappy": true }, "corpus": "demo" }captured from the reflex 0.2.4 release binary, 2026-10-03 · GET /healthz (healthz response)
5 · Decide
The live path: an answer with calibrated confidence, or an honest abstain when the evidence is thin. This runbook question is answered by the corpus the loop just authored.
IN · POST /decide — a question your corpus covers
{ "state": "our deploy regressed the error budget after the rollout — run the rollback and verify the health endpoints", "questions": [ { "id": "route", "kind": "choice", "prompt": "Which runbook applies?", "options": [ "billing", "deploy", "onboarding" ] } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (corpus_answered request)
OUT · the corpus's answer
{ "answers": [ { "question_id": "route", "outcome": { "choice": { "index": 1 } }, "probabilities": [0.3341486, 0.3407357, 0.32511574], "confidence": 0.00016820431 } ], "routing": { "lane": "modelless", "reason": "modelless corpus routing: billing=0 deploy=1 onboarding=0; fused abstain (score+distance) armed" }, "calibration": { "method": "none", "temperature": 1.0 } }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (corpus_answered response)
6 · Ship the binary
One static release per platform; the corpus and the fitted thresholds ride with it. Same binary, same answers, on every host.
Instinct — train a specialist.
Step by step: what goes in and what comes out
1 · Make the corpus
The training corpus is assembled from public data, with the splits frozen before anything trains — fit on one slice, choose on another, read test once for the verdict.
2 · Train a specialist
One small model per domain trains on its slice of the corpus — a specialist for exactly the cases the free engine finds hard.
3 · The winner law decides
The candidate earns a manifest row only by strictly beating the free engine on one frozen, label-stratified test read. A tie or a loss sells nothing — the free floor keeps answering.
4 · Lock it
A passing artifact's digest is pinned and checked at every load, so any change to the file is caught — and nothing trains at serve time.
5 · Register the row
The locked winner is registered in the manifest — the one selection surface. It is swapped whole, never blended, and a decision always observes one whole server.
6 · Serve with receipts
The lane answers with a decision receipt: the build fingerprint, hashes of the input and the canonical decision, and the lane id — an audit trail on every answer.
Rethink — mint a head.
Step by step: what goes in and what comes out
1 · Train the head
A small head trains above a frozen base — the base never trains, so its reading stays exact and repeatable. The heads on the public board today were made this way; their reads are measured there, record-only.
2 · Lock it
The head is hashed and checksum-verified: any change to the file is caught at load, and nothing trains at serve time.
3 · Mint the vessel
The head is minted into one HOSTED-ONLY vessel — a locked file whose weights never leave our servers. The format is built; the hosted lane it serves is planned.
4 · Deploy to our GPU hosts
The vessel deploys to GPU hosts we control, in one container shape. No step of this flow ever places the weights on hardware nobody controls.
5 · Serve at the storefront ○ illustrative · planned
You call, we think: the hosted API answers the questions the free floor abstained on, with a receipt on every answer. Planned — this is the public request it would carry, and its reply is published when the lane opens.
IN · the abstained question, sent up
{ "state": "The staging deploy of release candidate 4.2 finished but the error budget is down to 12 percent and two health endpoints are flapping after the rollout. Rollback is one command. Decide what happens next.", "questions": [ { "id": "route", "kind": "choice", "prompt": "Route this ticket to the team that owns it.", "options": [ "deploy-ops", "billing-support" ] }, { "id": "promote", "kind": "noul", "prompt": "Should the rollout be promoted to production right now?" }, { "id": "severity", "kind": "score", "prompt": "How severe is this situation?", "options": [ "routine", "needs-attention", "critical" ] } ] }captured from the reflex 0.2.4 release binary, 2026-10-03 · POST /decide (abstained request)
Under the hood — model classes, training, freezing.
The flows above assume some vocabulary; this part teaches it. The three model classes that answer typed questions, the words the industry uses for training and freezing — written for software developers — and why the family's serving ladder freezes everything below a small trained head.
The words — model classes and anatomy
- encoder
- A model that reads the whole input in one pass, every token attending both left and right, and produces per-token vectors — not text.
- BERT
- The canonical pretrained encoder: pretraining hides words and predicts them from both directions.
- ModernBERT
- The modern refresh of BERT — rotary positions, sliding-window attention; the encoder class our lanes build on.
- decoder-only
- The autoregressive shape: one stack, each token seeing only the past, built to predict the next token. The GPT family.
- causal mask
- The rule that hides the future from each token — what makes a model autoregressive rather than bidirectional.
- forward pass
- One run of input through a model to its output. "One forward" is the unit of serve cost.
- embedding
- A vector of numbers representing a piece of text; similar meanings land on nearby vectors.
- tokenizer · BPE
- How text becomes subword pieces before a model sees it — byte-pair encoding merges frequent pairs; the vocabulary is fixed before training.
- sigmoid vs softmax
- Two ways to turn scores into probabilities. Softmax makes options compete (probabilities sum to one); sigmoid scores each option alone. This family's own primitives use sigmoid; a ported reference model may keep softmax to stay faithful to its numbers.
The words — training techniques
- pretraining
- The first, expensive training run on huge generic data that produces a base model. Nobody in this family pretrains; we consume pretrained bases.
- fine-tuning
- Any further training that adapts a pretrained model to a task.
- SFT
- Supervised fine-tuning — fine-tuning on labeled examples with gold answers; the simplest adaptation. The heads in this family are a minimal SFT.
- gold label
- The correct answer for an example, written by people.
- distillation
- A big teacher model's probabilities train a small student; the student learns the teacher's graded opinions, not only its hard picks.
- teacher · student
- The big frozen model that labels (teacher) and the small cheap model that learns from it (student).
- soft target
- A teacher's probability spread over the options — as opposed to one hard gold answer.
- LoRA · adapter
- A small trainable patch injected into a frozen base, training a fraction of the parameters — parameter-efficient fine-tuning (PEFT).
- full fine-tune
- Updating every weight of the base — the most expressive and the most expensive option.
- behavioural cloning
- Training a critic by imitating an expert's moves. Our arena measured its limit: agreeing with the expert is not the same as playing better.
The words — freezing and serving discipline
- frozen weights
- Weights that are done training: locked bytes, never updated at serve time. Same input, same reading, forever.
- head-only training
- Freeze the whole base and train only a small head above it — the base's reading stays exact, and the head is cheap to fit per domain.
- linear probe
- The simplest head-only form: a single linear layer over frozen features — the classic baseline a real head must beat.
- catastrophic forgetting
- A fully fine-tuned model losing skills it used to have — the risk full fine-tunes carry and frozen-below designs avoid by construction.
- hot-swap
- Replacing an artifact atomically, whole-for-whole, so a decision always observes one whole model.
- never blend
- A weighted mix of two models' outputs is banned in this family: blends do not preserve rankings, so a decision could observe a model that never existed.
The words — evaluation discipline
- train · holdout · test
- Three disjoint slices of a corpus: fit on train, choose on holdout, read test once for the verdict.
- frozen test read
- The one-time read of the test split — a number quoted from it can never be improved by trying again. That is the point.
- overfitting
- Memorizing the training slice instead of learning the task; the holdout split is what catches it.
- winner law
- A student serves only where it strictly beat the free floor on the frozen read. A tie or a loss sells nothing.
- reference lane
- A frozen model nobody here trains, measured as the bar each student must clear.
Train or freeze — the techniques compared
| Technique | What trains | What stays frozen | Why we choose it — or don't | Where the gain shows |
|---|---|---|---|---|
| Frozen, as-is | nothing | everything | The zero-cost baseline: score a pretrained model without any training. Every lane must beat a frozen reference — or the free floor — before anything trains at all. | the comparison lanes on the board |
| Head-only — frozen base + small head | a tiny head | the whole base model | The hosted rung: the base's reading stays exact and repeatable, a head is cheap to fit per domain, and nothing below it can drift or forget. | the board's Rethink rows — measured, record-only until the hosted lane opens |
| Distillation — teacher → student | the student | the teacher | Moves a big model's knowledge into a cheap student. The caveat we measured: the student's feature class can cap the lift — a better teacher could not raise a bag-features student past its ceiling. | the board's Instinct rows |
| Adapter — LoRA (PEFT) | a small injected adapter | the base model | The industry's middle path, and the shape behind a published open decision model's recipe. Serve still pays the big base's cost — so it stays out of our serving ladder, kept on the map for a future retrain. | not seated — a mapped option |
| Full fine-tune | every weight | nothing | Most expressive, most expensive, and it risks catastrophic forgetting. Overkill for typed decisions; nobody in the family's serving ladder does it. | not used — shown for contrast |
| Modelless fit | a few gate thresholds, offline | everything — there is no network at all | The free floor: an authored corpus plus fitted gates. Not training in the neural sense, and that is the point — nothing to freeze, nothing to forget. | the Reflex rows, every suite |
Read the table this way: the serving ladder — modelless → bag specialist → encoder head — never leaves frozen-below-the-head, while the heavier techniques stay available to the training side, where a measured win can promote them. The measured side of every row is the benchmark; no number on this page is typed.