Jev with Claude Code

What Jev changes in the Claude Code loop

Ask a chat model whether a test passed and it generates a paragraph of reasoning before it says “yes.” That is generation doing a classification. The most useful count published on this came from the write-up that named the stack, cyrilXBT’s Jev + Claude Code guide: in a single multi-file refactor fixing a 340-line auth module, the author counted 31 yes-or-no or categorical checks across the run. He puts the general density at 25 to 40 percent of model calls in any agent loop with a review step. Those are one person’s counts on one run, not a benchmark — but the shape is easy to check against your own transcript.

Jev Claude Code plugins and skills, with their published figures

Taking the classification weight off the loop

Split the run: the model reasons and writes, Jev answers the bounded question and returns a confidence. The advertised multipliers are a ceiling, and the published builds below are what people actually measured.

CyrilXBT

@cyrilXBT

I built agents that run 200x faster and 400x cheaper than the standard Claude Code loop. Best case, not average, on the tasks where a $9 model was doing $0.0004 work the entire time and nobody noticed. Split reasoning from decision making. Let Claude Code write. Let Jev decide. From scratch, the whole architecture is below. follow @cyrilXBT

X·Agents and browsers

Pick

200× faster and 400× cheaper than a plain loop

Speed

~200× faster

Cost

~400× cheaper

CyrilXBT

@cyrilXBT

With a single prompt, the Jev + Claude Code stack can make AI agents 200× faster and 400× cheaper. The secret: agents that run wide not long. I broke down the complete system in 3 visuals. Save this. You’ll want it later. Follow @cyrilxbt for more AI updates.

X·Agents and browsers

The Jev and Claude Code stack, run wide

GitHub·Routing and model choice

jev-router

Routes each Claude Code task to the cheapest model that can do it.

PGPratyush Garg

325

erKam 🅰️

@erkamyaman_ng

in 2026, why is CLAUDE.md still a suggestion? one @typesafeai Jev request checks every Claude Code reply and edit against every rule you wrote. break a rule, Claude gets it quoted back and rewrites. 348ms per check. 93.3% of broken rules caught on our benchmark.

X·Security and abuse

Every rule checked in 348 ms

Check

348 ms

Compaction and pruning: dropping instead of summarising

A summary is lossy, so these plugins never write a sentence. They score tool calls and tool results and delete the stale ones, leaving the kept context word for word. The strongest published figure here is a session going from about a million tokens to 86,000 in one second.

tamara

@tamarajtran

found the perfect use case for @typesafeai Jev: instant compaction in 2026, why is compaction still a summarization prompt? Jev can make it instant by scoring every tool call and dropping what’s irrelevant

X·Context and memory

Pick

Instant compaction for Claude

Alex Volkov

@altryne

This is actually insane. This uses @typesafeai Jev model, as a plugin in Claude to review all the un-nesseasary tool calls, and it takes 1s to run! Like, literally, 1 second to take my Claude session from nearly 1M to ... 86K tokens! 😮 Ask your claude to install it and be amazed Use this prompt ``` Install, and configure : https://github.com/tamaratran/fast-jev-compaction ```

GitHub·Context and memory

Pick

fast-jev-compaction

Stars

6.2k

Reported

~1M → 86K tokens

GitHub·Context and memory

jev-pruner

Trims long Bash output with Jev before Claude reads it.

TTTamara Tran

138

Skill·Routing and model choice

jev-agent-skill-router

Routes which agent skill runs, with typed Jev decisions and confidence.

DHDewaldt Huysamen

15

The same split, rebuilt for Codex

A skill that teaches Codex to hand code judgement to Jev, a router that picks a model and a reasoning effort together, and a plugin that trims bulky tool results. One of them publishes a backtest, and labels it a simulation.

云析

@yunxi0623

分享个很火的 skill： typesafe-ai Skill 👇 安装命令：npx skills add typesafe-ai/skills --skill typesafe-ai 可以直接 让 Codex 理解 TypeSafe / Jev 的调用方式 它最有意思的地方，不是让 Jev 替 Codex 写代码，而是把代码里的“判断题”交给 Jev 不过注意它不是装完就会自动接管 Codex 的所有决策，你需要在 Prompt 或代码里明确哪些判断交给 TypeSafe

X·Coding and code review

Teach Codex to call Jev

201Stars · ≈ −60% vs largest model backtest

GitHub·Routing and model choice

Jev Codex Router

