AI customer support goes wrong in one predictable way: the model isn’t sure, it answers anyway, and the customer it gets wrong was already angry. This build fixes that part. Claude Code writes a small support app. Jev, TypeSafe’s decision model, decides which team gets each ticket, how urgent it is, whether it’s a refund and whether a person needs to look. When Jev isn’t sure enough, the app stops and hands the ticket to a human instead of guessing.
It’s measured, not demoed. On a 100-ticket batch it routed departments with 87% accuracy in 49 seconds for $0.0036 of Jev calls. On 82 hand-labeled tickets, only 2 were routed automatically to the wrong team. Every prompt used in the build is on the copy-and-paste Jev + Claude Code prompts page.
Key takeaways
- The real risk isn’t that AI is sometimes wrong. It’s that it’s wrong confidently, with your customer. A confidence gate turns “guess” into “ask a human”.
- Split the jobs. Exact rules go in code, fast judgments go to Jev, writing goes to an LLM like Claude, and uncertainty goes to a person.
- Measure before you trust it. On 82 hand-labeled tickets: 84.1% accuracy, 60 sent to review, 2 confidently wrong.
- Decisions get very cheap. On the same 8 tickets, Jev and Claude Opus 5.5 both scored 8 of 8, at about $0.00004 against about $0.008 per analysis.
- Don’t use it for everything. Articles, code, exact maths and high-stakes decisions such as credit, jobs or health belong elsewhere.
Why does AI customer support feel so risky?
Ask anyone who has switched on an AI support bot what worries them, and you hear the same three things.
- The confident wrong answer. A customer who was charged twice and has written three times gets routed to sales, or gets a reply promising a refund nobody approved. One bad answer costs more than the bot saves.
- The bill. Sending every small decision, such as “which team is this for?”, to a large generative model is slow, and it adds up.
- The black box. The demo worked on five hand-picked examples. Nobody knows how it does on the messy ones.
Most tutorials hand one big model the whole job: read the ticket, decide, write the reply. When that model is unsure, it still answers, because generating an answer is what it’s built to do. The fix isn’t a smarter model. It’s giving each part of the job to the right component, and letting uncertainty go to a person.
What is Jev, and how is it different from ChatGPT or Claude?
ChatGPT, Claude and Gemini are built mainly to generate: emails, code, explanations, reports. Jev is TypeSafe’s “System One” model, built to decide. Instead of “write me an answer”, you ask which of these outcomes is most likely, how severe something is, or whether a condition is true. The possible outcomes are defined before it answers, and it returns probabilities, not paragraphs.
| Primitive | What it answers | Used for in this build |
|---|---|---|
| Choice | Which of these options? | department: billing, technical_support, sales, account, other |
| Score | How much, on an ordered scale? | urgency: normal, elevated, urgent, critical |
| Noul | Is this true? (as a probability) | refund_requested and human_review_needed |
Type-safe isn’t the same as always right. If the options are billing, sales and technical support, Jev won’t invent a “Pirate Department”. It can still pick billing when the right answer was technical support. That’s why this build adds a confidence gate, an evaluation and a human fallback.
As recorded on 8 October 2026, Jev 1.13 on OpenRouter had a 32,000-token context window and charged for input tokens only. Check the live model page before you rely on prices.
How does the Jev + Claude Code support router work?
Claude Code, running Opus 5.5, wrote a small local Node.js web app from one detailed prompt. You paste a customer message. The server sends it to Jev through OpenRouter with four questions, applies the thresholds from one config file, and either routes the ticket or marks it Needs Review. The OpenRouter key never leaves the server.
| Job | Who handles it | Why |
|---|---|---|
| Exact rules and thresholds | Plain code | Anything that can be calculated exactly shouldn’t call AI |
| Route, urgency, refund, review | Jev | Fast, cheap, bounded judgments that come with probabilities |
| Writing the reply | Claude Opus 5.5, only when asked | Writing is what generative models are good at |
| Uncertain or high-risk tickets | A person | The confidence gate sends them here |
Compare that with the usual design, where one large model does all four jobs and you only find out it was unsure when a customer complains.
What happens when a ticket is ambiguous?
This is the test most tutorials skip. One message, three possible teams:
I was thinking about upgrading, but your app stopped working yesterday and I’m also not sure why my last invoice is higher.
Sales, technical support and billing are all reasonable. Jev’s top choice was technical support at about 0.94, and the app still sent the ticket to a human, because Jev’s probability that a person should review it came back at 0.65. A guessing bot would have picked one team and moved on. Watch it at 12:09.
How do you stop AI from guessing? Add a confidence gate
The first version used a single 0.5 threshold for everything. At 13:32 one prompt replaced it with explicit thresholds kept in one file, so they can be tuned after measuring:
| Threshold | Value | Rule |
|---|---|---|
| Department confidence | 0.80 | Auto-route only at or above it. Below it: Needs Review, not assigned, top two departments shown |
| Urgency confidence | 0.50 | Needs Review when Jev’s most likely urgency level is below it |
| Human review needed | 0.30 | Needs Review at or above it. A missed review lets a legal, security or disputed-money ticket through; an extra review only costs agent time |
| Refund requested | 0.40 | Flags a refund at or above it. Doesn’t change the routing, but a missed refund request can end in a chargeback |
A probability isn’t a truth score. Your threshold is a business decision. Choose it with labeled examples from your own inbox, not with the numbers in a video.
How accurate is it? The measured results
Two runs, both through the exact production setup. First, 82 tickets labeled by hand, including the hard cases: mixed intent, sarcasm, poor grammar, very short messages, multiple requests and vague complaints. Then a 100-ticket batch.
| Metric | 82 labeled tickets | 100-ticket batch |
|---|---|---|
| Department accuracy | 84.1% (69 of 82) | 87.0% (87 of 100) |
| Routed automatically | 22 (90.9% correct) | 31 (93.5% correct) |
| Sent to a person | 60 | 69 |
| Routed confidently to the wrong team | 2 | 2 |
| Speed | 531 ms average (p95 660 ms) | 49 seconds for all 100 |
| Errors | 0 | 0 |
| Total Jev cost | $0.0029 | $0.0036 |
The number that matters most is the confidently wrong one: 2 out of 82. Those are the tickets that would have reached the wrong team with nobody checking. Everything Jev wasn’t sure about went to a person instead.
The trade-off is the review rate. With a strict 0.80 gate, 60 of 82 tickets went to a human. That’s the price of never guessing, and it’s the dial you tune: lower the gate and more tickets route themselves, with more risk. The labeled sets are small and hand-made, so treat them as a method, not a benchmark.
Jev vs Claude Opus 5.5: is a decision model worth it?
Same 8 example tickets, same allowed departments. Claude Opus 5.5 was asked for structured JSON with its own confidence. The point wasn’t to prove Jev is always better. It isn’t. It was to see what happens to cost, speed and accuracy on one narrow, repetitive decision.
| On the same 8 tickets | Jev | Claude Opus 5.5 |
|---|---|---|
| Accuracy | 8 of 8 | 8 of 8 |
| Routed automatically | 2 | 4 |
| Sent to review | 6 | 4 |
| Confidently wrong | 0 | 0 |
| Average latency | about 0.7 to 1 s | 4.6 s |
| Cost per analysis | about $0.00004 | about $0.008 |
Both got all 8 right. The difference is speed and cost: under a second against 4.6 seconds, and about 200 times cheaper per decision. As rough arithmetic from those per-analysis figures, 10,000 tickets a month would cost about $0.40 in Jev decisions against about $80 with Claude Opus 5.5 making the same decisions.
One caveat on confidence. Claude’s probabilities are its own estimates, not calibrated ones. Its department confidence ranged from 0.80 to 0.96 on these tickets, and one ticket routed at exactly 0.80, right on the threshold. Eight tickets is also a tiny sample.
Jev decides, Claude writes: the hybrid workflow
Generation still has a job: writing the reply. Here’s the angry ticket from the start of the video:
I’ve contacted you three times. I was charged twice, nobody has fixed it, and if this isn’t solved today I’m cancelling.
Jev decided in 951 ms: billing, urgent, refund requested, needs human review. Only then did the optional Draft Reply button send the message and Jev’s routing to Claude Opus 5.5, which wrote a draft in 6.2 seconds for $0.0081. The draft was labeled for human approval, the routing didn’t change, and nothing went to the customer automatically. The rules for that live in Prompt 5 on the prompts page.
Why use Jev for customer support?
- It knows when to stop. Every decision comes with a probability, so your code, not the model, decides when a person takes over.
- It’s cheap enough to run on every ticket. About $0.00004 per analysis in the recording; 100 tickets cost $0.0036.
- It’s fast. 531 ms on average across 82 tickets, and the 100-ticket batch finished in 49 seconds.
- It can’t invent categories. The outcomes are defined before it answers.
- It’s measurable. The same configuration runs in production and in the evaluation, so the numbers describe what customers will actually get.
If you’re weighing automation against hiring more support staff, AI vs hiring covers where each one wins.
When should you not use Jev?
The video is blunt about this:
- Need an article written? Use a generative model.
- Need code? Use a coding model.
- Can it be calculated exactly? Use normal code and don’t call AI at all.
- Making a consequential decision about credit, employment, healthcare or another high-risk area? Don’t connect any model and let it decide on its own just because a confidence number looks impressive.
Jev earns its place on bounded judgments: classification, routing, ranking, filtering, verification and high-volume repetitive decisions. Support triage is exactly that.
Build it yourself
The whole app takes six prompts in Claude Code, plus two one-line follow-ups. They’re on the Jev + Claude Code prompts page, copied from the build’s session log, with copy buttons, the four test tickets, the CSV format and a build checklist.
- Create the .env file for your OpenRouter key.
- Paste the main build prompt and read the architecture Claude Code proposes.
- Add the confidence gate.
- Measure it on your own labeled tickets.
- Add the optional Draft Reply button.
- If you like, compare it with a big LLM on the same tickets.
Get the exact prompts and the checklist →
Taking it off localhost. The router in the video runs on your own computer. To let a team use it, you need hosting that can run a Node.js app and keep the API key in a server-side environment variable. I host this site on Hostinger, and it can run Node.js apps like this one. If you’re setting up hosting anyway, my Hostinger referral link gives you 20% off. Pick a plan that includes Node.js app hosting. Affiliate link: I may earn a commission at no extra cost to you (disclosure).
FAQ
What is Jev AI?
Jev is a decision model from TypeSafe, available through OpenRouter. Instead of generating text, it answers structured questions: which option is most likely (Choice), how severe something is on an ordered scale (Score), or whether something is true (Noul). It returns probabilities your code can act on.
Is Jev better than ChatGPT or Claude for customer support?
For the decision part, it was faster and much cheaper in this test. Jev and Claude Opus 5.5 both got 8 of 8 tickets right, but Jev took under a second and about $0.00004 per analysis, against 4.6 seconds and about $0.008 for Claude. For writing replies a generative model is still the right tool, which is why the build uses both.
How much does it cost to run AI customer support with Jev?
In the recording, Jev calls cost $0.0029 for 82 tickets and $0.0036 for a 100-ticket batch. Optional reply drafts from Claude Opus 5.5 cost about $0.008 each. Prices change, so check OpenRouter before you budget.
Can AI customer support run without humans?
Not safely, and this build does not try. Uncertain or high-risk tickets go to a person. With a 0.80 confidence gate, 60 of 82 test tickets went to review and only 2 were routed confidently to the wrong team.
Do I need to know how to code to build this?
Not much. Claude Code wrote the app from plain-English prompts. You need to install Node.js, run npm start, read what the agent proposes before it builds, and test it on your own tickets. The exact prompts are on the prompts page.
Sources
- AutomatorM — Jev and Claude Code: the full build video
- OpenRouter — Jev 1.13 model page and pricing
- TypeSafe — Jev documentation
Results are from the recording on 8 October 2026: Jev 1.13 (served as typesafe/jev-1.13-20260917) and Claude Opus 5.5, both through OpenRouter. The labeled ticket sets are small and hand-made. Models and prices change, so check the live pages.
