# Jev Won't Make Claude Code Cheaper. Its Own Bench Says So

Video: https://www.youtube.com/watch?v=iYp4-2fiXkg
Article: https://aidive.dev/videos/jev-claude-code-hint-mode/
Published: 2026-09-26

## Chapters

- [0:00](https://www.youtube.com/watch?v=iYp4-2fiXkg&t=0s) Intro: a hint, not savings
- [0:38](https://www.youtube.com/watch?v=iYp4-2fiXkg&t=38s) What Jev is, and what the wave sells
- [1:34](https://www.youtube.com/watch?v=iYp4-2fiXkg&t=94s) One env var, one line: hint mode
- [2:54](https://www.youtube.com/watch?v=iYp4-2fiXkg&t=174s) The hint: two sentences, and where it cannot land
- [4:05](https://www.youtube.com/watch?v=iYp4-2fiXkg&t=245s) The benchmark nobody quotes
- [5:22](https://www.youtube.com/watch?v=iYp4-2fiXkg&t=322s) What my session hands it: 24 tools clean, 40 full
- [6:36](https://www.youtube.com/watch?v=iYp4-2fiXkg&t=396s) Verdict per use

## TL;DR

- Jev will not make Claude Code cheaper: inside Claude Code the gateway can only hint, and its own benchmark shows Opus 5 at 47% more requests and 83% more time on a feature task with routing on.
- One line in jev-gateway decides it: with extended thinking or a cached conversation, the gateway hints instead of forcing the tool, and every real Claude Code request carries both.
- The hint is two sentences appended to the last user message, which the model may ignore; when the last block is a system reminder Claude Code appends itself, the hint is not attached at all.
- A clean Claude Code already sends 24 tools and 47,411 prefix tokens per request, a normal setup 40 tools and 57,277; the gateway re-sends that roster to Jev on every call.
- Verdict per use: routing in Claude Code, no (bug hunts on a huge tool roster aside); fast-jev-compaction, not yet; Codex, where the tool is forced, yes.

## Intro: a hint, not savings

Jev will not make Claude Code cheaper, and the gateway's own benchmark says so. This article reads jev-gateway's code and its benchmark repository, then puts a logging proxy in front of a real Claude Code session to see what a router would receive.

Jev is TypeSafe's decision model: a probability returned in milliseconds, wired into Claude Code by six videos in one week. The pitch is "the cheapest agentic coding loop". The gateway's own numbers show Opus 5 making 47% more requests and taking 83% more time on a feature task with routing on.

How does a router that answers in milliseconds make Claude Code slower? It comes down to one line of code. Inside Claude Code, Jev gets exactly two sentences, and a normal session hands it 40 tools on every call.

## What Jev is, and what the wave sells

Jev is a decision model from TypeSafe. It generates no text: you ask a typed question and it answers with a choice, a score, or a yes/no probability. The vendor's figures:

| Figure | Value |
| --- | --- |
| Input price | $0.04 per million tokens |
| Output price | free ("too cheap to meter") |
| Latency | 70 to 500 ms |
| Home page headline | 194× faster, 445× cheaper |

The blog post under that headline says the two multipliers are the higher end of real-world gains, measured against the average of two frontier models, a comparison the authors admit is biased toward those models.

Six videos in five days wired Jev into Claude Code. The biggest sits at 139,000 views and calls it the cheapest agentic coding loop yet. Two repositories carry the wave: jev-gateway, a local proxy for Claude Code and Codex created five days earlier with 181 stars, and fast-jev-compaction, a compaction plugin created the day before that, at 6,400 stars. The gateway is where Claude Code plugs in, so that is where the reading starts.

## One env var, one line: hint mode

jev-gateway sits between Claude Code and the Anthropic API. It launches Claude Code with a single environment variable, `ANTHROPIC_BASE_URL`, pointed at a local port. Nothing else changes; a comment in the source says there is no gateway credential, so a Pro or Max login keeps working as is.

Inside the adapter (`src/adapters/messages.ts`, line 99), one line decides what Jev is allowed to do:

```ts
steer: thinking || cached ? "hint" : "tool_choice"
```

With extended thinking on, or a cached conversation, the gateway can only hint. Otherwise it forces the tool. The comment above the line explains why: the API rejects a forced tool while extended thinking is on, and changing `tool_choice` invalidates the cached conversation Claude Code rereads on every turn.

To check what a real request looks like, a 60-line logging proxy took the gateway's seat on the same kind of port, with Claude Code launched through it and one request sent on a real repository. The request carries `thinking: adaptive` and three cache markers; `tool_choice` is absent; 24 tools ride along on a clean install. Run the gateway's line against that request and the forced path never fires. Every Claude Code call lands in hint mode. The README says as much: expect better tool picks on large tool lists, not lower cost or latency.

## The hint: two sentences, and where it cannot land

What Jev gets to do inside Claude Code is two sentences appended to the last message: "a routing model suggests this tool is the most relevant move now. Ignore this if it doesn't fit." That is the whole intervention. The model is free to ignore it, and `tool_choice` stays on auto.

Forcing a tool is not an option, per Anthropic's docs: a forced tool returns a 400 error on Opus 5.5 and Fable 5.1, and errors with manual thinking on the other models. Changing `tool_choice` is out too: the prompt caching docs say it invalidates the messages cache, the largest part of a long session. Editing a tool's description invalidates the entire cache: tools, system and messages.

| Change to the request | Effect on the prompt cache |
| --- | --- |
| Append a hint to the last user message | cached prefix unchanged |
| Change `tool_choice` | messages cache invalidated |
| Edit a tool definition | tools, system and messages invalidated |

The gateway's comment says why the hint goes last: the cached prefix stays byte-for-byte identical to what Claude Code resends on the next turn. A guard sits in front of it: when the last message is not the user's, the request passes through untouched. Both captured requests ended on a system block that Claude Code appends itself, an environment reminder in one and a hook's output in the other. On that shape, the hint has nowhere to land. It does land on other turns, since tool results come back as user messages, and the benchmark counts Jev steering a third to half of Claude Code requests.

## The benchmark nobody quotes

The gateway's own benchmark, jev-gateway-bench, answers the opening question. It ran 120 sessions, five runs per cell, on the same Claude Code and the same subscription everyone uses, with no MCP servers, plugins or skills. Two tasks on a small chess engine: a bug hunt with five injected bugs, and a feature, adding algebraic notation.

| Model, task | Routing on vs off |
| --- | --- |
| Opus 5, feature | +61% input tokens, +47% requests, +83% time (still solved 5/5) |
| Sonnet 5, feature | +16% input tokens, +37% time |
| Sonnet 5, bug hunt | −48% input tokens, −25% time |

Debugging is where routing pays, in the authors' words. Their explanation is the answer to the question: the gateway only hints with Claude models, so a hint that does not fit costs a detour instead of being ignored for free.

Codex gets the forced version. Jev decided 76 to 100% of Codex requests, against a third to half of Claude Code's. One model in the other harness got cheaper and wrong, three solves out of five instead of five. Cheaper and wrong is not a saving.

The limits are real: five runs per cell is a small sample, it is one toy engine, and nobody has rerun it. Input is mostly cached too, so an input saving is worth less than an output saving.

## What my session hands it: 24 tools clean, 40 full

What does a normal Claude Code session hand a router on every call? The proxy log answers: 40 tools. Same repository, same single-word prompt, two setups: a clean install with an empty config and no MCP server, and a normal setup with its servers and plugins.

| | Clean install | Normal setup |
| --- | ---: | ---: |
| Tools in the request | 24 | 40 (16 from MCP servers and plugins) |
| Prefix tokens billed | 47,411 | 57,277 |
| Output tokens | 4 | 4 |
| API-equivalent cost of one "ok" | $0.07 | $1.15 |

The roster is the bill. The heaviest definitions are built in: the shell tool alone is 12,000 characters, the agent tool almost 9,000.

The benchmark's footnote saw six tools and 7,000 tokens on a clean install, and 285 tools on one loaded setup. Today's clean Claude Code ships far more tools built in, and the loaded case is rarer: most MCP tools sit behind a search tool, deferred, so the roster a router sees stays small. Whatever its size, the gateway sends that roster to Jev on every request; an open issue on the repository says the full cost is paid before most answers are discarded. Nothing there is Jev's fault, and nothing there is Jev's to fix.

## Verdict per use

Routing inside Claude Code: no. It is a hint the model may ignore, it made feature work slower on both Claude models, and the one win is on debugging. The exception is a day of bug hunts on a very large tool roster, which the README itself names as the case.

The compaction plugin, fast-jev-compaction: not yet. It needs an early-access hook flag, its open issues say the hooks do not register on some builds, and after one compaction the model wrote nine reports saying the work was done, all fabricated. Practitioners got there first: the top thread on the plugin has 491 points, and its top objection is not speed but the terms of service on sending transcripts to a third party.

Codex: that is the real target. There the gateway forces the tool, Jev steered up to every request, and the bug hunt ran on 57% fewer output tokens.

| Use | Verdict |
| --- | --- |
| Routing in Claude Code | No, except bug hunts on a very large tool roster |
| fast-jev-compaction | Not yet |
| Codex | Yes |

One thing the wave got right: the subscription login never moves, the gateway only changes a URL. The limits of this reading: five runs per cell, one chess engine, a benchmark repository nobody reran, and no routed session of my own. I measured the roster and the request, not Jev. Jev itself is cheap. The detour is not.

## FAQ

### Does Jev make Claude Code cheaper?

No. jev-gateway can only hint inside Claude Code, and its own benchmark shows Opus 5 using 61% more input tokens, 47% more requests and 83% more time on a feature task with routing on. Sonnet 5 went the same way; the one win was a bug hunt at 48% fewer input tokens.

### What is Jev?

Jev is TypeSafe's decision model. It generates no text: you ask a typed question and it returns a choice, a score or a yes/no probability in 70 to 500 ms, priced at $0.04 per million input tokens with free output.

### What does jev-gateway change in Claude Code?

One environment variable, ANTHROPIC_BASE_URL, pointed at a local proxy; the Pro or Max login stays untouched. In its adapter, one line sets the steering mode to hint whenever thinking is on or the conversation is cached, which is every Claude Code request.

### What is Claude Code hint mode?

Two sentences appended to the last user message: a routing model suggests this tool is the most relevant move now, ignore this if it doesn't fit. The model is free to ignore it and tool_choice stays on auto, because forcing a tool errors with extended thinking and changing tool_choice invalidates the prompt cache.

### How many tools does a Claude Code request send?

Measured with a logging proxy on Claude Code 2.1.280: 24 tools and 47,411 prefix tokens on a clean install, 40 tools and 57,277 prefix tokens on a normal setup with MCP servers and plugins, for a four-token answer.

### Is fast-jev-compaction worth installing?

Not yet. It needs an early-access hook flag, its open issues report hooks that do not register on some builds, and one report of nine fabricated work-done summaries after a compaction. The top community thread's main objection is the terms of service on sending transcripts to a third party.

## Sources

- [jev-gateway (source, README)](https://github.com/vinilana/jev-gateway) — GitHub
- [jev-gateway-bench (the gateway's own benchmark)](https://github.com/vinilana/jev-gateway-bench) — GitHub
- [jev-gateway issue #24: the tool roster is re-sent on every request](https://github.com/vinilana/jev-gateway/issues/24) — GitHub
- [Introducing System One models and Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev) — TypeSafe
- [Tool use: define tools (forcing tool use)](https://platform.claude.com/docs/en/agents-and-tools/tool-use/define-tools) — Anthropic
- [Prompt caching](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) — Anthropic
- [fast-jev-compaction](https://github.com/tamaratran/fast-jev-compaction) — GitHub
- [Instant Claude Code compaction is my favorite use of Jev (r/ClaudeCode)](https://www.reddit.com/r/ClaudeCode/comments/1wkjnrz/instant_claude_code_compaction_is_my_favorite_use/) — Reddit