Jev Isn't an LLM, and That's the Point

Most of the AI calls in my apps aren't really asking for writing. They're asking for a decision: which category does this belong to, is this input safe, which screen should this go to, which tool should the agent call next. I ask a language model to write a little JSON, then I parse it and hope it's valid.

On Tuesday a startup called TypeSafe AI came out of stealth with a model built for exactly that, and nothing else. It's called Jev, it's in limited early access, and TypeSafe announced a $40M seed round led by DCVC alongside it. The Register reports the CEO is Diogo Almeida, a former OpenAI researcher.

What Jev actually is

TypeSafe calls Jev a "System One model", borrowing Daniel Kahneman's split between fast, intuitive thinking (System One) and slow, deliberate reasoning (System Two). An LLM is the System Two in this picture. Jev is the reflex.

The interface is the interesting part. You don't write a prompt and get text back. You send:

• a state: your data, as JSON or plain text, and
• one or more typed questions about that state.

Jev answers each question with a typed result, not prose. The docs list three question types:

Question type	What comes back
Choice	the chosen option, a probability for every option, and a confidence
Score	a score, with probabilities and a confidence
Noul	a value between 0 and 1

Every question is evaluated "in parallel and in isolation against the same state in one go," so adding questions barely changes the response time. Because the answer is a type, not text, there's nothing to parse and no way to return something outside the options you gave it.

Here's the shape of the idea (illustrative pseudocode, not TypeSafe's real API):

state:     { "ticket": "My card was charged twice for one order" }
questions:
  department: Choice ["billing", "shipping", "technical", "other"]
  urgency:    Score  1..5

answer:
  department: "billing"   probabilities { billing: 0.94, other: 0.03, ... }  confidence: high
  urgency:    4

Your code then does the routing: if confidence is high, act; if not, send it to a person or to a bigger model.

How it differs from an LLM

It doesn't generate. An LLM predicts the next token, over and over, and your answer is whatever text falls out. The Register reports Jev returns all its outputs at once rather than token by token, which is where the speed claims come from.

It gives you probabilities, not just an answer. TypeSafe says it trains with a method it calls Reinforcement Learning for Calibrated Decisions (RLCD), and contrasts it with the RLHF training behind chat models, which it says tends toward overconfidence. If the probabilities really are calibrated, you get something LLM JSON never gives you: a number you can set a threshold on.

The claims, clearly labelled as TypeSafe's:

• 70–500 ms per call.
• About $0.042 per million input tokens, with output tokens free.
• "Zero hallucinations." The Register points out this "really isn't a fair comparison": a structured answer can't invent text, but it can still be wrong.

None of these have been independently tested yet.

Where it would sit in an app

The way I think about it, with my distributed-systems hat on: Jev isn't competing with the LLM, it's competing with the if statements and the classifier you'd otherwise build.

• Routing in front of an expensive model. Decide cheaply whether a request needs the big model at all.
• Agent tool choice. "Which tool next?" is a Choice question. An agent loop that spends seconds on each step could spend milliseconds on the routing ones.
• Guardrails. "Is this input safe to act on?" with a probability you can threshold, instead of a yes/no you have to trust.
• On the hot path. At those latencies, a decision can sit inside a request instead of in a background job.

TypeSafe's own design advice reads like good API design: ask atomic questions, one factor each, and combine the results in your code rather than asking one fuzzy mega-question.

What I want to test when I get access

It's waitlist-only, so this is a try-list, not a review:

1. Calibration. When Jev says 90%, is it right about 90% of the time on my data?
2. Latency from Canada, end to end, not in a demo.
3. The failure mode. What happens with a question that's genuinely ambiguous, or a state it has never seen anything like?
4. A real swap. Take one place where I ask an LLM for JSON and replace it, then compare cost, speed and accuracy.

Quick hits

• An appeals court sides with GitHub on Copilot (Sep 16). In Doe v. GitHub, the Ninth Circuit affirmed dismissal of the claim that Copilot and Codex strip copyright notices, because the models generate new code rather than copying and removing notices. Contract claims continue in the lower court. The bigger question, whether output can infringe, is still open.
• iOS 27, macOS 27 and Xcode 27 are out (Sep 14). Xcode 27 ships with Swift 6.4. Time to move your toolchain.
• StoreKit gets subscription bundles (Sep 16). Apple added Bundles and Suites for subscriptions. Worth a look if you sell more than one app.
• Xcode 27.1 beta and iPhone Duo design kits (Sep 18). If you design for iPhone, the foldable is now something to plan layouts around.

What I'm watching

Whether the big labs answer with their own decision models, or decide this is a niche. OpenAI's DevDay is at the end of the month.

Sources

Jev

• TypeSafe, System One models and Jev
• TypeSafe docs, Introduction to Jev
• The Register, coverage of Jev's launch (Sep 16, 2026)
• VKTR, TypeSafe AI launch coverage

Quick hits

• US Court of Appeals for the Ninth Circuit, Doe v. GitHub, No. 24-7700, opinion (Sep 16, 2026)
• Apple Newsroom, iOS 27, macOS 27 and Xcode 27 release (Sep 14, 2026)
• Apple Developer, News and updates (StoreKit, Sep 16; Xcode 27.1 beta, Sep 18)