---
title: "What Is Jev? TypeSafe's System One Model — and Why the Decision Belongs in the Table"
date: "2026-09-19"
author: "Pierre Brunelle"
tags:
  - Jev
  - TypeSafe
  - System One
  - Agents
  - Classification
  - TableModel
  - Guardrails
description: "Jev is TypeSafe AI's System One model: text state in, typed probabilities out. It does not chat. LangChain put it in the agent loop. Pixeltable puts it on the row."
url: "https://pixeltable.com/blog/jev-system-one-model"
---

# What Is Jev? TypeSafe's System One Model — and Why the Decision Belongs in the Table

**Summary:** Jev is TypeSafe AI’s System One model: unstructured text state in, typed probabilities out. It does not generate replies. LangChain put it in the agent loop. Pixeltable puts it on the row — after ASR/caption, beside the media — because a decision you cannot query later is not production. `pip install pixeltable`.

 
## What Jev Is

 
[TypeSafe AI](https://typesafe.ai/) came out of stealth on 15 September 2026 with Jev, which the company calls the first **System One model**. The name is Kahneman’s fast/slow split, not a public ML standard. The product is named after William Stanley Jevons — cheaper decisions, more decisions — which is a different claim from the [Jevons Paradox post](/blog/economics-of-incremental-ai) we already published about re-computation. Founders: Diogo Almeida, Sasha Sheng, Erik Gafni. Seed: about $40M, DCVC-led, per [Business Wire](https://www.businesswire.com/news/home/20260915525333/en/TypeSafe-AI-Emerges-From-Stealth-With-%2440M-in-Funding-With-New-Model-for-Composable-AI).

 
Jev is not a chatbot. You send one `state` (a string, a JSON object, or an array of text) and a map of typed **questions**. You get one typed answer per question, with probabilities. Questions in a request share state, run in parallel, and do not condition on each other. Current alias: `jev-latest`, which docs pin to `jev-1.13.0`. HTTP: `POST https://api.typesafe.ai/v1/systemone`.

 
Three primitives, from [TypeSafe’s docs](https://docs.typesafe.ai/primitives.md):

 
| Type | Ask | Returns |
| --- | --- | --- |
| Noul | Is this statement true? | noul in [0, 1]. No separate confidence field. |
| Choice | Pick from options you define (up to 255) | choice, probabilities, confidence |
| Score | Place the state on ordered levels you write (2–10) | score, legend, probabilities, confidence |

 
A Noul is P(yes). A Choice distribution sums to 1. A Score can land between levels; the docs say not to interpolate it back into a fake magnitude. Training term: **RLCD** — Reinforcement Learning for Calibrated Decisions. Calibration is group-level. It does not make a single call correct.

 
Native request, shortened from the docs — not LangChain’s wrapper:

 
```json
{
 "model": "jev-latest",
 "state": "Hi, I've been trying to connect Stripe for 3 days. I'm losing sales. Help ASAP.",
 "questions": {
 "is_urgent": {
 "type": "noul",
 "instructions": "The message conveys urgency or time-sensitivity"
 }
 }
}
```

 
Answer shape: `{ "is_urgent": { "type": "noul", "noul": 0.999 } }`. Your code owns the threshold. Jev does not send the Slack page.

 
## Why It Took Over the Timeline

 
Four days. Launch blog 15 Sep. [Hacker News](https://news.ycombinator.com/item?id=49717558) ran the launch post to roughly 1,900 points. Almeida’s [launch tweet](https://x.com/CompleteSkeptic/status/2099925682726002904) was the credential + speed/cost blast. Then distribution: [Vercel AI Gateway](https://vercel.com/changelog/typesafe-ai-jev-now-available-on-ai-gateway) listed `typesafe-ai/jev` (waitlist bypass). Cloudflare listed `typesafe/jev`. LangChain shipped `langchain-typesafe` on 17 Sep.

 
Demos people actually clicked:

 

 - [Nathan Flurry](https://x.com/NathanFlurry/status/2100036101809619314) — the accurate social frame: a really smart switch statement. Does not replace GPT or Claude. Classifies, routes, scores, guardrails, labels rows.

 - [Guillermo Rauch](https://x.com/rauchg/status/2100307962262872105) — Vercel’s `fx` safety reviewer: up to 18× faster at p95 than GPT-5.6 Luna on *their* classifier, plus a claim of higher accuracy. That is Vercel’s measurement, not TypeSafe’s 193× homepage chart.

 - [Ryan Vogel](https://x.com/ryanvogel/status/2100042788851101842) — inbox classification at batch scale (later told as ~1,700 emails / 18¢ / ~200 ms on Greg Isenberg’s [YouTube](https://www.youtube.com/watch?v=4mTLpuQpB80)). Accuracy unpublished. Vogel also said not to use Jev as a trading brain.

 - [Kyle Jeong / Browserbase](https://x.com/kylejeong/status/2100622054945095934) — Stagehand + Jev: accessibility tree as state, actions as questions.

 - [Gregor Žunič / Browser Use](https://x.com/gregpr07/status/2100411066966749359) — “Jev Ultrafast” Google Flights clip. HN later noted the timer starts after first page observation.

 - [Jarrod Watts](https://x.com/jarrodwatts/status/2100356151468585346) — live trading bot on a ~300 ms loop. Demo exists. Skill at trading is a different claim.

 

 
Explainers piled on: Matthew Berman’s [We need to talk about Jev](https://www.youtube.com/watch?v=2z-7pIj57f8) (repeats vendor 200× / 400× and the zero-hallucination slogan); Syntax; AICodeKing’s own playground tests. Press: [Forbes](https://www.forbes.com/sites/the-prompt/2026/09/15/this-200-million-startup-wants-to-fix-ais-overconfidence-problem/) on valuation and overconfidence; [TechCrunch](https://techcrunch.com/2026/09/18/a-new-kind-of-ai-model-from-a-chatgpt-inventor-is-thrilling-developers/) 18 Sep; [The Register](https://www.theregister.com/ai-and-ml/2026/09/16/typesafe-ai-debuts-model-for-machines-that-plays-doom/5296711) on the Doom demo. HN’s useful fight: the product is real, the presentation overclaims. Doom is structured game state as text, not pixels. TypeSafe says so.

 
## What the Numbers Actually Are

 
Print list price. Attribute multiples. Do not average them into a Pixeltable bench.

 
| Claim | Number | Who |
| --- | --- | --- |
| List price | $0.042 / million input tokens; output free | TypeSafe models page |
| End-to-end latency | 70–500 ms (West Coast laptops, where the service is hosted) | TypeSafe launch post |
| Homepage workflow evals | 193.6× faster, 444.6× cheaper | TypeSafe, vs average of GPT-6 Astra + Claude Fable 5.1, “higher end of real world gains” |
| LangChain restatement | Up to 200× faster / 400× cheaper on classification | LangChain attributing TypeSafe, not measuring |
| Vercel fx safety reviewer | Up to 18× faster p95 than GPT-5.6 Luna | Rauch / Vercel, their classifier |
| Context | 64k tokens/request; 32k for state + longest question; text only | TypeSafe docs |

 
TypeSafe also wrote: “We can’t prove it isn’t subsidized.” Treat the homepage chart as a vendor workflow eval, not a public leaderboard. Third-party writeups (Every, DEV, unofficial clients) show tens-to-hundreds of milliseconds and sub-cent batches on classification-shaped jobs. Sample sizes are small. None of those numbers are Pixeltable measurements.

 
**Type-safety is not truth.** TypeSafe: matching the schema is “mathematically impossible” to violate, and the 0% type-error rate is “not empirical.” The Register: structured output does not preclude being incorrect. Jaggedness page: Jev is not a calculator, not a text generator, weak at math and multi-hop, and adversarial state can steer answers. English is best. Confidence on Choice/Score is peakedness of the distribution, not P(correct). Store the distribution. Retune the threshold later.

 
## LangChain Put It in the Loop

 
[Building a Harness with Jev](https://www.langchain.com/blog/building-a-harness-with-jev) (Sydney Runkle, Hunter Lovell, 17 Sep 2026) is the harness-loop version. Agents still pay an LLM for every control decision. Jev is a classifier in that loop: `TypeSafeClassifier` for state + questions; experimental `ModelRouterMiddleware` to pick a chat model once per run; experimental `AutoModeMiddleware` to Noul listed tool calls and refuse them before execution. Docs say Auto Mode does not request human approval. Pair it with HITL if you want a person. Package: `langchain-typesafe` 0.0.1a2. Env: `TYPESAFE_API_KEY`.

 
Keep that when the loop is the product. Pixeltable is not a LangGraph replacement. The [Pixeltable vs LangChain](/compare/pixeltable-vs-langchain) split still holds: LangChain orchestrates the agent; the table stores media, transcripts, embeddings, and now the judgment. See also the [agent harness](/blog/pixeltable-agent-harness) argument: memory, evals, and tool lineage are columns, not a hidden JSON file.

 
## The Decision Belongs on the Row

 
Jev’s contract is row in, typed scores out. That is closer to a computed column than to a chat completion. Generators write (Whisper, Gemini, CLIP). Jev scores. Code owns the cutoff. There is no first-party `pixeltable.functions.jev`. Wrap the official [`typesafe-sdk`](https://github.com/typesafe-ai/typesafe-sdk-python). This is not a partnership announcement.

 
Jev cannot see the recording. Official: text only. Pixeltable still owns the bytes. Transcribe first — the same pattern as [CallSense](/blog/callsense-sales-call-intelligence) — then pass the transcript as `state`. Store the full answers object, not argmax, so you can change “page on-call if urgent > 0.9” without calling Jev again.

 
```python
import pixeltable as pxt
from pixeltable.functions import whisper
from pixeltable.serving import FastAPIRouter
from typesafe_sdk import Choice, Noul, Score, TypeSafeClient

TableModel = pxt.model_base()

@pxt.udf
def jev_ticket(state: str) -> dict:
 with TypeSafeClient() as client:
 response = client.system_one(
 state=state,
 questions={
 'urgent': Noul(
 instructions='Does this call convey urgency or time pressure?',
 ),
 'route': Choice(
 instructions='Which team should handle this call?',
 criteria={
 'billing': 'Payment, invoice, or refund',
 'technical': 'Bugs, outages, or integrations',
 'sales': 'Pricing, upgrades, or new accounts',
 },
 ),
 'frustration': Score(
 instructions='How frustrated is the customer?',
 criteria=['Calm', 'Frustrated', 'Very angry'],
 ),
 },
 )
 return {
 'urgent': response.nouls['urgent'].noul,
 'route': response.choices['route'].choice,
 'route_probabilities': dict(response.choices['route'].probabilities),
 'route_confidence': response.choices['route'].confidence,
 'frustration': response.scores['frustration'].score,
 'frustration_probabilities': dict(response.scores['frustration'].probabilities),
 'frustration_confidence': response.scores['frustration'].confidence,
 'model': response.model,
 }

class Calls(TableModel, name='calls'):
 call_id: pxt.String
 audio: pxt.Audio
 transcript = whisper.transcribe(audio, model='base')
 judgments = jev_ticket(transcript)

api = FastAPIRouter(name='jev_calls')
api.add_insert_route(Calls, path='/calls', inputs=[Calls.audio, Calls.call_id])
```

 
Insert the MP3. Whisper fills `transcript`. Jev fills `judgments`. Query later: urgent calls, billing vs technical, low-confidence rows for review. The UDF is ordinary Python — same idea as [Python UDFs](/blog/python-udfs-pixeltable). `TypeSafeClient` reads `TYPESAFE_API_KEY`. Same file locally and on Cloud:

 
```bash
pip install pixeltable typesafe-sdk
pxt init
pxt schema update app.py jev_calls
pxt service update app.py jev_calls
pxt db update pxt://org:db
pxt schema update app.py pxt://org:db
pxt service update app.py pxt://org:db
```

 
Cloud needs `PIXELTABLE_API_KEY` and a database named `pxt://org:db`. Order is required: `pxt db update` → `pxt schema update` → `pxt service update`. `pxt service run` is local only. Put `TYPESAFE_API_KEY` in the environment the service actually runs in. We did not measure Pixeltable+Jev latency or cost. Do not quote the TypeSafe homepage multiples as ours.

 
## Where It Fits (And Where It Does Not)

 

 - **Judgment columns next to media.** After ASR, caption, or OCR, fan out Noul / Choice / Score in one call. Extra questions mostly cost tokens, not extra RTT — TypeSafe’s claim; we are not re-running their cookbook.

 - **Model routing for a row.** A cheap Choice that picks which generator a row should call only pays if routing is cheaper than always using the expensive model. Batch tables are the natural fit.

 - **Tool-risk before a write.** Same pattern as LangChain Auto Mode, stored on the row: Noul the proposed drop/publish/external call. Block vs HITL vs allow is application code. Jaggedness: this is not prompt-injection proof.

 - **RAG passage gates.** Noul per retrieved chunk; keep the probability with the chunk. Complements [DocuVision](/blog/docuvision-pdf-chart-qa) and [data-centric RAG](/blog/production-rag-data-centric) — it does not replace the index.

 - **Confidence-gated review.** Low-confidence Choice/Score rows go to a human table. Then you can measure calibration against labels over time. That is more defensible than repeating 193.6×.

 

 
Not a trading brain. Not a vision model. Not a chatbot. Not a drop-in LLM. Forcing generation by chaining Choices is exactly what TypeSafe says will be slow and bad. The [AI automation workflow](/blog/ai-automation-workflow) is still the table: insert a row, computed columns run. Jev is one of those columns when the job is a decision.

 
## Sources

 

 - [Introducing System One Models and Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev)

 - [TypeSafe docs](https://docs.typesafe.ai/introduction.md) · [models and price](https://docs.typesafe.ai/models.md) · [jaggedness](https://docs.typesafe.ai/model-jaggedness/jev-1.13.md) · [workflow evals](https://evals.typesafe.ai/)

 - [LangChain: Building a Harness with Jev](https://www.langchain.com/blog/building-a-harness-with-jev)

 - [Vercel AI Gateway changelog](https://vercel.com/changelog/typesafe-ai-jev-now-available-on-ai-gateway)

 - [Hacker News launch thread](https://news.ycombinator.com/item?id=49717558)

 - [The Register](https://www.theregister.com/ai-and-ml/2026/09/16/typesafe-ai-debuts-model-for-machines-that-plays-doom/5296711) · [TechCrunch](https://techcrunch.com/2026/09/18/a-new-kind-of-ai-model-from-a-chatgpt-inventor-is-thrilling-developers/)

 

 
## People Also Ask

 
**What is Jev?** TypeSafe AI’s System One model: unstructured text state in, typed probabilities out. It does not generate replies. LangChain put it in the agent loop. Pixeltable puts it on the row — after ASR/caption, beside the media.

 
**Jev vs an LLM?** LLMs generate tokens. Jev returns Noul / Choice / Score. Use an LLM to write. Use Jev to decide. Thresholds live in your code.

 
**Does Jev hallucinate?** It cannot emit a value outside the schema you defined. It can still pick the wrong allowed answer. Confidence is not correctness.

 
**Can Jev see images or video?** No. Text only. Caption or transcribe in Pixeltable, then call Jev on that text.

 
**Jev vs LangChain Auto Mode?** Auto Mode gates tool calls in the loop. Pixeltable stores the judgment as a column you can query and version. Keep both if you run LangChain agents on top of a table.

 
**How does Pixeltable use Jev?** A `@pxt.udf` around `typesafe-sdk`. Not a built-in provider. `pip install pixeltable`.

 
## Keep the Generator. Add the Judgment.

 
The internet is right that classification was an expensive LLM habit. It is wrong if it treats Jev as a new ChatGPT, a vision model, or a Pixeltable benchmark. Declare the schema. Transcribe the media. Score the text. Query the probabilities. That is the production shape.

 

 - **[Pixeltable on GitHub](https://github.com/pixeltable/pixeltable)**: `pip install pixeltable`

 - **[Get started](/get-started.md)**

 - **[How it works](/how-it-works)**

 - **[Why Pixeltable is the agent harness](/blog/pixeltable-agent-harness)**

 - **[Pixeltable vs LangChain](/compare/pixeltable-vs-langchain)**

 - **[AI automation workflow](/blog/ai-automation-workflow)**

 - **[Pixeltable documentation](https://docs.pixeltable.com)**