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.

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.

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.

Why there is no browser Kev button

Scope correction: the upstream Hugging Face Space is a browser interface backed by Python inference, not weights executing in your browser. The inspected Kev tree and Hub cards publish PyTorch adapters and a custom head, not a ready-to-use ONNX/Transformers.js package. [4] [14] Small parameter count alone does not make that runtime portable.

A real port would need merged base/adapter weights, tokenizer and special-token fidelity, block-causal attention and position-ID behavior, the pointer head and temperature, an export compatible with browser operators, and parity tests on distributions—not just top-1 labels. It would then need quantization checks, memory measurements and device testing. This is unimplemented here, not a claim that ONNX or WebGPU could never support it.

Scale matters: 0.8 billion parameters at two bytes each is roughly 1.6GB of raw weights before metadata and runtime memory. Four-bit storage is roughly 400MB before overhead, only if a suitable quantized export exists. Those are arithmetic estimates, not a download offered by this site. No model weights download on page load.

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 serving interface; Python 3.12+, dependencies and model weights are needed. First launch downloads from Hugging Face on your server machine. Hardware support and memory vary. Choose “Kev local server” in the lab. The upstream server currently enables CORS; browser local-network permission may still be required. If Pages cannot access loopback, serve this site locally and retry. Do not expose an unauthenticated inference server to a public interface. We have not run these weights in this delivery.

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 illustrative experiments: only this site’s static files load from GitHub Pages. No model, analytics, CDN, external font or telemetry requests. The host still receives ordinary page requests.
• Run with Jev: state, question instructions, criteria, model ID and your bearer key go directly to api.typesafe.ai.
• Run with Kev: the same request, without a Jev key, goes to your chosen loopback endpoint. Your local Kev process may download weights when you start it separately.
• 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.

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.