How to Use Jev in Claude Code and Codex

Why Jev cannot be the model

Claude Code talks to the Anthropic Messages API. Codex talks to the OpenAI Responses API. Both will let you move the base URL, but the wire format stays the same, and that is the whole problem: Jev's request shape is a state plus a map of typed questions, and its response is typed answers with probabilities per option. There is no assistant message to render, no token stream to print, no tool call to parse.

TypeSafe documents exactly one evaluation endpoint, POST /v1/systemone, plus GET /v1/models to list the aliases your account can send in the model field. jev-latest is the default; versioned IDs such as jev-1.13.0 are accepted whether or not they appear in the list. Nothing in the documentation describes an OpenAI-compatible or Anthropic-compatible surface.

That is not a gap TypeSafe forgot to fill. Jev is a decision model on purpose: it returns an answer inside a schema you defined, and it charges nothing for output because there is no output. A coding CLI is the opposite kind of program — it exists to write text. So the useful question is not "can Jev be the model", it is "which decisions inside the agent should Jev own", and there are four places that answer fits.

Route 1: the official agent skill

This is the only officially supported integration, it ships from TypeSafe, and it is the one to install first because it cannot break anything: it teaches the agent, it does not intercept the agent.

Claude Code, as a plugin:

claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

Then invoke it directly with /typesafe:typesafe-ai, or just name it in a prompt — "use the TypeSafe skill". To update:

claude plugin marketplace update typesafe-ai
claude plugin update typesafe@typesafe-ai

Restart Claude Code or run /reload-plugins. Automatic updates can be switched on from /plugin → Marketplaces → typesafe-ai.

Codex and everything else, through the skills installer:

npx skills add typesafe-ai/skills --skill typesafe-ai

It asks which agent to install into. You can also paste TypeSafe's own prompt into the agent and let it do the installation, or copy the skills/typesafe-ai directory into your agent's skills folder by hand. The repository is MIT-licensed, the plugin manifest is typesafe v0.5.7, and the skill itself is a single Markdown file plus references.

What the skill actually changes is worth knowing, because it is not just API trivia. It carries the three question types, how to build state, what confidence means as opposed to probability, the architectural patterns, and a table pointing at the right documentation page for each task — including the trick that appending .md to any docs URL returns the Markdown. TypeSafe's documentation is explicit about the failure mode it is correcting: "coding agents fall into the one question per call habit more than people do." The skill tells the agent to put many questions in one call, including speculative ones whose answers only matter for some inputs, and let your code decide which answers to use. That pattern is the reason the numbers work out — TypeSafe's own GDPR example batches 13 questions into one call and reports it as 12.2× cheaper and 10.0× faster in the cookbook index, 11.5× cheaper and 9.6× faster in the building guide, with no change in the answers. Two slightly different figures for the same test; treat both as the vendor's own measurement.

One limit to plan around: the state and every question in a request share a budget of roughly 32,000 tokens, about 150,000 characters of English.

Route 2: put Jev at the boundaries

This is where most of the real-world use is, and it is all community work. The pattern is the same everywhere: the CLI is not modified, a hook or a proxy is, and Jev makes one bounded judgment at a moment where a language model would otherwise spend tokens and seconds.

Where it sits	Project	★	Agents
Session compaction	tamaratran/fast-jev-compaction	4,697	Claude Code plugin; replaces the compaction summary with per-item keep/drop judgments
Session compaction	leonaaardob/fast-dev-compaction	3	Codex plugin, a port of the same idea
Terminal output	tamaratran/jev-pruner	122	Claude Code; trims long Bash output before the model sees it
Context proxy	compozy/yoshi	18	Claude Code, Codex; Jev judges which history is still needed
Pre-tool gate	shiftynick/jev-axi	17	Claude Code, Codex; scores each shell command for destructiveness, exfiltration, RCE and security weakening before it runs
Pre-tool gate	leepokai/jev-guard	12	Claude Code, Codex, Pi, ACP
Stop hook	valentynkit/jev-belay	13	Claude Code; reads the transcript before trusting a "done" claim
Above Codex workers	thruwire/foreman	418	Codex; Jev judges whether an implementation is complete and its tests sufficient
MCP and ACP bridge	tacticocc/Jevbridge	26	Codex, Claude, Grok, OpenCode
Plugin bundle	shitianfang/jev-use	9	Claude Code, Codex, Pi; installs hooks, a routing skill and the PreToolUse gate in one command
Desktop actions	yikangy873-gif/jev-desktop	31	Codex Computer Use; picks among desktop actions instead of asking a language model every step

