Most Automation Is a Decision, Not a Conversation

Most of the AI steps I see people build into automations aren’t really about generating anything. They’re about deciding something.

Is this comment spam? Which team should this form go to? How urgent is this support request, on a scale of one to five?

Until now the only tool we’ve really had for questions like these has been a chat model. So we write a prompt that says “answer only YES or NO”, cross our fingers, and parse whatever comes back. Sometimes it’s “YES”. Sometimes it’s “Yes, because the comment contains a suspicious link, although…” and your workflow falls over.

It works, mostly. But it’s always felt like using a novelist to fill in a checkbox.

Enter Jev

A couple of weeks ago TypeSafe AI announced a new kind of model they call a “System One” model, and the first one is called Jev.

Jev doesn’t generate text at all. You tell it up front the shape of answer you want: a yes/no, a pick-one from a list, or a score on a scale. It gives you back exactly that, along with a confidence value. The name nods to the “System 1 / System 2” idea from psychology: chat and reasoning models have been getting better at slow, deliberate System 2 thinking, and Jev goes after the fast, intuitive System 1 judgement.

TypeSafe make some big claims about it:

• Speed. 70 to 500 milliseconds, which they put at 40 to 200 times faster than frontier chat models on comparable tasks.
• Cost. $0.042 per million input tokens, with output “too cheap to meter”.
• No malformed answers. It can only return a value that fits your schema. They go as far as “can’t hallucinate”, though they’re open that this is a theoretical claim rather than a measured one.
• Calibrated confidence. Every answer comes with a probability that’s meant to actually mean something.

It’s early access, and the post is upfront about the limits of its own benchmarks, so I’d treat those as TypeSafe’s numbers for now. But even at a fraction of those gains, it’s the shape of the thing that caught my attention.

Why this is a big deal for Umbraco Automate

Umbraco Automate is built around triggers, actions and conditions. Something happens, you do some work, and at various points you branch: if this, do that, otherwise something else.

That “if” is where most AI steps really want to live, and it’s exactly where a chat model is weakest. A branch needs a clean, predictable value, and a chat model gives you a paragraph.

A surprising number of the AI steps people want fall into one of three buckets:

• A yes/no. Is this spam? Is this off-brand?
• A pick-one. Which category? Which language? Which editor should review it?
• A score. How positive is this review? How urgent is this request?

Those are Jev’s three answer types, almost exactly.

It changes the economics too. When every AI step costs real money and takes seconds, you don’t run it on every comment, form submission or save. When a decision costs a fraction of a cent and returns faster than a page load, you can check everything, and chain several checks together.

And the confidence score gives you a principled way to know when not to trust the AI. “Spam” at 0.98, delete it. “Spam” at 0.55, send it to a human. That’s the kind of safety net that makes it reasonable to let an automation act on its own.

What we’ve been experimenting with

This got interesting enough that we’ve been building an experimental “Decision” capability in Umbraco AI, alongside Chat, Embedding and Speech to Text, with a TypeSafe provider to power it.

On the Automate side that means three new AI actions: Ask yes/no, Ask pick-one and Ask score. Each returns a typed answer plus a confidence value that later steps can branch on, and the question can pull in values from earlier steps. So: take the comment that was just submitted, ask whether it’s spam, and if we’re sure, reject it.

Because Decision is a capability rather than an Automate feature, we’ve also tried it somewhere less obvious. Copilot’s auto mode has to pick which agent handles your message, and today it asks a chat model and parses the reply. With Decision set up, it asks Jev a pick-one question instead, falling back to the old way if anything goes wrong.

It’s all an internal experiment for now. The .NET AI libraries we build on don’t have a standard way to describe decision models yet, though there’s an open proposal we’d like to line up with. So read this as where my head is at, not a roadmap promise.

A shift in the models we automate with?

For the last few years, “AI in your workflow” has mostly meant “a chat model in your workflow”. One general, capable, fairly slow and fairly expensive tool, bent to fit every job. TypeSafe make a sharp point about that: the flexibility of strings makes chat models “incredible for quickly making prototypes that only work sometimes.”

Only work sometimes is fine for a prototype. It isn’t fine for an automation that runs a thousand times a day with nobody watching.

I think Jev hints at a split. Chat and reasoning models for the open-ended, creative parts. Small, fast, typed decision models for the many small judgements in between, the ones that just need to be right, quickly, cheaply, and in a shape software can use without a parser and a prayer.

If that split happens, automation is where it’ll matter most. Automations are made of decisions, most of them small, and until now we’ve been paying novelist rates for every one.

I don’t know yet whether Jev itself will be the model that makes this stick. But I’m fairly sure the idea is right, and I’m excited to see where it leads for Automate.

Until next time 👋