jev is a decision model from TypeSafe. You send it a JSON state and typed questions (a choice between options, a yes/no as a probability, a score on a rubric) and it returns probabilities over your options in under a second. It does not generate text.

How much does a jev verdict cost?

jev is priced on input tokens only, $0.042 per million at list price. One verdict on an X post with its author profile and first 20 replies is about $0.0001; a signup with its enrichment is about $0.00005.

How is jev different from asking GPT or Claude for a JSON answer?

A chat model writes its answer, so it takes 2 to 4 seconds and bills output tokens; on the same three questions it cost 7 to 28 times more in our runs. jev only reads, and every answer carries a full probability distribution and a confidence, so you can set thresholds and route uncertain cases to a person.

jev cannot fetch anything. treg is one token for a catalog of live data endpoints. treg builds the state, jev decides on it, your code acts on the numbers. Your own provider keys always take precedence over treg's and are never metered.

Through the Vercel AI Gateway: POST to its evaluation-model endpoint with your gateway key, the model id typesafe-ai/jev and a body of state and questions. jev is also available on OpenRouter as typesafe/jev-1.13.

Are the demos on this page real?

The viral-posts board is a real daily run over public X posts, and the post you paste is analysed live. The buyer-signal demo replays a real LinkedIn run with every email address replaced. The signup demo is a synthetic sample built to show the four segments.

How long a state can jev read?

About 30k tokens. Above that the request fails, so split long inputs or summarise them first with a chat model and let jev verify the summary field by field.

How to use Jev, TypeSafe's decision model: examples, use cases and code

what is jev

jev predicts probabilities, not text

Ask a chat model and it writes an answer, one token after another, which your code then has to read. Ask jev and every option you named gets a probability, all at once, summing to one. Same message, same question:

The numbers are the answer. Your code compares them to a threshold; nothing is parsed, nothing can be made up outside your list.

state"Our API integration started returning 500 errors on every request about 20 minutes ago, and we can't process any customer orders until this is fixed."questionWhich team should handle this: billing, technical or sales?

chat model

0.0 s

writing…

jev

technical1.00

billing0.00

sales0.00

0.38 s

0 output tokens · confidence 1.00 · $0.000018

what is jev

Much faster and cheaper than the cheapest LLM

We sent the same three support questions to jev and to GPT-5.6 Luna, the cheapest chat model we could find, with real support tickets padding the input from 2k to 200k tokens. Where both run, jev is 5 to 6× cheaper and 5 to 7× faster, and its time barely moves with input because it never writes.

jev stops at about 30k of its own tokens; above that you split the state. Luna's time is dominated by writing ~80 output tokens, so it sits at 2 to 4 s whatever you send. TypeSafe's own workflow demo claims far more (193.6× faster, 444.6× cheaper); these are our numbers.

cost per call

2k1.7×

8k5.8×

16k5.8×

32k5.7×

time per call

2k7.0×

8k5.9×

16k6.1×

32k4.5×

jevGPT-5.6 Luna

input	jev		GPT-5.6 Luna
2k	$0.0000755	0.39 s	$0.0001299	2.74 s
8k	$0.0002248	0.40 s	$0.0013071	2.35 s
16k	$0.0004122	0.40 s	$0.0023791	2.46 s
32k	$0.0008031	0.51 s	$0.0045953	2.29 s
34k	over limit		$0.0080371	3.59 s
100k	over limit		$0.0233656	3.03 s
200k	over limit		$0.0467147	3.89 s

real English support tickets from a public dataset · cost as billed by OpenRouter · single runs

what is jev

What jev can, and can't

It is a judge, not a writer. Everything on the left is a typed question; everything on the right needs a model that generates text, so you pair the two.

CAN

+pick an actionone of your options, a probability on each · the game further down

+classifybilling 0.99 · technical 0.01 · account 0.00

+score / rank368 people in 42.8 s, $0.013

+say yes or nojailbreak 0.99, four hazards in one call

+route on confidencetwo thresholds in your code, nothing re-run

+read your JSON as it isrows, tables, element lists, ticket histories

+at 5 to 7× a chat model's speedand 5 to 6× cheaper, our runs · ≈ $20 per million decisions

CAN'T

−~~write a sentence~~an LLM writes, jev verifies each field

−~~explain itself~~the distribution is the explanation: log it

−~~write code~~it can judge code: risky change, needs review

−~~reason step by step~~you write the steps as questions, it answers all at once

−~~read past ~30k tokens~~chunk the state, or summarise first and judge the summary

−~~fetch anything~~that is treg: one token, the catalog, then jev decides

−~~remember the last call~~every request is stateless: put the history in the state

real-time decisions

Real-time decisions: a game loop

A game only ever has a handful of inputs. That is a choice question with the buttons as options, so jev answers it as a distribution every tick: nothing to parse, nothing invented outside the set, and fast enough to sit inside the loop.

Seven ticks of a small side-scroller, each judged live by jev from the game state: positions, ammo, the pit, the exit. About 0.35 s and $0.00002 a decision. A chat model writing "I would press jump" took 2.7 s in the race at the top.

GAMEstate in, action out, every tick

action set · fixed

LEFT

RIGHT

JUMP

SHOOT

real-time decisions

Real-time decisions: a page that picks itself

A decision fast enough to run while the page loads. Bryant Chou's Ploy reads a site's conversion data and enriched visitors, forms hypotheses per audience segment, and at load time jev selects the copy and the design for each part of the page for that visitor, then tracks the result and improves the hypotheses.

