How we choose an AI model for each step of a build

We choose a model per step, not per project. For each step in a build we ask two questions: is this step a decision with fixed answers, and does it need a frontier model or can a light model do it?

Decisions such as routing, yes or no, and “what happens next” go to Jev by TypeSafe, a fast, very cheap model that can only return one of the options you give it. Mechanical text work goes to a light model such as Claude Haiku 5.5 or GPT-6 Luna. Open reasoning, planning, writing, and code go to a frontier model. If Jev isn’t confident enough, the step moves up to the frontier model.

Who this is for: founders and product leads planning an AI feature or agent with several steps, who want to know where the model bill goes. Who should look elsewhere: if your feature is one prompt and one answer, or one long chain of reasoning, a single well-tuned model is simpler and often cheaper. Start with our guide to which AI model your business should use.

The rule: one model per step

The common approach is to pick one model for a whole project. That model then does everything, from choosing a label to writing a long reply. It works, but you pay frontier prices for steps a cheaper model gets right.

We split the work first. Each step of a build falls into one of three types:

If Jev’s confidence is below the floor set for that step, the same question goes to the frontier model. Light-model prices come from Anthropic’s pricing page and OpenAI’s pricing page, checked 2026-10-13. Our AI API pricing table lists every current model.

Here is the rule applied to one example: a support inbox where each email goes through six steps.

Three of the six steps are decisions. That’s common. A lot of what an agent does is choosing between known options, and only a few steps need real writing or reasoning.

Is this step a decision? A checklist

Ask these questions about each step. If every answer is yes, the step is a decision, and a decision model like Jev can try it first.

1. Can you list every possible answer before the step runs? For example “billing, bug, sales, other”, or “send, hold”. If the answer is free text, it isn’t a decision.
2. Is the list short and fixed? Jev’s Choice question accepts up to 255 options, per TypeSafe’s launch post. Most good decisions have 2 to 20.
3. Is there a safe “other” or “none of these” option? TypeSafe’s own docs say to “add an other or none of the above option when the list might not cover every input.”
4. Is everything needed for the answer in the input? Jev doesn’t look things up or reason over many steps. If the step needs a search, a calculation, or a plan, it isn’t a decision.
5. Does the step run often? Saving a fraction of a cent matters at 10,000 runs a month. At 50 runs it doesn’t.
6. Can you act on a confidence score? You need a place to send unsure cases: a frontier model, a person, or a safe default.
7. Is a wrong answer cheap to catch or undo? Routing a ticket to the wrong queue is cheap. Issuing a refund is not. For costly actions, set a higher floor or keep a person in the loop, as in our guide to human approval in AI agents.

If the answer to question 1 is no, ask the next question: is the step mechanical? Pulling fields out of an email, reformatting a date, or summarising a thread has one right shape and needs little judgment. A light model handles it. Anything left, such as writing a reply a customer will read, planning a fix, or writing code, goes to a frontier model.

And before any of this, check whether the step needs a model at all. A rule or a regular expression is cheaper than Jev and never unsure. Our checklist on whether a feature should be AI covers that.

What Jev is, and what TypeSafe claims

Jev is the first model from TypeSafe AI, launched in early access on September 15, 2026. It doesn’t write text. You send it some text or JSON plus typed questions, and it returns typed answers with probabilities. TypeSafe’s docs list three question types: Choice (“Which of these options?”), Score (“Which level?”), and Noul (“Is this true?”).

The key property for us is that it can’t answer outside your list. TypeSafe’s primitives docs say “Every answer is constrained to the options you supplied.” That makes it a good fit for routing and gates, where a free-text answer from an LLM would need checking anyway.

Speed and price are TypeSafe’s own claims, from its launch post, checked 2026-10-14:

