A model that chooses.
Code that acts.

Not a chatbot. Not a magic if-statement.

TypeSafe AI introduced Jev on 15 September 2026. Its “System One” name borrows the fast, intuitive half of Daniel Kahneman’s Thinking, Fast and Slow: focused judgments rather than a long generated chain of reasoning. That is a product metaphor, not a claim to reproduce human cognition. [1]

Supply a state (text or JSON) and named questions. Receive values your program can use directly: a named option, a yes/no probability, or a score over an ordered rubric. The application still decides what to do, checks permissions and maintains state. Jev cannot write an email, explain a proof or invent an arbitrary tool argument. [2]

Typed is not synonymous with deterministic or correct. A valid option can be the wrong option. Similar inputs can change probabilities; a moving model alias can change results. There is still text conditioning through state, instructions and criteria. “No generated prose” does not mean “no prompt” or “no context window”.

Traditional classifiers are not obsolete. If a fixed label set, simple rules or a trained linear model solve the task, measure those first. A decision model is interesting when the meaning is messy, options vary at runtime and training a separate classifier for every workflow would be expensive. A schema-constrained generative model is another legitimate baseline.

What is known about the mechanism?

Jev: vendor description. TypeSafe describes parallel evaluation of independent questions against shared state and training for calibrated decisions (RLCD). Its full architecture, weights and training recipe are not public. Archer Hume’s reconstruction is an informed hypothesis from observable behavior, not a disclosure by TypeSafe. Do not present the reconstruction as a verified diagram of Jev. [1] [3]

Kev: inspectable implementation. Jared Palmer’s family adds LoRA adapters and a small pointer readout head to Qwen bases. A packed input contains the state, question instructions and option boundaries. A block-causal attention mask lets each question see the shared state and its own branch, not the other questions. The readout compares the decision-position hidden state with option-boundary hidden states, then softmax produces probabilities. There is no autoregressive text-decoding loop. JSON is assembled by ordinary application code. [4]

This is not the same as running a Qwen chat model with “answer JSON”. The adapter, special-token mapping, mask, position IDs, head and calibrated temperature all matter. Current Kev cards cover 0.5B, 0.6B, 0.8B, 4B and 9B checkpoints; base families and weights have changed over revisions. Pin a revision rather than assuming a size name is a stable experiment. The original 0.5B is explicitly superseded. [5]

Calibration is a population property. If events assigned 0.8 happen about 80% of the time on a relevant labelled dataset, that region is calibrated. One confident answer proves nothing. Accuracy, calibration, coverage and the cost of confident errors are separate measurements. Kev’s later checkpoints fit a temperature on development data; this does not guarantee calibration under a new distribution. [6]

A related paper, “The smart if-statement”, describes another typed decision model. Its reported 30.9ms laptop-GPU figure is the paper’s own workload, not a latency measurement of Jev, Kev or this site.

Three primitives, three different jobs

Choice confidence is not the winning option’s raw probability. TypeSafe derives it from distribution shape; Kev approximates those statistics. The lab displays both rather than labelling a 0.8 probability “80% confidence” indiscriminately. [6]

{
  "model": "jev-1.13.0",
  "state": "The export fails in Safari; CSV still works.",
  "questions": {
    "severity": {
      "type": "score",
      "instructions": "How severe is the issue?",
      "criteria": ["Cosmetic", "Workaround exists", "Blocking"]
    }
  }
}

Independent questions can share one call. If one answer truly changes the next question or determines which external data to fetch, use another call. Batching is not a way to let question B secretly read question A’s answer. TypeSafe’s smart-home demo asks speculative questions together and ignores irrelevant results in code. [7]

Cheap decisions change the shape of software

As checked on 22 September, TypeSafe lists jev-1.13.0 at $0.042 per million input tokens, output tokens free, 64k tokens per request and 32k for state plus the longest question. [8] Output-free does not mean no output bytes: the response still contains JSON. Nor does it mean unlimited throughput or zero latency.

A worked arithmetic example, not a benchmark: 1,000 input tokens × 100,000 classifications = 100 million tokens, or $4.20 at that list price. Add state, criteria and examples to the token count. Add retries, preprocessing, generation, networking and engineering to the workflow bill. If a generative model first summarizes every document, that may dominate cost.

