5 AI Decision Models That Skip Text Generation Entirely

On September 15, 2026, TypeSafe AI published Jev and argued that “LLM call” is the wrong primitive for a large class of software decisions. Within four days, at least four independent open-source implementations arrived, each making the same architectural bet from a different direction. The window for original comparative coverage is short: DataCamp already published a Jev explainer, and a dedicated System One Models directory appeared within days of the initial launch. What has not yet been written is a rigorous comparison of how Jev, Laya, Von, FLock’s this-that-model, and mateolafalce’s System One actually differ in architecture, measured performance, and production readiness.

Why This Comparison Is Timely

The multiplicity threshold is what makes this category worth examining. One proprietary launch is a product announcement. Five independent teams converging on the same interface in under a week is a signal that the interface itself resonates.

Laya reached PyPI on September 19 as an Apache-2.0, non-autoregressive decision engine with 16,000 GitHub stars at the time of writing. Von shipped its first public release the same week and reported 91.23% accuracy on adversarial multi-hop benchmarks. FLock published both a model and an arXiv paper (2609.23886) from Oxford and FLock.io researchers. mateolafalce’s System One appeared as a reproducible training recipe targeting 8 GB consumer GPUs. These are not forks of Jev. They are independent decisions to implement the same software interface.

The interface is: caller declares the option set in advance; model returns a probability distribution over exactly those options; no text generation happens at any point.

The Shift: Generate a String, Then Parse It vs. Score Your Options Directly

The conventional path from a language model to a decision looks like this: send a prompt requesting a classification or a score, receive a generated string, parse that string into a value your code can branch on, validate the value against your schema, and retry when parsing fails. Every step after the forward pass is engineering overhead, and the parsing step can fail in ways that are difficult to anticipate. If a reasoning budget runs out mid-sentence, the reply arrives truncated. If the model hedges, the parser has to decide whether “likely” means true or false. If the model hallucinates an option name that is close but not exact, the downstream branch receives garbage.

Decision models take a different path. The caller specifies allowed outputs before the forward pass. The model scores those options from its hidden states, applies softmax across the declared set, and returns an index and a probability. An output outside the declared schema is not just unlikely; it is unrepresentable. Understanding what happens during a standard inference pass makes clear why this matters: the model’s hidden states encode semantic information that the standard decode loop translates into tokens one at a time. Decision models read that semantic encoding directly without the token-generation step, which removes both the latency of sequential decoding and the parsing problem that follows it.

The architectural question each implementation answers differently is: where in the model does the decision head attach, how are multiple simultaneous questions packed into a single forward pass, and how are the resulting probabilities calibrated so that a 90% confidence number actually means the model is right 90% of the time?

TypeSafe Jev: Proprietary Parallel Sampler With Calibration-Oriented Training

TypeSafe AI launched Jev on September 15, 2026, founded by Diogo Almeida, who previously worked on the reinforcement learning methods behind ChatGPT at OpenAI. The company describes Jev as “a frontier-intelligence function call: unstructured state in, typed probabilistic decisions out.”

Jev’s architecture is proprietary and not fully published. What TypeSafe has disclosed is a new model architecture with a parallel sampler (all output logits are produced in a single query rather than autoregressively), and a training method called Reinforcement Learning for Calibrated Decisions (RLCD). RLCD optimizes for calibration rather than human preference (RLHF) or verifiable reward (RLVR). The motivation is that a confidence score is only useful for routing if it tracks actual accuracy: a model that reports 90% confidence on decisions it gets right 60% of the time cannot be trusted to gate an automated pipeline.

The published performance claims are notable. TypeSafe reports end-to-end response times of 70ms to 500ms, compared to 3 to 329 seconds for frontier autoregressive models on the same tasks. Their workflow evals benchmark, comparing against the average of GPT-6 Astra and Fable 5.1 responses, claims 193.6x faster and 444.6x cheaper on representative production workflows. Jev’s pricing is $0.042 per million input tokens; output tokens are listed as free. The option cardinality cap is 255; above that, Jev performs a two-stage system of independent scoring followed by an explicit choice.

The honest caveat from TypeSafe itself: the workflow benchmarks were authored by their own model capabilities team, which introduces potential bias. The RLCD training recipe and internal architecture remain unpublished. The evals use the average of two OpenAI and Anthropic models as reference, which the company acknowledges biases results toward those providers. Jev is cloud-only, API-access only, with no open weights.

Laya: 421M ModernBERT With a Router, Three Checkpoints, and Public Benchmarks

Laya, released by ConvAI Innovations (GitHub: NandhaKishorM/laya), is the most substantial open-source implementation to appear in this window. It reached PyPI on September 19, 2026, under Apache 2.0, and accumulated over 16,000 GitHub stars and 1,300 forks within days.

