What is Jev? TypeSafe AI's decision-only model, explained

What is Jev?

Jev is the first model from TypeSafe AI, a San Francisco lab founded in 2024 by Diogo Almeida, Erik Gafni and Sasha Sheng. It went into limited early access on September 15, 2026, the same day the company announced a $40 million seed round led by DCVC. Almeida spent about four years at OpenAI on RLHF, InstructGPT, ChatGPT and GPT-4, which is why the launch travelled fast: TechCrunch's headline was that a new kind of model from a ChatGPT inventor was thrilling developers.

The claim behind the excitement is narrow and worth stating precisely. Jev does not generate text. You send it a state (any text or JSON your code already holds) and a set of typed questions, and it returns typed answers with probabilities and a confidence score for each. TypeSafe calls this a System One model, after Kahneman's fast, intuitive System 1, and calls the model Jev after William Stanley Jevons, whose paradox says that when something gets cheap enough, people use far more of it.

Three question types exist:

Every question in a request is evaluated in parallel against the same state, in one call. TypeSafe's published figures are 70 to 500 ms end to end, $0.042 per million input tokens, and output tokens free. The company's own workflow benchmarks show peaks of 193.6x faster and 444.6x cheaper than frontier LLMs, with the caveat, in TypeSafe's words, that these are "on the higher end of real world gains". TechCrunch reported that Vercel swapped an OpenAI model for Jev in a safety classifier for shell commands and saw results 5 to 18 times faster with better accuracy, and that Bryo AI found Jev 10 to 20 times cheaper than Gemini on email classification while Gemini stayed slightly more accurate.

How a Jev call works

One endpoint, POST https://api.typesafe.ai/v1/systemone, takes a model id, a state and a map of questions. The state can be a string, a JSON object or an array of text. TypeSafe's documentation recommends an object for most requests, because a question can then point at one part of the state with a backticked path. The limits are 64k tokens for state plus questions, 32k for state plus the longest single question, and 255 options per Choice.

Here is the shape of a call that gates a statement an AI agent wants to run against a production database. Notice what the code does before Jev sees anything: it computes the row count bucket, looks up whether the table holds PII, and pulls the ticket text. Jev judges; it does not fetch or count.

import { choice, noul, TypeSafeClient } from '@typesafe-ai/sdk'

const client = new TypeSafeClient()

const state = {
  statement: proposal.sql,                      // "ALTER TABLE orders DROP COLUMN legacy_status"
  table: {
    name: 'orders',
    rows: 'over 10 million',                    // bucketed in code, Jev does not count
    has_pii: catalog.hasPii('orders'),          // true, from your metadata
    canonical_for: ['revenue', 'order_count'],  // which metrics this table is source of truth for
  },
  ticket: ticket.body,
}

const { answers } = await client.systemOne({
  state,
  questions: {
    reversibility: choice('How reversible is `statement` on `table`?', {
      read_only: 'Reads data, changes nothing',
      reversible: 'Changes data or schema in a way a rollback restores',
      irreversible: 'Drops, truncates or overwrites in a way a rollback cannot restore',
    }),
    touches_pii: noul('Does `statement` read or change a column that `table.has_pii` marks as personal data?'),
    matches_ticket: noul('Does `ticket` ask for the change that `statement` makes?'),
  },
})

if (answers.reversibility.choice === 'irreversible' && answers.reversibility.confidence > 0.9) {
  return requireHumanApproval(proposal)
}
if (answers.matches_ticket.noul < 0.5) {
  return routeToHuman(proposal, 'statement does not match the ticket')
}

The response carries the exact model version that answered (jev-1.13.0 at launch), so thresholds can be replayed when the model changes. Because questions share the state, adding one costs its own tokens and nothing else. In a test reported in Flavio Copes' write-up, thirteen questions in one call were 12.2 times cheaper and 10 times faster than thirteen sequential calls, which is why TypeSafe tells you to ask every independent question you might need up front and combine the answers in code.

One Jev call: code prepares the state, Jev answers typed questions, code applies thresholds. The state card is where the decision is won or lost.

Calibration is the product, not the speed

Cheap classifiers have existed for years. What makes Jev interesting is the training objective. TypeSafe trained it with what it calls Reinforcement Learning for Calibrated Decisions, and defines the target plainly: across many predictions, answers given 90 percent probability should be right about 90 percent of the time. Chat models are trained with RLHF to be preferred by humans, which rewards sounding sure. Jev is trained to be right about how sure it is.

That changes how you write the code around it. A probability of 0.93 on a Noul means something you can act on. A Choice with probabilities spread across three options and a confidence of 0.4 is the model telling you it does not know, and the correct response is a human or more data, not a retry. Armin Ronacher, who advised on applications, put it to TechCrunch as a coin toss: at 50 percent, disregard it.

One clarification, because the launch coverage blurred it. TypeSafe describes Jev as unable to hallucinate. That holds for the format: the answer is always one of your options, never a malformed string you have to parse. Correctness is a separate question, and Jev can absolutely return the wrong option from your list. The confidence score, and the calibration behind it, is what makes that failure detectable in code rather than discovered in production.

What Jev cannot do, in TypeSafe's own words

