Jev: intelligence you can call like a function

Why don't superhuman chat models automate anything?

TypeSafe's founding question, asked by CEO Diogo Almeida after helping build the research behind ChatGPT: if models are this smart, why is most software still not intelligent?

His answer is structural, not capability-based. LLMs are trained with RLHF, reinforcement learning from human feedback, which optimizes for answers human raters prefer. That produces models that are articulate, helpful, and pleasant. It also produces three failures that matter for software: overconfidence (models state wrong answers firmly), inconsistency (similar inputs get different answers), and text output (strings must be parsed and validated before code can act on them).

TypeSafe's manifesto calls this the "horseless carriage" problem: we bolted new intelligence into the shape of a chat window, the way early cars kept the buggy whip socket. Their bet is that the bottleneck for automation is not raw intelligence, which they argue already exists, but intelligence that is dependable enough to bury five layers deep in a system, like any other software dependency.

State in, typed decisions out

Jev exposes three AI primitives, modeled on software primitives: modular, composable, and fast. Each question is evaluated in parallel and in isolation against the same state, in a single call. Adding more questions barely changes response time, and no question contaminates another (no context rot).

{
  "state": // anything: JSON program state, or plain text
    "My card was charged twice. Order #8412. I need this fixed today.",
  "questions": {
    "route_to":    { "type": "choice", "options": ["billing", "technical", "sales"] },
    "is_urgent":   { "type": "noul" },
    "refund_fit":  { "type": "score", "rubric": "duplicate-charge refund likelihood" }
  }
}

{
  "route_to":   { "choice": "billing", "probabilities": {"billing": 0.85, "technical": 0.08, "sales": 0.07}, "confidence": 0.82 },
  "is_urgent":  { "noul": 0.94 },
  "refund_fit": { "score": 0.91, "confidence": 0.77 }
}

The core discipline: atomic questions, composed in code. Don't ask "rate this startup pitch". Ask about market size, technical feasibility, and differentiation separately, then combine with your own formula in code. Each question should be a "gut-check determination": the kind of judgment a knowledgeable person makes in a few seconds. If it needs extended reasoning, that's an LLM job, not a Jev job.

• Constraints: 32k context window, JSON-only input, up to 255 options per choice (a two-stage score-then-choose pipeline above that).
• It's zero-shot and general: no per-task training; the same model takes any question shape at runtime.
• What it gives up: all string generation. No prose, no explanations, no code. That's the entire business model.

A parallel sampler and a new training target

Two claims of novelty: a new architecture that answers in one parallel pass, and a new training algorithm called RLCD. Here is what that means, and what remains secret.

Parallel sampling kills the output bill

An LLM generates one token at a time, each conditioned on the last. Sequential generation is why output tokens cost ~5x input. Jev never generates a sequence: all fields of the answer are computed in a single query, which is why output tokens are free ("too cheap to meter"). The founder draws a direct line to history: replacing sequential computation with parallel is how Transformers leapfrogged RNNs.

RLCD: Reinforcement Learning for Calibrated Decisions

Where RLHF optimizes human preference and RLVR optimizes programmatically verifiable rewards, RLCD optimizes calibrated decisions: answers whose stated probabilities are epistemically honest. The pitch: if a model is right 95% of the time but never signals when it's in the failing 5%, you cannot automate with it. A calibrated model lets your code set the threshold: act autonomously above 0.9, escalate to a human below.

What's unpublished matters: there is no paper, no architecture disclosure, and no public benchmark scores. The community's informed guess (HN user paraschopra, who did related work): an encoder-style transformer of roughly 2–3B parameters, distilled from frontier models, post-trained with a calibrated-RL objective, i.e. heavily penalizing probability distributions that disagree with observed outcomes. An open replication ("Qwen-2.5-1B-RLCD") appeared on Hugging Face within 48 hours of launch.

Extraordinary claims, measured

TypeSafe's own blog says "extraordinary claims require extraordinary evidence" and publishes its own nuances, which is rarer than it should be. Here is every major claim against the evidence.

"Can't hallucinate" and other contested words

The launch's flashpoint. On Hacker News (1,860 points, 490 comments), the loudest argument was semantic: is type safety the same as truth safety?

The prior-art deflation

