Meet Jev: Why an AI That Makes Small Decisions Could Be a Big Deal

Daniel Nygaard — Mon, 21 Sep 2026 06:14:32 +0000

AI can write poetry, explain quantum physics, and turn a two-line email into a royal proclamation.

But sometimes, all you need is a decision.

Where should this support ticket go? Does this document need a human review? Is this customer mildly annoyed or about to write a LinkedIn post?

So, what is Jev?

Jev is TypeSafe’s AI model built to make decisions that software can immediately use.

You provide information and define what you want assessed. Jev can choose from a list, give something a score, or estimate whether a statement is true. It can handle several questions about the same information together.

Imagine a support inbox. For each message, you might ask:

What is the customer contacting us about?
How urgent is it?
Does someone need to step in?

Those small judgments help determine what happens next. Multiply them by thousands of messages, and you have a substantial amount of work.

Why has plugging AI into software been such a headache?

LLMs have historically been built around generating text. That’s great when someone wants an explanation. It gets awkward when an application needs a specific value.

A human can understand, “This customer seems pretty upset, so I’d probably escalate.”

Software would prefer escalate: true. It has things to do.

Turning those conversational answers into dependable data has required plenty of engineering: careful prompts, extracting values, checking formats, and retrying when something goes wrong. Structured outputs address this by making models follow a schema—essentially, a form with defined fields and allowed answers. Modern implementations can enforce that structure, saving developers a lot of “please return valid JSON” pleading.

What does Jev do differently?

Structured decisions are Jev’s native output.

You define the questions and possible answers, and Jev returns values your application can use directly, along with probabilities. That removes the need to turn a conversational response into a usable decision.

For supported tasks, this can mean less code devoted to translating answers and a simpler path from “assess this situation” to “take the next step.”

Developers still have to define sensible questions and decide what happens with the results. Jev won’t magically understand your company’s refund policy, especially if your company doesn’t either.

The interesting difference is that Jev makes structured decision-making the starting point of the model’s design. That’s a natural fit for applications that need a choice, a score, or a signal—and have absolutely no use for three paragraphs of introductory remarks.

Why is that exciting?

Because businesses run on small decisions.

Sorting requests. Flagging problems. Prioritizing work. Deciding which cases can proceed and which need another look.

None of this makes for a particularly glamorous demo. Nobody is standing onstage announcing, “We have revolutionized the sorting of moderately confusing support tickets.”

But these decisions are everywhere. Making them faster and cheaper could make automation practical in many more situations.

How much faster and cheaper are we talking?

TypeSafe reports Jev being roughly 194 times faster and 445 times cheaper in its workflow evaluations. Launch announcement

Yes, those numbers deserve a second glance.

However, these are TypeSafe’s own results for particular workloads. The company acknowledges that they sit toward the high end of expected real-world gains. AI performance announcements can be ... optimistic, so keep the champagne chilled for now.

Still, the potential matters. When each AI decision takes very little time and money, developers can afford to use more of them throughout an application.

Wait—does it really have “zero hallucinations”?

No.

Wait, what?

TypeSafe guarantees that Jev’s answers fit the options and formats developers define. This prevents it from returning an invented option or an answer the surrounding software cannot use. Launch announcement

It does not mean every decision is correct.

If the available departments are Billing, Sales, and Support, choosing Billing when the customer needs Support is still a mistake.

It is simply a mistake delivered in the correct format. Anyone who has filled out an expense report will recognize the distinction.

What happens when Jev isn’t sure?

This is one of its more interesting ideas. TypeSafe aims to give Jev useful confidence estimates, so developers can set rules for when software acts automatically and when it asks for review. TypeSafe

In a support system, that could mean handling an obvious billing question immediately while sending an ambiguous complaint to a person.

Think of an employee who knows when to say, “I’ve got this,” and when to say, “Someone should probably take a look.”

Of course, those confidence estimates need testing on the actual work. An AI confidently announcing that it is confident is not, by itself, a quality-control process.

Does it live up to the hype?

Too soon to say.

TypeSafe’s published evaluations cover four workflows and compare decisions with reference answers generated by other leading AI models. Evaluation methodology

That comparison makes Jev look very impressive, but agreement with other models doesn’t establish whether the answers are actually correct.

The real test is everyday use: messy requests, incomplete information, unusual cases, and customers who describe their problem as “the thing is doing it again.”

So, why could Jev be groundbreaking?

Jev tackles a practical problem: how do you make intelligent decisions cheap, fast, and easy to use inside everyday software?

If TypeSafe’s approach holds up across real applications, developers could automate more routine work while giving uncertain cases the attention they need.

The result could be applications that quietly sort requests, catch issues, and keep things moving throughout the day.

If it works, you might never notice Jev is there.

That would be a refreshing development for anyone who has recently opened an app

ChatGPT is less than 4 years old

Daniel Nygaard — Sat, 12 Sep 2026 17:49:01 +0000

For many of us, ChatGPT was the first time we became acquainted with AI. By now, I think it's safe to say that we have all felt the impact. Does anyone remember all the quirks of the initial OpenAI GPT-3.5?

The hallucinations? The endless apologetic tone? How people used ChatGPT to turn everything into a rap - and all the interesting jailbreak methods involving hilarious roleplay scenarios?

Despite ChatGPT being less than 4 years old, we have lived through 3 eras already.

The auto-complete era

Remember just prior to coding agents taking over, we had the auto-complete period powered by Cursor & GitHub Copilot? It was a short-lived period - from 2023 to 2024 - but we all thought it was amazing.

Especially when you had a block of code suggested that was identical to what you were just about to write - and it was only a tab away!

The agentic coding era

Then in 2025 we got agentic coders - Anthropic released Claude Code in February, followed by OpenAI releasing Codex 3 months later.

They started as apologetic assistants. They felt like junior developers that displayed a remarkable inconsistency in their abilities to deliver. Sometimes they would suggest an event-sourced system with a complex reducer as an elegant solution to a complex problem. Other times, they would try to run npm run dev without installing the dependencies - and spiral into increasingly elaborate fixes, instead of simply running npm install.

They were entertaining to work with (although frustrating from time to time) - but overall, a fascinating new way to code.

But they quickly evolved, and I think Claude Sonnet 4 was a major milestone for quality of agentic coding. It still had its flaws, but overall it felt more senior in the way it would approach issues.

The loop engineering era

While many people are still using the agentic coding approach in 2026, the new trend is the construction of agentic loops. Boris Cherny (Anthropic) helped popularize this approach.

Being able to prompt an AI to solve tasks is amazing - but it still requires prompting. If you could bypass this by building autonomous loops that are triggered by events or scheduling - you would never have to prompt an AI directly.

The potential for scaling is enormous - provided you (or the AI!) can verify the results.

The next era?

It's wild how far this technology has come in such a short time. If this trend continues, I think in a year we will all look back at the models that are currently considered "state of the art" from Anthropic, OpenAI and Kimi, and wonder why we were ever impressed with them at all.

Personally, I'm excited to see what is next to come. Fingers crossed that it is not the total extermination of the field of software engineering. Despite my enthusiasm about AI these days - I still really like to write, read and understand code myself.

If this post left you feeling nostalgic, you have a final chance to play with GPT-3.5 via OpenAI's API - but not for long. The gpt-3.5-turbo-1106 model (which to be fair is the later 2023 version of gpt-3.5) is shutting down on September 28, 2026!

https://developers.openai.com/api/docs/models/gpt-3.5-turbo

DEV Community: Daniel Nygaard