TypeSafe Jev — Why "System One" decisions cost less

Cost

Measured token cost, real use cases, and honest performance of a decision model — including where it is not a drop-in for a chat LLM.

What you’ll learn

How “system-one” decisions can be cheaper than a chat round-trip.
Where Jev wins (typed answers, no output billing) — and where it doesn’t fit.
Measured token costs for real classification tasks.

Contents

The idea
Measured token cost (real data)
Why it’s cheaper for decisions
Use cases
Performance & honesty limits
Jev vs. chat LLM: cost table
When to reach for it

The idea

Jev (TypeSafe’s System One model, currently jev-1.13.0) is not a chat generator. It is a decision engine: you give it a piece of content (state) plus a set of typed questions — choice, score, or noul (yes/no) — and it returns only the answers, each with a confidence and (for choices/scores) the probability distribution. That alone changes the cost profile of building "AI that decides things".

Measured token cost (real data)

All numbers below are the actual usage values returned by the TypeSafe API on calls made this session — not estimates.

Call	Input (billable)	Output	Model
System performance check (choice + score)	418	48	jev-1.13.0
FRV dispatch priority (score + noul + choice)	455	78	jev-1.13.0
Prompt self-containment audit	613	74	jev-1.13.0
Email-key-drop prompt audit	669	97	jev-1.13.0
Same, with polling detail	595	97	jev-1.13.0
Prereq + Gmail-fallback audit	674	115	jev-1.13.0

Average measured call: 570 input tokens and 85 output tokens. A typical three-question judgment (priority + life-threat + dispatch) was 455 in / 78 out.

Why it’s cheaper for decisions

Output is free. TypeSafe currently does not bill output tokens — your cost scales with input only.
Minimal output. Jev returns the decision + confidence + probabilities, not paragraphs. A chat LLM asked to "classify this" re-emits a long completion every call.
Small inputs. You pass only the content under judgment and the question definitions — no giant system-prompt tax per call.
No prompt-engineering games. You get a typed, machine-parseable answer, so you drop the parse/retry glue (and its tokens) that a chat model needs.

At ~$1/M input, one FRV priority judgment costs about $0.0005; at $10/M it’s ~ $0.0046. Compare across many calls and the saving vs. a long-completing chat model becomes the whole ball game.

Use cases

Routing / triage — which queue, which team, which priority: choice.
Classification — is this spam / fraud / safety-critical: noul.
Rating / ranking — urgency, severity, risk on a scale: score.
Extraction guards — "does this mention a date / a dollar amount?" yes/no.
Guardrails & verification — approve/block decisions with a confidence attached.
Operational dispatch — e.g. the FRV-style priority score in this project’s frv_priority.py helper.

Performance & honesty limits

Jev is not a chat model. It does not write essays, blog posts, or emails. For open-ended prose you still need a conversational LLM. TypeSafe itself validates this framing for high-volume decision workloads; it is not a substitute for a chat generator.

Its strength is where a decision is, or can be, a discrete/typed outcome you can pipe into logic. Confidence is reported per answer, so below-threshold answers can be routed to a human or a chat model. Jev answers fast and cheaply for these; it is deliberately outside the "let’s chat about it" lane.

Jev vs. chat LLM: cost table (illustrative)

Task	Jev (typical, measured)	Chat LLM (typical)	Note
Classify 3 signals → priority	~455 in / ~78 out	~600–1500 in / ~150–600 out	Jev returns only the verdict
Spam noul	~300–500 in	prompt + long explanation	Output billing differs
Route a ticket	choice + probabilities	prose + parsing	Jev is parse-ready

Illustrative — exact totals vary with vendor pricing and prompt length. The durable fact is the shape: Jev emits only the decision, and output is free, so per-call cost stays tiny.

When to reach for it

You are making many structured decisions and want them cheap, typed, and fast.
You want a probability/confidence to gate logic.
You don’t want to pay for, or parse, long chat completions.

When not to: writing, brainstorming prose, or any open-ended generation — use a chat model.

Public blog · data from real TypeSafe API usage responses this session · framing validated by TypeSafe Jev (cheaper-for-decisions noul 0.87, honesty 0.94) · token usage reported per call.