JEV: Multiple choice revolutionizes AI processing

JEV is a type of AI model that points toward a different way of building intelligent systems: instead of asking a language model to generate text for every task, we can use a decision model to determine what should happen next.

Large language models have changed how we interact with software. Instead of navigating menus and filling out forms, we can simply ask for what we want.

An LLM works by generating text. It can read a situation, explain it, and even decide what to do next. An AI agent can then turn that answer into an action.

A JEV-style decision model starts from a different place: the choices are predefined, like multiple choice. The model’s job is to help choose between those options.

Imagine a customer-service system with three possible next steps: continue the conversation, ask for more information, or hand the customer to a human.

An LLM agent might read the conversation and produce:

“The customer seems frustrated, so I think we should escalate this to a human.”

A decision model can instead return:

Customer frustrated: 58%
Customer angry:      38%
Customer neutral:    10%
Customer happy:       2%

And, based on that context, make a further choice:

If frustrated or angry => escalate to human
If neutral or happy => continue

The distinction is important. An LLM is essentially a black box. You give it instructions through a prompt and hope it interprets them correctly. Even with careful prompting, its behavior is probabilistic: small changes in the input can sometimes produce unexpectedly different outputs.

“Getting an LLM to reliably perform a specific task can therefore feel more like training a person to follow a procedure than writing the procedure itself.”

You can explain what you want, but you cannot fully specify or guarantee how it will behave. Just like with humans.

“A Decision model directly provides a structured signal that the system can handle explicitly to choose an action.”

Now, you can guarantee the outcome.

That makes this approach particularly interesting for narrow AI systems, where the possible actions are already known.

Multiple Choice

Who remembers their school exams? Wasn't multiple choice always way easier than open answers?

An LLM can generate almost anything. It can invent an explanation, suggest an unexpected action, or produce an answer that the system never anticipated.

A decision model works differently. The system defines the possible outcomes in advance. If there are three possible next steps — continue, ask for more information, or escalate — the model can only choose between those three. It cannot suddenly invent a fourth option.

And those school exams? Even if you didn't know the answer for sure, you often guestimated the right answer!

The model can still be wrong or the answers have similar scores. If one outcome is strongly ahead of the others, the signal is clear and the software can confidently follow that path. If the probabilities are close, the situation is uncertain — and the software can choose to ask for more information, try another step, or involve a human.

“The system defines what is possible; the model determines what is appropriate.”

This is particularly valuable when predictability and control matter. The AI does not need to be trusted with an open-ended ability to generate actions through a prompt. Its role is bounded by the system around it.

Speed

Then there is speed.

Those school exams: multiple choice wasn't just easier — it was faster. You didn't have to write an answer. You just had to recognize the right one and tick a box.

Decision models benefit in a similar way.

We all know how traditional chat models can take time to generate an answer. A decision model does not need to generate text to arrive at an answer. It evaluates the current state and determines which predefined outcome is most likely.

As a result, it is dramatically faster than a text-generating LLM. The difference can be several orders of magnitude: milliseconds instead of seconds. This makes it practical to consult the model continuously as part of an application's decision-making.

It also makes a JEV-like model much cheaper than a traditional LLM. One of the most expensive parts of an LLM interaction — generating all those tokens — simply doesn't exist.

That opens up a different way of using AI.

Instead of calling an LLM occasionally to perform a relatively large reasoning task, a decision model can sit inside the software and be consulted every time the system reaches a meaningful decision point.

A Medical Example

A JEV-like AI could navigate a medical treatment protocol, helping a doctor make better-informed decisions more efficiently.

A patient enters laboratory results. The protocol already defines several possible paths. The decision model evaluates the current state and assigns probabilities to those paths.

Step 1

Treatment A:              84%
Treatment B:              11%
More information required: 5%

The application follows the appropriate branch of the protocol.

Step 2

After the next result arrives, the situation has changed. The model is consulted again:

Continue treatment A: 63%
Adjust treatment:     29%
Escalate:              8%

The application now has a new decision signal and can determine the next branch.

The protocol itself has not changed. The model is helping determine where the current situation fits within the existing decision structure.

That is a fundamentally different role from asking an LLM:

“Look at these lab results and tell me what to do next.”

The LLM may produce a useful answer, and an agentic harness could turn that answer into an action. But the model is still generating an open-ended response.

With the decision model, the application has already established the boundaries. The model supplies the judgment needed to navigate them.

A New Way to Build Software

For decades, software has been built by writing rules that tell computers what to do.

Then came LLMs, which gave software something it had never really had before: the ability to understand language, reason about unfamiliar situations, and interact with the world in a much more flexible way.

Decision models introduce another possibility:

“Software that can make intelligent decisions inside its own logic.”

Instead of building an application as a collection of rigid rules and then adding an AI chatbot on the side, we can start putting intelligence directly into the application's decision points.

AI becomes part of the software's normal operation.

This will change the way we build software.

It is no longer just:

“What can we make an LLM do?”

It becomes:

“What could software become if every important decision could have intelligence behind it?”

That is the direction we're exploring with JEV.