Jev does not write. It decides.

Jev is hot because it refuses to chat. It writes no words.

On 15 September 2026 TypeSafe AI released Jev, its first public System One model. Founder Diogo Almeida framed it as a function call: unstructured state in, typed probabilistic decisions out. The docs are blunter. You send state plus typed questions and get structured answers your code can branch on, sort, and route. No text generation. No second pass to parse a model essay.

This is AIjiaU's flagship column. The job is not to reprint a launch post. It is to help people who build agents and model routers decide which seams belong to Jev, which seams still need a model that writes, and which seams should stay as ordinary rules; how Vercel experimental_evaluate maps onto TypeSafe noul; and why Chinese / Traditional Chinese cutoffs cannot be copied from English. The "193.6× faster, 444.6× cheaper" figures on TypeSafe's homepage also have to be read with their caveats.

What it is

Jev is TypeSafe's flagship model and the first public member of the System One class. The name borrows System 1 from Daniel Kahneman's Thinking, Fast and Slow: fast, narrow, on-the-spot judgment. That is a job description, not a claim that the model thinks like a person.

Per current official docs, Jev:

• Accepts text, JSON objects, and arrays of text. Images, audio, and video are not supported yet.
• Asks three primitives: Choice (pick from a supplied set), Score (place an item on a rubric), and Noul (how true is this statement, as a value from 0 to 1).
• Evaluates every question in one request in parallel and in isolation against the same state. Extra questions barely change latency and do not rot each other's context.
• Is trained with RLCD (Reinforcement Learning for Calibrated Decisions) and sampled in parallel, not token by token.
• Is called with HTTP POST /v1/systemone or the official SDKs. Docs default the model alias to jev-latest.

The name is a pointer. TypeSafe says Jev is after economist William Stanley Jevons: after the steam engine burned coal more efficiently, total coal demand rose. Their bet is that each order-of-magnitude drop in the cost of decision intelligence unlocks orders of magnitude more places to put it.

Why this matters now

For two years teams handed classification, routing, scoring, and tool gates to general LLMs because that was the AI they already had. The loop is familiar: write a prompt, wait for tokens, parse prose back into a label. It is slow, expensive, and it can invent a fourth class that does not exist.

Agents make the mismatch worse. A single run keeps asking which model should take this request, whether a tool call is safe, whether to retry, whether the work is done. Those judgments sit on the hot path. Paying a frontier chat model to act as every if burns latency and budget before intelligence gets a chance.

Jev splits the job. A writing model still writes plans, replies, and code. A decision model answers only the questions you framed. LangChain's 17 September 2026 note uses the same shape: not an LLM replacement, a classifier and gate inside the harness, including model routing and pre-tool checks.

That mapping is exact for AIjiaU. api.aijiau.com is the LLM router and call gateway. Almost every router question is System One shaped: is this request simple or hard, should we upgrade the model, should we retry, should we block a tool.

On 20 September 2026, https://api.aijiau.com/jev was a second HTML product surface (an Express static mini-site with Playground, docs, and curl). The canonical human page is now https://www.aijiau.com/jev. Do not POST to /jev. Call POST /v1/systemone. The model id on AIjiaU is jev.

The three questions

There are only three primitives. The wrong primitive will warp a system faster than the wrong model.

Choice selects from an unordered label set: billing versus technical, which agent, which skill. The response includes the pick, the distribution, and confidence. TypeSafe documents a cardinality cap of 255. For larger sets, narrow first, then choose. Do not flatten hundreds of near-duplicate labels into one question.

Score places an item on an ordered scale: urgency, whether a retrieved passage is good enough to send onward, how much an agent trace looks like failure. Adjacent scores have distance, so code can cut service levels or review queues at thresholds.

Noul asks how true one statement is and returns a probability from 0 to 1. Unlike Choice and Score, the current Noul response does not add a separate confidence field. Your code owns the threshold. Copy edits might pass at 0.65. Payments and deletes may want 0.98 plus a second check.

Official guidance is to split large questions. Do not ask "score this startup pitch." Ask about market, feasibility, and differentiation, then weight the scores in your code. When priorities change, change a coefficient instead of rewriting a prompt.

Jev vs LLM vs rules

Three jobs get mashed into "call a model again." Keep them apart.

| Seam | Who owns it | Why | | ------------------------------------------------------------------------------------- | ---------------- | -------------------------------------------------------------------------- | | Known answer set, repeated judgment, you can act on confidence | Jev | Schema-bound output, parallel eval, probabilities you can if on | | Plans, explanations, user-visible replies, code, open extraction, multi-step argument | LLM | Jev does not generate text. An agent on Jev alone stays silent | | Permissions, quotas, idempotency, audit, hard compliance gates, known denylists | Rules / code | Confidence is not truth, and it is not authorization. Policy lives in code |

