What If AI Didn't Have to Talk?
Tejas GK| (7d ago)
Every AI product seems to want to talk to me.
ChatGPT talks. Claude talks. Gemini talks. Even when we put AI inside an application, we usually ask it a question and wait for it to generate some text.
But I recently came across Jev, a model by TypeSafe AI, and the interesting thing about it is that it doesn't really want to talk at all.
It just wants to make a decision.
And the more I read about it, the more that idea started making sense.
We don't always need another paragraph
Imagine I'm building a customer support system.
A message comes in:
"I've been charged twice and nobody has replied to me for three days."
I could send this to an LLM and ask:
"Read this message and tell me whether it's a billing issue and whether I should escalate it."
And the model might respond:
"This appears to be a billing-related issue. Given that the customer has been charged twice and has been waiting for three days, I would recommend escalating..."
Cool.
But my code doesn't need an essay.
It needs something closer to:
{
category: "billing",
escalate: true
}
That's basically the problem Jev is trying to solve.
Decisions, not strings
TypeSafe describes Jev as a System One Model.
Instead of generating arbitrary text, you give it some state and ask it structured questions.
It gives you typed decisions back.
For example, I could give it a support ticket and ask:
category = billing | account | bug | feature
urgency = 0 → 3
escalate = yes | no
Jev evaluates those questions and returns the decisions along with probabilities.
So instead of AI producing something that a human is supposed to read, it produces something that software can immediately use.
That distinction is small, but pretty interesting.
It's basically a fuzzy if
This was the easiest way for me to think about it.
Normal code is great when the rule is obvious.
if (age >= 18) {
allow()
}
But real-world decisions aren't always that clean.
if (thisCustomerSoundsLikeTheyMightLeave) {
escalate()
}
How do you write that condition?
You could build a bunch of rules. Search for words like "cancel", check sentiment, maintain some giant scoring system...
Or you could ask a model.
LLMs already let us do this, but they're much more general than what we need here. They generate tokens sequentially, can return unexpected text, and usually require us to parse or validate their output.
Jev is built specifically for this second kind of if.
A fuzzy if statement.
Give it messy information.
Get a constrained decision back.
System One?
The name comes from the System 1 / System 2 idea popularized by Daniel Kahneman.
System 1 is fast and intuitive.
System 2 is slower and deliberate.
That maps surprisingly well to AI.
If I ask:
"Design the architecture for a distributed payment system and explain your tradeoffs."
I probably want a powerful reasoning model.
But if I ask:
"Is this transaction suspicious?"
I don't necessarily need a model to think for thirty seconds and write four paragraphs.
I need:
suspicious: 0.94
Then my application can decide:
if (suspicious > 0.9) {
sendForReview()
}
That's the space Jev is targeting.
The speed is kind of the point
This becomes more interesting when you look at the numbers TypeSafe is publishing.
They report Jev responses in roughly 70–500 milliseconds, with input pricing of $0.042 per million tokens and no separately metered output-token cost.
Their argument is basically that once AI becomes cheap and fast enough, you stop thinking:
"Where should I add an AI feature?"
and start thinking:
"Where could my software make a slightly smarter decision?"
Those are very different questions.
A normal application might make thousands or millions of tiny decisions.
Which email gets priority?
Which lead should sales call?
Is this comment spam?
Which model should handle this request?
Should this agent be allowed to execute this tool?
Does this need human review?
Today, a lot of those are hand-written rules.
Jev's bet seems to be that many of them can become tiny AI decisions instead.
The confidence part matters
One thing I particularly like is that Jev doesn't just return the decision.
It returns probabilities.
Because in production, I don't really want an AI pretending that every answer is equally certain.
Suppose Jev says:
fraud: 0.52
Maybe I don't do anything automatically.
But:
fraud: 0.997
could trigger a completely different workflow.
The application still controls what happens.
The AI makes the fuzzy judgment.
The code makes the actual decision.
I think that's a much healthier way to think about AI automation.
Does this replace LLMs?
No.
And I don't think that's the interesting question anyway.
If I need to write an email, generate code, have a conversation or reason through a complicated problem, I still want an LLM.
But a lot of software doesn't need generation.
It needs judgment.
So I can imagine systems where Jev handles hundreds of tiny decisions and an LLM only gets called when something actually requires deeper reasoning or language generation.
Something like:
input
↓
Jev
↓
route / classify / score
↓
normal code
↓
LLM (only if necessary)
That could make AI systems cheaper, faster and, more importantly, easier to reason about.
One last thing
There's also a funny story behind the name.
Jev is named after economist William Stanley Jevons, associated with what we now call the Jevons paradox.
When steam engines became more efficient and required less coal to do the same amount of work, people didn't simply use less coal.
Coal became useful for more things.
Demand increased.
TypeSafe seems to be making the same bet about intelligence.
If an intelligent decision becomes 10x or 100x cheaper, maybe we don't just spend less money running today's AI applications.
Maybe we start putting intelligence in places where using AI previously would've seemed ridiculous.
And I think that's the part of Jev I find most interesting.
Not that it's another AI model.
But that it's asking a slightly different question:
What happens when intelligence becomes cheap enough to use like an if statement?