The hosted decision tier

Trained decisions,
one rung deeper.

The free Reflex engine always answers first — on your machine, for free, and honest when it abstains (says “I'm not sure” instead of guessing). When the hosted lane opens, Rethink picks up only those abstentions: a trained model reads the whole question and thinks. It is hosted-only in v1 — the trained weights run on our servers and never ship to anyone else's machine; v2 plans a distributed lane (the roadmap). Today its cells are measured on the public board, record-only: nothing hosted is served yet.

hosted API: not open (waitlist)

Try the free floor How we handle your data Benchmark board ↗

One question, end to end — “Is this support ticket a refund request?” (the hosted step is still forming — this example describes the design)

You ask — your app sends the question to Reflex, free, on your machine.
Reflex abstains — not sure, and it says so instead of guessing.
Rethink answers — yes, 0.91 confidence, receipt #… attached.
Your code acts on the answer; the receipt re-checks it later.

New to decision models? The two-minute primer on reflex.gist.rs explains what they are — and how Reflex goes further.

Accuracy over the free floor on the three suites with the most test questions (chosen by size, not by gain) among the cells where Rethink has its own read, rendered from the published comparison board — never typed by hand. Tier-fallback cells (a lower rung's read, not Rethink's) stay in the graph below. Each tile carries its posture: record-only cells are measured, not served yet. The board carries every cell's provenance.

Decision index

On the Jev Decision Index.

The Jev Decision Index is an independent leaderboard for decision models (models that pick one answer and state how sure they are): every entrant faces the same public suite and gets one 0–100 score, beside the parameter count where the board publishes one. Rethink's internal read on that score, beside the board's published rows and its full scored field — wins, ties and losses all visible:

The serving runtime itself is the tiny-framework story — measured on reflex.gist.rs/#sizes.

Why

The measured answer.

Every Rethink cell from the public board, against the free floor, best accuracy first — wins, ties and losses all stay visible. The full board, every lane and every disclosure, lives at the benchmark.

What the numbers mean: accuracy on each suite's public test set — the question count rides the suite's cell on the board. Chance level differs per suite (a two-option task and a 77-way task are not comparable); the bench FAQ explains how to read them.

loading the published feed…

Bar = the Rethink cell — violet its own record-only read, grey tier-fallback (a lower rung's read — what actually serves, not the encoder) · tick = the free floor · the delta reads the verdict: green ahead · yellow tied · red behind — on a grey (tier-fallback) bar a tie means the served rung matched the floor, not a specialist tie. Bars run best accuracy first; each suite links to its cell on the board.

Record-only = measured on the board, not yet served by the hosted tier. Tier-fallback = a lower rung's answer is what gets served for that suite (the specialist rung, or the floor).

How it works

The rung model.

One idea, depth-graded. Each rung answers only what the rung below is not confident about — you pay for thinking, never for re-answering what the free floor already knows.

Reflex — the free floor

Modelless, on your machine.

No trained model at all: it answers from your examples in microseconds, and a calibrated confidence check (tuned so “90% sure” is right about 90% of the time) decides when to abstain. Install it today.

Instinct — the specialist rung

Locked per-domain specialists.

When the floor abstains, a small per-domain scorer ranks what is left — the open teaching lane, fast on a plain CPU.

Designed — the middle rung

Between the specialists and the encoder.

A lighter rung for cases the specialists miss but that do not need the full encoder. It is designed and not seated yet.

Rethink — this tier

The trained encoder head.

An encoder head (a trained model that reads the whole question — word order, context, nuance — and picks an answer) for the cases a word-count view gets wrong. Runs on our GPU hosts when the hosted lane opens, shipped in a locked, hosted-only package — record-only on the board today.

R4+

Designed — the deeper rungs

Batch thinking + curation.

The design keeps rungs above the encoder for batch work and corpus curation. They seat as the product earns them.

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.

Why hosted-only in v1? Why not ship the weights?

In v1 it is built in, not a policy. The trained heads ship in a locked package that only our hosted reader can open — a build without that reader cannot load them at all. So in v1 the weights cannot land on hardware nobody controls, not by accident and not as an option. Shipping them is a v2 step: leased to staked accounts and renewal-bound — see the roadmap.

Can I run Rethink myself?

Not in v1 — that is the honest answer. The lanes you can run today are Reflex and the Instinct teaching lane; v1 Rethink is the hosted rung on top of them. v2 plans a downloadable rethink program with leasable specialists and encoders — planned, not scheduled (roadmap).

What runs today, and what is still forming?

The measured cells are live on the board today. In plain words: the free, record-only board is live today; the hosted waitlist is next; purchases open when the payment lane lands. The trust table marks every piece live, on the test network, or planned.

Trust

Managed + distributed — how we balance private and shared.

Rethink is a managed service with an open edge. Your machine stays private by default; the shared part is opt-in, checkable by anyone, and gets better for everyone. Here is the whole loop, end to end.

Private self-run free · no account

The free floor runs on your machine: your hardware, your data, no account.

Nothing leaves by default. The Reflex floor answers locally.
Only “not sure” goes up — once the hosted lane opens, and only if you point your app at it.
Sharing is a switch you flip. Off until you say so.

A shared corpus, managed + self-improving

The shared side has two halves, and we are clear which is which.

We run (centralized) — the GPU heads, the hosted-only weights, the quality gate and the retraining.
Anyone can check (decentralized) — opt-in contributors, receipts anyone can re-run, signed stats with a public view, settlement on the public ledger, one account across the network.

Step by step: what goes in and what comes out

1 · You ask, on your machine
Your app or your agent sends Reflex a typed question: a sentence describing the situation plus the questions to decide. It runs on your own machine, with no account.
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 free floor decides

The Reflex floor decides right there, in-process. It answers when it is sure; when it is not, every outcome comes back null — it abstains (says “not sure” instead of guessing). This deploy question is one it abstains on.

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 → the answer stays here

When the floor is sure, the answer goes straight back to your app and nothing leaves your machine. In the open serve every answer also carries a receipt: the exact build plus hashes of the input and of the decision — hashes, not your data.

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 · Not sure → the hosted Rethink head ○ illustrative · planned

Only questions the floor abstained on go up, to a trained head whose weights run only on our hosts; its answer comes back to you with a receipt. The hosted API is planned: this is the public request it would carry, and its reply is published when the lane opens.

IN · the same 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)

3b.2 · Metered on the ledger
Each hosted answer is metered on the public ledger: one account, TUNA trial credit first, then KAT, with spend and rewards in public. Planned for Rethink — pricing is published when the lane opens.
4a · Anyone can check a receipt
Same release + same input = same answer, so anyone can re-run a receipt and compare the hashes. This runs on our test network today.
4b · Opt-in decision stats
Off unless you switch it on — off until you switch it on. A row holds counts only (how many decisions, how many abstentions), signed by your key; never your text. Test network today.
5 · The public stats pool
Signed rows land in a public pool anyone can read, and each epoch gets a commitment root you can verify. Test network today.
6 · Retrain, lock, redeploy
The pool feeds a quality gate. A new head ships only if it passes; it is locked and runs on our hosts only, and the loop returns to step 3b.1 with better answers for everyone. Planned — it waits on enough stats.

What is live, and where it runs

Piece	Runs on	Status
Reflex floor — answers or abstains	your machine	live
Rethink hosted head	our hosts	measured on the board · hosted API planned
Paying per hosted answer (TUNA trial credit first, then KAT)	network	planned · pricing published when the lane opens
Receipts with every answer	your machine	live in the open serve
Re-checking a receipt by re-running it	network	test network
Opt-in decision stats + the public stats pool	network	test network
Rewards for decision stats	network	planned · zero until checking is switched on
Quality-gated retrain + locked redeploy	our hosts	planned · waits on enough stats

Our promises — and how you can check them

Nothing leaves your machine by default.

The free floor runs locally with no account and no telemetry. Decision stats stay off unless you switch them on — unset means nothing is sent.

check it: run Reflex with your network off.

Your words are never in the stats.

Decision stats are counts — how many decisions, how many abstentions, per suite — signed by your key. Never your questions, never the answers' text.

check it: the pool's public view shows exactly what a row holds.

Every answer can be re-checked.

A receipt names the exact build and carries hashes of the input and the decision. Same release + same input gives the same answer, so anyone can re-run it and compare.

check it: re-run the release; the hashes must match.

In v1, the trained weights never leave our hosts.

Hosted-only is built into the v1 package format: a build without our hosted reader cannot open it. v1 never ships the trained heads to a machine we do not control; if v2 leases them, that change is announced here first.

check it: the open lanes contain no hosted reader.

No hidden rewards, no hidden losses.

Rewards for decision stats stay at zero until re-checking is switched on; when they pay, settlement shows on the public explorer. Benchmark losses stay on the board next to the wins.

check it: explorer · board.

Words on this page

abstain / abstention: Say “I'm not sure” instead of guessing. On the free floor it is a designed answer, not an error — and it is the only thing Rethink is paid for.
calibration: Tuning a confidence score so “90% sure” is right about 90% of the time. It decides when the floor abstains.
commitment root: One fingerprint over every stats row in a settlement period (an epoch). Change any row and it no longer matches.
controlled hardware: The servers we run ourselves. In v1 the trained weights exist only here — never on a machine we do not control.
decision stats: Opt-in counts of decisions and abstentions per suite, signed by your account key. No question or answer text.
decision wire: The small JSON contract both engines speak: a state plus typed questions in, typed answers with probabilities and a receipt out. The free floor and the hosted tier speak the same wire.
encoder head: A trained model that reads the whole question — order and context — and picks an answer.
free floor: The free Reflex engine that answers first, on your machine. It answers when sure and abstains when not — those abstentions are what Rethink takes next.
hosted-only: The v1 rule: the trained weights run only on our servers, inside a locked package that nothing else can open.
KAT: The network's metered service credit — no cash value. Spent after TUNA runs out; earned by contributing.
lease (v2, planned): Time-boxed access to a specialist or encoder on your own machine, renewed while your account's stake holds its tier. Stop renewing and it stops loading.
posture: Which lane produced a number: Rethink's own read, a lower rung's, or measured-only. Every cell on this page wears a posture chip.
receipt: A short record with every answer: which build answered, plus hashes of the input and the decision. The hashes are fingerprints, not copies of your input; re-running the same input proves the answer.
record-only: Measured on the public board but not served by the hosted tier yet — the honest state of every Rethink cell today.
rung: One level of the answer ladder: the free floor (R0), the specialists (R1), the encoder (R3). Each rung answers only what the rung below was not sure about.
specialist: A small per-domain model, fast on a plain CPU, that answers one narrow kind of question. The specialist rung is the open teaching lane.
test network: Our public test deployment of the network: real and running, with rewards held at zero.
tier-fallback: A cell where a lower rung's answer is what actually gets served — the number shown is that rung's, not the encoder's.
TUNA: Free trial credit on your network account. It pays first.

Try

The free floor first.

The free engine is what the family stands on, so start there: install it, point it at your domain, and watch where it abstains. Those abstentions are exactly what the hosted tier is priced for.

Reflex — free, local, yours

The modelless decision engine. Runs on your machine. No account, no telemetry.

reflex.gist.rs →

Playground, install commands and the agent skill live there.

Rethink — the hosted trial

Ships with the access plane: sign in with one network account, get a key, call the API, see the receipts. Trial credit (TUNA) pays first.

forming — waitlist

Purchases are not open yet — the buy card carries the waitlist address.

Pricing

Pay only where the floor abstains.

One gist.rs account. Pay per answer only where the free floor abstains — free trial credit (TUNA) first, then KAT. Pricing is published when the hosted lane opens.

Rethink hosted

Keyed hosted decisions (the /v1/decide lane)
Metered per answer, on the same account as the rest of the network
Per-key quotas — sizes to be announced, published with the hosted lane's launch — plus key rotation with grace
Receipted answers — build fingerprint, input and decision hashes
The free floor stays free, forever, underneath

forming — waitlist

Nothing is collectable and nothing is claimable until the hosted lane opens. The price and the refund terms publish here and at terms before anything can be charged.

Want in early? Purchases are not open yet. Write to hello@gist.rs to say you want in — purchases open to the list first.

Capabilities only on this card. No accuracy claim without its measured cell — and every measured cell is on the public board, either way.

Roadmap

v1 hosted. v2 distributed.

Rethink ships in two phases. v1 is hosted only: the trained heads run on our servers and you reach them over the API. v2 is distributed: a program you download, with specialists and encoders leased to staked accounts. Nothing on this list is live yet — each card says its state.

In plain words: the free, record-only board is live today; the hosted waitlist is next; purchases open when the payment lane lands.

v1 — hosted only next · waitlist

The hosted decision API

Keyed calls to /v1/decide — the same decision wire as the free engine. Per-key quotas (sizes to be announced, published with the hosted lane's launch), key rotation with grace.

not open yet · waitlist

Only “not sure” goes up

The free floor answers on your machine; only its abstentions reach the hosted head. Every reply says which rung answered.

planned

Pay per hosted answer

One gist.rs account: TUNA trial credit first, then KAT. Pricing is published when the hosted lane opens.

planned

Receipts on hosted answers

The build plus hashes of the input and the decision, so anyone can re-run and compare — as the open serve already does.

planned · live in the open serve

Scored on the field’s own index

The serving stack will be read on the Jev Decision Index (the decision models’ public leaderboard) with the same scoring rules as every entrant. Results will land here with wins and losses together — before any claim is made.

planned

Opt-in stats, gated retrain

Counts only, never your text. A new head ships only if it passes the quality gate, and runs on our hosts only.

test network

The agent skill

rethink-integration: API-key header, rate-limit and error codes, quota handling, the receipts.

planned · ships with the tier

v2 — distributed after v1 · planned

The `rethink` download

One program on your machine. The Instinct engine is built in and runs offline. The free floor's answers stay free; Instinct's answers are metered like hosted ones — only where the floor abstains. The engine is MIT open source: read it, or build it yourself with your own corpus.

planned

Leasable specialists

All of them, or only the domains you pick, once your stake reaches a tier. Verified before they load; renewed while the tier holds.

planned · tiers set when the lease plane opens

Leasable encoders

The trained encoder heads, all or selected, by stake tier — encrypted on disk, unlocked per lease, expiring unless renewed.

planned · after v1

Updates are the product

New specialists, encoders and corpus arrive as committed updates to leases that renew. A copy that stops renewing stays frozen where it stopped.

planned

Honest limits: 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. No tier is offered before its gate exists, and tier sizes are published with the lease plane, not before.

Agents

For agents.

The family is agent-first: the free engine ships a published integration skill today, and the hosted tier speaks the same decision wire with API-key auth.

Today — the free engine's skill

The reflex-integration skill: the decision wire, abstention handling, thresholds from your own data.

Get the skill →

With the access plane

The rethink-integration skill ships with the hosted tier: API-key header, rate-limit and error codes, quota handling, the receipts.

planned · ships with the tier

Preview: the hosted /v1/decide wire not open yet

Preview — subject to change. The hosted lane speaks the same decision wire as the free engine: a state plus typed questions in, typed answers with probabilities out, plus a receipt naming the build and blake3 digests of the input and the decision. The values below are illustrative placeholders — the lane is not open, and the final reply schema publishes with it.

IN · POST /v1/decide

POST /v1/decide
Authorization: Bearer <key>
Content-Type: application/json

{
  "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?"}
  ]
}