• Price: “Input tokens: $0.042 / MTok”. Output tokens are free. For comparison, Claude Haiku 5.5 and GPT-6 Luna charge $0.10 in and $0.50 out.
• Speed: “End-to-end response time is 70ms-500ms”. TypeSafe says this “can range from 40x-200x faster” than frontier models on the same kind of question.
• Caveats TypeSafe gives itself: “We can’t prove it isn’t subsidized”, and it calls its headline gains of 193.6x faster and 444.6x cheaper “on the higher end of real world gains.”

Jev is closed and hosted, in early access with a waitlist. There are no open weights. Your input goes to TypeSafe’s servers, so check that against your data rules before you send customer email to it.

What independent tests found

Independent tests mostly put Jev a little below frontier models on accuracy, sometimes level with them, and always far cheaper. Two tests used current frontier models:

On the routing test, AI/ML API reports that “Opus 5.5 and GPT-6 Sol were about 7 percentage points more accurate than Jev.” On the claims test, Vals says Sonnet 5.5 and Opus 5.5 “score a few items higher, but the gap is small enough that we can’t call it real.” Vals priced Jev at $0.02 per 1,000 cases against $9.64 for Opus 5.5.

The same Vals report has two warnings worth keeping. On a slice of LegalBench, “Jev finishes last of twelve on raw accuracy and on class-balanced accuracy.” And GPT-6 Luna matched Jev’s score on the claims test at 8 cents per 1,000 cases. A light model can be a fine decision maker too. Jev’s case is speed and a fixed answer set as much as price.

Neither report states a funding link to TypeSafe. AI/ML API sells API access to many models, so weigh its numbers with that in mind.

Why the confidence floor matters

Jev’s lower accuracy is fine if you only trust it when it’s sure. Every Choice and Score answer comes with a confidence value from 0 to 1. TypeSafe’s confidence docs say “A confidence threshold is not one number” and suggest you “start with conservative thresholds, test with your own data, and adjust as you observe results.”

The independent tests show why this works:

• In the AI/ML API test, when Jev answered only at confidence 0.9 or higher, it handled 66% of routing messages and got 93.9% of those right. Sending the rest to Opus 5.5 gave 85.3% overall at $3,154 per million decisions, against 85.7% at $8,243 for Opus alone.
• AY Automate tested a floor of 0.80 on the same 77-intent set, with GPT-5.6 Terra as the fallback. It sent 23.0% of items to Terra and scored 84.8%, against 84.3% for Terra alone, at 27.9% of Terra’s cost. AY Automate notes that the cutoffs “were evaluated on the same items”, so real results may be lower.

So the floor is the main dial. A higher floor sends more work to the frontier model and costs more. A lower floor saves money and lets more wrong answers through. We’d start a new step between 0.8 and 0.9, measure on real inputs, and move it from there.

Cost: one frontier model for every step, or a model per step

Here is the support-inbox example priced both ways. It uses list prices and token counts typical of the steps in our builds. It is not measured traffic from one client.

Inputs:

• 10,000 emails a month, six steps each.
• Frontier model: Claude Opus 5.5 at $4 in and $20 out per million tokens. We used Opus 5.5 because Anthropic’s guide says “For most agent workloads, start with Claude Opus 5.5”. It is the cheaper end of the top tier, so this is the smaller version of the gap.
• Light model: Claude Haiku 5.5 at $0.10 in and $0.50 out.
• Jev: $0.042 per million input tokens, output free (TypeSafe’s claim).
• We plan for 25% of Jev decisions to escalate to the frontier model. The published tests above sent 19% to 34% at floors of 0.8 to 0.9. An escalated step pays for Jev and then the full frontier call.
• Visible output only. Opus 5.5 runs at medium effort by default, and any thinking tokens bill as output, so a real frontier bill would be higher.

The per-step method costs 58% less. With GPT-6 Astra or Claude Fable 5.1 as the frontier model ($10 / $50), both columns grow by 2.5 times: $1,805 against $741.

Three things stand out:

