Introducing JevRouter

Most coding requests don’t need the most expensive model. Fixing a typo and chasing a hard concurrency bug cost the same when every request goes to Opus 5.5.

JevRouter reads each request, works out what it actually needs, and sends it to the model that will do it well for the least money. You change one thing: call jev-router instead of a specific model, and the choice is made for you on every request.

To check that cheaper doesn’t mean worse, we ran JevRouter on public agentic coding benchmarks. These are real jobs, not quiz questions: fix a bug inside an actual repository, finish a task in a terminal, answer questions about a codebase you have never seen. Terminal-Bench 4.0, DeepSWE v1.1 and SWE-Atlas-QnA are three of the benchmarks in our dataset.

Two numbers matter for each model. The score is how many tasks it gets right. The cost per task is what one complete task costs, from the first message to the finished change.

FIG. 01

The saving comes from matching. Hard tasks still go to the strongest models. Easier ones go to models that finish them just as well for a fraction of the price, so you stop paying Opus prices for work that doesn’t need Opus.

Most auto-routers are a small classifier trained once on old data: it spots a few keywords and guesses. Jev works the way an engineer would. It is given every frontier model and its benchmark results in every category, and reads your request in plain language. Here is what happens on each request.

1. 01

   You send a request

   Your tool sends the conversation to jev-router, exactly as it would send it to any model.

2. 02

   Jev splits it into parts

   The conversation is cut into slices: the task itself, the code you pasted, error messages, earlier turns. Each slice goes to its own Jev, and they all read at the same time.

3. 03

   Each Jev scores its part

   A Jev works out what its slice needs, for example frontend design, careful debugging or a quick answer, and checks how every model in the pool scores on benchmarks for that kind of work.

4. 04

   They vote on one model

   The scores are combined into one pick: the cheapest model that is strong enough for the whole request.

5. 05

   Your request goes through

   The request is forwarded unchanged to that model and the answer streams straight back to you. Your Activity page shows which model answered.

FIG. 02

Every model provider keeps a prompt cache. When you send a conversation, the provider remembers the part it has already read. On your next turn, those tokens cost a tenth of the normal price or less.

That cache belongs to one model. Switch to a different model and it has to read the whole conversation again at full price. On a long coding session, one unnecessary switch can cost more than the cheaper model saves.

So JevRouter only switches when the task really changes, for example when you go from planning a feature to renaming variables. While you keep working on the same thing, it stays on the same model and your cache stays warm.

FIG. 03

A request from a coding agent is rarely one message. It carries the whole session: your instructions, the files it opened, tool results and earlier answers. What the task really needs is often buried well before the last message.

Single-pass routers read only a small window, usually the last message, because one small model can only take in so much. JevRouter gives each slice of the conversation to a different Jev and runs them side by side, so together they read up to a million tokens.

FIG. 04

Sometimes you know better. You might trust one model for frontend work, or a client might need a specific provider. Write what you want in square brackets, starting with jev:, anywhere in your prompt.

Fix the mobile logout bug [jev: only use Fable]Write tests for checkout [jev: only use Astra]Rename these variables [jev: only use DeepSeek]

Jev reads the instruction, follows it, and removes it before the request reaches the model. The model never sees it, so your prompt stays exactly as you wrote it and your cache is not disturbed.

You can pin one model or narrow the choice to a few. A pinned request still earns 30% back.

FIG. 05

JevRouter speaks both the OpenAI and the Anthropic API. Anything that lets you set a base URL and a model name works with it: Claude Code, Cursor, Codex, Cline, OpenCode and the rest.

Point your tool at Straitly and set the model:

base_url = https://api.straitly.ai/v1model    = jev-router

Nothing else changes. Your tool keeps working the way it does today, and every request is routed.

FIG. 06

After every JevRouter request, 30% of what you spent goes back into your Straitly wallet. The same goes for direct calls to 24 frontier models, including Opus 5.5, Fable 5.1, Astra, Sol and Sonnet 5. Every other model pays 5% back.

Spend $100 through JevRouter and $30 comes back as credit you can use on any model.

Today JevRouter picks one model for each request. Next, it will split a single request into parts and route each part on its own.

Ask for a full-stack app and the frontend design goes to one model, the backend and security to another, and the unit tests to a third, all inside one request.

Try JevRouter on straitly.ai →