Jev Engineering 101

Build the brain that predicts your agents’ next step

The #1 Directory for Skills & MCPs (Sponsor)

Get Agentic Tools

Are you building with AI agents?

GetAgenticTools is a massive directory of 40,000+ skills, plugins, MCP servers, and agent loops, searchable in one place.

Find the tools your agent is missing → getagentictools.com

Motivation

Everyone is talking about Jev.

Last week, TypeSafe introduced Jev, its new AI “System One” model that could revolutionise how we use LLMs. They call it the “Internet moment” for AI.

Their launch post made 75K likes and 38 million views in just a few days, and developers are already building crazy use cases with it.

But what is Jev?

Jev is a decision-only AI model. It takes a state plus typed questions and returns a choice, score, or true/false probability with confidence.

It is designed for fast, cheap routing and classification inside software.

Jev is not a chatbot. It does not write emails, code, or explanations. That’s what makes it different from traditional LLMs like Claude Fable or GPT-6 Astra.

It became an overnight success for two reasons:

• It unlocks a whole new class of low-latency classification and decision-making features.

• People are realizing they use expensive LLMs for a huge number of decisions that Jev can make much faster and cheaper.

So let me break down what it is, the best use cases, and how you can start using it in your agentic systems.

How Jev Works

The main goal of Jev is to separate decision from execution. Think of it as a smart switch statement.

Or think of a football game: Jev is the referee. Your code and LLM calls are the players.

The referee only decides: was it a goal or not? Is it a red card or not? It gives you a yes/no answer with a confidence score.

The players do the actual work. Your code runs the next step: writes code, clicks buttons, issues refunds, retries, or stops.

Jev judges. Your agents act.

You give Jev two things:

1. State — a message, JSON object, page description, ticket, or any other input.

2. Questions — each one is a Choice, a Score, or a Noul: “Is this statement true?”

Jev reads the state once and answers every question in a single pass.

You get a Choice, a Score, or a probability. Not a paragraph you have to parse.

Your program already has the next step written: route the ticket, click the button, block the tool. Jev only tells it which branch to take.

Why Jev Better Than Fable or Astra

You might ask: Fable and GPT-6 Astra can also make decisions, so why use Jev?

Frontier models are excellent at making decisions.

But they are too slow and too expensive for the hot path.

On TypeSafe’s System One tasks, Jev is claimed to be up to ~200× faster and ~400× cheaper than frontier models like Claude Fable or GPT-6 Astra.

That is the difference between “ask once” and “ask constantly.”

The speed unlocks a completely different class of applications where latency is a core non-functional requirement.

In some products, latency is the product.

For example, imagine a moderation system processing thousands of comments, listings, and ads every minute. You do not want to send every item to a frontier model and wait seconds for an explanation. Jev can classify each one in a few hundred milliseconds: scam, spam, NSFW, or safe.

Or imagine an AI agent controlling Chrome. With a frontier model, every “what should I click next?” can take seconds and burn expensive tokens. Jev looks at the current page, picks the next action based on the goal, and your agent executes it.

Jev is an LLM-decision on steroid.

The LLM → Jev → Code Loop

Jev does not replace Fable. It takes over the decisions Fable was never cheap enough for.

Keep the LLM where language is the job: draft the email, write the code and plan the next steps.

A simple rule to remember:

• “What do I say?” → LLM

• “Which option?” → Jev

• “Do the thing.” → code

If you skip Jev, you pay frontier-model prices for a switch statement.

If you skip the LLM, you lose the part that can handle ambiguity and language.

If you skip code, you give the model the production button.

The Three Primitives of Jev

Jev does not answer in paragraphs.

It answers in three shapes:

• Choice - picks one option from a list you define.

  • Which bucket is this? What should happen next?

  • You get the winning option, a probability for each choice, and a confidence score.

• Score - places something on a scale you define.

  • How urgent? How relevant? How severe?

  • The result can fall between values. Like 1.4 on a 0–2 scale.

• Noul - answers yes or no as a probability from 0 to 1.

  • Is this true? Should we do it?

  • A result near 0.5 means Jev is uncertain. Treat that as “don’t act yet.”

You can ask several of these questions in one call. Jev reads the state once and answers all of them.

💡 State should contain evidence. A one-line summary is weaker than the actual message, fields, and facts your code already has.

How to Use Jev in Your Projects (3 steps)

1. Pick one judgment

Find a decision in your agentic system that Jev can take over.

Look for a step that requires judgment, but not generation.

For example:

• Search / RAG: which chunk is relevant enough to keep?

• PR gate: security-sensitive, nits only, or safe to merge?

• Email triage: spam, billing, bug, feature request, or needs a human?

• Ticket routing: which team, how urgent, refund request or just confusion?

2. Define the state and questions

Imagine you want to classify every new PR before anyone reads it.

Not to write a review.

Just to decide: can we merge it, what kind of risk does it have, and how severe is it?

You already have the raw PR. That becomes the state:

As discussed, Jev answers only three kinds of questions: Noul, Choice and Score.

For this PR-gate job:

3. Call Jev and implement the smart switch

Send the state and questions to Jev.

Then keep the actual merge logic in your code:

You input state.

Jev outputs Noul, Choice, or Score.

Your code decides what happens next.

What APIs to use?

You do not need to integrate directly with TypeSafe. There are already several ways to use Jev depending on your stack.

I recommend three:

• TypeSafe API — the official API

• OpenRouter — useful if you already route models through OpenRouter

• Vercel AI Gateway — easy to integrate and free to try until September 25

For most existing AI applications, OpenRouter or Vercel will probably be the easiest starting point.

What Jev Is Bad at.

• It will not write code.

• It will not draft emails.

• It will not design architecture.

• It will not look at a raw screenshot. Today, you describe the state in text or JSON.

• Jev will also not fix a bad question. If your Choice list has no other option, it will pick the least-wrong label.

If the state is vague, the answer will be vague too.

Low confidence is not a soft yes. A Noul near 0.5 means: “I don’t know.” Send that step to Fable, Astra, or a human.

Recap

Jev is not another chatbot.

It is a fast, cheap decision model built for the parts of software where you already know the possible outcomes.

The mental model is simple:

• LLM → understands, writes, plans

• Jev → decides

• Code → executes

Use Jev for routing, classification, scoring, filtering, and other closed decisions.

Give it good state, define the possible outcomes, and let your code decide what happens next.

Stop using expensive frontier models for decisions that are basically smart switch statements.

Use Jev to Craft Better Software!