His figure: the selection takes 25 ms, with no real impact on LCP. Each section is a choice among variants you wrote, so nothing is generated on the fly and nothing off-brand can appear.

@bryantchou on X ↗

25 ms per page loadno real impact on LCPcopy and design, per section, per segmentresults tracked in real timevideo and figures: @bryantchou

web & computer use

Web and computer use

browser-use's jev-ultrafast agent never sends a screenshot. It reads the page into a numbered element table and asks jev one request: which operation, plus a target for each kind of operation, all answered at once. It then uses the target that matches. Only a TYPE_TEXT step calls a small LLM, and only for the text itself.

browser-use/jev-ultrafast ↗

how jev-ultrafast takes one step · from its README

                      one TypeSafe request
                     ┌───────────────────────────┐
page → element table → operation                 │
                     │ click_target              │
                     │ type_text_target          │
                     │ select_target, if present │
                     └─────────────┬─────────────┘
                        use the matching target
                                   │
                 CLICK [7] ────────┼──→ browser
             TYPE_TEXT [3] ────────┘
                       ↓
             small LLM → text → browser

7.07 s flight search, end to end1,092 → 101 browser calls per task2.8 s open a Wikipedia article1.9 s hotel search and filterjev-ultrafast README · single runs

automation & data

Automation: judge every one, not a sample

At a fraction of a cent and under a second, with a confidence on every answer, the business logic goes in the code, and jobs that never paid for a frontier model become a rule that runs on every record.

borja's SEO audit: internal linking is not writing, it is 8,790 yes/no calls. Does this page have a real reason to link to that one, and is the anchor text already in the copy? Left column jev, right column Claude Opus 5, same queue, same rubric. The signup recipe below is the same shape.

@borjafat on X ↗

586 pages in 45.1 s$0.21 total584 links placed, 139 pages refusedOpus 5: 21 pages, $1.43≈ 190× cheaper per pagevideo and figures: @borjafat

search

A search model: filters nobody built

Search usually means the filters someone indexed in advance. With jev the query is a sentence and every record is judged against it, so you can filter and rank by things no column holds: architecture, renovation status, who actually decides. No index, no embeddings, no vector column.

thousands of listings scanned< 20 s$0.18filters: architecture · renovation status · freeway proximityvideo and figures: @venturetwins

how to use it

Three kinds of question

Every jev question is one of three types, and you can send several in one call. Each returns a full distribution, not just a label, so a close call looks different from a sure one.

choice picks one of your options and tells you how close it was. noul is a yes/no as a probability, with a playbook for each side when the line is subtle. score is a position on your ordered rubric: the probability on every level plus their weighted mean.

All three are real answers from our runs.

state · a support enquiry

"The export button double-charged my credits, so my invoice is wrong this month."

question

"department": {
  "type": "choice",
  "instructions": "Which team should handle this?",
  "criteria": {
    "billing": {
      "what": "charges, invoices, credits, refunds",
      "examples": ["I was charged twice",
                   "Where is my refund?"] },
    "technical": {
      "what": "bugs, errors, integrations",
      "examples": ["The export is empty",
                   "API returns 500"] },
    "account": {
      "what": "login, password, profile",
      "examples": ["I can't log in"] }
  }
}

answer

billing0.99

technical0.01

account0.00

→ choice billing · confidence 0.99

The customer needs their invoice fixed, and the examples under billing make that near-certain. Strip the options back to one-line labels and a tenth of the mass moves to technical, because a bug caused it; add "focus": "route to whoever must fix the root cause" and the same message flips, shown under the steering tips. The rubric is where your routing policy lives.

how to use it

Route based on confidence

jev hands back probabilities; your code owns the decision. In TypeSafe's guardrail cookbook the whole policy is two thresholds and a map from hazard to action. Pick a message and watch it walk the tree.

One jev call per message, four hazard nouls plus a severity score, about $0.00002. Edit the two numbers and the same assessments route differently, nothing is re-run.

review_threshold = 0.35
action_threshold = 0.70
severity_block   = 2.0
action = { jailbreak: block, harmful: block,
           medical: review, self_harm: support }

user message

jev · one call

how to use it

Tips for steering jev

There is no system prompt. Everything you would say in one goes into the question itself, and every field that takes text also takes structure: instructions, each option under criteria, each level of a score. jev reads the keys as well as the values.

Shapes shows the same question written three ways. Effect keeps one message and changes only the instructions; the numbers are from our notebook, single runs.

Name keys for what they hold and put the steering in the value. When two labels overlap in plain language, give each option a what, a not_for and examples.

1 · a string

"department": {
  "type": "choice",
  "instructions": "Which team should handle this?",
  "criteria": {
    "billing": "Charges, invoices, credits",
    "technical": "Bugs, errors, integrations"
  }
}

The minimum. One sentence per field.

2 · instructions as an object

"department": {
  "type": "choice",
  "instructions": {
    "question": "Which team should handle this?",
    "focus": "Route to whoever must fix
              the root cause."
  },
  "criteria": { … same as 1 … }
}

Keys are yours to name: question, focus, context, read. None is reserved; the model sees the names with the values.

3 · options as rubrics

"criteria": {
  "billing": {
    "what": "charges, invoices, credits, refunds",
    "not_for": "a bug that caused a wrong charge",
    "examples": ["I was charged twice",
                 "Where is my refund?"] },
  "technical": {
    "what": "bugs, errors, integrations",
    "not_for": "a correct charge the customer
                disputes",
    "examples": ["The export is empty",
                 "API returns 500"] }
}

Each option says what it covers, what it does not, and what it looks like. Score levels take the same shape with summary and signals.