Stay up to date with AI tools, model releases, and developer workflows that matter.

In a recent development, weekly. Free. One click to leave.

7 Day Free Trial. Cancel Anytime.

A support email lands: "Order NW-47790, the tent poles snapped on the first night, I paid $389 and I want every cent back today or I'm disputing the charge.".

Industry observers note that to act on that, your code needs answers to a handful of small questions. Is it a refund request? How urgent is it? Should a person handle it? What's the order number? How much money is involved? It's the same problem whether you're sorting a support inbox or building a custom chatbot that has to work out what each customer is asking for.

The usual move is to send the whole email to a chat model with a prompt that ends "respond in JSON", then validate whatever comes back. It works, but you're paying a model built to write essays to fill in five fields, and you're parsing its guess at a schema.

System One models are built for exactly this kind of job. In this tutorial we'll build a small support inbox pipeline with two of them: Jev from TypeSafe makes the decisions, and Clairic from Cloudflare reads the values. Plain TypeScript then turns their answers into an action. No prompt engineering for output formats, and no JSON repair.

Sources indicate that the name comes from Daniel Kahneman's Thinking, Fast and Slow. System 1 is the fast, intuitive kind of thinking you use to read a face or a sign. System 2 is the slow, deliberate kind you use for long division.

A System One model is an AI model that understands natural language but doesn't generate text. You give it some input (the state) and a set of typed questions, and it gives back typed answers with probabilities. There's no free text to parse, because the model can only answer in the shape you asked for.

That's different from asking a chat model for structured output. SitePoint's guide to LLM structured output with JSON Schema highlights how to constrain a chat model and validate its JSON with Zod. With a System One model, the type is the interface: a yes/no question comes back as a probability, a pick-one question comes back as one of your options, and a date comes back as a date.

Two other properties matter in practice:.

Jev and Clairic are both System One models, but they do different jobs, and that's what makes them a good pair.

According to recent reports, jev can't hand you an order number, and Clairic has no way to pick from a list of options or answer yes or no. Give each one the job it's built for.

Industry observers note that if you've read SitePoint's Jev and LangChain tutorial, you've seen Jev deciding which model handles an agent's request. Here we'll use it on the incoming text itself.

Five made-up emails for a made-up outdoor gear store go in. For each one:.

Both models read the same email, so they run at the same time.

Put the three values in your environment:.

No SDKs are needed. Both models are a single fetch call.

Here's the test inbox. Each email is there to test a different path through the rules:.

Jev takes a state (the email) and a set of named questions. We'll ask three, one of each type:.

According to recent reports, all three questions go in one request. Jev reads the email once and answers every question in parallel, so adding a question costs very little:.

Sources indicate that we pin jev-1.14.0 rather than the jev-latest alias. Your thresholds get tuned against one version's probabilities, so you want to choose when that version changes.

For the angry tent email, Jev came back with:.

(Trimmed: the real response also includes the probability of every option and level.).

Clairic takes the same state, plus a set of typed fields instead of questions:.

Sources indicate that reference_date anchors relative dates like "the 14th" or "last Monday". In production, pass the date the email arrived.

Each answer comes back with three things worth using:.

For the "where is it?" email, Clairic read the deadline like this:.

"The 14th" became a full date, worked out from the reference date. Text fields like order_number also come back as character spans of the original email. The value is copied from the input, not generated, so it can't invent an order number that isn't there.

The two models don't depend on each other, so send both requests together:.

The time for each email is whichever model is slower, not the two added together.

According to recent reports, this is the part a chat model usually ends up doing badly: the business rules. Here they're ordinary code you can read, test, and change without touching a prompt:.

Notice that the model's confidence sits right next to the business rule. A $18.95 refund is only automatic if Clairic is sure about both the order number and the amount. Raising the refund limit or the confidence bar is a one-line change, and you don't need to call either model again to see what it would do. Save the answers and replay them.

Here's the run on all five emails:.

Every email went where it should. The whole run used 2,703 input tokens on Jev and 2,292 on Clairic, about US$0.0003 in total. At that rate, 10,000 support emails would cost roughly US$0.70.

The interesting part of the run wasn't the right answers. It was the two wrong ones.

"From last Monday." The run used 2 November 2026 as the reference date, which is a Monday. "Last Monday" means 26 October, but Clairic answered 2026-11-02, the reference date itself. Its confidence on that answer was 0.54, compared with 0.99 or higher on almost every other value in the run.

"A couple of weeks ago." Clairic turned this into 2026-10-19, which is a fair reading but still a guess. Its confidence was 0.43.

Neither date changed any action, because the rules only trust values at 0.9 or above. That's the habit to build: a value under your bar counts as unknown. A chat model returning JSON would have handed you "2026-11-02" with the same certainty as everything else.

One more catch: Clairic copied the order number as #NW-48213, hash included, because that's how the customer wrote it. Text values are spans of the input, so normalising them is your code's job. That's one line of code.

Industry observers note that system One models handle the reading and the routing. They don't hold a conversation. Once an email is routed, something still has to write the reply, ask a follow-up question, or explain a returns policy in the customer's own words. That's where a chat model earns its cost.

The split that works is: System One models decide, code applies the rules, and a chat model only gets the cases where words matter.

We built a support inbox triage pipeline from two small models and some ordinary code:.

Recent findings suggest that each email took about half a second and cost less than a hundredth of a cent. Most importantly, the two answers that would have been wrong came back flagged as unsure.

Industry observers note that the full code is about 160 lines with no dependencies. Try adding a fourth Jev question (does the customer mention a photo?) or an estimate field in Clairic (how many days until the trip?), and see how little the rest of the pipeline has to change.

Recent findings suggest that 7 Day Free Trial. Cancel Anytime.

β†’ Read original article