TypeSafe's Jev proved that a model can answer software's questions with calibrated probabilities instead of text. Today we're releasing Lev, an open System One model that speaks the same API and runs on a single GPU you control.

What is classification?

Classification is picking one label from a fixed set. Is this email spam, which team owns this ticket, is this comment toxic?

Most of the AI inside a real product has this shape: routing, moderation, intent detection, triage, and grading, thousands of times a day.

How it used to work

BERT made classifiers understand language, but froze the label set at training time. Zero-shot NLI unfroze it, at the cost of one forward pass per label.

Then LLMs arrived

LLMs made classification feel solved: describe the labels, ask for JSON, and a frontier model gets it right most of the time. But they generate token by token, can return labels outside your list, and are overconfident about how sure they are.

So you add validation, retries, and a human review queue. Fine for a chatbot, a deal-breaker for an if statement.

What is Jev?

Jev is the first System One Model from TypeSafe AI, launched on September 15, 2026. You give it some context and a set of questions (yes/no, pick one, or rate on a scale), and it returns a probability for every option instead of text.

• No generated text. All answers come from one parallel pass. Output tokens are free and input costs $0.042 per million tokens.
• Type-safe. The answer space is the option set you send, so an out-of-set label is impossible.
• Calibrated. Gate on the probability: act above 0.9, send the rest to a person.
• Fast. 70 to 500 ms end to end, where a reasoning LLM takes seconds.

RLCD: the training behind it

RLHF shapes probabilities around what raters liked, which makes models overconfident. Reinforcement Learning for Calibrated Decisions (RLCD) rewards honest probabilities instead: when Jev says 0.8, it should be right 80% of the time.

TypeSafe hasn't published how RLCD works. But calibration is measurable, and our benchmark below measures it.

Open source Jev: Lev

Lev is our open System One model. It answers every typed question in one forward pass, reading answers from logits it already computed, and generates no tokens.

Lev is only a 4B model which can easily run on your Macbook or small GPU while being slightly less accurate than Jev. No open model at 4B or smaller scores higher on S1Bench.

Quickstart

Needs Python 3.12+ and, for real-time use, a CUDA GPU. It also runs on CPU, but much slower: seconds per call instead of milliseconds.

The first load downloads the base model (about 8 GB) and the adapter (about 200 MB), with nothing to configure.

pip install "lev[serve] @ git+https://github.com/InterfazeAI/lev#subdirectory=packages/lev"

Questions are noul (yes/no), choice (pick one), or score (2 to 10 levels). Run Lev in Python, or start lev serve and call /v1/systemone over HTTP.

import lev

model = lev.load("interfaze-ai/lev")

state = "Hi, I was charged twice for my order #4471 and I want a refund."
questions = {
    "intent": {
        "type": "choice",
        "instructions": "What does the customer want?",
        "criteria": {
            "refund": "wants money back",
            "cancel": "wants to cancel an order",
            "track": "wants to know where an order is",
            "other": "anything else",
        },
    },
    "urgent": {"type": "noul", "instructions": "Does this need a human within the hour?"},
    "frustration": {
        "type": "score",
        "instructions": "How frustrated is the customer?",
        "criteria": ["calm", "mildly annoyed", "annoyed", "angry"],
    },
}

result = model.system_one(state, questions)
print(result.answers["intent"].choice)  # refund
print(result.answers["intent"].probabilities)
# {'refund': 0.84, 'cancel': 0.094, 'track': 0.012, 'other': 0.054}
print(result.answers["urgent"].noul)  # 0.43
print(result.answers["frustration"].score)  # 1.57, between "mildly annoyed" and "annoyed"
print(result.usage.output_tokens)  # 0

These are real outputs from the released checkpoint.

How Lev works

• Label-token readout. Each option gets a one-token code, and the answer is read from the logits over those codes.
• Candidate-path head. When options run out of codes, a small head matches the state to each option's text, so there's no option limit.
• Calibration. Fitted temperatures turn raw scores into honest probabilities.

Other open re-creations pick one readout and cap the option count. Lev routes between both.

The optimizations that mattered

• 169 → 69 ms: one batched forward pass instead of forking the cache per question.
• +51 points on 60-intent routing: label codes instead of the head for large option sets.
• banking77 0.818 → 0.980: skipping codes that split into two tokens.
• +5.7 points before training: using the base model's own chat format.

The evidence for each is in the decision log.

Classification in Interfaze

Text classification in Interfaze runs on a similar system to Lev: the model reads the answer from the set of labels you define. The difference is that Interfaze is still token based, so it's a hybrid.

Tokens cost a little speed, but they let one request classify a document while also reading, searching, and extracting from it. Define your labels as an enum in the schema, and the label comes back as a typed field.

import { Interfaze, responseFormat } from "interfaze";
import { z } from "zod";

const interfaze = new Interfaze({ apiKey: process.env.INTERFAZE_API_KEY });

const ticketSchema = z.object({
  intent: z.enum(["refund", "cancel", "track", "other"]),
  urgent: z.boolean().describe("Does this need a human within the hour?"),
});

const response = await interfaze.chat.completions.create({
  messages: [{ role: "user", content: "Hi, I was charged twice for my order #4471 and I want a refund." }],
  response_format: responseFormat(z.toJSONSchema(ticketSchema), "ticket_schema"),
});

console.log(JSON.parse(response.choices[0]?.message.content ?? "{}"));

Read more in the structured output docs.

Benchmarks

We ran Lev and Jev through the same harness on all 3,880 S1Bench items, pinned by Nimble's manifests. Our Jev run lands within 0.8 points of TypeSafe's published figures, so the harness isn't the gap.

• Jev leads clearly on minimal-edit pairs (paws, vitaminc) and summary faithfulness, where Lev rates faithful summaries one level too low.
• Lev leads on multinli and helpsteer2, though both are within noise (5 to 9 points).
• Calibration: Lev is better calibrated on 5 of 13 subsets.

Lev is at the top of its size class. On the six subsets every model on the public S1Bench board completed, no model at 4B or smaller scores higher: Lev ties reflex-4b at 71.9%. Only Jev and three models 6 to 9 times its size are ahead.

On held-out intent sets, Lev hits 0.980 on banking77 (77 intents) and 0.968 on clinc_oos (151 intents).

Speed

Compute is one batched pass, so it stays flat from one question to eight.

End to end from a laptop, Jev's hosted API answered in about 340 ms median and Lev on one H100 in 414 to 654 ms.

Training

• Data: 200,000 examples from 29 public sources, with questions paraphrased and recast so the model learns the format, not one wording.
• No contamination: any source overlapping S1Bench is refused.
• Recipe: LoRA r=32 on one H100, about 6 hours per run.

The full pipeline is in the GitHub repo.

Takeaway

• Classic classifiers: fast and cheap, but the label set is frozen at training time
• LLMs: any label at runtime, but tokens, retries, and no confidence you can trust
• Jev: typed decisions with calibrated probabilities from a hosted API
• Lev: the same protocol with open weights, 4B parameters, on your own GPU
• Interfaze: a hybrid that classifies with tokens, alongside OCR, search, and extraction in one request

Classification doesn't need a model that writes. It needs one that picks from your options and tells you how sure it is, and now there's an open one.

• Weights on Hugging Face
• Code, harness, and decision log on GitHub
• Try classification in the Interfaze playground
• Read TypeSafe's Jev launch post
• Join the Discord

Lev is not affiliated with or endorsed by TypeSafe AI.