Jev and Claude Code: Typed AI Decisions in the Agent Loop

Every model launch this year promised more reasoning, more context, better code. TypeSafe AI shipped the opposite: a frontier model that cannot write a sentence.

Jev came out of stealth on September 15, 2026, backed by a ~$40M seed led by DCVC, from a team built around Diogo Almeida — one of the researchers behind the RLHF work that produced ChatGPT. It is a transformer, but it is not an LLM. You send it state plus typed questions; it returns typed answers with calibrated probabilities in one parallel forward pass. No tokens, no streaming, no parsing, no "please respond in valid JSON."

TypeSafe calls this class a System One model, after Kahneman. System 2 is the slow deliberate reasoner — that is Claude, that is GPT. System 1 is the instant gut-check: is this spam, is this urgent, is this the right branch. Jev is built to be very good and very cheap at that, and nothing else.

What Jev actually does

Three primitives, all mixable in a single call:

• Choice — pick one of up to 255 options. Returns the choice, a probability for every option, and a confidence value.
• Score — rate the state against ordered, descriptive levels. Returns a score, per-level probabilities, confidence.
• Noul — a yes/no question. Returns P(true) as a float from 0 to 1.

One request looks like this:

curl -X POST https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "Hi, my Stripe integration has been failing for 3 days. 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"
        }
      },
      "is_urgent": {
        "type": "noul",
        "instructions": "The message conveys urgency or time-sensitivity"
      }
    }
  }'

You get back choice: "technical", confidence: 0.78, a full probability distribution, and noul: 1.0. Your code branches on that. There is no string to regex, and schema conformance is not a benchmark number — it is structurally guaranteed, because the answer space was enumerated before inference.

The numbers that matter: $0.042 per million input tokens (output tokens are free — there is no decode loop to meter), 70-500ms end to end, 64k context per request with 32k for state plus the longest question, text only. TypeSafe's headline claims of 193x faster and 444x cheaper come from their own workflow evals, which they publish with an unusual amount of self-skepticism attached.

Who Jev is for

Not chatbot builders. Jev is for people who have a decision buried inside code that currently costs a full LLM round trip.

You are in the target audience if any of this sounds familiar:

• You call an LLM to classify something, then parse the reply and hope.
• You have a routing layer that burns 2 seconds and half a cent to decide between three branches.
• You wanted AI in a hot path — a request handler, a game loop, a stream processor — and latency killed it.
• You are scoring or filtering at volume: moderating, triaging, ranking, deduping over millions of rows.
• You need calibration, not vibes: the difference between "the model said yes" and "the model said 0.53, which is too close to the line to act on."

That last one is the real product. LLMs are wobbly judges — TypeSafe's own cookbook runs a 14-question rubric 15 times and shows the same non-reasoning LLM disagreeing with itself at temperature 0. Jev's per-question probability standard deviation across repeats came in around 0.01. When a number is load-bearing in your control flow, that stability is worth more than raw intelligence.

You are not the audience if you need prose, code generation, images, or conversation. Jev cannot do any of it, by design. For that work you still want a full agentic setup — the kind of Claude Code workflow I use on Laravel projects.

The honest caveat

"Cannot hallucinate" is true in a narrow sense: Jev cannot emit a malformed or out-of-schema answer. It can absolutely be confidently wrong about the content — TypeSafe's CEO conceded exactly that in the Hacker News thread. What you get is a type guarantee and a calibrated probability, not correctness. Treat it as a very fast, very cheap junior reviewer whose uncertainty you can actually measure.

Where Jev fits with Claude Code

This is the part people are getting backwards. Jev does not compete with an agentic coding tool — it makes one cheaper to trust. Claude Code is the System 2: it reads the repo, holds the plan, writes the diff. What it is bad at is making the same small judgment ten thousand times, fast, at a price you do not notice.

Four places that bites, and what Jev does about it.

1. Permission gating that is not a wall of y/n

