Every frontier lab for the last three years has been racing toward the same shape of product: a model that talks. Bigger context windows, better reasoning traces, more fluent chat. TypeSafe AI, a new lab founded by Diogo Almeida (who worked on the instruction-following research behind ChatGPT at OpenAI), just shipped something built on the opposite premise. Their first model, Jev, doesn't generate text at all. It answers typed questions with structured, probability-scored decisions, and it does it in milliseconds instead of seconds.
The Core Problem They're Solving
Large language models were built to produce text for humans to read. The moment you want a model to make a decision your code will actually use, department routing, a risk score, a yes or no flag, you're forcing a text generator to do something it wasn't optimized for. You write a prompt, hope the model returns valid JSON, parse the string, validate it, and hope it didn't hallucinate a field that doesn't exist in your schema. That whole dance, prompt engineering, output parsing, retry logic for malformed JSON, is overhead that exists purely because the model's native output is a string, not a structured value.
TypeSafe calls this category of task "System One" work, a nod to Daniel Kahneman's fast, intuitive System 1 thinking versus slow, deliberate System 2 reasoning. Their bet is that most automation in real software doesn't need deep multi-step reasoning. It needs a fast, reliable gut-check: is this urgent, which category does this belong to, how confident are we. That's a fundamentally different shape of problem than writing an essay or debugging a stack trace, and they built a model specifically for it.
What Jev Actually Does Differently
Jev takes two inputs: a state (your raw unstructured context, a support ticket, a log line, a document) and one or more questions with a defined type. There are three question types:
- Choice: pick one option from a list you define, with a probability distribution across all options
- Score: rate the state against a rubric you define, with a probability distribution across score bands
- Noul: a yes or no judgment returned as a value between 0 and 1
Every question in a single request gets evaluated in parallel against the same state, in one pass. This is the architectural break from LLMs: instead of sampling tokens one at a time, sequentially, each conditioned on the last, Jev's parallel sampler evaluates all questions simultaneously. That's why adding more questions to a request barely moves the response time, and why there's no context-rot as you stack up more judgments.
The practical numbers, per TypeSafe's own published benchmarks: 70 to 500 millisecond end-to-end response times, versus 3 to 329 seconds for frontier LLMs doing comparable structured-decision work. Input costs of $0.042 per million tokens with free output tokens, versus $0.20 to $10 per million input tokens for LLMs, where output tokens run roughly five times the input price. And because outputs are constrained to a schema you define upfront, type errors are mathematically impossible, not just rare.
The Honest Trade-off
Jev gives up something real to get there: it can't generate free-form text. No chat, no code generation, no open-ended writing. If your task needs deep reasoning through an ambiguous problem or generating genuinely novel content, this isn't the tool. TypeSafe is explicit about this rather than hiding it, their own comparison table puts LLMs ahead for human-in-the-loop chat, verifiable problems like math proofs, and quick prototyping. Jev is positioned for a different category entirely: structured decisions embedded inside running software, where the surrounding code constrains what the model is allowed to do.
The other notable claim is around calibration. Every Choice and Score answer comes back with a confidence score, and TypeSafe trained Jev specifically so that higher stated confidence actually correlates with higher accuracy, using a method they call Reinforcement Learning for Calibrated Decisions (RLCD). That matters more than it sounds. A model that's right 95% of the time but never signals when it's in the uncertain 5% can't be trusted to automate a decision unsupervised. A model that reliably flags its own uncertainty can be wired into a system where low-confidence answers get routed to a human and high-confidence ones flow through automatically.
Where this actually fits: real-time classification and routing inside a live system, scoring or verifying the outputs of other AI systems (guardrails, jailbreak detection, judging reasoning traces), map-reduce style processing over large volumes of unstructured data, and anywhere a hand-written if-statement is currently doing a job that's actually fuzzy and would be better served by a calibrated probability. It's not a replacement for a coding agent or a chatbot. It's meant to sit inside the plumbing of software that already exists, making small, fast, structured calls the way a function call would, except the function is judgment instead of arithmetic.
The API, In Practice
The interface is deliberately narrow. You send a state and a set of typed questions, you get back typed answers with probabilities.
curl -X POST https://api.typesafe.ai/v1/systemone \
-H "Authorization: Bearer $TYPESAFE_API_KEY" \
-H "Content-Type: application/json" \
-d @- <<'EOF'
{
"state": "Hi, I've been trying to connect my Stripe account for 3 days and the integration keeps failing. I'm losing sales. Please help ASAP.",
"model": "jev-latest",
"questions": {
"department": {
"type": "choice",
"instructions": "Which team should handle this",
"criteria": {
"billing": "Payment or subscription issues",
"technical": "Bugs or integration problems",
"sales": "Pricing or account questions"
}
},
"frustration": {
"type": "score",
"instructions": "How frustrated the customer appears",
"criteria": [
"Calm, just stating facts",
"Frustrated but civil",
"Very angry, strong language"
]
},
"is_urgent": {
"type": "noul",
"instructions": "The message conveys urgency or time-sensitivity"
}
}
}
EOFAnd the response comes back fully typed, no parsing required:
{
"model": "jev-1.13.0",
"answers": {
"department": {
"type": "choice",
"choice": "technical",
"confidence": 0.78,
"probabilities": { "technical": 0.85, "sales": 0.0, "billing": 0.15 }
},
"frustration": {
"type": "score",
"score": 1.0,
"confidence": 1.0,
"probabilities": { "0": 0.0, "1": 1.0, "2": 0.0 }
},
"is_urgent": { "type": "noul", "noul": 1.0 }
},
"usage": { "input_tokens": 392, "output_tokens": 65 }
}Three questions, one round trip, no string to parse, no schema to validate after the fact. That's the entire pitch condensed into one call.
Building a Daily-Use Harness Around It
Given how cheap and fast each call is, the natural next step isn't a one-off script, it's a small always-on harness that watches a real stream of inputs (support tickets, PR descriptions, log lines, whatever you touch daily) and routes them automatically using Jev's judgments. Here's a practical, minimal version you could actually run day to day.
A minimal Python harness implementing that loop:
import os
from typesafe_sdk import Choice, Score, Noul, TypeSafeClient
client = TypeSafeClient() # reads TYPESAFE_API_KEY from env
CONFIDENCE_THRESHOLD = 0.75
def triage(item_text: str) -> dict:
response = client.system_one(
state=item_text,
questions={
"category": Choice(
instructions="What kind of item is this",
criteria={
"bug": "A defect or broken behavior",
"feature_request": "A request for new functionality",
"question": "A question needing an answer, not a fix",
"urgent_incident": "Something actively broken in production",
},
),
"severity": Score(
instructions="How severe or high-priority this item is",
criteria=[
"Low priority, no rush",
"Normal priority, handle this week",
"High priority, handle today",
],
),
"needs_human": Noul(
instructions="This item is ambiguous or high-stakes enough that a human should review it before any automated action",
),
},
)
return {
"category": response.answers["category"].choice,
"category_confidence": response.answers["category"].confidence,
"severity": response.answers["severity"].score,
"needs_human": response.answers["needs_human"].noul,
}
def route(item_id: str, item_text: str, result: dict) -> str:
low_confidence = result["category_confidence"] < CONFIDENCE_THRESHOLD
if result["needs_human"] > 0.5 or low_confidence:
return "queued_for_review"
return f"auto_routed:{result['category']}"
def run_harness(items: list[dict]):
log = []
for item in items:
result = triage(item["text"])
outcome = route(item["id"], item["text"], result)
log.append({"id": item["id"], **result, "outcome": outcome})
return log
def daily_summary(log: list[dict]):
total = len(log)
reviewed = sum(1 for r in log if r["outcome"] == "queued_for_review")
avg_confidence = sum(r["category_confidence"] for r in log) / total if total else 0
print(f"Processed {total} items today")
print(f"Auto-routed: {total - reviewed}, sent for human review: {reviewed}")
print(f"Average category confidence: {avg_confidence:.2f}")Wire run_harness to whatever feeds it daily, a cron job pulling new support tickets, a webhook on new GitHub issues, a tail on a log file, and you have a working automated triage layer that costs a fraction of a cent per item and responds in under half a second. The confidence threshold is the important lever: raise it and more items get kicked to a human for review, lower it and more gets auto-routed. Because Jev's confidence scores are trained to be calibrated, tuning that threshold actually behaves the way you'd expect, rather than being a knob you're guessing at with an LLM's often-overconfident self-assessment.
The bigger idea behind a harness like this: because a single Jev call is cheap and fast enough to run on every single item that flows through a system, you can afford to ask several small, well-scoped questions per item rather than one broad judgment. Decompose "how should I handle this" into category, severity, and needs_human, combine the three with your own logic, and when priorities shift, you change a threshold or a weight in your code instead of rewriting a prompt and hoping the model's behavior doesn't drift.