OUT · answers, each with its receipt digests

{
  "answers": [
    {"question_id": "route",   "outcome": {"choice": {"index": 0}}, "probabilities": [0.91, 0.09], "confidence": 0.91},
    {"question_id": "promote", "outcome": {"noul":   {"yes": false}},  "probabilities": [0.62],          "confidence": 0.62}
  ],
  "routing": {"lane": "rethink", "reason": "the free floor abstained — the hosted head answered"},
  "receipt": {"build": "rethink-hosted <build>", "input": "blake3:…", "decision": "blake3:…"}
}

Only questions the free floor abstained on go up. The request shape above is the public wire the free engine speaks today — see the reflex-integration skill. The hosted reply shape publishes with the lane, in the family primer's terms: an answer, its probabilities, and a receipt anyone can re-check.

Trained decisions,one rung deeper.

Modelless, on your machine.

Locked per-domain specialists.

Between the specialists and the encoder.

The trained encoder head.

Batch thinking + curation.

Private self-run free · no account

A shared corpus, managed + self-improving

What is live, and where it runs

Our promises — and how you can check them

Nothing leaves your machine by default.

Your words are never in the stats.

Every answer can be re-checked.

In v1, the trained weights never leave our hosts.

No hidden rewards, no hidden losses.

Words on this page

Reflex — free, local, yours

Rethink — the hosted trial

Rethink hosted

v1 — hosted only next · waitlist

The hosted decision API

Only “not sure” goes up

Pay per hosted answer

Receipts on hosted answers

Scored on the field’s own index

Opt-in stats, gated retrain

The agent skill

v2 — distributed after v1 · planned

The rethink download

Leasable specialists

Leasable encoders

Updates are the product

Today — the free engine's skill

With the access plane

Trained decisions,
one rung deeper.

The `rethink` download