The architecture uses ModernBERT-large (421M parameters) as the encoder backbone for the primary English checkpoint, and mmBERT-base (322M parameters) for the multilingual variant covering 100+ languages. Rather than generating text, Laya attaches a decision head that scores the caller’s declared options against the encoder’s output representations. The three available checkpoints: laya (512-token English), laya-multilingual (1024-token, 100+ languages), and laya-typed-decisions (421M, fine-tuned for workflow-style typed decision tasks), are served through a built-in Router that detects language in sub-milliseconds and dispatches to the appropriate checkpoint automatically.

The measured latency on a Tesla T4 is 33ms for a single question and 7.2ms per question when questions are batched in a single forward pass. The batching behavior is meaningful: if a workflow needs eight independent decisions about the same piece of state, a single Laya call produces all eight in one pass at roughly the cost of one. On the published typed-decisions benchmark (2,000 examples), Laya reports 0.766 accuracy against Jev’s published 0.727, and an expected calibration error of 0.081 against Jev’s 0.246, which is substantial. TypeSafe Jev’s measured API latency in that same comparison is 236 to 276ms.

The limitations are documented in the repository with unusual candor. The base checkpoints score near chance on the typed-decisions benchmark before fine-tuning on that task family; the strong number comes specifically from laya-typed-decisions. The multilingual checkpoint shows severe failures on some languages despite reporting high confidence: the research notes document a case where the English checkpoint scored 0.000 on Khmer items while reporting 0.952 confidence. On the 51-language sweep, routing raises coverage from 23 to 45 languages; the remaining 6 are below the accuracy threshold without routing. And on the large-option Banking77 classification task (77 intents), Laya performs poorly because the classification head is not designed for high-cardinality label spaces without the embedding shortlist workaround added in a recent commit.

FLock this-that-model: 1.9B With an arXiv Paper and an OpenAI-Compatible API

FLock’s this-that-model (GitHub: FLock-io/this-that-model) is the largest open implementation in this comparison at 1.9 billion parameters, and the only one to ship an accompanying academic paper. The paper (arXiv:2609.23886, authored by Cheng, Dai, and Sun from Oxford and FLock.io) derives the typed answer head formally, explains the training objective, and reports results at the same resolution on failures as on successes.

The mechanism is straightforward to describe: the model reads an answer from hidden states and normalises the distribution over the caller’s declared option labels. “The support of the distribution is the caller’s option list and a malformed answer is unrepresentable rather than merely unlikely.” The two-part prompt layout separates a schema prefix, computed once and reused across states, from the variable state text, which reduces per-call overhead when the question set is stable. The training objective is a strictly proper scoring rule estimated from single sampled outcomes, which is the property that makes the confidence number meaningful for threshold-based gating.

On the published results: 0.941 accuracy on a 68-question cohort over 17 states, compared to Jev’s 0.765 on the same cohort. On the 7,305-question spatial benchmark released with the paper, the model scores 0.844 after a targeted training round on those task families, up from 0.409 before training. The measured latency is 30.9ms. The model is available locally (MIT license) and free via the FLock API at platform.flock.io/models. FLock also implemented an OpenAI-compatible endpoint that maps the typed interface to the structured output format: the enum in a response_format becomes the option set, and usage.completion_tokens is reported as 0, because it is.

The failures are stated explicitly. Multi-step arithmetic scores 0.560 against 0.98–1.00 for frontier models, because one forward pass has no mechanism to carry an intermediate computation result across steps. The 1,500 spatial benchmark questions that require searching across the map average 0.574 while all other question families are above 0.77. The model recognises a distance band but cannot hold a parity derived from that band. When FLock measured Laya on their exact benchmark subset (zero-shot), Laya scored 0.345 against a chance rate of 0.343, but the paper notes this is not a fair comparison, since their model trained on those task families while Laya did not.

Von: 395M Option-Marker Architecture With Sub-18ms Latency

Von (GitHub: wfzyx/von) is a single-developer open-source implementation with 472 stars and active daily commits. The current release is Von 1.1, which uses an Option-Marker joint attention backend that the author describes as achieving 93.5% macro benchmark accuracy on the architecture’s benchmark suite. The model weighs 395M parameters (1.5 GB on disk), runs in 18ms on GPU, and is evaluated on two independent test suites.

The architecture is distinct from Laya’s in how it handles multiple simultaneous questions. Laya packs questions against a shared state and runs one forward pass per call. Von’s Option-Marker approach encodes option markers directly into the attention pattern of the transformer, so the model can score options across questions in a way that is aware of the full option set during the forward pass rather than treating each question independently. This is the architectural variant that the Von README reports gives the largest accuracy improvement on the jabr v2 49-task benchmark.