• The writing step is most of the new bill. Drafting the reply is $240 of the $301.85. The savings come from moving everything else off the frontier model, so a build with many decisions and few writing steps saves more.
• Escalations cost more than Jev does. Jev itself costs $2.10 a month across the three decision steps. The other $53.00 is the 25% that go to Opus. At 0% escalation the total is $248.85. At 50% it is $354.85. Tuning the floor matters more than the price of Jev.
• A light model is close on price. Running the three decisions on Haiku 5.5 instead of Jev would cost $5.30 a month. Jev costs $2.10. At this volume, the reasons to pick Jev are its speed, its fixed answer set, and its confidence score.

In practice we’d ask steps 1 and 2 in one Jev call. TypeSafe’s docs say extra questions in a call cost “only the tokens for the extra questions.” To try your own numbers per user, use our AI feature cost calculator, and see how much GPT or Claude costs per user for the full method.

How other teams choose models per step

We’re not the first to split the work. The model vendors and researchers say much the same:

• Anthropic says in its guide to optimizing for cost and intelligence that mixing models fits “workloads whose task complexity varies enough that different steps are best served by different models.” It describes an advisor pattern, where a lower-cost model “runs the agent loop” and calls a stronger model when it “hits a decision that needs deeper judgment.”
• Anthropic also warns against splitting too early. Its first step is to “Sweep effort on your current model first”, because “most workloads end there.” In its own tests, “a multi-model configuration that looked cheaper than the default single model cost more than that same model at lower effort.”
• OpenAI’s model selection guide says to “keep the lightest setting that meets your quality bar.”
• Research on routing found large savings. The FrugalGPT paper reports a cascade that “can match the performance of the best individual LLM (e.g. GPT-4) with up to 98% cost reduction.” The RouteLLM paper reports that routing between a strong and a weak model cut costs by over 2 times in some cases “without compromising the quality of responses.”

What we add is the first question: is this step a decision? Most routing write-ups pick between two text models. A decision model is a third option for the steps that only need to pick from a list.

When we don’t split

Splitting has costs: more prompts to test, more models to watch, more vendors holding your data. We keep one model when:

• The feature is one chain. Anthropic says that when difficulty is uniform “or it is one dependent chain, a single well-tuned model is usually the better choice.”
• Volume is low. At a few hundred runs a month, the saving is a few dollars and not worth a second vendor.
• Data can’t leave a set vendor. Jev is hosted by TypeSafe, so it’s one more processor for customer data.
• An auditor needs a reason. Jev returns choices and probabilities with no explanation. For regulated decisions, a model that writes its reasoning may be the better fit.

Whatever we pick, we keep every model call behind one function and pin model IDs, so a switch is a config change. Our post on the AI SDKs we reach for shows how.

FAQ

Do I need a frontier model for my AI agent?

For some steps. Writing, planning, and code usually need one. Routing, classifying, and yes or no checks usually don’t. Split the agent into steps and price each one. In our example, only one of six steps stayed on the frontier model.

What is Jev by TypeSafe?

A decision model launched in early access on September 15, 2026. It returns a choice, a score, or a yes or no probability from options you define, never free text. TypeSafe says it answers in 70 to 500 ms and charges $0.042 per million input tokens with free output. Those are TypeSafe’s own figures.

Is Jev as accurate as GPT or Claude?

Usually a little less. In an independent routing test, Claude Opus 5.5 and GPT-6 Sol scored about 7 points higher. In Vals AI’s claims test it tied GPT-6 Astra. With a confidence floor and a stronger model as fallback, two published tests came within half a point of the stronger model alone, at 28% to 38% of its cost.

How much can model routing save?

It depends on how many steps are decisions or text chores. In our worked example, 10,000 support emails cost $722 a month on Claude Opus 5.5 for every step and $301.85 with a model per step, at list prices. The writing step stays expensive either way.

Can a cheap LLM make the decisions instead of Jev?

Yes. Vals AI found GPT-6 Luna matched Jev on its claims test at 8 cents per 1,000 cases. Jev adds speed, a fixed answer set, and a confidence score. Test both on your own inputs.

We plan model choice step by step as part of our AI agent builds and AI integration work, with the test results in writing before anything ships.