The roughly 193× speed / 445× cost headlines are TypeSafe’s selected workflow comparisons, not universal speedups. The launch explicitly says shorter inputs favor its demonstration and reasoning settings affect comparisons. The reported 70–500ms is not a promise for every geography, queue depth, prompt or model version. [1]

Where this matters: classify each item instead of sampling a batch; score multiple independent properties per event; gate an expensive reasoning model behind a cheap assessment. Where it does not: if the gate rejects good requests or requires costly repair, a cheap call can make the workflow worse. Evaluate end-to-end quality and spend together.

The early usage landscape

Evidence below means “this source describes or supplies it”, not that we independently replayed every demo. This ecosystem was days old at research time. A video or tweet is evidence of an experiment, not production reliability.

Direct Logits vs Token Generation: SemIf / OpenJev

Another in-browser approach is explored by SemIf (formerly OpenJev). Running via wllama (WebAssembly and WebGPU GGUF execution), it compares two methods on the exact same local model (Qwen3 0.6B, MiniCPM5 2B, Qwen3.5 4B):

• Direct Readout: constrains output via a GBNF grammar (root ::= "A" | "B" | ...) with max_tokens: 1, reads the raw option logprobs for allowed letter tokens in one forward pass, and normalizes them via softmax over the supplied choices without decoding.
• Autoregressive Generation: prompts the model to write out the full JSON distribution token by token, watching each token stream in.

The speedup is measured directly in the tab: direct readout bypasses the multi-token decoding loop entirely. On accuracy across a 102-row public TypeSafe benchmark subset, the open models scale from 40.7% (Qwen3 0.6B) and 63.7% (MiniCPM5 2B) to 84.5% (Qwen3.5 4B) compared to published Jev’s 88.3%. This illustrates the trade-off: constrained single-token logits on standard chat backbones provide quick directional decisions without custom pointer heads, while specialized models (Kev’s block-causal attention pointer head, or Laya’s bidirectional mask encoder) eliminate the need for GBNF grammar sampling while scoring arbitrary multi-token option descriptions directly.

What the X search actually established

We queried X for Jev/Tetris and fetched the public TypeSafe and Jared Palmer profiles. The HTTP pages returned a JavaScript/login shell, not readable timelines. Public web-index searches were noisy. LangChain’s article embeds direct posts by CompleteSkeptic, Kyle Jeong, Jarrod Watts and Ryan Vogel. These are discovery leads, not independently verified post contents.

Gap: no exhaustive X inventory, no primary Tetris source independently inspected, and no external state-machine deployment verified. We retain those gaps instead of laundering secondary anecdotes into first-party proof. The repository records fetch outcomes, including access failures.

Visual decisions & JevImageBench v0.1.5

In October 2026, the benchmark tracker JevImageBench v0.1.5 catalogued 50 vision decision models evaluated on bounded multimodal tasks: UI automation, receipt legibility, exposed secret scanning, and robot navigation. [17]

Why visual System One matters: Traditional vision-language models (VLMs) process an image and autoregressively generate descriptive text token by token. Generating a 30-token sentence explaining an image takes 500–1,500ms and costs $0.50–$3.00 per 1,000 queries. Multimodal decision models replace the generative decoding loop with direct option logit projection. In a single forward pass, vision tokens pass through a block-causal pointer head or cross-attention pooler, producing calibrated probabilities across bounded choices in 0.26–0.71 s at $0.0074–$0.063 per 1,000 decisions (general multimodal LLMs range up to 4.83 s and $2.06 per 1k).

Interactive evaluation: You can test image decisions directly in your browser using the Interactive Image Decision Lab, which includes drag-and-drop uploads, preset UI/receipt/security/navigation test images, and an embedded explorer for all 50 JevImageBench systems.

The useful part: where it breaks

TypeSafe’s own Jev 1.13 jaggedness page (reviewed there 17 September) documents literal reading, numerical precision, dates, indirection, irrelevant context, adversarial input, contradictory criteria, structural invariants and generation failures. [13]

• Arithmetic and dates: compute in code. Feed the model a day count or boolean result if needed. Asking “is this overdue?” does not turn a language model into a calendar library.
• Indirection: point directly at the relevant evidence; split a complex judgment into independent properties.
• Long noisy state: filter irrelevant material; use retrieval before classification.
• Adversarial text: typed output is not prompt-injection immunity. A malicious document can still steer a valid label.
• Structural consistency: independently asked propositions need not satisfy logical identities. Enforce mutually exclusive states and allowed transitions yourself.
• Unknown labels and unfamiliar workflows: descriptions may transfer; arbitrary private conventions cannot be recovered from nothing. Read and test the adaptation question.