On the jabr v2 benchmark (49 tasks, 869 cases, covering compliance, triage, legal, DevOps, linguistics, and safety), Von 1.1 scores 72.0% macro accuracy. On the ViZDoom real-time gameplay evaluation (controlling a game agent purely from structured scene text at sub-20ms), Von records 9.00 kills per 8-seed run against Jev’s 5.62. The ViZDoom result is interesting because it tests whether a decision model can operate at interactive frame rates on a dynamic state that changes faster than a generative model could respond. Von runs on NVIDIA CUDA, AMD ROCm, Apple Silicon MPS, and CPU, and implements TypeSafe’s /v1/systemone wire protocol, making it a local drop-in for the Jev API. Python and JavaScript SDKs are published.

Von’s documented limitation is a training corpus shortcut. The most recent commit describes a root cause analysis of near-chance hard-tier accuracy: in Von’s 290,000-example training corpus, the correct option shares more words with the premise 79.8% of the time. The model learned to pick the highest-overlap option rather than the semantically correct one, which is a near-optimal rule on that corpus but performs at chance on JevBench’s hard tier, which deliberately decorrelates lexical overlap from truth. The fix, rebalancing by selection rather than rewriting examples, is underway, but has not yet produced a new checkpoint.

mateolafalce/system-one-model: 149M Specialist for 8 GB GPUs

The system-one-model repository by Mateo Lafalce (GitHub: mateolafalce/system-one-model) is the earliest-stage implementation in this comparison: three commits, one star, no release. It is worth including because the training recipe is fully reproducible and it targets a hardware constraint the other implementations do not directly address: a single 8 GB consumer GPU.

The approach uses knowledge distillation from a Qwen2.5-7B-Instruct-AWQ teacher (4-bit quantized, 8 GB inference) into a ModernBERT-base student (149M parameters, 512-token context). The teacher scores options by reading letter logits, never by sampling JSON, which means the teacher’s signal is itself a typed decision rather than a generated parse. The student uses a sequence layout that places a [MASK] token in front of each option, reads the hidden state at each mask position, projects to one logit, and softmaxes within the question. Confidence is computed as normalized entropy (1 – H(p) / log(K)) rather than a learned head, which means it does not require a separate calibration training pass.

Current evaluation results on the proof preset (BANKING77, SMS spam, SST-5): BANKING77 88.5%, SMS spam 98.9%, SST-5 55.9% with ECE 0.033. The go/no-go criteria for shipping are explicit: BANKING77 test accuracy at or above 90%, ECE at or below 0.08, p95 latency below 80ms for a 10-question batch at 512 tokens. The stated limits are also explicit: English only, 512 tokens maximum (longer inputs are tail-truncated in code), no arithmetic, and the model is a domain specialist that requires re-distillation for new task families. The README is specific: “This is not a TypeSafe Jev clone. Jev is closed, uses unpublished RLCD, and claims a 64k window. This repo is a domain System One: a calibrated specialist on short English text.”

How They Compare

What This Category Reveals

The entries are ordered from broadest deployment scope and architectural ambition to most narrowly scoped and earliest-stage. Jev sits at the top because it is the only system with a cloud API, published commercial pricing, and workflow evaluations on representative production tasks. Laya sits second because it has the widest open-source uptake, a reproducible benchmark, and a router that makes multilingual deployment practical. FLock’s this-that-model ranks third because it has an academic paper, a free hosted API, and the most explicit reporting of its own failure modes. Von ranks fourth because it is actively shipping but has an identified training corpus problem that has not yet been resolved in a released checkpoint. The mateolafalce implementation ranks last because it is pre-release, though it is notable for being the only implementation that explicitly targets a hardware constraint and provides a complete training recipe.

The most interesting finding across the five implementations is not their accuracy numbers. It is that they converge on three output primitives: choice (categorical),, score (ordinal), and a binary probability, independently. TypeSafe coined the names; Laya uses the same three names; Von supports discrete, probabilistic, and ordinal. FLock generalises to any option set passed by the caller. The convergence suggests these three output types cover a large fraction of the fuzzy-decision surface in real software workflows.

The open question the category has not answered is whether these models can be made to work well zero-shot on unseen task families. Every model except Jev shows significantly worse performance on task families outside its training distribution. FLock’s comparison of Laya on their spatial benchmark (0.345, near chance) and their own model before training (0.409, also near chance) makes the point bluntly: the difference between a useful decision model and a useless one is 87,651 training examples for those specific question shapes, not architecture.

Limitations and Open Questions

