TypeSafe · Jev · System One

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.

YOU SEND state any string or JSON — a ticket, a diff, a transcript, app state questions noul is_urgent? choice which team? (of 4) score how angry? (0–3) Jev all answers in parallel ~130 ms YOU GET BACK { "is_urgent": { "noul": 0.97 }, "department": { "choice": "technical", "probabilities": {technical .75, billing .25, …}, "confidence": 0.67 }, "frustration": { "score": 2.76, "confidence": 0.76 } }
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.

LLM · sequential each token waits for the last 8.5 s …now parse the string, validate the schema, and retry if the model wandered off Jev · parallel every answer emitted at once One round trip. 1 question or 200 questions — measured at the same 0.13 s either way. 0.13 s
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.”

noul Is this statement true? “Does this convey urgency?” 0.0 no yes 1.0 0.97 one float. no confidence field — the number is the confidence
choice Pick one of N (max 255) technical .75 billing .25 sales .00 legal .00 confidence 0.67 a split field ⇒ lower confidence
score Rate on a rubric (max 10 levels) 0 calm 1 mild 2 frustrated 3 very angry 2.76 lands between levels — sortable

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.

GATE 1 Does your code branch on a judgement about messy human text? GATE 2 Can you write down every possible answer before the call? GATE 3 Is a number enough — you need no prose, code or explanation back? GATE 4 Is it a judgement rather than a calculation? YES YES YES YES TypeSafe fits. Use it. NONO NONO It’s plain logic. Write the if statement. Never pay a model for something a comparison can do. Open-ended extraction. Use an LLM. Jev can pick a candidate; it can never invent a string. You want a reason, not a verdict. Use an LLM. There is no “why” field. Ever. Arithmetic, dates, counting → use code. It won’t lie to you — it just returns ~0.5 and shrugs.

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.

CONFIDENCE 0.0 1.0 Show a balance wrong = a wasted tap ACT AUTOMATICALLY 0.30 0.40 Auto-reply to a ticket wrong = an annoyed customer ACT CONFIRM 0.50 0.70 Approve a transfer wrong = money is gone ESCALATE TO A HUMAN ASK THE USER 0.60 0.90 blast radius grows …so the bar to act without a human moves right
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.

BEFORE “Is this message directed at the assistant?” “Tintu can you check the deploy?” 0.50 it has never heard of “Tintu”. so it says so. add one line "the assistant is named Tintu" AFTER “Tintu can you check the deploy?” 0.96 “Tintu says hi to everyone” 0.34 The decoy stays low. It learned the name, not a keyword match on it.
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 today one Jev question
0%25%50% 75%100% share of cases classified correctly “Is the caller making an offer?” call-assist · pipeline.py:469 12 phone-call utterances 7/12 10/12 “Does this diff touch security?” orchestrator · review_gate.py:27 6 diffs, 3 traps in each direction 0/6 6/6
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

fileregexJev
tokenizer.pyRISKY0.03
roles/carousel.tsxRISKY0.02
hashtags.goRISKY0.02
core/identity.rssafe0.94
store/handler.gosafe0.93
util/helpers.gosafe0.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

utteranceregexJev
“that’s fine by me”miss0.52
“another twenty on top”miss0.88
“I’ll hold that for you”miss0.43
“we’re at number 42”false fire0.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.

simple-host/internal/handler/collections.go:36 · visitorsession.go:241 · sf-fog/push.go:160

Security tiering in review_plan easy win

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.

orchestrator/review_gate.py:27 (RISKY_PATTERNS) · :88 (size-only tiering)

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.

hermes/gateway/platforms/whatsapp_common.py:348 · :309 · signal.py:624

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.

call-assist/call_assist/pipeline.py:469 (_TERMS) · :478 (_effort_for)

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.

hermes/agent/error_classifier.py:554 · simple-host/internal/analytics/classify.go:104

Getting started

The whole integration is one POST.

# 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.