Do not treat “decision model” as “incapable of any reasoning”: it may learn useful rule compositions. The narrower, defensible point is that it does not produce a chain-of-thought or free-form solution, and documented multi-hop/arithmetic weaknesses matter. Its value is not a license to ask harder questions with more confidence.

An evaluation plan before you trust a threshold

Freeze request schemas, criteria, model revision and preprocessing. Build representative labelled inputs, edge cases, harmful false positives and unknowns. Split by source or time, not duplicate rows. Compare against rules, embeddings and a small generative model. Measure accuracy, Brier score, reliability by probability bin, coverage and confident-error rates; separately measure latency and cost. Tune on development data and test once on held-out data. Re-evaluate after changing a rubric or checkpoint.

Kev runs in a browser, and it does so as of two days ago

Corrected 22 September 2026. This page previously said that Kev published PyTorch adapters and a custom head but “not a ready-to-use ONNX/Transformers.js package”. That was accurate when it was written and is no longer accurate. onnx-community/kev-0.6b-ONNX was published on 20 September 2026 and is exactly that: tagged transformers.js and onnx, pipeline text-classification, with the pointer head inside the graph. Run it in this tab.

The export takes only input_ids and attention_mask. It derives the segments, positions and block-causal mask from the delimiter tokens in-graph, and returns one score per token; the caller reads the score at each option’s closing delimiter and softmaxes within the question. The full-precision export is not published. [15]

A trap that produces plausible nonsense

The model card’s own helper passes the five delimiter strings through the caller-text escape and then tokenizes them. That is wrong. All five then tokenize to one ordinary token, the graph finds no option spans, and it returns a vector of zeros instead of raising: every question reads as a uniform distribution. We hit this, and four of thirteen known-answer cases “passed” anyway, because a uniform distribution breaks ties toward the first option — the check was satisfied by the failure. Take the ids from kev.delimiter_ids in the model’s config.json. tests/kev-pack.test.js guards the index arithmetic, and the on-device page says so on screen whenever a score vector is flat.

What the download costs

Only two quantisations are published: q4, 374.8 MB and q4f16, 335.4 MB, plus roughly 11 MB of tokenizer and vocabulary files. That download happens once per browser and is the real price of on-device decisions. It is the only request the page makes, and it goes to huggingface.co. Your text does not leave the tab.

A free check before you write a browser client

On 22 September 2026 we sent an OPTIONS preflight to https://api.typesafe.ai/v1/systemone, with Origin: https://paulkinlan.github.io, requested method POST and headers authorization,content-type. It returned HTTP 400 with no Access-Control-Allow-Origin. No key was used; no inference was requested. That origin cannot make this direct browser call under the observed policy. This does not establish that every origin is refused; vendor policy can change.

curl -i -X OPTIONS https://api.typesafe.ai/v1/systemone  -H 'Origin: https://paulkinlan.github.io'  -H 'Access-Control-Request-Method: POST'  -H 'Access-Control-Request-Headers: authorization,content-type'

The Pages interface exposes the failure honestly. For real hosted API use, clone this repository, run npm run serve, open the printed loopback URL and choose “This local server → fixed provider API”. This optional relay binds only to loopback, checks same-origin requests and forwards only three fixed API routes. It never persists or logs keys. There is no project-hosted proxy.

Run actual Kev on your machine

git clone https://github.com/jaredpalmer/kev.git
cd kev
uv sync --extra serve
KEV_DTYPE=bf16 uv run --extra serve python -m kev.serve   --run jaredpalmer/kev-0.8b --port 8009

This follows the upstream Python serving interface for larger checkpoints like kev-0.8b and kev-4b; Python 3.12+, dependencies and model weights are needed. First launch downloads from Hugging Face on your server machine. Hardware support and memory vary. In this site’s Decision lab and Playground, selecting Kev runs the 0.6B ONNX export directly in your browser without a local Python server. Do not expose an unauthenticated inference server to a public interface.

Where it could fit Paul’s public repositories

These are proposals based solely on unauthenticated public GitHub API listings and public READMEs fetched on 22 September. No private repositories, local project state or personal data informed them. They are not claims of existing integrations.

