An LLM writes you a sentence. Jev hands your code a number.
That is the entire idea. Everything else on this page is a consequence of it —
including why it is 100× cheaper, and why there are things it simply cannot do.
The shape of one call
You define the answers in advance. It just fills in the probabilities.
Because the answer space is fixed before the call, a malformed or invented answer is
structurally impossible — not unlikely, impossible.
A real response from your key. No prose, no markdown fence, no parsing step, no retry loop.
The keys you get back are the keys you sent.
Why it is fast
Giving up sentences is what buys the speed.
An LLM must write its answer one token at a time, each one waiting on the last.
Jev emits every answer at once, because it never has to phrase anything.
Because extra questions are nearly free in wall-clock time, the right habit is to ask
everything you might need in one call and let your code ignore what turned out to be irrelevant.
The whole API
Three question types. That is all there is.
Every bar below is a real probability returned by your key for the support-ticket state
“payouts failing for 3 days, considering Stripe.”
Measured on your key, not quoted from the site
The numbers that decide whether it fits.
~700 live calls, 16 September 2026, model jev-1.13.0.
The two caps in orange are the ones that will bite you, and the score cap is documented nowhere.
130ms
typical round trip, 1 → 200 questions
$0.000022
a 4-question triage call output tokens are free
238/s
sustained at 64-way concurrency, zero 429s
~31k
input-token ceiling (≈120 KB of text)
255
max options on a choice
10
max levels on a score — undocumented
There is a floor. Every call carries ~265 tokens of fixed overhead, so nothing costs
less than about $0.00001. Batch your questions; don’t make ten calls where one will do.
The nuance that matters most
Four questions decide whether it fits.
Any single “no” sends you back to ordinary code or to a real LLM. This is the filter
worth internalising — most bad TypeSafe ideas die at gate 2 or gate 4.
The same rule, as a list
Green zone, red zone.
✓ Reach for it
Route / triage / classifyWhich handler, which team, which tier — from a fixed list.
Gate an expensive thingDecide in 130 ms whether to spend 8 s and $0.02 on an LLM.
Moderate a public writeSpam, abuse, injection — on a path where today there is nothing.
Score and rankBreak one fuzzy judgement into atomic scores; weight them in your code.
Backstop a regexKeep the fast path; call Jev only when the pattern list says “unknown”.
Verify an LLM’s outputCheap enough to check every single response.
✕ Walk away
Anything it must writeA reply, a summary, code, a name. It emits no strings at all.
Free-text extraction“Pull the invoice number out.” It can only choose among candidates you supply.
Arithmetic and datesI asked it to total a cart: right answer, confidence 0.50. Use code.
Anything needing a reasonNo chain of thought, no justification, no audit trail of why.
More than ~31k tokens of stateHard 400. Retrieve and trim before you call.
A replacement for the whole agentIt is a primitive inside your software, not a worker.
The feature people miss
Confidence is a second axis — and the threshold is not one number.
The answer tells you what. Confidence tells you whether to act at all.
The bands move right as the consequence of being wrong gets worse.
Note that noul answers carry no separate confidence field — the number itself is
the belief, so a 0.5 there means exactly the same thing as a flat distribution on a choice.
How you actually tune it
A 0.5 is not a weak model. It is a question missing context.
This is the single most useful working habit. An LLM asked an underspecified question
invents a confident answer. Jev flattens the distribution and tells you.
Real measurements. The loop is: run it, read the answers nearest 0.5, put the missing fact
into the question’s structured instructions, re-run. Never “try a different model”.
Tested against your own code
Two real heuristics on this box, replayed.
I took two existing regex classifiers, wrote the cases they were designed for,
and ran both the regex and Jev over them.
the regex that ships todayone Jev question
Small hand-built sets, chosen to probe each heuristic’s known blind spot — indicative,
not a benchmark. The point is which cases each one gets wrong.
Why the path regex scores zero
file
regex
Jev
tokenizer.py
RISKY
0.03
roles/carousel.tsx
RISKY
0.02
hashtags.go
RISKY
0.02
core/identity.rs
safe
0.94
store/handler.go
safe
0.93
util/helpers.go
safe
0.81
The regexes match file paths. token hits
tokenizer; role hits roles/. Meanwhile a diff replacing
ConstantTimeCompare with == in helpers.go matches nothing at all.
What the call-assist regex misses
utterance
regex
Jev
“that’s fine by me”
miss
0.52
“another twenty on top”
miss
0.88
“I’ll hold that for you”
miss
0.43
“we’re at number 42”
false fire
0.02
Each miss is a broken commitment invariant; each false fire
burns ~3 s of thinking mid-call. Jev is better but not clean — it misses “I’ll hold that for you” too.
Two of its four hard cases land near 0.5, which is the tell that the question needs the call’s context,
not just the sentence.
Where it fits here
Ranked by value, from a scan of the whole box.
Two agents inventoried every rule-based judgement across the orchestrator, Hermes,
call-assist, simple-host, sf-fog, God’s Eye View and IELTS. These are the ones worth doing.
Public writes with no content check at all biggest gap
The shared host takes an anonymous POST of any valid JSON and makes it a permanent public
row — comments, guestbooks, state blobs. Rate limits and size caps are the only guards, and the body is
never read. One noul at $0.00002 is the cheapest insurance available.
Your own standing rule — “anything touching auth, crypto, payments, permissions, migrations, deps or CI
gets a security pass regardless of size” — is currently enforced by matching regexes against file paths.
It scored 0/6 above. Reading the diff instead scored 6/6.
IELTS free-text marking is exact string equality wrong answers today
tidyAnswer lowercases, trims and strips one leading article — then demands an exact match
against a single expected string. No colour/color, no plurals, no
20/twenty, no “any one of these is acceptable” key. Real candidates are being
marked wrong. A noul per answer — “is this equivalent to the key?” — is a direct fix.
apps/ielts-test/tests/official-3/index.html:1349 — duplicated across all 7 tests
Hermes inbound gating observability
Three silent gates drop messages with no log line, and the mention check is a bare substring search for
the bot’s number. Replacing the wake decision with a logged probability turns a silent drop into a number
you can look at — which is exactly what cost you half a day in August.
Speaking band scored from recording length integrity
Four IELTS criteria — including lexical resource and pronunciation — are computed from
duration and how many questions were answered. The audio is never examined; silence of the right length
scores like a Band 8. This one needs a transcript and a real model, but the scoring step is
exactly a set of scores with rubrics.
apps/ielts-test/courses/speaking/index.html:669
Thinking-budget gate on live calls latency-shaped
A keyword regex on noisy speech-to-text decides whether the model is allowed to think. Missing means a
broken commitment invariant; false-firing costs ~3 s mid-call. At 130 ms, Jev fits inside the latency
budget the regex exists to protect — which is the rare case where adding a network call is still faster.
Error classifiers: keep the regex, add a fallback pattern to copy
Hermes has a 22-bucket error classifier and simple-host triages vendor errors by substring. Don’t replace
these — the fast path is free and correct most of the time. Call Jev only when the cascade falls
through to unknown. Same trick for the 130-entry bot user-agent list.
# pip install typesafe-sdk · npm install @typesafe-ai/sdk · or just curl
curl -X POST https://api.typesafe.ai/v1/systemone \
-H "Authorization: Bearer $TYPESAFE_API_KEY" \
-H "Content-Type: application/json" -d '{
"state": "Help! My payouts have been failing for 3 days.",
"model": "jev-latest",
"questions": {
"is_urgent": {"type":"noul", "instructions":"Does this convey urgency?"},
"department": {"type":"choice", "instructions":"Which team should handle this?",
"criteria":{"billing":"payments","technical":"bugs","sales":"pricing"}},
"frustration":{"type":"score", "instructions":"How frustrated is the customer?",
"criteria":["Calm","Frustrated","Very angry"]}
}
}'
The one rule for keeping this reviewable: put every question
and every threshold in a single constants file. The questions are the logic — if they’re scattered
through handlers, nobody can review what the system actually decides.