this-that-model-1.0

A typed decision model. One forward pass, no decoding loop, no parser, no retry.

Your program reaches a branch it cannot express in code — is this refund within policy? is this shell command safe to run unattended? — and what it needs back is not prose. It is one of n declared options and a number it can threshold.

This model returns exactly that, in about 31 ms on a consumer GPU, generating zero output tokens.

• Parameters: 1.88 B
• Architecture: Qwen3.5-style hybrid, 18 of 24 layers DeltaNet linear attention, 6 full attention
• Inference code: github.com/FLock-io/this-that-model
• Benchmark: limberc/this-that-spatial-bench

Usage

pip install git+https://github.com/FLock-io/this-that-model

from thisthat import TypedDecider, Question

decider = TypedDecider.from_pretrained("flock-io/this-that-model-1.0")   # cuda, mps or cpu

answer = decider.decide(
    "command: rm -rf /var/lib/postgresql/data",
    Question("Is this shell command safe to run unattended on a production host?",
             ["yes, it only reads state",
              "no, it modifies or deletes data",
              "no, it contacts the network"]),
)

print(answer)                 # no, it modifies or deletes data (100%)
print(answer.index)           # 1
print(answer.probabilities)   # (0.001, 0.998, 0.001)

if answer.confidence < 0.8:
    escalate()                # the number is calibrated, so the threshold means something

Those outputs are measured, not illustrative. The escalation branch is not decoration: ask this model something away from what it was trained on and it says so rather than guessing confidently. "user=alice tier=free requests_this_minute=847" / "Should this request be rate-limited?" returns no (71%) — unconfident, and for 847 requests a minute, wrong.

Several questions about one state are answered in the same forward pass, because no answer is written back into the prompt and the decisions are conditionally independent given the input:

answers = decider.decide(order_json, [
    Question("Within the refund window?", ["no", "yes"]),
    Question("Which queue?", ["standard", "priority", "manual review"]),
    Question("Risk band", ["low", "medium", "high"]),
])

On Apple Silicon, from_pretrained selects MPS automatically and loads in float16.

Why a malformed answer is impossible

The answer is read from the hidden state at a designated position and scored against the label tokens of the options you declared, normalised over exactly those:

$$p_k(j\mid x)={\mathrm{softmax}}_j(⟨w_{\mathrm{\ell }(k,j)},h_k⟩\mathrm{/}\tau )p\_k(j\; \backslash mid\; x)\; =\; \backslash operatorname\{softmax\}\_j\backslash left(\backslash langle\; w\_\{\backslash ell(k,j)\},\; h\_k\; \backslash rangle\; /\; \backslash tau\backslash right)$$

The support of that distribution is your option list. An answer outside it is not improbable, it is unrepresentable. There is no token budget to exhaust, no letter to mis-parse, and no try/except to write. Up to 255 options are supported; ten or fewer use an (A) … (J) rendering and wider sets switch to single-token labels.

Results

Every number below is reproducible from the inference repository; each script prints what it measured beside what was published.

Against Jev, a hosted commercial decision service, on 68 questions over 17 states that a third party recorded and neither party chose. The wording is theirs, not ours — this model was trained on a different phrasing of the same question, so this measures transfer rather than recall.

System	Accuracy	Brier ↓	NLL ↓	ms/question	Cost of one pass
majority-class baseline	0.647	—	—	—	—
claude-fable-5-1	0.676	—	—	2395	$0.471
glm-5.3	0.721	0.204	0.601	819	$0.008
qwen3.8-max	0.735	0.263	2.681	1014	$0.021
NanoJev-0.6B	0.750	0.166	0.479	—	—
Jev	0.765	0.133	0.403	—	—
kimi-k3	0.779	0.143	0.430	989	$0.009
deepseek-v4.1-flash	0.794	—	—	808	$0.002
gpt-5.6	0.926	—	—	1180	$0.018
this-that-model-1.0	0.941	0.042	0.126	30.9	$0.000014

A dash under Brier and NLL means the endpoint exposes no token probabilities, so those quantities are not observable there — not that they are poor. Time is the median per-question latency at the client. Our cost is electricity at 80 W and $0.30/kWh, a different kind of number from a price that must cover serving and margin: read our distance from the hollow square as one order of magnitude, not five. Jev's position on that axis is its published rate of $0.042 per million input tokens applied to the token count we measured — its accuracy is ours to measure, its price is theirs to state. Five further frontier models answered all 68 correctly and are omitted: at this size they are saturated and rank nothing.

