The car can’t wait for a sentence

Watch a self-driving car from above. Every time the road asks a hard question, the simulation freezes and shows you the same moment answered two ways: a large language model writing out its reasoning, and Jev returning typed judgments your code can act on. Same situation, same facts, two very different shapes of answer.

A teaching simulation, not a real autonomy stack. The numbers in the panels are illustrative; the Jev figures come from TypeSafe’s published launch material. Four situations, about four minutes.

Speed0 km/h

Distance0 m

Jev judgments0

LLM calls0

StatusParked

LLM answers here+35 m

Jev answers here+1.4 m

A quiet suburban road, seen from above

The blue car drives itself. Four times on this trip the road will ask a question that a rule cannot answer on its own — a ball, an ambulance, a blocked lane, an amber light. Each time, the drive pauses and you see how the two kinds of model handle it.

Situation 1 of 4

The same input, both ways

Then your code decides

LLM0 msprompt → text → parse

Jev0 msstate + questions → typed answers

Then your code decides

The clocks run in real time. The olive marker is where the car is when Jev answers; the clay marker is where it is when the LLM finishes writing.

What happened on the drive

Each situation, the decision both models reached, and what it cost to reach it.

Nothing yet — start the drive above.

LLM and Jev, side by side

Both models read the same words and understand the same situation. The difference is what comes back, and how long the world has to wait for it.

	LLM	Jev
The question it answers	“What should I say about this?”	“Which of these, and how sure are you?”
What comes back	Free text, token by token. Your code has to parse it and handle the times it drifts.	Only the answers you defined, with probabilities and a confidence value. Nothing to parse.
Time to answer	2–3 seconds in these panels; 3 to 329 seconds on the benchmarks TypeSafe cites for frontier models.	70–500 ms, whether you ask one question or eight.
At 54 km/h that is	35 to 45 metres of road travelled before the first useful byte.	About 1.4 metres.
Asking a sixth question	Longer prompt, longer answer, more latency, more cost.	Same round trip. Questions are evaluated in parallel over one state.
Same input twice	May word it differently, may land on a different call.	Same distribution over the same options.
Knowing it’s unsure	You can ask it to rate its confidence. It tends to be sure of itself.	Calibrated confidence on every answer — the number your threshold reads.
Where the policy lives	In prose, inside the prompt, weighted differently each call.	In your code: `if (ped.noul > 0.5) brake()`. Readable, testable, diffable.
Cost of running it 10× a second	Roughly $300 an hour of driving, at frontier prices — and it still would not keep up.	Cents. $42 per billion input tokens, output free.
Can it explain itself	Yes, fluently, at length.	No. It returns numbers. The explanation is your code.
Best job on this car	Off the critical path: planning the route, writing the incident report, designing the questions, handling the genuinely novel.	The fast loop: watch, judge, gate, route — ten times a second, every second.

What the four situations showed

Latency is distance. A correct decision that arrives 35 metres late is not a correct decision.
Confidence is a feature. When the answer was genuinely split, Jev said so in 88 ms and the code took the reversible action instead of guessing.
Cheap means you can ask again. The world moves. Jev re-asks ten times a second; an LLM answer is a photograph of a road that has already changed.
Policy belongs in code. “Never pass a cyclist on a blind stretch” is a line you can test and show a regulator, not a sentence buried in a prompt.

Not a replacement — a division of labour

Jev is System One. Fast, cheap, narrow, always on. It turns a situation into typed judgments your code can branch on.
The LLM is System Two. Slow, expensive, general. It thinks about the case that has never happened before, and it explains itself to a human.
Your code is the driver. It holds the thresholds, the vetoes, the fallbacks and the escalation rules — and decides which model it needs, if any.
Most of the time, neither is needed. Lane keeping is control theory. The models are for the moments where the answer needs meaning.

Ask an LLM “is that child going to run out?” and it writes you a paragraph. Ask Jev and it writes 0.88 — and it has already answered the next five questions too.

The honest part

This is not how cars are built

Real autonomous vehicles run dedicated perception and planning models on hardware in the car, not a text API in the control loop. The car here is a way to make latency and output shape visible. The lesson is about the shape of a decision, not about driving.

Jev cannot see

The facts in the left column come from perception — cameras, radar, maps. Jev reads state as text or structured data and returns judgments. It takes no images today.

Typed is not the same as true

Jev cannot return an option you did not define, so the output never breaks your parser. It can still pick the wrong option. Calibration is a property of many answers, not a guarantee about one.

The numbers

Every panel value is invented for the demo. The Jev figures behind them — 70–500 ms, $42 per billion input tokens, calibrated confidence — are TypeSafe’s own, published at launch on 15 September 2026, and Jev is in early access.