Jev picks the model and the thinking effort for every Codex turn.

NNatoshi

GitHub·Context and memory

codex-context-diet

A Codex plugin where Jev trims bulky tool results.

KBKonstantinos Botonakis

3

Is Jev with Claude Code really 200× faster?

The ceiling band is specific: high frequency, low ambiguity, tightly bounded decisions, run at volume. Triage queues, CI gating, content filters and multi-agent handoff all live there. A workflow that is almost entirely generation does not, because there is nothing to move.

The failure mode is worth stating plainly, because it does not look like a failure. Jev cannot hallucinate free text — it never writes any — but it can select the wrong option inside a valid schema and return it with a clean confidence. Overlapping or ambiguous categories do not throw an error; they produce a slow drift in decision quality that is hard to trace. Two defences, both from the same write-up:

• Set the threshold per decision, not globally. A merge/retry/flag call and a spam/not-spam call have different acceptable error rates. Tune each against cases you already know the answers to, rather than copying a round number.
• Sample above the threshold for drift. Confidence above the line means the model is sure, not correct. On high-stakes decisions, run a small percentage through the larger model in parallel and log the disagreements.

Jev compaction: how it works, and the argument against it

The fastest-spreading use in this stack is not routing; it is dropping context. The plugins here never ask a model to summarise. They score each tool call and tool result, delete the stale ones, and keep everything else word for word, so a file path or an exact error cannot disappear inside a paraphrase.

It is not free of critics. Theo’s case against Jev compaction — kept on the resources page as the case against Jev compaction — reports lost reasoning, higher cache-write costs and agents stuck in loops. It is the most useful counterweight in the directory: the same pattern that removes the summary tax can remove context the agent needed. Read both before you install it on a long-running session.

Alex Volkov

@altryne

This is actually insane. This uses @typesafeai Jev model, as a plugin in Claude to review all the un-nesseasary tool calls, and it takes 1s to run! Like, literally, 1 second to take my Claude session from nearly 1M to ... 86K tokens! 😮 Ask your claude to install it and be amazed Use this prompt ``` Install, and configure : https://github.com/tamaratran/fast-jev-compaction ```

GitHub·Context and memory

Pick

fast-jev-compaction

Stars

6.2k

Reported

~1M → 86K tokens

tamara

@tamarajtran

found the perfect use case for @typesafeai Jev: instant compaction in 2026, why is compaction still a summarization prompt? Jev can make it instant by scoring every tool call and dropping what’s irrelevant

X·Context and memory

Pick

Instant compaction for Claude

GitHub·Context and memory

jev-pruner

Trims long Bash output with Jev before Claude reads it.

TTTamara Tran

138

How to use Jev with Claude Code, in the order that fails least

1. Audit the loop first. Go through one real transcript and mark every place the model was asked a bounded question instead of to generate. Run it on a real session, not a hypothetical one.
2. Write the schema down. Name the questions, their answer sets and their confidence thresholds before you route anything.
3. Move one decision. Not the whole loop. Keep generation on Claude and measure the difference on that one call.
4. Keep the fallback. Below the threshold, hand the question to the larger model. The escalation path is the safety feature, not an admission of weakness.
5. Install the skill. For a coding agent, npx skills add typesafe-ai/skills --skill typesafe-ai teaches it to hand code judgement to Jev.

The concept behind the split is Jev Engineering; the harness it fits into is on the agentic harness page; the model-versus-model numbers are on Jev vs an LLM and Jev as a judge. More agent integrations live on the MCP page and the skills page.

The Claude Code write-ups, including the objections

The stack article the headline figures come from, the best-argued case against compaction, and the people who installed the plugins and reported back.

CyrilXBT

@cyrilXBT

x.com/i/article/2101…

Guide·x.com

The Jev + Claude Code Stack

cyril on where the 200× and 400× headline figures come from and why they are a ceiling rather than a typical result: 31 bounded checks counted in one real session, and the decision-point audit that finds yours.

Theo - t3.gg

@theo

