Your pipeline doesn't need an essay. It needs a probability.

Arne Kellmann ·

Every LLM call in a pipeline ends the same way. The model writes three paragraphs, and a regex reads one line of them. The paragraphs cost tokens and seconds. The regex is the part that runs.

TypeSafe released Jev on 15 September 2026, and by the next morning it was the top story on Hacker News with 1,800 points. Since then people have made it play chess, drive a browser, trade order books and play Doom at ten decisions a second. Fun. None of it tells you whether it belongs in your CI.

So I did the boring version. I took the one place in my autonomous build chain where a regex reads a model’s prose, ran every real code review the chain has ever produced through Jev, and wired the answer in. This is what came out.

Who is behind it. Jev is the first model of TypeSafe AI, a San Francisco lab that left stealth on 15 September 2026 with a $40 million seed round led by DCVC. The founders are Diogo Almeida, formerly a researcher at OpenAI, with Erik Gafni and Sasha Sheng. On X: @typesafeai and @CompleteSkeptic. I have no relationship with the company; the API key is a normal early-access key and I paid for every call in this post.

What Jev returns, in one paragraph

You send a state and a typed question. Three question types: Noul returns a probability that a condition holds, Choice returns one option with a distribution, Score returns a position on ordered levels you define. Several questions over the same state run in one call, in parallel, and the model cannot see one answer while producing another. That is the whole API. No prose, no explanation, no JSON schema to repair.

curl -s https://api.typesafe.ai/v1/systemone \
  -H "Authorization: Bearer $TYPESAFE_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{"model":"jev-1.13.0","state":"Help! My payouts have been failing for 3 days.",
       "questions":{"is_urgent":{"type":"noul","instructions":"Does this convey urgency?"}}}'
# {"model":"jev-1.13.0","answers":{"is_urgent":{"type":"noul","noul":0.95}},"usage":{"input_tokens":283,"output_tokens":23}}

The case: a review that says “mergeable” and lists a blocker

The chain that builds blockquote.io has a review routine. It reads every draft pull request and ends its review with a marker line, MERGE-VERDICT: mergeable or MERGE-VERDICT: changes. A gate script reads the marker with a regex. The regex is the only thing between that review and the merge.

The failure mode is obvious once you have seen it. The reviewer writes: “The migration drops a column, which violates the expand-only rule. Must be fixed before merge. MERGE-VERDICT: mergeable.” The regex sees mergeable. The code merges.

I gave Jev the review body, the verdict, and one Noul:

{
  "model": "jev-1.13.0",
  "state": {
    "verdict": "mergeable",
    "review_body": "...",
    "context": "A code review on a pull request. The verdict is a machine-read marker the reviewer wrote at the end. mergeable means: the code may merge as is, no open blocker. changes means: not mergeable."
  },
  "questions": {
    "supports": {
      "type": "noul",
      "instructions": "Does `review_body` support the marker `verdict`? Answer no if the body names an unresolved blocker, a failing check, a missing file or asks for a change before proceeding while the verdict is positive, or if the body finds no problem while the verdict is negative."
    }
  }
}

74 real reviews, every number verbatim

Every review with a merge verdict on a closed pull request in the repository. Not written for the test. Two to six kilobytes each, produced by a reasoning model over the last five weeks. I read the ones the model doubted and labeled them by hand.

Set Reviews supports
Verdict mergeable, prose agrees 46 0.58 to 0.98, median 0.96
Verdict changes, prose names a blocker 25 0.61 to 0.96, median 0.85
Prose contradicts the verdict, read by hand 3 0.32, 0.44, 0.52

The three contradictions are real. Two reviews list every finding as “non-blocking”, say “nothing blocks” in so many words, and still write changes. One review is an empty body with changes. Jev ranked all three at the bottom, and nothing that agreed with its verdict fell below 0.58.

What it cost:

Metric Value
Calls 74
Latency 210 to 959 ms, mean 292 ms
Input tokens, total 126,142
Price $0.0053 for all 74, output is free

That is the number to hold next to a reasoning model that reads the same 74 reviews. I pay more than that for one.

A caveat the hype skips: the vendor says 70 to 500 ms. My earlier one-off calls with curl showed 530 to 630 ms. Inside a Node script with a warm connection it is 210 to 300 ms. Measure from where you will run it.

The rule: a probability is a signal, not a decision

The chain has a constitution. The pause switch, the merge, and the gate thresholds are code that a person edits and a hash pins. A model answer goes in as one more input to that code. It never replaces a condition.

So the gate does three things with supports, and the thresholds come from the table above, not from the docs:

Nothing merges because Jev said so. Something waits because Jev disagreed. That asymmetry is the whole design. A false positive costs one human look. A false negative costs what it cost before, nothing new. When the API errors or the key is missing, the gate behaves as it did before the model existed. Fail open on the model, never on the code.

The whole change is one client module of 80 lines, one pure function that builds the question, one if in each gate, and a fixture test that pins the thresholds against the 74 numbers. When the model pin moves, the fixture reruns and the test tells me whether the thresholds still hold.

Where I use it, and where I do not

Seven places in the chain were candidates. Four survived:

Three did not:

And the pattern behind the popular demos, for what it is worth: chess works because the legal moves are a list and every move is one Choice over it. The browser agent works because an LLM plans and Jev picks the click from a snapshot. The trading bot works because BUY, SELL and HOLD are three options. In every case code owns the option list and the model picks. That is the shape to look for in your own system. If you cannot write the options down, Jev is the wrong tool.

What the reviews do not say loudly enough

None of that changes the design above. It is the reason for the design above.

Try it in an afternoon

  1. Get a key. Early access is open, keys come in batches.
  2. Find one place where a regex reads a model’s prose, or where a prompt says “be careful with X”.
  3. Write the question so a stranger could answer it from the state alone. Put the meaning in the instructions, not the key name.
  4. Pull every real case you have. Not twenty you wrote. Run them, read the ones the model doubts, label those by hand.
  5. Set the thresholds from that table. Wire the number in as an input to the code that already decides. Fail open on the model.

The docs are at docs.typesafe.ai. Append .md to any page path and you get Markdown. Read the confidence page first.

Sources