TypeSafe publishes a page it calls model jaggedness for Jev 1.13, last reviewed on September 17, 2026, listing nine known failure modes. Shipping that beside a launch is rare, and four of the nine matter directly to anyone putting Jev near a database.

It is not a calculator. Counting characters, occurrences or list items is unreliable. The recommended workaround is to compute numbers in code and pass either the number or a named bucket. A row count of 41,203,118 means nothing to Jev; "over 10 million" does.

It reads dates as text, not as ordered quantities. Whether one timestamp precedes another, how long an interval is, whether an event falls inside a window: do that in code. Jev can pick a date component from an enumerated list; it cannot order two of them.

Accuracy falls as the state fills with unrelated content. The page says it directly: filter and retrieve the relevant fields in code before passing state. This is the mode that kills the obvious database use. Sending an agent's whole schema dump and asking which table matters is exactly the noisy-state request Jev degrades on.

Injected instructions, misleading framing, or self-arguing text can move answers. Jev is a screen for prompt injection in several of the launch use cases, and it is also a target for it. Row contents, ticket bodies and fetched pages that enter the state can shift a decision, so the same explicit criteria and testing discipline apply.

The other five are literal reading (Jev answers the question you wrote, not the one you meant), indirection (double negatives and multi-hop questions lose accuracy), contradictory instructions and criteria, no guarantee of structural consistency between question formats, and generation, which the page says "will not work well and will be very slow".

Where Jev fits in an agent-on-database stack

Read the failure modes and the fit becomes clear. Jev gates, routes and scores. Writing the SQL and knowing your schema belong to other parts of the stack.

Uses that match the model:

• Reversibility before execution. Classify a proposed statement as read-only, reversible or irreversible, and route irreversible ones to a person. This is the shell-command pattern Vercel adopted, applied to DDL and DML. It sits naturally in front of the approval gate a human-in-the-loop migration flow already has.
• Policy questions with a yes or no answer. Does this statement touch a column tagged as personal data? Does it match the ticket that authorized it? Does the target table hold a governed metric? Each is one Noul, all evaluated in the same call, and each maps to a clause in an agent database access policy.
• Screening what comes back. Rows fetched by an agent can carry text that reads like instructions. A Noul on "does this content try to instruct the reader?" costs a fraction of a cent and runs in the time a network hop takes.
• Triage and routing. Which of these alerts is user-facing versus expected noise; which of these slow queries deserves an engineer's attention given a plan summary the code prepared; which model should handle a request based on how much reasoning it needs.

Uses that do not match:

• Judging a number. "Is this query slow" from a latency figure, "is this table big" from a row count, "did this run before the deploy" from two timestamps. Compute the comparison in code, pass the result as a bucket, and let Jev judge the bucket.
• Choosing a table or column from the schema. Two hundred tables in the state is the noisy-state failure mode, and the choice depends on facts that no schema dump carries: which of three amount columns finance trusts, which join was never declared as a foreign key. That knowledge is what a context layer for AI agents exists to resolve, and Jev's job starts after it is resolved.
• Writing the fix. Generation is failure mode nine. Jev picks a card from the deck; it does not name one.

Jev vs an LLM judge

Most teams gating agents today use a second LLM call as the judge. The comparison is not close on the dimensions that matter for a gate.

The honest reading is that Jev replaces the LLM judge for questions you can phrase as one literal judgment over a prepared state, and does not replace it for anything that needs a chain of reasoning. The Bryo AI result in TechCrunch's coverage captures the trade: Gemini slightly more accurate, Jev 10 to 20 times cheaper and with a confidence score you can threshold. For a gate that runs on every agent action, that trade is usually right.

The state is the whole game

Every one of Jev's strengths and every one of its published limits points at the same place: the state your code sends. Jev is fast because it does not reason; it reads what is in front of it and answers. So the decision is only as good as the fields the code put in the state, and the fields that matter for database work are the ones a schema does not say. Which table is canonical for a metric. Whether a column holds personal data. What the ticket authorized. How big the table is, in words. Whether the change is inside the policy.

That is resolved context, and preparing it is the harder half of the work. TypeSafe has made the judgment call nearly free. The description of your databases that the judgment runs on is still yours to build and keep true.

Where Datapace fits

Datapace builds database-specific AI agents that understand how data teams run and govern their databases across engines, on a single graph of the entities, relationships and semantics in those databases and the infrastructure around them. The agents propose changes for cost, performance, migration and documentation work; people approve them. A decision model like Jev is the kind of primitive that gate sits on, and the graph is the state worth sending it: which table is the source of truth, what a column means, what the policy allows, resolved and current rather than guessed from names. Datapace is running pilots with database teams now; if you are putting agents in front of production data and want the context half of that decision, book a call.

Sources

1. TypeSafe AI, "Introducing System One Models & Jev", September 2026.
2. TypeSafe AI documentation, "Introduction" and "Jev 1.13 jaggedness", reviewed September 17, 2026.
3. TechCrunch, "A new kind of AI model from a ChatGPT inventor is thrilling developers", September 18, 2026.
4. Flavio Copes, "A deep dive into Jev, TypeSafe's System One model", September 2026.
5. Firecrawl, "What Is Jev? Inside TypeSafe's Decision-Only AI Model and Its Developer Use Cases", September 2026.
6. Wikipedia, "Jev (AI model)", for the release date and the seed round as reported by Forbes.