This is a terrible compaction strategy that fundamentally doesn't understand how compaction and context management work. Seems like a lot of people are confused so let's break this down. 1. Compaction isn't a filter The role of compaction is to clean up history to keep the agent focused, not just deleting noise. It should be used sparingly when context gets too long, not constantly to keep context small. 2. Jev doesn't even know what it's deciding on! Models use the context of the thread to decide what to keep or not keep in a summary. This implementation goes through on a "line-by-line" (per tool call) basis to decide what should be left or deleted. Not only does this 32k token context model know very little of what happened before, but (in this implementation) it doesn't even know what the result of the tool call is! Deleting these things randomly will keep the model from knowing what it's tried and dooms you to end up in "stupid loops" where the model keeps trying the same thing over and over. 3. You're giving up the reasoning entirely Frontier models from OpenAI, Anthropic, XAI, and Google do not share reasoning traces over the API. They share encrypted payloads, which Jev cannot see (and often will drop). Anthropic is even stricter with this, requiring you to preserve the entire history in order to get any of the reasoning data. As a result, using this in Claude Code guarantees the model will act way dumber. 4. Models are tuned on their compaction flows For the last year, Frontier Labs have been including compaction and long runs as part of the training process. These models have learned ways to compact that are more effective than any rudimentary solution. Fun fact: If you switch models in Codex and compaction is necessary, compaction will run on the model that was previously used in the thread. 5. Cache writes are more expensive than cache reads. Cache writes are the biggest cost by far for agents. I often see cache write costs go over 60% of my total LLM spend in my personal use of Claude Code and Codex. Cache writes are insanely expensive when data earlier in the history is changed (because the old cache is invalidated when things change at the top). Every history edit requires a cache rewrite for ANY data past the history edit. If your history is "1,2,3,4,5,6" and you delete "2", you have to rewrite "3,4,5,6". This is more expensive than leaving "2" in the history. Good news. Since we're already killing all of the reasoning tokens by doing this stupid compaction strategy, the rewrite cost won't actually be that high because the model is missing so much data! 🙃🙃 6. The implementation is hot garbage. > "Whatever is not kept is deleted permanently, but the assistant can always re-run a tool or re-read a file." Good luck with that one. To be clear: this is a cool experiment and I find it genuinely interesting. That said, if you think this style of bs filtering on a probability threshold is actually a compaction strategy, I highly recommend you just use the defaults in tools like Claude Code and Codex. You're much less likely to hurt yourself that way.

Guide·x.com

The case against Jev compaction

Theo on why per-tool-call filtering is not compaction: lost reasoning, higher cache-write costs and agents stuck in loops.

Alex Volkov

@altryne

This is actually insane. This uses @typesafeai Jev model, as a plugin in Claude to review all the un-nesseasary tool calls, and it takes 1s to run! Like, literally, 1 second to take my Claude session from nearly 1M to ... 86K tokens! 😮 Ask your claude to install it and be amazed Use this prompt ``` Install, and configure : https://github.com/tamaratran/fast-jev-compaction ```

Guide·x.com

The compaction plugin, tried

Alex Volkov: a Claude session went from nearly 1M tokens to 86K in about one second.

Guide·youtube.com/@RAmjad

Jev and Claude Code: the cheapest agentic loop yet

Ray Amjad puts Jev inside an agentic coding loop and looks at what it costs to run.

Guide·youtube.com/@MG_cafe

Jev Claude Code: Quick Setup

MG walks through setting Jev up with Claude Code from scratch.

Guide·youtube.com/@RoboNuggets

Jev will 10x your Claude Code (Here's How)

RoboNuggets: how to put Jev to work inside Claude Code.

Common questions

What is the Jev and Claude Code stack?

A split. Claude keeps the generative work — reading a diff, writing a review, producing a fix. Jev takes the bounded questions in between: does this pass, is this the right file, merge, retry or escalate. The published builds below are the ones with a figure attached.

Is it really 200× faster and 400× cheaper?

TypeSafe's published range is 20 to 200× faster and 40 to 400× cheaper, and that range is a ceiling reached only where decisions are frequent, tightly bounded and ask the same schema every time. A loop that is mostly generation gets nowhere near it, because there is nothing to offload.

What does Jev actually cost in the loop?

Jev is $0.042 per million input tokens with output free. The saving is not the whole bill; it is the classification tax you were paying to route yes-or-no questions through a model that generates a paragraph to answer them.

Does compaction with Jev lose information?

It can, and one widely read critique says so. The plugins here never rewrite anything — they delete tool calls and tool results that Jev scores as stale, keeping the rest word for word. The reported risk is lost reasoning, higher cache-write costs and agents that loop.

How do I install the Claude Code skill?

One command: npx skills add typesafe-ai/skills --skill typesafe-ai. After that the agent understands TypeSafe and Jev calls, so code judgement is delegated instead of answered by the writing model.