Jev: what if an AI didn't need to generate text?

Much of what we do with AI today follows roughly the same model: we send some context, the model processes it, and it generates a text response, token by token.

That works very well when we want to chat, write code, summarize documents, or generate content. But there are a huge number of problems in software that don't need any of those things.

Sometimes, we just need a decision.

Which workflow should run? Which category should be selected? Is a request urgent? Which tool should be called? Should a particular action continue or stop?

This is where Jev, from TypeSafe, comes in.

The proposal is relatively simple: instead of asking a model to generate an open-ended response, you define the possible outcomes in advance and provide the context needed for it to choose between them.

For example:

Which action should be executed?

[approve, reject, request_review]

The model doesn't need to write an explanation of its decision. It simply chooses one of the alternatives and can provide a probability for each.

That changes the way we can think about using AI.

Less generation, more decision

A traditional LLM is extremely flexible precisely because it can generate practically any sequence of text.

The problem is that this flexibility also comes at a cost.

If I only need to determine whether a ticket should go to support, finance, or sales, using a model capable of writing thousands of words can feel a bit like using an entire compiler to solve an if statement.

Jev tries to target exactly this part.

TypeSafe designed the model to work with structured decisions and, according to the company, uses parallel processing to evaluate alternatives instead of generating a response sequentially.

The promised consequence is interesting: very fast responses and extremely low inference costs.

But there is an important trade-off.

The more you constrain what the AI can answer, the more predictable it becomes, and the fewer things it can do.

And perhaps that is Jev's most important characteristic.

It isn't trying to be a smaller, cheaper, or faster GPT.

The idea is to be a different component inside an application.

Where could this actually make sense?

Think about an industrial system.

An event happens and we need to decide:

Is the machine in a condition that requires intervention?

[yes, no]

Or a SaaS application:

Which flow should be executed?

[create_ticket, reply_to_customer, route_to_human]

Or even as a layer between an application and another AI agent:

Can the received response be executed automatically?

[yes, no, human_review]

In these cases, we don't necessarily need creativity.

We need fast, structured, and sufficiently reliable decisions.

And that's where the concept starts to become interesting.

But there is a difficult question

Speed and cost are easy to measure.

What really matters is whether the decision is correct.

A model that responds in 100 ms but frequently chooses the wrong alternative isn't necessarily better than a model that is ten times slower.

There is also an important difference between choosing an alternative and actually understanding the context behind it.

Jev's approach depends on us correctly defining the possible options. If we forget an important alternative, the model cannot choose it.

That puts Jev in an interesting position.

It may be valuable precisely because it doesn't try to solve everything.

But that same characteristic may significantly limit where it is actually useful.

Hype or a new piece of the stack?

This is where I think it is worth experimenting.

It doesn't make much sense to ask whether Jev is “better” than GPT, Claude, or Gemini. They are solving different problems.

The more interesting question is:

how many places inside an application where we currently use an LLM could actually be treated as a decision problem?

If the answer is many, there may be a real opportunity here.

If, after testing it, we find that the interesting use cases are few, the accuracy doesn't justify it, or a traditional rule solves the problem better, then perhaps Jev is simply an interesting technology.

And that's exactly what makes the launch interesting.

Not because it promises to be the next big AI, but because it proposes a simple idea:

maybe not every AI problem needs an AI that knows how to talk.

Now we just need to find out how many problems only need an AI that knows how to decide.