TypeSafe's Jev is fascinating. But I think the bigger idea behind it may matter even more for the future of AI agents.
For the last few years, the dominant way to build AI software has been surprisingly simple:
Send something to a large language model.
Need to classify a message? LLM.
Need to decide which tool to call? LLM.
Need to check whether a result makes sense? LLM.
Need to decide whether another LLM should retry?
Another LLM.
It works.
But as we move from chatbots to systems containing dozens — eventually hundreds — of AI decisions, I think this architecture starts to look increasingly strange.
Then TypeSafe AI introduced Jev.
And while most of the discussion around Jev has understandably focused on its speed, cost and unusual architecture, I think there is another lesson hiding underneath the launch.
We may have been treating intelligence as a single resource when it should actually be managed as a hierarchy.
Jev changes the unit of AI
Traditional LLMs produce strings.
Jev does something deliberately narrower.
TypeSafe describes JEV as a System One model: you provide state and structured questions, and the model returns typed probabilistic decisions that software can consume directly.
Instead of asking:
Read this customer request and explain what our system should do.
you might effectively ask:
Is this urgent?
Which department should handle it?
Does this require human review?
And receive structured probabilities rather than paragraphs.
The difference sounds small.
Architecturally, it isn't.
Jev moves intelligence closer to something like a probabilistic function call.
TypeSafe's published numbers are striking: the company reports end-to-end latency between 70 and 500 milliseconds and a price of $0.042 per million input tokens.
In some of its workflow evaluations, it reports gains as high as 193.6× in speed and 444.6× in cost.
Those are TypeSafe's own benchmarks, and the company itself acknowledges important methodological caveats.
So I don't think the numbers should be the main story yet.
The architecture should.
Not every decision deserves a frontier model
Consider an autonomous agent working on a real business process.
During a single task it might need to decide:
- Is this information relevant?
- Which tool should I use?
- Did the previous step succeed?
- Should I retry?
- Is this result suspicious?
- Does this require human approval?
- Do I need deeper reasoning?
Those decisions do not have equal complexity.
Yet a common agent architecture effectively treats them as if they did.
That is like asking a senior engineer to personally answer every support ticket, check every log line and approve every routine operation.
It works.
It is also a terrible organizational design.
The same may be true for AI.
FAST, REVIEW and DEEP
One mental model I have started using is to separate machine reasoning into three layers.
I call them:
FAST → REVIEW → DEEP
This is not TypeSafe terminology. It is simply a way I find useful to think about agent architecture.
FAST
Cheap, low-latency judgments.
Routing, classification, relevance, simple validation and confidence estimation belong here.
Most decisions in a large autonomous system may eventually happen at this level.
Jev is an interesting candidate for exactly this layer.
REVIEW
Something is uncertain, contradictory or important enough to deserve more computation.
A stronger model examines the state, checks evidence and determines whether the original decision should stand.
DEEP
Expensive reasoning is reserved for the relatively small number of problems that actually require it.
Planning.
Complex diagnosis.
Novel situations.
High-impact decisions.
And in sufficiently important cases, the next step is not another model at all.
It is a human.
So the architecture becomes something closer to:
EVENT
↓
FAST
↓
confidence high? ─── yes ──→ ACT
│
no
↓
REVIEW
↓
resolved? ────────── yes ──→ ACT
│
no
↓
DEEP
↓
high impact / uncertainty?
│
yes
↓
HUMAN
Now intelligence is no longer simply something an application "calls."
Intelligence becomes something the system allocates.
That may be more important than model routing
Model routing already exists.
Send simple prompts to a cheap model and difficult prompts to an expensive one.
Useful, yes.
But I think the bigger opportunity goes beyond routing.
The real system needs to manage:
effort, uncertainty, evidence and authority.
A fast model saying "92% confident" should not automatically mean that an action is safe.
Confidence must interact with consequences.
Deleting a temporary file and deleting a production database can have exactly the same model confidence while requiring completely different governance.
So a mature agent architecture eventually needs something like:
decision
+ confidence
+ consequence
+ evidence
+ permissions
= execution policy
That layer interests me much more than simply choosing between Model A and Model B.
About the "zero hallucinations" claim
I would interpret that claim carefully.
Jev's output space is typed and defined in advance, so the model cannot suddenly return an essay when the software expects one of three categories.
Type errors can therefore be eliminated by construction.
That's genuinely valuable.
But a structurally valid answer can still be wrong.
A classifier that confidently selects the wrong category has respected the schema perfectly.
It has still made the wrong decision.
Type safety solves an important software problem. It does not eliminate epistemic uncertainty.
Interestingly, Jev exposing probabilities may make that distinction more useful rather than less useful: software can decide what to do with uncertainty instead of pretending it doesn't exist.
The real opportunity: cognitive governance
This is where I think things become particularly interesting.
Imagine an agent system where every task starts with inexpensive judgment.
Most operations finish there.
Some escalate to stronger reasoning.
A smaller number reach deep analysis.
And only consequential or unresolved cases reach humans.
The objective would no longer be:
Use the smartest AI available.
It would become:
Use the minimum sufficient intelligence required to reach a reliable decision.
That is a very different optimization problem.
We could measure a system not only by benchmark accuracy, but by:
quality
×
latency
×
cost
×
human intervention
×
evidence
This could eventually matter enormously for AI economics.
If agents execute thousands of decisions while completing one business process, reducing the cost of an individual decision by an order of magnitude changes what is economically possible.
TypeSafe explicitly connects Jev's name to William Stanley Jevons and the Jevons paradox: making intelligence dramatically cheaper could increase total consumption of intelligence rather than reduce spending on it.
That may prove to be a very good analogy.
Jev may be a primitive, not the platform
And this is perhaps my biggest takeaway.
I don't currently see Jev as a complete agent platform.
I see something potentially more fundamental.
A primitive.
Something that could sit inside orchestration systems, agents, CRMs, security systems, support platforms and business automation.
The interesting product may therefore not be a system built entirely around Jev.
It may be an architecture capable of combining:
deterministic code
+
fast probabilistic judgment
+
frontier reasoning
+
human authority
and knowing when each should be used.
Jev happens to make one part of that architecture dramatically more interesting.
We may be entering the age of intelligence budgets
Cloud computing taught us to think about CPU, memory, storage and network as resources that software architecture must allocate.
AI systems may add another resource:
cognitive effort.
Some decisions deserve milliseconds.
Some deserve seconds.
Some deserve minutes.
Some deserve humans.
If autonomous agents become as common as many of us expect, deciding how much intelligence a decision deserves may become just as important as the intelligence itself.
That's why I'm watching Jev.
Not because I think every LLM is about to be replaced.
Quite the opposite.
Jev makes the differences between kinds of intelligence much clearer.
And that may lead us toward agent architectures that are faster, cheaper — and, more importantly, much better governed.
Top comments (0)