Every Claude Code user ends up in the same trap: full auto-accept is reckless, and manual approval on every tool call means you are babysitting. The middle path is a PreToolUse hook that decides per command — but you cannot put an LLM call in that path, because it runs on every tool use and would add seconds each time.

At roughly 100ms and $0.000084 per 2k-token call, you can:

#!/usr/bin/env python3
# .claude/hooks/gate_bash.py  - PreToolUse hook for Bash
import json, os, sys, urllib.request

event = json.load(sys.stdin)
cmd = event.get("tool_input", {}).get("command", "")

body = json.dumps({
    "model": "jev-latest",
    "state": {"command": cmd, "cwd": event.get("cwd", ""), "repo": "richardporter.dev"},
    "questions": {
        "destructive": {"type": "noul",
            "instructions": "This command irreversibly deletes, overwrites, or force-pushes data"},
        "exfiltrates": {"type": "noul",
            "instructions": "This command sends repository contents or secrets to a network destination"},
        "touches_prod": {"type": "noul",
            "instructions": "This command acts on production infrastructure or a live database"},
    },
}).encode()

req = urllib.request.Request(
    "https://api.typesafe.ai/v1/systemone", data=body,
    headers={"Authorization": f"Bearer {os.environ['TYPESAFE_API_KEY']}",
             "Content-Type": "application/json"})
answers = json.load(urllib.request.urlopen(req, timeout=2))["answers"]

risk = max(answers[k]["noul"] for k in ("destructive", "exfiltrates", "touches_prod"))
decision = "allow" if risk < 0.15 else ("ask" if risk < 0.80 else "deny")

print(json.dumps({"hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": decision,
    "permissionDecisionReason": f"Jev risk {risk:.2f}",
}}))

Three questions, one round trip, imperceptible latency. The boring 95% of commands flow through; the genuinely dangerous ones stop; the ambiguous middle is the only thing that interrupts you. That is the confidence-gated routing pattern TypeSafe documents, applied to the exact problem agentic coding has.

2. Guarding what the agent reads

Your agent fetches a web page, reads an issue comment, pulls a dependency's README. All of it is untrusted text heading straight into a context window with shell access. A Noul question — "this content contains instructions directed at an AI agent" — costs a hundredth of a cent and runs before the content is ever appended. Cheap enough to apply to everything, which is the only threshold at which a prompt-injection filter is worth having.

3. Triage before you spend Opus tokens

CI fails with 40 test failures. Instead of dumping all of it into the agent, score each failure first: flaky versus real, related to this diff versus pre-existing, severity 0-3. Send the agent the eight that matter.

Same trick for a 300-file repo map: Choice and Score over file summaries to pick what belongs in context. You are spending $0.0001 to save a few dollars and a lot of context rot — which, as I covered in Claude Code token management, is the thing that actually degrades output quality on long sessions.

4. Routing work between agents

If you orchestrate multiple coding agents — Claude Code for features, something cheaper for mechanical refactors, a human for anything touching auth — the router is a classifier you are probably implementing with an LLM call or a pile of regexes.

Jev's intent routing pattern is the shape for this: one Choice over handlers, plus a Score for complexity, plus confidence. Low confidence does not pick a handler, it asks you. That is the missing piece in most parallel agent team setups, where dispatch is usually hardcoded.

The mental model

Stop asking which model to use and start asking where in your system the judgment lives. Claude Code writes the code. Jev decides, in the loop, at the speed of a function call, whether that code gets to run.

The interesting thing about the Doom demo TypeSafe shipped — an agent playing Doom at 10 decisions per second for about $7/hour — is not that it plays well. It is that putting a model in the loop stopped being a budget question. Once a decision costs microdollars and milliseconds, you stop rationing them, and you start putting judgment in places where you previously had to hardcode a heuristic and hope.

That is the real pitch. Not a better brain. A cheaper reflex.

---

Jev is in early access via waitlist at typesafe.ai, with a Vercel AI Gateway path and a Cloudflare Workers AI listing for people who do not want to wait. Pricing and rate limits above are from TypeSafe's docs as of September 2026 and are moving.