Classifying with Claude Haiku or with Jev: two ways to decide

Haiku belongs to the same family as Sonnet, Opus and Fable: large language models that generate an answer token by token. It is the fastest and cheapest of the line-up, not a different kind of model. To use it as a classifier, you describe the categories in an instruction and ask it to write one.

Jev starts from somewhere else. TypeSafe describes it as a model that "gives up string generation": it receives a state (an email, a ticket, a JSON object) and typed questions, and produces all its answers in a single request. Three question types: Choice (one option from a list, up to 255), Score (a position on a scale of 2 to 10 levels) and Noul (the probability that a statement is true). According to its maker, it is trained for calibrated decisions rather than to please a human reader.

The word "classifier" covers both uses even at Anthropic. Claude Code's auto mode relies on a "classifier" that reviews each action before it runs: it is a generative model (Claude Sonnet 5 by default) asked to rule, which returns a decision and the rule it applied. A classifier, in the everyday sense, is a function that picks a label. What separates Haiku and Jev is what is inside the box.

With Haiku, format reliability comes from structured outputs. You supply a JSON schema, the API compiles it into a grammar and constrains decoding: the answer is valid JSON, with the required fields, and an enum field can only take one of the listed values. The documentation keeps two caveats. A refusal (stop_reason set to "refusal", which Haiku 5.5's safety classifiers can trigger) or a max_tokens cut-off can produce output outside the schema; and the capitalisation of an enum value is not guaranteed, so compare case-insensitively.

With Jev, there is no text to validate. A Choice answer is the chosen option, the probability of every option and a confidence; a Score answer is a level, its probabilities and a confidence; a Noul answer is a number between 0 and 1. TypeSafe presents this output as typed by construction: the model only returns a value that was provided for. An option you add, such as none_of_the_above, lets it say nothing fits; the documentation also suggests a separate Noul question for that case.

The real difference is there: the probability. Anthropic's Messages API offers no parameter to get the probability of each option. With Haiku, a "confidence" is obtained by asking for it as a schema field, which gives a number written by the model, not measured; or by calling several times and counting votes, which multiplies the cost. With Jev, the distribution is part of the answer, and a rule such as "above 0.8 we carry on, below a human takes over" is written directly.

A nuance TypeSafe documents honestly: its "confidence" measures how concentrated the distribution is, not the probability of being right. The documentation page publishes no calibration measurement. Whether 0.8 means 80% correct answers on your flow is checked on your data, not in a brochure. The same is true for Haiku, with one more difficulty: you first have to manufacture the number.

Haiku 5.5 costs $0.10 per million input tokens and $0.50 per million output tokens, as long as the request stays under 100,000 tokens (above that, $0.50 and $2.50). Cache reads cost $0.01 per million tokens, from 512 tokens of instructions, and the Batch API halves the price for work that can wait. Jev costs $0.042 per million input tokens, and output is not billed; TypeSafe states it cannot guarantee this price is not subsidised.

Take the flow from our industry and after-sales scenario: 120 requests a week, about 520 a month. Count 1,200 tokens per call (the email and the instruction describing the six reasons) and, for Haiku, around fifty output tokens with thinking off. Haiku comes to about $0.15 per 1,000 calls, Jev to about $0.05. On 520 requests a month, one costs a few cents, the other even less. The two models do not split text into tokens the same way: these are orders of magnitude, not an invoice.

At that volume, price decides nothing. It matters from hundreds of thousands of calls a month, or when you ask ten questions per document. It also matters the other way: on Haiku, adaptive thinking is on by default, and its tokens are billed as output. For a classifier, turn it off or lower the effort, and measure.

On latency, TypeSafe announces 70 to 500 ms end to end, measured from the US West Coast, and adding questions to the same call barely changes it. Anthropic publishes no figure for Haiku 5.5: it is the fastest of its line-up, and its latency depends on prompt length, output length and thinking level. In an interactive loop, the difference may show; in email processing that runs every five minutes, it will not. Measure from Europe, on your flow.

Write. Haiku can add a one-sentence justification to the category, extract an order number and a date, summarise the request for whoever handles it. Jev generates no text: TypeSafe advises against forcing it to write through chained Choices, which it calls slow and ineffective. If your step must also produce text, Haiku does it in the same call.

Read long, and in French. Haiku takes a million tokens of context, and it is multilingual. Jev takes 64,000 tokens per request and 32,000 per question (262,000 with a header TypeSafe has named "Danger Zone"), and its documentation says English is where its accuracy is best. On a French after-sales flow, the gap has to be measured before setting a threshold.

Be in production. Haiku 5.5 is available on the Claude API, Amazon Bedrock, Google Cloud and Microsoft Foundry. On the Claude API, Anthropic commits not to retire it before 7 October 2027; Bedrock and Google Cloud set their own dates. For an SME, going through the cloud it already uses simplifies the contract, the billing and the data hosting question. Jev is in early access, on a waiting list, with a jev-latest alias still pointing at version 1.13 and a 1.14 in preview since 14 October.

Reason. A generative model can, if allowed, think before answering. Jev has limits TypeSafe publishes itself for version 1.13: it counts poorly, treats dates as text (durations and comparisons are unreliable), loses accuracy on double negatives and multi-step reasoning, and slightly favours the first option of a Choice. A decision that hinges on "was the delivery more than 30 days ago?" is computed in code whatever the model, but even more so with Jev.

Say when not to decide. This is the core argument, and it is concrete: a probability distribution per option, in every answer, with no extra call. The scenario "reason is clear, route it; reason is uncertain, a human sorts it" is a single condition. With Haiku, you have to build the equivalent, and the cheap equivalent (a "confidence" field in the schema) is not a measurement.

Ask several isolated questions. The questions in a Jev call are evaluated in parallel and independently, on the same state: the answer on urgency does not influence the one on the reason. With Haiku, all the questions in a schema are written in the same answer, and the first can steer the next. You can make one call per question, but you pay for the instruction each time, unless you cache it.

Stay in the list. Haiku's structured outputs guarantee an enum stays in the list, barring a refusal or cut-off. Jev has no special case: it produces nothing but a value from the list. For the code consuming the answer, that removes an error branch.

The flip side is the same for both: Jev reads only the state you pass it, and it does not treat that state as hostile by default. TypeSafe says so: an instruction slipped into an email can change its answer. Haiku is not immune either. In both cases, what the customer writes is data, and the action that costs stays behind a rule or a person.

Choose Haiku if the step must also write or extract, if documents are long, if the flow is in French and you have no time to measure the gap, or if the component must go into production this quarter with a supplier your purchasing team already knows.

Test Jev if the decision fits a closed list, if you need an honest threshold to send doubtful cases to a human, if you ask several questions about the same document, or if volume makes the cost per call significant. Test it on real data, with a fallback: it is an early-access model.

The two can also be combined. In its guardrail examples, TypeSafe already sends uncertain cases to a person. You can go one step further, and this is our design, not theirs: Jev on the front line for the reason, Haiku for requests below the threshold or to write the summary, and a human for what is left. The path stays written in code, and each model does what it was built for.

In every case, the work that matters is the same, and it comes before choosing the model: an option list someone owns, described in sentences rather than keywords, a few hundred examples already sorted by hand to measure against, and a threshold set where the errors start. A model does not fix a list of overlapping reasons: it spreads the ambiguity around.

Our position, to be clear: we recommend Haiku when a lightweight generative model is needed in production today. We are testing Jev on our own cases, and not yet deploying it for clients, for the reasons given above.

Anthropic, Claude documentation: models overview and Claude Haiku 5.5 page (released 7 October 2026, intended use, tiered pricing, caching, Batch, context, adaptive thinking, retirement not before 7 October 2027 on Anthropic's platforms), what's new in Haiku 5.5 (safety-classifier refusals, turning thinking off), structured outputs (constrained decoding, enum, refusals and cut-offs, capitalisation). Models, Claude Haiku 5.5, What's new, Structured outputs.

Claude Code documentation, permission modes: auto mode and its classifier, Claude Sonnet 5 by default. Permission modes.

TypeSafe AI, "Introducing System One models and Jev", 15 September 2026: giving up string generation, $0.042 per million input tokens, output not billed, 70 to 500 ms latency, early access. TypeSafe AI article.

TypeSafe AI, documentation: introduction, models (versions 1.13 and 1.14, context limits, languages), confidence (definition, no published calibration measurement), known limits of Jev 1.13, guardrails around an LLM. Introduction, Models, Confidence, Jev 1.13 limits, Guardrails.

The per-call costs in the third section are our calculations from these prices, not measurements.