Vercel's agent-control shape matches this table: experimental_evaluate asks Jev; application code reads probabilities and confidence, then branches. Clear tickets auto-queue; department confidence below 0.6 or a selected-option probability below 0.7 goes to a human. Those floors are starting points, not this column's SLA.

If any of three conditions is missing (known answer set, repeated judgment, ability to act on confidence) that seam is probably not Jev's. If a regex, state machine, or permission table already decides it, do not give it to Jev either.

How to read "zero hallucinations"

The launch post says Jev "can't hallucinate." The homepage uses "Zero Hallucinations." Split that sentence or you will mistake a schema guarantee for a safety boundary.

TypeSafe is explicit about what is easy to verify:

• Type errors. The output shape is fixed in advance. The model cannot return an undeclared field or invent a fourth class. TypeSafe treats schema match as guaranteed and plots type hallucination at 0%. That is schema, not meaning.
• Semantic errors. It can still pick the wrong label, miss a score, misread an indirect instruction, or degrade on adversarial input. The Jev 1.13 jaggedness page lists known rough edges.
• Calibration. An 80% probability should be right about 80% of the time across many similar predictions. It does not prove this one answer is right. High confidence can auto-act. Low confidence should escalate to a person or a reasoning model.

Jev constrains the boxes on the answer sheet. It does not make the marks inside those boxes always true. Do not use it as the last policy gate. Code, permissions, and audit still sit outside.

Do not treat the homepage multiples as a converter

TypeSafe's published list price is $0.042 per million input tokens (also written as $42 per billion input tokens). Output is free, because the model does not generate long text. Vercel AI Gateway's typesafe-ai/jev cites the same vendor list price.

On speed, the launch post says end-to-end time on TypeSafe's side is about 70ms to 500ms, and that System One shaped queries can be 40× to 200× faster than the frontier models in their comparisons. The homepage 193.6× Faster, 444.6× Cheaper line is the high end of four published workflow evals. The company attached caveats. Keep them:

• Most timings were from West Coast laptops to their current deployment, not from your racks.
• The four workflows were written by TypeSafe's model-capabilities team. They say the tasks are outside the training distribution and were not built to flatter the model, but authorship is still a bias.
• The reference answer is the average of GPT-6 Astra and Claude Fable 5.1, not an independent human gold set. That leans toward those two labs and may understate Jev and models such as DeepSeek.
• The LLM baseline uses TypeSafe's System One wrapper, which forces structured decisions compatible with their API. They say that is more accurate than labels without probabilities, and also slower and more expensive.
• They cannot prove current prices are unsubsidized, and they expect prices to fall, not rise.

Use the numbers to understand the product shape. Do not use them as a converter for your own bill. Outside evidence is still thin. Engineer Malte Ubl wrote that Jev saturated a pre-existing classifier eval that had used Gemini 2.5 Flash-Lite and ran faster. That eval predates Jev, and it is still one point, not a public benchmark suite.

Jev is also still in early access. Launch day was about taking people off a waitlist.

Where it sits inside an agent

Treat an agent as a set of seams, not as one thinking model.

Give Jev the seams where the answer set is known, the judgment repeats, and you can act on confidence: intent routing, model choice, tool or skill choice, retrieval quality, retry or stop, a risk gate before execution, and a cheap check for jailbreaks or drift.

Leave the LLM the seams that write: plans, explanations, user-visible replies, code, open-ended extraction, and investigations that need multi-step argument. Jev will not write those. An agent on Jev alone stays silent.

A stable two-model shape:

1. A router (the job of api.aijiau.com) uses a decision model to read difficulty, domain, and risk, then picks a generator.
2. The generator writes the plan, calls tools, and writes the reply.
3. Before a tool actually runs, a decision model asks a narrow question: does this match the user, look dangerous, or need confirmation.
4. Code reads probabilities and confidence, then allows, reroutes, retries, or hands off to a person. Thresholds live in policy, not in a prompt.
5. Pin the model version in production. Launch-week writeups noted that the jev-latest alias resolved to jev-1.13.0. Aliases move. Reproducible seams pin an ID and recalibrate on upgrade.

The AIjiaU gateway already exposes this capability as model id jev. The official protocol entry is POST https://api.aijiau.com/v1/systemone. The same-protocol alias is POST https://api.aijiau.com/api/alpha/decisions (same body, auth, and billing; new code does not need the alias). That is what api.aijiau.com/jev said on 20 September 2026. This column does not invent QPS. Humans should stay on www. Login and Playground stay on api.aijiau.com. /jev on the API host should not remain a second homepage.

