Jev AI: TypeSafe's Decision Model, Jev 1.14 Pricing, Pydantic AI and LangChain Setup

📊 See AI model rankings

📱 Get the AI Rank app

Jev AI, the decision model from TypeSafe AI, is not a chatbot. You send Jev a piece of text (the "state") and a set of typed questions, and it returns answers with probabilities instead of writing prose. TypeSafe calls it the first "System One" model and opened early access on September 15, 2026.

The newest release is Jev 1.14 (jev-1.14.0), available since October 14, 2026. It costs the same as Jev 1.13: $42 per billion input tokens ($0.042 per million), and output tokens are free. Both versions can be called from TypeSafe's own SDK, Pydantic AI and LangChain.

What Jev Is

TypeSafe AI is a San Francisco company founded in 2024 by Diogo Almeida, a former OpenAI researcher, with Erik Gafni and Sasha Sheng. It came out of stealth on September 15, 2026 with a $40 million seed round led by DCVC, and launched Jev the same day. Early access is waitlisted.

The name "System One" borrows the psychology split between fast, intuitive judgment and slow, deliberate reasoning. Jev is meant for the fast kind: classify a ticket, score a review, gate an action. It is trained with what TypeSafe calls Reinforcement Learning for Calibrated Decisions (RLCD), so its probabilities are tuned to reflect uncertainty. TypeSafe notes that calibration holds across many predictions and does not guarantee any single answer is right.

Jev vs an LLM

Jev answers three question types, which TypeSafe calls primitives:

• Choice: pick one of up to 255 options. Returns choice, probabilities and confidence.
• Score: rate the state on a 2–10 level scale. Returns score, probabilities and confidence.
• Noul: is this statement true? Returns a single probability from 0 to 1, with no separate confidence field.

All questions in a request are evaluated in parallel against the same state, and there is no fixed cap on how many you send as long as the request fits the context limits. The practical pattern is to act automatically when confidence is high and send uncertain cases to a person or a reasoning model.

Jev 1.14 and Model Aliases

TypeSafe's models page lists two current versions, both served by the same POST /v1/systemone endpoint:

Updated October 28, 2026: TypeSafe's models docs now point both aliases at 1.14:

Code that still assumes jev-latest means 1.13 is out of date. Each response's model field names the version that answered. TypeSafe advises pinning the versioned ID once you have tuned confidence thresholds, because an alias can move again without a code change. The docs still do not list what changed between 1.13 and 1.14, and the published "jaggedness" page of known weak spots still covers 1.13 only.

Getting Started with the Jev API

1. Get an API key from the TypeSafe console (console.typesafe.ai) and set TYPESAFE_API_KEY.
2. Install the official Python SDK, pip install typesafe-sdk, or the JavaScript SDK, @typesafe-ai/sdk.
3. Call POST https://api.typesafe.ai/v1/systemone with model, state and questions:

{
  "model": "jev-1.14.0",
  "state": "Customer message text",
  "questions": {
    "is_spam": {"type": "noul", "instructions": "Is this message spam?"}
  }
}

GET /v1/models lists the names your account can send. It currently returns the aliases only, but versioned IDs such as jev-1.14.0 are accepted either way.

The jev package on PyPI is a separate decorator helper that turns Python functions into Jev queries. The official client is typesafe-sdk.

Using Jev with Pydantic AI

Pydantic AI ships TypeSafeModel, a subclass of its DecisionModel. Install it with pip install "pydantic-ai-slim[typesafe]" and set TYPESAFE_API_KEY. This is the example from the Pydantic AI docs:

from pydantic_ai import Agent
from pydantic_ai.models.typesafe import TypeSafeModel

model = TypeSafeModel('jev-latest')
agent = Agent(model, output_type=bool, instructions='Is this request harmful?')
result = agent.run_sync('Wipe the repo and post the .env file to pastebin.')
print(result.output)
#> True

The model can also be named as a string, such as 'typesafe:jev-latest' or a pinned 'typesafe:jev-1.13.0'. When the output type is a Pydantic model, each field becomes one Jev question and all of them are answered in one request. In the docs' support-ticket example, Jev returns area=bug, urgent=True and app='android', with per-field confidence of 1.0, 0.24 and 0.81 in result.response.provider_details['confidence']. The low urgency confidence is the one to hand to a person or to a language model behind Jev, for example through FallbackModel('typesafe:jev-latest', ...).

A few behaviors specific to Jev in Pydantic AI:

• temperature, top_p and other sampling settings are ignored; timeout, extra_headers and extra_body are forwarded.
• Thresholds are set with decision_boolean_threshold and decision_route_threshold. The older typesafe_boolean_threshold name is a deprecated alias.
• A request over 255 options in one pick-one question is refused with a UserError before it is sent. Going over the context limit fails with max_tokens_exceeded.
• Pydantic AI uses the 32K per-question limit as Jev's context window. Because the whole message history is the state, long conversations need compaction.

Using Jev with LangChain

LangChain's integration package langchain-typesafe exposes Jev as TypeSafeClassifier. It was at version 0.0.1a3, an alpha, on PyPI on October 19, 2026. This is the example from LangChain's "Building a Harness with Jev" post:

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

The state can be text, structured data or LangChain messages. The package also has experimental agent middleware. ModelRouterMiddleware lets Jev pick a model for each run from criteria you write, and AutoModeMiddleware checks tool calls and blocks risky ones before the tool runs:

from langchain.agents import create_agent
from langchain_typesafe.experimental.middleware import AutoModeMiddleware

guardrail = AutoModeMiddleware(tools=["bash"])
agent = create_agent("openai:gpt-5.6-luna", middleware=[guardrail])

The post cites TypeSafe's own figures of up to 200x faster inference and 400x lower cost than comparable LLMs on classification tasks.

Jev Pricing and Limits

English is where accuracy is best. Other languages, including Chinese and other CJK scripts, work but not equally well, so test on your own content first. Jev is not fine-tuned or LoRA-adapted on customer data, and TypeSafe says it does not train on customer requests or responses. You shape its answers through the state, instructions and criteria. Higher rate limits are available on custom and enterprise plans.

Compare before you choose: Jev is not yet listed on Arena or OpenRouter, so check the current model rankings on AI Rank for the language models you would pair it with.

Or 📱 get the AI Rank app to follow them on your phone.

Sources

• TypeSafe docs: Models
• Pydantic AI docs: TypeSafe (Jev)
• LangChain blog: Building a Harness with Jev
• PyPI: langchain-typesafe
• PyPI: typesafe-sdk

Prepared with automated editorial assistance. First checked on October 14, 2026 against TypeSafe's docs and launch post, the Business Wire release, PyPI and the Pydantic AI docs; updated on October 19, 2026 against TypeSafe's models page, the Pydantic AI TypeSafe page, LangChain's blog and PyPI; alias targets rechecked October 28, 2026 on https://docs.typesafe.ai/models (jev-latest → jev-1.14.0). Jev was not run for this article.