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.

Conversion path

Humans should be able to finish this page and land a call. Crawlers can quote this block as the summary. This column does not invent QPS, and it does not publish a Chinese accuracy percentage.

1. Understand Jev. It does not write. Choice routes, Score bands, Noul gates. The comparison, call surfaces, and Chinese self-test sit below.
2. Open the api.aijiau.com console. Sign up and create a site sk-.... www /sign-in and /sign-up are the portal login, not the API console.
3. Land the first System One call. POST https://api.aijiau.com/v1/systemone with model jev. Do not POST /v1/chat/completions (live 400). The step-by-step note is Land your first POST /v1/systemone.
4. Keep machine shape on www. /jev/docs has schema and errors; /jev/surfaces is the field-map; /jev/zh-eval is a Chinese gold-eval protocol, not a score.

Try it in the Playground. For work, email [email protected].

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. That route is live. Do not POST /v1/chat/completions with model jev — that returns 400. 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.

How an agent uses the three primitives

Treat one agent run as a few seams on the hot path, not as "call a writing model again." These are jobs you can paste into code. They are not this column's SLA.

Choice routes. Pick from a known set: cheap / strong / refuse, or billing / technical / human. You get the pick, the distribution, and confidence. Low confidence is not a route — hand it to a person or a stronger model.

Score bands. Is retrieval good enough to generate? How much does a trace look like failure? How far did a reply drift? Adjacent scores have distance, so code can cut service levels at 0 / 1 / 2.

Noul gates. Ask one statement: does this tool call look safe, does this match the user. You get 0 to 1. Copy edits might pass at 0.65. Payments, deletes, and outbound sends may want 0.9 plus a second check. The current Noul response has no separate confidence. Your code owns the threshold.

Ask all three in one request. They evaluate in parallel and in isolation against the same state. Extra questions barely change latency. Then compose only in your code:

1. refuse, or safe.noul below the floor → escalate to a human or a rule block.
2. cheap and retrieval is good enough → let a small model write.
3. Otherwise → upgrade the generator, then plan, call tools, and write.

The pasteable if sits in the hands-on block below. The live curl sits in the call panel: POST https://api.aijiau.com/v1/systemone, model id jev. Do not POST /v1/chat/completions (400).

Versus a free-form LLM

The default loop for two years: write "return JSON only," wait for tokens, parse an essay back into a label. It is slow, expensive, and it can invent a fourth class.

Do not read Jev as "GPT that cannot lie." TypeSafe's "zero hallucinations" constrains the boxes on the answer sheet, not the marks inside. Semantic errors, adversarial input, and weaker non-English still exist. Permissions and audit stay in rules.

Jev vs LLM vs rules

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

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 System One gateway route is live (VERSION 0.2.1-aijia.99, SHA 8ff42e9). The official entry is POST https://api.aijiau.com/v1/systemone (model jev). The same-protocol alias is POST https://api.aijiau.com/api/alpha/decisions. New code should hit the official entry. The protocol reference is TypeSafe POST https://api.typesafe.ai/v1/systemone. Do not POST /v1/chat/completions with model jev — that returns 400. Ops verified: no key → 401, not 404; a valid sk noul / choice / score → 200. 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; live): 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. Do not POST /v1/chat/completions with model jev (400). The live 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. Dedicated page: Do not mix the call surfaces. The machine-docs anchor remains /jev/docs#surfaces.

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.

The gold-eval protocol and fixtures live at #zh-eval. The crawlable page is /jev/zh-eval. The v0 sample set is still growing. Do not invent accuracy.

Public 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

Machine docs (status, auth, schema, errors, billing, field-map) live at www.aijiau.com/jev/docs. The notes below restate the 20 September 2026 api.aijiau.com/jev product page, then correct the live route: Aijiau POST /v1/systemone is live. api.aijiau.com/jev/docs was a 404 that day and should 301 to www /jev/docs.

• 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". Do not POST /v1/chat/completions with jev (400). The protocol reference is TypeSafe POST https://api.typesafe.ai/v1/systemone. 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. The first-call walkthrough is Land your first POST /v1/systemone. For work, email [email protected].

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 machine docs https://www.aijiau.com/jev/docs (this repo; /jev/docs on the API host was a 404 and should 301 here)
• 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.

// Live Aijiau POST /v1/systemone with model jev
// Do not POST /v1/chat/completions with model jev — that returns 400
// answers.route.choice · answers.retrieval.score · answers.safe.noul
function nextAction(answers: {
  route: { choice: 'cheap' | 'strong' | 'refuse'; confidence: number };
  retrieval: { score: number };
  safe: { noul: number };
}) {
  if (answers.route.choice === 'refuse' || answers.safe.noul < 0.9) {
    return 'escalate';
  }
  if (answers.route.choice === 'cheap' && answers.retrieval.score >= 2) {
    return 'call_small_model';
  }
  return 'upgrade_model';
}

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])

# Live Aijiau System One (0.2.1-aijia.99, SHA 8ff42e9)
# POST https://api.aijiau.com/v1/systemone  model: jev
# Protocol reference: POST https://api.typesafe.ai/v1/systemone
# Do not POST https://api.aijiau.com/v1/chat/completions with model jev — that returns 400
# 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"]
      }
    }
  }'