How I Added Jev to My AI Coding Agent for Typed AI Decisions

Why I looked at Jev

A lot of my automation work comes down to one small decision made thousands of times. Is this lead worth a call? Is this message a complaint or a booking? Which follow-up template fits this person?

For a long time I answered those with a full LLM call. In my AI lead qualification workflow the AI reads the inquiry, scores it, and recommends a service. In my AI inquiry triage system it sorts incoming messages so the right person sees them. Both work, but they share the same weak spot. I ask a model that writes text to return a decision, then I parse that text and hope the format holds. When the format slips, the workflow needs a guard to catch it.

Jev, from TypeSafe AI, is built for exactly that kind of decision. So I set it up in my coding workflow to see where it fits.

What Jev actually is

Jev is not a chatbot and it does not write anything. TypeSafe calls it a “System One” model. You send it some state, like a form submission or an email as text or JSON, plus a list of questions. It answers every question in a fixed shape:

• Noul is a yes/no question. It returns a probability between 0 and 1.
• Choice picks one option from a list I define, up to 255 options, with a probability for each and a confidence score.
• Score places the input on a scale I define, from 2 to 10 levels, again with a confidence score.

The answer is always one of the options I allowed, so there is nothing to parse and nothing to repair. That alone removes a whole class of bugs from an automation.

The other two numbers that matter for my clients are cost and speed. TypeSafe lists input at $0.042 per million tokens, output is free, and a call usually comes back in around 100 milliseconds. A decision that used to need a few seconds and a full LLM call now takes a fraction of a second and costs close to nothing. For a lead funnel that sees hundreds of submissions a day, that difference adds up fast.

The part that confused me at first

My first assumption was that Jev was a skill that would make my coding agent smarter. It is not.

There are two separate pieces:

1. Jev, the model. My app calls it at runtime through TypeSafe’s API, the same way an app calls any other AI provider.
2. The TypeSafe skill. This is what I installed into Claude Code. It gives the agent TypeSafe’s current docs and patterns, so when I ask for a Jev feature, the agent writes the request correctly the first time.

That second piece matters more than it sounds. Coding agents learned from years of LLM code, so without the skill they tend to treat Jev like a chatbot. They invent request fields, send one question per call, or ask it to write text it cannot write. The skill fixes that by putting the real API in front of the agent.

Flavio Copes wrote a clear guide on using Jev with coding agents that helped me get this straight, and it is worth reading if you use Cursor, Codex or OpenCode instead.

How I set it up in Claude Code

Two commands, run once:

claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

I installed it at user level, so it is available in every project on my machine, and I ran the same two commands on my laptop so both setups match. After a restart the skill shows up as /typesafe:typesafe-ai.

I do not have to call it by hand. The agent loads it when a task needs a structured decision, like routing, ranking, scoring or checking something, or when an existing step sends a prompt to an LLM and then parses the answer. For unrelated work like fixing a layout or writing a report, it stays out of the way.

For other agents, TypeSafe also publishes the skill through npx skills add typesafe-ai/skills --skill typesafe-ai.

Where Jev fits in my work

The pattern I am planning around is simple. Jev decides, my code acts, and an LLM writes anything that needs words.

• Lead qualification. Is this a real buyer (Noul), which service fits (Choice), and how urgent is it (Score), all in one call. My workflow then routes the lead and an LLM writes the personal follow-up.
• Inquiry triage. Complaint, booking, question or spam, with the confidence deciding whether it routes automatically or goes to a person.
• Call outcome tagging for voice agents. Booked, emergency, wrong number or spam, read straight from the call transcript.
• Review recovery. Flagging which reviews need a human reply first, similar to my negative review recovery workflow.

One habit carries through all of these. I ask every independent question in the same call, because TypeSafe runs them in parallel against the same state and extra questions add very little time.

The rules I am following

These come from TypeSafe’s docs and from reading other people’s setups, and they match what I already learned building automations:

• Gate on confidence. High confidence runs automatically. Low confidence goes to a person or a slower LLM path. A 0.5 on a yes/no question does not mean “medium”, it means the model cannot tell.
• Keep math and dates in code. Jev is not reliable at counting, arithmetic or comparing dates. Code handles those, Jev handles judgment.
• One judgment per question. If a question mixes two things, I split it and combine the answers in code.
• Always give an exit. Every Choice question gets an “other” option so the model is never forced into a wrong bucket.
• Pin the model version. jev-latest can move to a new release, so once thresholds are tuned I pin the exact version and log it with each answer.
• Keep it server side. The API key never goes into browser code.

One thing to know before you start

According to Flavio’s guide, TypeSafe paused new signups in late September 2026 because of demand. The skill installs fine without an account, but your app needs an API key from the TypeSafe console to actually call Jev. Check that you can get one before you plan a client feature around it.

Where I go from here

The skill is installed and the plan is set. The first real build will be swapping the scoring step in my lead qualification workflow for a single Jev call with confidence gating, then comparing cost, speed and accuracy against the LLM version on the same leads. I will write that up with real numbers once it runs.

If you have a workflow where an AI step keeps breaking on format, or where every small decision is costing you a full LLM call, that is exactly the kind of thing I build.