Two of these are worth reading before you install anything. jev-axi publishes its own labeled set of 44 tool calls — 24 of which must be blocked or escalated, including base64-obfuscated ones — and reports 44 of 44 decided as labeled; it also documents the honest edge, which is that when the hook cannot read the agent's transcript it does nothing. jev-belay shows the cost control that makes this whole category work: it spends one four-question Jev call, and only when files changed with no passing check since, and it fails open on any error.

Two caveats you should hold on to. These repositories are days old — most were created between September 17 and September 20, 2026 — so the star counts above are attention, not maturity, and fast-jev-compaction aside, they are small projects. And the install commands differ per project; read the README rather than assuming the skill-style command works.

The one-command entry point, if you want the bundle rather than a single hook:

npx -y jev-use install    # wires Claude Code, Codex and Pi, whichever it finds
npx -y jev-use doctor     # checks the wiring

jev-use reads its key from TYPESAFE_API_KEY, OPENROUTER_API_KEY or AI_GATEWAY_API_KEY, and JEV_BACKEND=mock gives you a keyless dry run that keeps every judgment local. Its published demos are worth the read for the shape of the wins: a context compaction run that judged 200 messages in 7 calls and took a 94%-full window down to 44%, and a shell-command gate that denied dangerous commands in about 230 ms with zero language-model tokens.

Route 3: MCP tools

If you want Jev available to the model as a callable tool rather than as a hook, MCP is the portable route — and it is community-only. TypeSafe's own documentation never mentions MCP, so there is no first-party server to install.

Claude Code:

claude mcp add jev -e TYPESAFE_API_KEY=sk-... -- npx -y @jkudish/jev-mcp

Codex, in ~/.codex/config.toml:

[mcp_servers.jev]
command = "npx"
args = ["-y", "@jkudish/jev-mcp"]
env = { TYPESAFE_API_KEY = "sk-..." }

That server (npm @jkudish/jev-mcp 0.5.0) exposes ten tools — jev_verify, jev_screen, jev_find, jev_rerank, jev_classify, jev_decide, jev_compare, jev_extract, jev_review and jev_gate — and its README quotes roughly 150 to 500 ms per judgment at a fraction of a cent. The design point is the one that matters here: these are the cheap mechanical checks an agent skips because a frontier model is too slow to run them on every page, claim or candidate list.

Alternatives exist if you want a different shape: itsmostafa/typesafe-mcp (★128) is a Go server and CLI, and Jevbridge speaks MCP over stdio from a source clone, which is how its Codex example is written:

[mcp_servers.jevbridge]
command = "node"
args = ["--experimental-strip-types", "/absolute/path/to/Jevbridge/src/cli.ts", "mcp"]

One naming warning: there are now two unrelated npm packages in this space, @jkudish/jev-mcp and an unscoped jev-mcp published from a different repository. Pin the scoped name in your config so a future npx does not resolve to the wrong one.

Route 4: per-turn model routing

This is the most visible use of Jev in a coding agent, and it is clever: Jev does not answer anything itself, it chooses which model should. One Jev call per fresh user turn picks a tier, and the CLI runs exactly as before.

npm install -g jev-router
echo "JEV_API_KEY=..." > ~/.jev-router.env
jev-claude      # Claude Code, with Jev Router selected in /model
jev-codex       # Codex, with a temporary Jev Router provider selected

Requires Node.js 20.12+ and at least one of the two CLIs. Your existing claude login or codex login is untouched — the loopback proxy forwards the CLI's own authorization headers without reading, storing or modifying them, and no Anthropic or OpenAI API key is involved. Claude Code is redirected through ANTHROPIC_BASE_URL; Codex gets a temporary custom provider with requires_openai_auth=true. In both, Jev Router appears in the model picker: selecting a concrete model pauses routing, selecting Jev Router resumes it. Tool calls, permissions, sessions, /compact and /resume behave as they always did, because they are still the CLI's own.

The tier table is the part that should interest anyone buying API access:

Tier	Claude Code default	Codex default
Fast	Haiku	gpt-5.6-luna
Balanced	Sonnet	gpt-5.6-terra
Strong	Opus	gpt-5.6-sol
Long	Fable (opt-in)	gpt-6-astra

Every model in that table is on sale on APIMaster today at the prices in the quick answer, from about 89% to about 96% below list. Buying the routed half here and paying TypeSafe directly for the judging half is the cheapest version of this setup we can see — the router's own defaults point at our catalog, and the whole point of the pattern is that most turns land on the cheap tier.

