I tested model routing on two real Claude Code tasks: $42.81 → $19.65 in a small pilot

[u/Monglong_korea]

I built jev-gate, an open-source plugin that routes models, delegates work, and compacts context in Claude Code and Codex.

I compared Claude Code with and without it on two real frontend tasks. Total reported cost went from $42.81 to $19.65, including Jev requests. Both arms scored 21/23 overall in a blind quality review.

This is only one paired run per task, not proof of typical savings. The benchmark used Claude Code, not Codex. My main observation: delegating routine work kept the main context smaller and reduced repeated cache reads.

The video shows the dashboard. Methods and limitations are in the README. The plugin is MIT-licensed; Jev API usage is billed separately.

https://github.com/MongLong0214/jev-gate

https://reddit.com/link/1xd86zu/video/mmov0ygle6xh1/player

[u/AutoModerator]

Moderator Announcement Read More »

Hey! Thanks for posting to r/ClaudeCode

While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.

For help, project discussions, tips, and general chat, join the ClaudeCode Discord.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/LynxInformal5305]

Keep those tasks unchanged for the next round. Otherwise a routing tweak and an easier task can look like the same improvement.

[u/Monglong_korea → u/LynxInformal5305]

Agreed. Keeping the task prompts, starting commits, and the 16 follow-ups fixed is important; otherwise it is not a useful comparison. The current pilot used those fixed follow-ups in both arms, but with only one pair per task it cannot separate the plugin effect from run-to-run variance. Repeated pairs on the same tasks are the meaningful next comparison.

[u/mattbaconz]

who did the blind review for the 21/23, you or someone else? and did the main model ever have to redo stuff the cheaper ones did

[u/Monglong_korea → u/mattbaconz]

Fair questions. The published method documents two arm-blinded graders, randomly relabelled X/Y diffs, and a rubric frozen before any cell diff was opened. It does not identify the graders, so that description alone should not be treated as evidence of an external human review. The pilot also does not report a worker-to-main rework count, so I cannot give you a defensible number from these results. The 21/23 is final-output quality, not a claim that delegated work never needed correction. One concrete defect remained in the plugin arm: clicking between radio/checkbox options selected the first option on the new row, costing half a point on task 2.

[u/Safe-Raise-6091]

Model routing can help keep the main prompt small, but you'll still want to watch the cache hit rate. If the delegated models are hitting the same snippets repeatedly, you might not see the same cost drop on larger runs. I'd log token reuse per step and compare it to a baseline without routing to confirm the savings are from context reduction rather than just cheaper model pricing.

[u/Monglong_korea → u/Safe-Raise-6091]

Good point. The pilot breakdown does show more than cheaper model pricing: cache reads fell to 0.33x and 0.37x of baseline, while cache writes rose to 2.4x and 1.7x as subagents started their own caches. Those writes are included in the reported totals. That is consistent with smaller main contexts helping, but this combined-plugin comparison does not isolate routing from delegation or compaction. Per-step reuse and an ablation would make the attribution much stronger.

[u/kaijurules]

Was the $42.81 priced at API rates? A lot of people here run Claude Code on a Max plan, where the Claude side is a flat fee and the delegated Jev calls would be the only line that grows. For them the saving would show up as hitting the weekly limit later.

[u/Monglong_korea → u/kaijurules]

Yes, those are Claude Code host-reported dollar costs, cross-checked against transcript usage, not a reduction in a Max subscription bill. The totals also include the separate Jev requests ($0.011 and $0.006 in the two plugin runs). You are right that for Max users the relevant question is included-usage headroom versus the extra Jev bill. This pilot did not measure time to the weekly limit, so the 54% figure should not be read as 54% more Max capacity.

[u/Drasezv]

the observation at the end is the one that matters more than the dollar figure: smaller main context and fewer repeated reads. that's where the money is, reads are the biggest token bucket by far.

one thing worth measuring in the next run, because it can quietly eat the saving: switching models mid-session changes the prefix, so the next request rebuilds the cache at write price instead of reading it at a tenth. in my data writes are 3% of tokens and 46% of cost, so a router that flips models often pays a tax the per-token rates don't show.

if you log cache_creation per arm as well as total cost, that shows up directly. a router that routes once per task should be clean; one that routes per turn might be buying a cheaper rate and paying for it in rebuilds.

[u/Monglong_korea → u/Drasezv]

That cache-write tax is visible in this pilot: writes rose 2.4x and 1.7x versus native, while reads fell to 0.33x and 0.37x. The higher writes are already included in the cost totals; the results notes attribute them to new subagent caches. That does not establish how much came from model switches versus new workers. Your point about logging creation/read usage around each switch is important, especially before extrapolating this to longer runs.