The HN consensus landed on a reframe: Jev is a generalized zero-shot classifier that takes its option set at runtime — a framing the CEO explicitly endorsed ("exactly right!"). The cited family: GLiNER/GLiClass (encoder-based, no text generation, multi-task single forward pass), BERT-style encoders, DeBERTa zero-shot classifiers, conformal prediction ("productionized conformal prediction"), and logit-inspection tricks with constrained decoding. The sharpest counter from the company: LLM-based constrained decoding "makes models dumber", and prompting an LLM for one word is slower, pricier, and less self-consistent than a purpose-built model.

The benchmark refusal

TypeSafe deliberately declines public benchmarks, arguing their workflow evals better represent production use. Skeptics read the same fact differently: "I bet they would publish them if their score were good" (jceg). The fairest synthesis: their evals are transparent about method but self-made; independent evidence so far supports narrow classification strength and does not test breadth.

Two stress tests, one split decision

Within 48 hours of launch, independent developers ran Jev against real workloads. The results trace its shape with unusual clarity.

Early-access reports from Hacker News

• "Works incredibly well in concert with LLMs, not as a replacement" — GoodStart Labs, using Jev's noul checks as a second form of verification over other models.
• Shipped in production for "decision tree stuff" — with the caveat that the 32k context window is limiting (nickstinemates).
• Chess demo: full legal-move probability distribution in ~300ms at ~$0.00004/move (leo4242).
• Could not generate code logic — "kept wanting to create a literal number instead of refer to a variable" (cooljoseph). Expect this: generation is architecturally absent.
• A developer who tried replicating with zero-shot classification on a 4B Qwen model: "could not reach the level of intelligence they've got here. Tho speed/cheapness was similar" (padolsey).

When to reach for Jev — and how to evaluate it

The pattern the market is converging on: LLMs as slow, brilliant System 2; Jev as the fast, cheap, calibrated System 1 underneath. The subconscious and the conscious.

An evaluation checklist

• Demand rejection curves: at confidence ≥ 0.9, what % of decisions can be automated, and at what accuracy — on your task, not their workflow evals.
• Test adversarial inputs: the poker result shows confident wrongness when the task involves hidden information. Know which of your decisions look like poker.
• Compose, don't replace: strongest reported results use Jev to cross-check or offload from an LLM, with code holding the branching logic.
• Watch the open replication: if a post-trained 2–3B open model matches Jev's accuracy at similar cost, the pricing power evaporates.
• Read the marketing as branding: "can't hallucinate" = "cannot break the schema". "Frontier" = "on the speed/cost Pareto frontier for structured decisions".

The people, the name, the bet

Diogo Almeida, co-founder & CEO. Verified 4th author of the InstructGPT paper (arXiv:2203.02155), the research that became ChatGPT; ex-Google Brain. His "co-invented ChatGPT and RLHF" phrasing is defensible for InstructGPT and generous for RLHF, which predates him. Sasha Sheng, COO, is an ex-Meta/FAIR research engineer; Erik Gafni, CTO, a repeat founder (Ravel) and early employee at Invitae and Freenome. The company raised $40M, works in-person in San Francisco, and its manifesto tagline is "Build Prod, Not God."

The name is the thesis. Jev is named for William Stanley Jevons, the 19th-century economist who observed that making coal engines more efficient increased coal consumption rather than reducing it. TypeSafe expects the same with decisions: every order of magnitude drop in the cost of intelligence unlocks more use cases than it saves. Whether the token market behaves like the energy market is the wager the whole company sits on.

• Sep 15, 2026Out of stealth. Founder thread: 20–200x faster, 40–400x cheaper, output tokens free. HN retitles the "frontier model" framing within the hour.
• Sep 15–16HN thread reaches 1,860 points / 490 comments; ~3:1 bullish. Doom and wikiracing demos make the rounds; hallucination debate ignites.
• Sep 16The Register covers the launch ($40M). Near Here publishes the first independent benchmark: Jev 96% at 1/9th the cost.
• Sep 17Poker eval lands: "the fish at the poker table". Open replication (Qwen-2.5-1B-RLCD) appears on Hugging Face. Early-access reports land on HN.
• OpenNo paper, no public benchmarks, no architecture disclosure. Pricing sustainability, out-of-distribution calibration, and breadth of intelligence all unproven.