// open source · for teams running llm calls in production
jev-swap finds the LLM calls in your code that only ever return a label, a yes/no or a 1–5 score, rewrites them for TypeSafe Jev with your current call as the fallback, and proves the swap on your own traffic.
No API key needed to scan · TypeScript, JavaScript, Python
Ticket routing, spam checks, moderation verdicts, refund triage, priority scores: each one runs a text-generation model to return one word from a list you already wrote.
Jev is built for that job. Send the input and typed questions; get back a typed answer with probabilities and a confidence score, with no text generated and no output tokens billed.
The hard part is finding which calls qualify and trusting the swap. That's what jev-swap does.
// cost and speed
On Claude Sonnet 5, a typical 400-token decision call costs $0.00100 and takes about 3.1 s. On Jev it costs $0.000024 and answered in 327 ms at the median of our live test calls.
~3.1 s for this call: OpenRouter p50 latency + output time, busiest provider, fetched 2026-09-24
327 ms: its p50 over 45 live calls we timed on 2026-09-24 (TypeSafe reports 70–500 ms)
Lane lengths are to scale for these two figures. Your model and inputs will differ: the shadow run measures them.
A 400-input, 20-output-token call at OpenRouter list prices fetched 2026-09-24: Claude Sonnet 5 at $2 in / $10 out per 1M tokens, Jev at $0.042 in, output free. Jev bills its own framing: 574 input tokens for this call, from 259 + 31 per question + 0.71 × input, measured on live calls.
Independent check: a test of 1,000 eight-way routing decisions found Jev about 40× cheaper than GPT-5.6 Terra ($0.0151 vs $0.6089). AY Automate
// how it works
Reads your code's syntax tree and flags LLM calls whose output is an enum, a boolean, or a small integer range, whether it's a zod schema, a Pydantic model, JSON schema, or a raw HTTP call to the API. Also catches plain "answer yes or no" prompts.
npx jev-swap scan ./appWrites one module per call, in the same language, on TypeSafe's official SDK: one short question per field, all in a single request. Free-text fields Jev can't produce are flagged, never silently dropped.
npx jev-swap convertReplays inputs your LLM already answered through Jev and measures agreement, Jev's latency and cost per call. It picks the confidence threshold that hits your accuracy target and writes it into the code.
npx jev-swap shadow logs.jsonl// the safety net
Every Jev answer carries a confidence score. The generated code acts on Jev above your threshold and calls the model you use today below it, so the cases Jev isn't sure about keep the accuracy you have now. Your existing call stays in the code.
// generated: jev-swap-out/jev/triage-classifyTicket.ts export const THRESHOLD = 0.7; // set by shadow run const ticket = await decideWithFallback( text, () => classifyWithLLM(text), // your existing call ); ticket.source // "jev" or "llm"
// in the wild
Estimates at OpenRouter list prices and latency, data as of 2026-09-24. Every call links to its file and line; here's the method.
// also from jev-swap: the shadow proxy
Point your OpenAI or Anthropic client at the shadow proxy. Every request still reaches your model untouched, while decision calls are mirrored to Jev in parallel and a live dashboard compares answers, latency and cost.
Meet the shadow proxy// savings calculator
Plug in one decision-type call from your app. The share Jev handles comes from your shadow report. Until you run one, it's your estimate.
Hybrid = Jev on every call + your LLM on the share Jev isn't confident about. Jev priced at $0.042 per 1M input tokens, output free. Jev input tokens = 259 + 31 per question + 0.71 × your input tokens, fitted from live calls. Check your provider's current rates, then measure with a shadow run.
// the report
Every shadow run writes a REPORT.md that drops straight into a pull request: agreement with your current model per field, a confidence-versus-coverage table, the recommended threshold, and cost per call on your real token counts.
Measured on inputs your model already answered, not on a benchmark.
# jev-swap-out/REPORT.md ## triage-classifyTicket src/triage.ts:15 Agreement with your model per field: category, urgent, priority Coverage vs confidence share of calls Jev answers at each threshold Recommended threshold lowest one that meets your accuracy target Latency Jev p50 and p95 on your inputs Cost per call your model vs Jev vs hybrid, on your token counts
// ts · js
OpenAI chat completions and Responses, Anthropic Messages including forced tool schemas, the Vercel AI SDK (generateText, generateObject, Output.choice), and raw fetch/axios calls to those APIs. Reads zod and JSON schema.
// python
OpenAI, Anthropic, LangChain's with_structured_output, and raw requests/httpx calls. Reads Pydantic models, Enum classes, Literal, Field(ge, le) and JSON schema dicts, even when they live in another file.
No. It writes new modules and a report into jev-swap-out/. You decide what to merge.
Not to scan or convert. Shadow runs call Jev, so they need a TypeSafe API key in TYPESAFE_API_KEY.
Below the confidence threshold, the generated code calls your existing LLM instead. The shadow run sets that threshold from your data, against the accuracy target you choose.
No. Against mid-size and large models it is, by a wide margin. Against the cheapest small models, like Gemini Flash-Lite, the cost can come out about even or higher, and the case is speed. The explorer shows every call, including the ones with no saving.
Anything that generates text: summaries, drafts, explanations. Jev doesn't write, so those calls stay on your LLM, and any text fields mixed into a decision schema are flagged for review.
No. jev-swap is an independent open-source tool built on TypeSafe's official SDKs.
Node 22.12+. Python 3.9+ on your PATH for Python projects.
# run it on your app, no install needed npx jev-swap scan ./your-app npx jev-swap convert npx jev-swap shadow logs.jsonl \ --llm-price-in 2 --llm-price-out 10 # or install it npm install -g jev-swap