• chrome-agent-platform: rank a short list of advertised tools, or identify whether a request needs page inspection, navigation or clarification. Keep the existing permission/run boundary authoritative. Evaluate tool-choice precision and abstention against actual user intents before replacing routing.
• agent-do: add an optional decision step before an expensive model, or score whether a proposed tool result addresses the task. Measure the whole loop, including false routes and fallback spend; do not bolt on a second execution authority.
• idb-vector: use retrieval to select a bounded candidate set, then a Choice or relevance Score to rerank. Compare retrieval quality and latency on labelled queries. The index remains the index; a cloud reranker changes the offline/privacy promise and must be opt-in.

A good first trial is a shadow-mode tool router: log the proposed tool and uncertainty alongside the existing decision without executing anything new. It makes wrong answers measurable before they become actions.

What leaves the browser, and when

• Reading and local experiments: only this site’s static files load from GitHub Pages. In-browser inference with Laya or Kev runs entirely on your device with weights cached from Hugging Face. No user data, analytics or telemetry leaves the browser.
• Run with Jev: state, question instructions, criteria, model ID and your bearer key go directly to api.typesafe.ai.
• Run with Kev or Laya in-browser: state and questions are evaluated locally inside WebAssembly in your tab after the one-time Hugging Face weight download; no user text leaves your machine.
• Generate a specification: the idea and fixed system prompt go to OpenAI or Anthropic with that provider’s key. Current lab state and Jev key are not automatically included.
• Follow a source link: your browser navigates to that external site. No sources are embedded or prefetched here.

With the optional local relay, the request and key also pass transiently through your local Node process to the fixed provider. Keys live only in page memory/input fields and that request: never localStorage, URLs, generated JSON or downloads. Clear them or reload to remove them. Browser extensions and a compromised same-origin page can still access page inputs. Use restricted, disposable keys and set provider spending limits. This is a bring-your-own-key experiment, not a secret vault. Provider retention terms still apply.

The CSP allowlists same-origin resources, the three API hosts and loopback; it does not claim connect-src 'none'. Generated content is strictly validated JSON and rendered as text/native controls—never inserted as HTML, evaluated as JavaScript, or permitted to choose an endpoint. The narrower generator is deliberate: it creates a fixed-shape experiment, not an arbitrary app.

Sources and evidence ledger

Primary material inspected directly; access date 22 September 2026. External articles and provider model cards are claims by their authors. No paid Jev/Kev quality benchmark was run for this edition. The lab’s automated checks use labelled synthetic fixtures, not hidden real-model results.

1. TypeSafe: Introducing System One Models & Jev — announcement, comparisons, Doom and Wikiracing, with vendor caveats.
2. System One concepts and HTTP quickstart — public contract.
3. Archer Hume: Jev’s Architecture Unmasked — third-party inference, not inside knowledge.
4. Kev source, especially kev/api.py, serving and model code — inspectable implementation.
5. Kev-0.5B card and Kev-0.8B card — intended use, model details, evaluations.
6. TypeSafe confidence and Kev-4B card — distinguish probability, derived confidence and calibration.
7. Smart-home demo walkthrough — batching and LLM fallback.
8. Models, pricing and customization — current alias, price and no per-account Jev fine-tuning.
9. LangChain: Building a harness with Jev — code examples and embedded X links.
10. Flavio Copes: A deep dive into Jev — secondary landscape, accessed after update dated 21 September.
11. TypeSafe use-case map — proposals, not production evidence.
12. Documentation index — hierarchical classification, semantic search and scoring cookbooks.
13. Jev 1.13 jaggedness — first-party failure modes.
14. Kev Space Python app — server-side model loading, not browser inference.
15. onnx-community/kev-0.6b-ONNX — a Transformers.js-ready ONNX export of jaredpalmer/kev-0.6b, published 20 September 2026, pipeline text-classification; its model card documents the packed format, the five delimiters, the in-graph mask and the readout. Driven by us in Node on 22 September 2026 and in Chrome from the on-device page.
16. SemIf / OpenJev (openjev.com) — in-browser comparison of direct option logit extraction (wllama GBNF single-token readout) versus autoregressive JSON generation on WebGPU across Qwen and MiniCPM GGUF models.
17. JevImageBench v0.1.5 — 50-system benchmark evaluating multimodal System One models on bounded image decisions.

Open questions: real-provider CORS and account access on your machine; domain-specific calibration; complete X discovery; browser export/parity; performance on low-memory devices. This report is a starting map, not a claim that the terrain has stopped changing.