Fit and misfit

Fit: ticket and request routing; scoring retrieval hits; asking whether an agent trace looks like failure; cheap guardrails on prompts and tool calls; crushing unstructured state into features that ordinary code can use.

Misfit: replacing GPT, Claude, or Gemini for chat or writing; serving as the only agent brain; open-ended extraction (let an LLM pull fields, then ask Jev whether a claim holds); proofs, long-horizon planning, or anything that needs images or video; treating confidence as a legal or compliance finding.

Three call surfaces. Do not mix shapes.

The same decision has at least three doors. Field names differ. Prices differ.

AIjiaU HTTP (this site's users): POST https://api.aijiau.com/v1/systemone, "model": "jev", question types noul / choice / score. Auth is a site sk-.... Price is ¥0.6 / 1M input, output free. The curl sits in the call panel below.

Vercel AI SDK (via AI Gateway): experimental_evaluate, model id typesafe-ai/jev. Questions are choice / score / boolean. A boolean answer field is probability, not noul. Vercel says boolean maps to TypeSafe Noul. Gateway cites TypeSafe's $0.042 / 1M, not AIjiaU's ¥0.6. The snippet sits in the hands-on block below.

LangChain: TypeSafeClassifier in langchain-typesafe. Question objects are Choice / Score / Noul. Read a Noul as response.nouls["urgent"].noul. Experimental ModelRouterMiddleware and AutoModeMiddleware use Jev to pick a model and gate tools. You need TYPESAFE_API_KEY. The package is still a 17 September 2026 alpha.

Do not put Vercel's boolean in an AIjiaU JSON body. Do not put AIjiaU's noul inside evaluate(). That is the easiest line to copy wrong.

How to test Chinese and Traditional Chinese

TypeSafe says English is the main training language and that non-English, including Chinese, is currently weaker. They have not published Simplified, Traditional, Cantonese, or code-switched numbers. So: do not copy English thresholds onto Chinese tickets, and do not treat "it runs" as "it matches English." This is why AIjiaU made the flagship column thick — the Chinese community is loud, and official evals are almost all English.

This is a self-test protocol, not a score from this column:

1. Build a gold set before you tune. At least 50 examples; 150–200 is better. Label Simplified, Traditional, and mixed EN+CJK separately. Labels must be human Choice / Score / Noul decisions. Do not let an LLM grade itself after the fact.
2. Run the same state three ways. Write the same questions in Simplified, Taiwan Traditional, and English. Record accuracy, calibration (does high confidence actually win more often), and failure modes: understatement, rhetorical questions, idioms, mixed script, Taiwan wording (伺服器, 汇款).
3. Split thresholds by language. A Noul that auto-acts at 0.80 in English may need 0.90 in Chinese, or a human handoff. Do not assume the confidence scale translates.
4. Treat zh-TW as CJK, not as "another English." There is no TypeSafe-published Traditional-specific number. Group zh-TW / zh-HK on their own: traditional characters, Taiwan punctuation, honorifics, implied requests.
5. Add a second opinion on high-risk seams. Payments, deletes, outbound sends: escalate Chinese low-confidence cases, or translate to English and ask again, and require both to pass. Translation drops tone. It is corroboration, not a gold label.
6. Publish failures, not inflated scores. If you write in public, report set size, date, and misses. This column does not invent accuracy percentages.

ShipAny locales in this repo are zh + en only. A Traditional Chinese testing guide inside the Chinese column is not a zh-TW site.

Open clones are not Jev

After launch, a community explainer appeared at jevai.dev (OpenRouter examples; not the TypeSafe site), plus research clones such as jevlike, OpenJev, and NanoJev. They are starting points. They are not Jev. Do not assume matching calibration, the same jaggedness notes, or the same schema guarantee. A production decision layer either hits TypeSafe / AIjiaU jev, or treats the clone as another model you have to evaluate yourself.

Jev is still in early access. Confidence is not truth. The existence of clones does not lower the official model's responsibility, and it is not an excuse to say they are all the same.

How to call it on AIjiaU

The call surface below is folded from api.aijiau.com/jev and /jev/docs as read on 20 September 2026, so the two homes become one.

• Auth: a logged-in session, or a site sk-.... Do not use an upstream key.
• Public model id: jev.
• Billing: ¥0.6 / 1M input tokens, output free. That is AIjiaU's customer price, not TypeSafe's $0.042 / MTok.
• Text only. Their model card splits the budget as about 64k tokens for the whole request, and about 32k for state plus the longest question.
• English is the main training language. Chinese runs, but they say accuracy is currently lower. Measure confidence on your own corpus before you ship.
• Their docs include an answers-shape example and say those numbers illustrate the shape, not a live guarantee.

The curl and steps sit in the call panel below. Try it in the Playground. Do not keep opening api.aijiau.com/jev.

What to do now

1. Read TypeSafe's launch post and docs intro. Frame questions with their primitives, not another JSON-mode wrapper.
2. Mark the decision seams in your agent: routing, tool choice, stop/retry, pre-exec checks. Leave open writing to an LLM. If a rule can decide it, do not give it to any model.
3. POST /v1/systemone with an AIjiaU sk-... and "model": "jev". On Vercel Gateway, use experimental_evaluate and typesafe-ai/jev, and remember boolean ≠ noul.
4. Run your own Chinese / Traditional gold set before you pick cutoffs. Do not copy English thresholds.
5. Humans read www.aijiau.com/jev. Use the api.aijiau.com console when you need to pick a chat model, not a decision model. For work, email ming@aijiau.com.

Later docs and blog posts will follow the same rule: ship a full bilingual draft, or ship nothing. No empty shells.

Sources

• AIjiaU live product page https://api.aijiau.com/jev (read 20 September 2026; that URL should 301 here)
• AIjiaU live docs https://api.aijiau.com/jev/docs (same day)
• TypeSafe, Introducing System One Models & Jev, Diogo Almeida, 15 September 2026
• TypeSafe docs: Introduction, System One
• TypeSafe homepage (upstream list price and workflow multiples)
• Vercel, TypeSafe Jev and the AI SDK (experimental_evaluate, model typesafe-ai/jev, boolean maps to Noul)
• LangChain, Building a Harness with Jev, 17 September 2026
• LangChain integration langchain-typesafe (TypeSafeClassifier, 17 September 2026 alpha)
• Community explainer jevai.dev (not the TypeSafe site)

TypeSafe speed, price, and multiples are vendor figures. AIjiaU's ¥0.6 / 1M and model id jev come from its live product page. Do not mash them into one price list. If either document moves, that source wins.

import { experimental_evaluate as evaluate } from 'ai';

export async function triageTicket(ticket: {
  subject: string;
  message: string;
}) {
  const result = await evaluate({
    model: 'typesafe-ai/jev',
    state: ticket,
    questions: {
      department: {
        type: 'choice',
        instructions: 'Which team should handle this ticket?',
        criteria: {
          billing: 'Charges, invoices, and refunds',
          technical: 'Bugs, outages, and integration failures',
          account: 'Login, permissions, and profile changes',
        },
      },
      urgent: {
        type: 'boolean',
        instructions: 'Does this need attention now?',
      },
    },
  });

  return {
    queue: result.answers.department.choice,
    urgent: result.answers.urgent.probability >= 0.8,
  };
}

from langchain_typesafe import Noul, TypeSafeClassifier

classifier = TypeSafeClassifier()

response = classifier.invoke(
    state=(
        "The deploy failed twice and customers are seeing 500s. "
        "Can someone look now?"
    ),
    questions={
        "urgent": Noul(
            instructions="Does this need attention right now?"
        ),
    },
)

urgency = response.nouls["urgent"].noul

from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import (
    ModelChoice,
    ModelRouterMiddleware,
)

router = ModelRouterMiddleware(
    choices={
        "fast": ModelChoice(
            model="openai:luna",
            criteria="Direct lookups, extraction, and localized changes.",
        ),
        "powerful": ModelChoice(
            model="openai:sol",
            criteria="Architecture and high-stakes decisions.",
        ),
    },
    instructions="Choose the least costly model that can complete the task.",
)

agent = create_agent("openai:gpt-5.6-luna", middleware=[router])

# Replace sk-... with a key created under AIjiaU API keys
curl -sS -X POST https://api.aijiau.com/v1/systemone \
  -H "Authorization: Bearer sk-your-aijiau-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev",
    "state": "Customer: payment has failed for three days, order ORD-2024-1234, amount $299, needs handling now.",
    "questions": {
      "urgent": {
        "type": "noul",
        "instructions": "Is this issue urgent?"
      },
      "team": {
        "type": "choice",
        "instructions": "Which team should handle it?",
        "criteria": {
          "billing": "Payments, refunds, invoices",
          "technical": "Outages, API errors",
          "sales": "Pricing, new accounts"
        }
      },
      "frustration": {
        "type": "score",
        "instructions": "How frustrated is the customer?",
        "criteria": ["Calm", "Annoyed", "Very angry"]
      }
    }
  }'