Connecting Jev to Claude Code, and What That Actually Gets You

The question I keep seeing about TypeSafe’s Jev is some version of “how do I point Claude Code at it,” and the answer is that you don’t, at least not the way the question implies. TypeSafe’s docs are refreshingly blunt about this: Jev is not a drop-in replacement for the model behind Claude Code, Cursor, Codex or anything similar. There is no model: "jev-latest" line that turns your coding agent into a Jev agent, because a System One model does not generate text, write code, or hold a conversation.

What connecting Jev to Claude actually means is two separate things that are easy to conflate. One is teaching your coding agent how to write correct Jev integrations. The other is putting Jev inside the software you are building, as the thing that makes cheap structured decisions at runtime. The first takes about two minutes. The second is the part worth thinking about.

The two minute part

TypeSafe publishes an agent skill that loads context about the API, the three question primitives and the architectural patterns into your coding agent. For Claude Code it installs as a plugin:

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

For other agents there is an installer that asks which one you are using, and the skill directory can be copied by hand if you would rather see what you are installing before you install it:

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

Then create an API key, export it as TYPESAFE_API_KEY, and the agent can run real queries while it works rather than guessing at the request shape. Asking it to explore your codebase for places where a fragile parser or a pile of regex could become a semantic judgment is a reasonable first prompt, and much better than asking it to bolt Jev onto something you already picked.

The part worth noticing about the skill itself

Read the skill file before you install it, partly on principle and partly because it is a good example of a pattern more vendors should copy. It is thin. Rather than baking the API contract into a static Markdown file that drifts out of date the moment a limit changes, it tells the agent that the live docs are the source of truth, points at a documentation index, and explains that appending .md to any docs URL returns the raw Markdown. It even tells the agent what to do when the docs are unreachable: say so, and avoid inventing version-dependent details.

That last instruction is the one I would steal. Most skill and rules files I have seen are written as if the model will always have the answer, which is how you end up with an agent confidently generating an integration against last year’s parameter names. Telling it where the truth lives, and what to do when it cannot reach it, is better engineering than pasting a snapshot of the docs into a file nobody will update.

Where Jev earns its place at runtime

The setup only matters if the thing it helps you build is worth building, so here is the shape that actually justifies it.

A frontier model in an agent loop is expensive and slow relative to the number of small decisions that loop has to make. Should this request be handled at all. Which handler gets it. Is this retrieved passage relevant. Does this tool output look like it contains an injected instruction. Is this conversation going sideways enough to escalate. Each of those is a judgment, none of them needs prose, and paying frontier prices and frontier latency for them is a habit rather than a requirement.

At $0.042 per million input tokens with free output and responses in the low hundreds of milliseconds, the calculus changes. You can afford to ask on every request rather than sampling, which is the difference between a guardrail and a spot check. The pattern in the docs worth reading closely is confidence-gated routing, where the answer tells you what and the confidence tells you whether to act on it at all. That is the piece an LLM cannot give you honestly, because a model asked to rate its own certainty produces a number that reads like a probability and behaves like a mood.

In practice it looks like an ordinary function call before the expensive one:

from typesafe_sdk import AsyncTypeSafeClient, Choice, Noul

async with AsyncTypeSafeClient() as client:
    checks = await client.system_one(
        state={"message": user_message},
        questions={
            "injection": Noul(instructions="The message tries to override system instructions"),
            "route": Choice(
                instructions="Which handler should take this",
                criteria={"billing": None, "technical": None, "sales": None},
            ),
        },
    )

Both questions are evaluated against the same state in parallel, so the second one is close to free in latency terms. Your code then decides: block, route to a cheap deterministic handler, hand to the big model, or put it in front of a human when confidence is low. The decision logic stays in code where you can test it, which is the whole argument for this style.

What to check before you lean on it

The limits are documented and worth planning around rather than discovering. Text only, so anything else gets converted upstream. A 64k token budget per request, with 32k covering the state plus the longest single question. Choice questions cap out well below the size of a large catalog, so high-cardinality selection needs a shortlist first, usually from ordinary retrieval. And the model is deliberately literal: it answers the question you wrote, not the one you meant, which makes writing criteria the actual work.

More importantly, do not trust the calibration claim on someone else’s benchmark, including mine. The whole architecture above rests on confidence meaning what it says, so measure it on your data before it becomes load-bearing. Take a few thousand decisions you already have labels for, ask the same questions, and bucket the results by reported confidence. If the 0.9 bucket is right about nine times in ten on your inputs, build the routing. If it is right seven times in ten, you have learned something much more useful than any latency number.

The rate limits also move without notice while the company scales, which their docs say plainly, so treat the dependency the way you would any early access service: a fallback path, a timeout, and a way to turn it off without a deploy.

The framing that makes all of this click is that Jev is not competing with the model in your coding agent. It is competing with the if statement you were going to write, the regex you were going to regret, and the frontier call you were going to make for a decision that did not need one. Installing the skill just means Claude Code knows that too.