The policy is more careful than "pick the cheapest", and the details are the reason it does not fight you: an explicit request such as "use opus" wins; low confidence never downgrades and caps upgrades at the balanced tier; large conversations refuse downgrades that would waste more prompt-cache work than they save; an unavailable tier steps upward rather than silently choosing something weaker; and the long tier stays off unless you set JEV_ALLOW_FABLE=1. Routing is fail-open — a Jev failure leaves the current model in place rather than blocking the CLI — and each launcher restores the CLI's previous default on exit.

There is a sibling project with the same name that also covers the Grok CLI and opencode. Its README gives an npm command that is not published yet, so use the repository clone if you need those two agents.

What to install first

1. The skill, in whichever agent you use most. It is MIT, it changes no behavior you did not ask for, and it makes every later step easier because the agent stops asking one question per call.
2. One boundary hook, chosen by what annoys you. If long sessions get expensive, compaction. If you are nervous about shell commands, the pre-tool gate. If you keep getting "done" on unfinished work, the stop hook.
3. Routing, only if you are already comfortable with a proxy in front of your CLI. It is the highest-leverage and the most invasive of the four.
4. Keep the arithmetic, dates and counting in your own code. Jev documents those as unreliable, and the same is true of the models above.

Three things people get wrong

• "Point Claude Code at Jev." There is no compatible endpoint. This is the single most common error in the content written about Jev this week.
• "One question per call." A decision model's economy comes from parallel questions over one shared state. Asking one question per request throws away most of the advantage and all of the latency argument.
• "Confidence is accuracy." Jev's confidence is calibrated, which is a different and more useful property: it tells you which answers to escalate. We went through the published calibration numbers in Jev vs LLMs.

FAQ

Can I use Jev as the model in Claude Code or Codex? No. Jev returns typed decisions and generates no text, and its API is POST /v1/systemone with no OpenAI- or Anthropic-shaped surface. Use it as a judgment layer, not as the assistant.

Does Jev have an OpenAI-compatible endpoint? Not as documented. The API reference lists the evaluation endpoint and GET /v1/models, and nothing else.

Does TypeSafe ship an MCP server? Not in its documentation — MCP does not appear in the docs bundle at all. Community servers exist, and the most complete one is @jkudish/jev-mcp.

What exactly does the official skill install? In Claude Code, a plugin named typesafe from the typesafe-ai marketplace, invoked as /typesafe:typesafe-ai. Everywhere else, a skill directory that npx skills add typesafe-ai/skills --skill typesafe-ai places in the right folder for your agent.

Do I still need my Claude or ChatGPT subscription? For the routing setup, yes — the launchers reuse the login the CLI already has, so a Pro, Max, ChatGPT or SuperGrok subscription works as-is. Without a Jev key you get the plain CLI with no routing.

Do I need a TypeSafe key? For anything that calls Jev, yes. Get one from TypeSafe, or point the tooling at OpenRouter or the Vercel AI Gateway, which jev-use also supports.

Can I try it without a key? JEV_BACKEND=mock in jev-use runs every judgment locally with no provider call, which is enough to see whether the hooks fire where you expect.

Is Jev available on APIMaster? It is in onboarding, and this page will be updated when the integration is live. The models a Jev router sends work to are already here, at the prices above.

Will any of this break my CLI? The skill changes nothing about how the CLI runs. The routing proxy is fail-open and restores your previous model default on exit. Hooks are the one place to be careful, and the better ones document their fail-open behavior explicitly.

How much does a Jev judgment cost? $42 per billion input tokens, with no output charge, because there is no output. One routing decision per user turn, or one question set per hook firing, is the whole bill.

Which route should I pick for a team? The skill for everyone, one boundary hook for the shared pain, and routing only where the model bill is large enough to measure.

Sources and further reading

• TypeSafe — API reference — the POST /v1/systemone request shape, question types and answers
• TypeSafe — Models — aliases, versioned IDs, $42/Btok pricing and limits
• TypeSafe — Agent skill — the official Claude Code plugin and the npx skills route, with the update commands
• TypeSafe — How to build with TypeSafe — speculative fan-out, the 32,000-token request budget and the batching comparison
• typesafe-ai/skills — the skill source, MIT
• gargpratyush/jev-router — the routing proxy, its tier table and compatibility notes
• jkudish/jev-mcp — the MCP tool set
• shiftynick/jev-axi — the pre-tool gate and its 44 labeled cases
• tamaratran/fast-jev-compaction — the compaction plugin

Repository stars, install commands, npm package versions and APIMaster route prices were all checked on September 20, 2026. Community projects in this space are moving daily; check the repository before you install.

Create an APIMaster account, add pay-as-you-go credit from $1, create a key in the console, and point an OpenAI- or Anthropic-compatible client at https://apimaster.ai/v1. The setup guides for the two CLIs in this article are Claude Code and Codex.