The benchmarks across these implementations are not comparable without careful reading. Von’s jabr v2 and FLock’s spatial benchmark measure different things on different data. Laya’s typed-decisions benchmark is an in-house evaluation. TypeSafe’s workflow evals use the average of two frontier models as the reference answer, which introduces its own bias. There is no shared benchmark that all five systems have been evaluated on under identical conditions.

The “cannot hallucinate” claim requires a precise interpretation. These models cannot emit a string outside the caller’s declared schema. They can absolutely choose the wrong option within that schema. The distinction matters for software: schema compliance is guaranteed, semantic correctness is not. FLock’s paper makes this concrete: on multi-step arithmetic tasks, this-that-model scores 0.560 while frontier models score 0.98–1.00. The model cannot carry an intermediate result across a forward pass, and no amount of schema enforcement helps with that.

Calibration claims also vary in robustness. Laya reports ECE 0.081 on its typed-decisions benchmark, but the research notes document a 0.952 confidence on Khmer inputs that score 0.000 accuracy. Von documents a routing AUC of 0.632 on its hard tier; random escalation would achieve 0.5, so the gating signal is present but weak. The mateolafalce implementation uses entropy-based confidence rather than a trained head, which may or may not transfer across task families. Only Jev, with RLCD, claims a principled training-time objective for calibration, and that recipe is unpublished.

The largest open question is what happens at scale. These evaluations are single-GPU, single-task-family, or limited-cohort. None of the open implementations has been evaluated on the kind of production traffic where calibration matters most: millions of decisions per day across hundreds of diverse input distributions, where the confidence score is used to route to an expensive generative model only when the decision model is uncertain. That is the architecture the category is gesturing at, and no public evidence yet shows it working at that scale.

What This Means for Engineering Teams

The practical question is not which model is best. It is whether this interface belongs in your stack at all, and for which decisions. The category makes most sense for decisions that have a well-defined option set, do not require multi-step reasoning, are called frequently enough that LLM latency is a bottleneck, and where a wrong answer in the uncertain tail is acceptable as long as the model reports its own uncertainty honestly.

Email routing, customer support triage, content moderation labels, structured extraction from documents, safety classification of generated outputs: these are the task families multiple implementations identify as natural fits. They are also the tasks where a generative model is arguably overpowered: you do not need token-level generation to decide whether a support ticket is about billing or technical issues. Optimizing the inference stack for AI agents involves identifying exactly this kind of decision point: where an expensive frontier call can be replaced with a typed classification that costs a fraction of the latency and compute.

For teams evaluating these tools, the comparison dimensions that matter most in practice are: whether the confidence scores are calibrated on your task distribution (not just the published benchmark), whether the model handles your option cardinality and context length, and whether the latency budget fits your architecture. Von’s 18ms and Laya’s 7.2ms-per-question-batched are fast enough for synchronous calls inside request handlers. FLock’s 30.9ms and Jev’s 70ms minimum are fast enough for agent decision steps. The 80ms target in the mateolafalce implementation covers most interactive use cases.

If your team is building production AI workflows and discovering that LLM calls are the latency or cost bottleneck at branch points in your pipeline, this category is worth a prototype. The barrier to entry is low: Laya installs with pip install laya, Von with a pip install from its repository, and FLock’s this-that-model is available free via their API without any local setup.

Key Takeaways

• TypeSafe Jev reports 193.6x faster and 444.6x cheaper than frontier LLMs on its own workflow evals, at $0.042 per million input tokens and 70–500ms end-to-end via cloud API.
• Laya achieves 33ms latency on a T4 GPU (7.2ms per question when batched) and reports 0.766 typed-decisions accuracy against Jev’s 0.727, with ECE 0.081 versus Jev’s 0.246.
• FLock’s this-that-model (1.9B, arXiv:2609.23886) scores 0.941 on a 68-question cohort where Jev scores 0.765, but explicitly discloses near-chance performance on multi-step arithmetic (0.560) and large spatial search tasks (0.574).
• Von 1.1 (395M) leads all open local implementations on the 49-task jabr v2 benchmark at 72.0% macro accuracy and outperforms Jev on ViZDoom real-time gameplay (9.00 kills vs 5.62), but has an identified training corpus shortcut problem on its hard tier.
• Zero-shot generalization remains the gap: every open implementation shows near-chance performance on task families outside its training distribution, meaning deployment requires task-specific fine-tuning or distillation.
• The three output primitives, categorical choice, ordinal score, and binary probability, appear across every implementation independently, suggesting they cover a practical decision surface in real software workflows.

Work With Origins AI

Origins AI builds production AI infrastructure for engineering teams. If your LLM pipeline spends most of its budget on decisions that could be typed classifications, talk to our team.