Calibration, where the true answer is a computed probability. A noisy actuator executes the intended move with probability ρ and otherwise picks uniformly among the alternatives, so the answer follows from the transition rules rather than from anyone's opinion.

	Accuracy	qL2 ↓
accuracy ceiling (computed — no predictor can exceed it)	0.746	—
constant predictor	—	0.0962
this-that-model-1.0	0.750	0.0250

Of nine hosted frontier models measured on identical questions, only three expose token probabilities at all, and all three score worse than the constant predictor.

Decomposition. The same questions about the same worlds, asked once from the whole rendered map and once from the agent-centred window the answer provably depends on:

World	Whole state	The part it depends on
32×32	0.562	0.979
80×80	0.583	1.000
128×128	0.479	1.000
200×200	0.646	0.979

The whole-state input at 200×200 is 15,603 tokens; that rung was measured on an 80 GB card, the others on a 16 GB laptop where it does not fit.

On the released spatial benchmark (limberc/this-that-spatial-bench), 7,305 questions over 15 families: 0.839 against a chance rate of 0.343, up from 0.409 before this checkpoint was trained on those families. Read it with the caveat it deserves: the items and the maze windows are held out by fingerprint and by rendered state, but the question shapes were trained on, while every hosted system it is compared against met them for the first time at test.

On the 2,250-question subset every system answered: gpt-5.6 0.897, claude-opus-5 0.892, this-that-model-1.0 0.844, claude-sonnet-5 0.836, Jev 0.803, glm-5.3 0.789, chance 0.343. Jev is the closest comparison — the only other system there that generates no tokens — and that figure was run for us by a third party, since we hold no key for it.

the state rendered as	before	after	chance
an ASCII block	0.457	0.779	0.388
the same cells as JSON	0.373 (chance)	0.936	0.394
the same cells as prose	0.420	0.942	0.394

Limitations

Stated here rather than left to be discovered.

• Not more accurate than a frontier model. On the harder half of our internal suite it is not, and on the benchmark we built and released it is the least accurate system we measured. The claim is about the cost and the shape of a decision, not about being the best at making one.
• It cannot search a graph. The sharpest limitation, and the one to plan around. On the released benchmark the 1,500 questions that need a shortest path or a reachability test average 0.574; every other family is between 0.77 and 0.998. Asked for the same shortest-path distance twice on the same 300 mazes — once as one of five bands, the readout it was trained on, and once as even or odd, which it has never seen — it names the band and then answers the parity correctly 0.513 of the time. A coin is 0.500. It recognises the band; it does not hold the number. A single forward pass through a fixed stack of layers admits a bounded number of sequential steps, and a breadth-first search over a large maze is not one of them. Run the search yourself and ask this model about the result.
• Held-out question shapes show where the ceiling is. Four families appear in no training data at all: 0.980 on relative geometry and 0.570 on local counting, against 0.515 on distance parity (chance 0.500) and 0.276 on plan progress (chance 0.333). Across all 1,496 it scores 0.558. The two it fails are the two that need a search — the same boundary the paired probe draws.
• An earlier surface dependence, now fixed. This checkpoint's predecessor scored 0.373 — chance — when a maze window was written as JSON rather than as ASCII. Training on all three renderings raised it to 0.936. That was the whole of what the extra data bought; it left the search families where it found them.
• A well-formed distribution is not a correct one. The head guarantees the output is a distribution over your options; it guarantees nothing about whether that distribution is right, and off the training surface it is confidently wrong.
• No multi-step arithmetic. One forward pass cannot carry intermediate results through: 0.560 against 0.98–1.00 for frontier models.
• English only, and short states. Evaluated up to roughly 33k tokens of state on a 16 GB card.

Training

Adapted from decider-2b (Apache-2.0) against a strictly proper scoring rule, so the model has no way to lower its loss except by reporting what it believes — which is what makes the probability usable as a threshold. The whole adaptation is a single scalar λ applied as θ(λ) = θ₀ + λΔ, so θ(0) is bit-exact the prior checkpoint and rollback is a configuration change rather than a restore.

Citation

@misc{cheng2026thisthat,
  title  = {A typed decision model that decides in 30 ms, for a millionth of a cent},
  author = {Cheng, Zehua and Dai, Wei and Sun, Jiahao},
  year   = {2026},
  note   = {University of Oxford and FLock.io}
}

Licence and attribution

MIT. Adapted from decider-2b under Apache-2.0. The environment simulator and the recorded 68-question cohort come from NanoJev under the MIT licence and are used as published; we thank its authors.