Jev: Practical Use Cases and a Builder’s Guide

Jev is worth testing when your application repeatedly needs a small semantic decision: which queue, which skill, which evidence passage, or which candidate value. The promising application is a cheap judgment inside a larger system. Your code still retrieves information, enforces rules, and decides what happens next.

The launch has prompted a wave of public prototypes. That establishes developer interest, not durable adoption or dependable automation. This guide separates documented capabilities, inspectable projects, and proposed experiments. We have not run a Jev inference benchmark. The interactive example below uses synthetic answers and makes no API calls.

If you are handing this page to a coding agent, start at the implementation handoff. For choosing between providers more broadly, use our September value shortlist and cost-saving playbook.

What Jev actually does

TypeSafe calls Jev a System One model. Give it a state containing text or structured text data, plus narrowly defined questions. It returns values your program can consume. It does not write the explanation, browse for sources, or execute the action. Several independent questions can share a state; a question that depends on an earlier answer needs another step in your code. TypeSafe introduction.

Make the question complete in instructions: the question ID is a program key, not a substitute for instructions. Add unknown, other, or insufficient_evidence when your choices do not cover every input. A score is not an extracted measurement, and a Noul of 0.5 means uncertainty about a proposition, not “medium quality.” Question reference.

Typed output prevents an out-of-schema answer; it does not prevent a wrong answer. Choice and Score confidence summarize the concentration of their probability distributions. Confidence is not independently measured accuracy on your dataset. Inspect actual errors before setting a threshold. Confidence reference.

Where it belongs in the stack

This table is our architectural recommendation. The useful comparison is with the cheapest adequate rules, embeddings, or small-model baseline—not automatically with the most expensive reasoning model.

Patterns emerging in early projects

The recurring pattern in the projects below is frequent, bounded judgments inside an existing loop. Classification, context selection, and routing have clear inputs and observable mistakes. Those are stronger starting points than an impressive game or trading video with no evaluation record.

These repositories and reports were inspected September 27; we did not install or run them. Their reusable contribution is the decomposition of a workflow, not a promise that the linked code is ready for your production system.

What the social discussion shows (reviewed September 27): in a launch-week agent-routing report, a developer routed recipe transcripts either to a scraper or a recipe agent, reporting 145 ms and 271 ms including network time. The author explicitly calls this two examples, not an evaluation, and says load behavior is untested. A launch-week LocalLLaMA discussion, reviewed September 27, mixes enthusiasm for classification with skepticism about novelty and demands for stronger evidence. These are signals of attention and useful questions, not adoption statistics.

A more substantial community evaluation shared on Reddit publishes its September 21 protocol and results: 5,500 CLINC150 utterances, including 1,000 outside the supported intents. The author reports 89.4% overall agreement and 83.8% out-of-scope recall. Of 162 missed out-of-scope cases, 54 still received a specific intent at confidence ≥0.9. That is a concrete reason to test confident errors. It remains one self-run, untuned Choice evaluation on one dataset/version/day; it says nothing directly about your workflow or Noul/Score calibration.

There is also early research beyond demos. An edge-service orchestration preprint, submitted September 19, combines Jev’s bounded intent decisions with validators and scheduling code. Its reported latency improvement is specific to that system. A fresh preprint and a few prototype runs are not evidence that Jev can generally replace a reasoning model.

Three builds worth trying first

1. Evidence triage for a research registry. Fetch known sources and compute timestamps, changed text, identifiers, and expiry in code. Ask Jev whether a new passage concerns the tracked entity and whether it supports, contradicts, or leaves a particular claim unresolved. Queue meaningful changes for a research worker. Keep the source URL, passage, retrieval time, and claim ID attached to the decision.

For a CBDC status registry, “a pilot expanded” and “the currency launched nationwide” are distinct claims. For a stablecoin registry, a contract address must still match the correct chain and authoritative issuer record exactly. Jev can help choose the relevant passage; it cannot establish ownership from an address-shaped string. These are proposed applications, not claims that either registry currently runs Jev.

2. Skill selection before expensive context loading. Keep a small catalog of approved skill IDs, descriptions, required tools, and explicit exclusions. Retrieve a shortlist, ask which skill fits, and separately ask whether any candidate is suitable. Load the selected instructions only after validating the ID. A generic worker can then use the skill; you do not need a persistent subagent for every category.

TypeSafe’s skill-suggestion cookbook demonstrates shortlist-and-recheck routing. Its reported evaluation uses Jev 1.12, a specific Hermes catalog, and a particular agent model; do not relabel it as a Jev 1.13 production result. “No suitable skill” must remain a valid outcome. Selection also does not grant tool permissions.

3. A personal opportunity research queue. Filter job postings by explicit constraints first. Compare the remaining requirements against a user-approved evidence profile, one requirement at a time. Surface documented matches and missing information for the job seeker. Use an LLM for subsequent company research or application drafting. Measure whether this finds useful opportunities that keyword search missed. Treat absent information as unknown; do not turn this experiment into automatic candidate rejection.

Explore the decision boundary

Change the scenario and threshold. The fixture answers stay fixed; only the routing policy changes. All text and numbers are invented examples, not live Jev output, calibrated thresholds, or benchmark results.

The workflow is always retrieve → check exact rules → ask a narrow question → validate the answer → route. Even the high-confidence branch above only queues work. Source verification, permissions, and publication approval remain separate.

Easy access, price, and the details that save time

Checked September 27, 2026. The simplest no-code introduction is the TypeSafe Playground. For an application, choose one access route and keep its credentials, endpoint, and model identifiers together.

The direct endpoint is documented in the quick start. OpenRouter documents account access in its TypeScript tutorial. Ordinary chat-completions integrations cannot call the Jev decision model just by changing the model name. Use the Decisions API or an adapter that explicitly supports it. OpenRouter model page.

Both providers list $0.042 per million input tokens, with free output for this version. At that rate, 1,000 requests with 1,000 billed input tokens each cost $0.042 in Jev inference. This is arithmetic, not an observed workload bill: include question tokens, repeated context, retries, retrieval, and downstream model calls. TypeSafe models, OpenRouter pricing.

TypeSafe documents a 64k total request budget and a 32k budget for state plus the longest question. OpenRouter’s model card lists 32,000 context tokens; do not assume that route accepts every direct-API packing strategy. Jev’s input is text, not native images, audio, or video. A visual demo may contain a separate perception model. Direct rate limits are explicitly changeable, so read the current model limits before choosing concurrency.

Jev Router is a separate product. OpenRouter also lists typesafe/jev-router, which selects other models and reasoning effort. That does not make the underlying Jev decision model a text generator. At review time, the router page’s free-pricing wording and the live catalog’s -1 price fields did not establish downstream billing clearly. Treat router cost as unresolved until the provider confirms it; this guide’s $0.042 figure applies to Jev 1.13 decisions.

A minimal OpenRouter request

Save this as request.json. It asks about a supplied excerpt, not the real-world status of any currency. No answer has been prefilled.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

{
  "model": "typesafe/jev-1.13",
  "state": {
    "claim": "The project has launched nationwide.",
    "excerpt": "The bank expanded its limited pilot to two additional cities."
  },
  "questions": {
    "relationship": {
      "type": "choice",
      "instructions": "Using only `excerpt`, how does it relate to `claim`? Do not infer facts outside the excerpt.",
      "criteria": {
        "supports": "The excerpt explicitly establishes the complete claim.",
        "contradicts": "The excerpt explicitly establishes an incompatible fact.",
        "insufficient_evidence": "The excerpt does not establish or explicitly contradict the complete claim."
      }
    }
  }
}

With OPENROUTER_API_KEY set privately in your shell:

1
2
3
4
5

curl --fail-with-body --max-time 30 \
  https://openrouter.ai/api/alpha/decisions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H 'Content-Type: application/json' \
  --data-binary @request.json

Read answers.relationship.choice, its probabilities, and confidence; log the returned model, request ID, and usage. This is a documentation-based request example, not-run against the paid API here. The expected human label is insufficient_evidence: a pilot announcement alone does not settle nationwide status. Compare the returned answer with that label rather than assuming agreement. OpenRouter request/response examples.

For TypeScript, OpenRouter’s tutorial uses openrouter.alpha.decisions.create({ decisionsRequest: ... }). Its September 23 example pins @openrouter/[email protected]; use bun add --exact @openrouter/[email protected] to reproduce that version, then check its installed types before upgrading. Raw HTTP avoids an SDK dependency for the first experiment.

Give this to your coding agent

Use the plain-text builder brief when your agent needs a compact reference without the interactive page. It includes the source links, access snapshot, output shapes, and evaluation contract.

The official TypeSafe skill teaches an agent to build Jev integrations. It does not replace the agent’s coding model. Read its SKILL.md and the live documentation index. Individual documentation pages also have .md versions for targeted retrieval.

For a project-local installation, the documented skills command expressed with Bun is:

1

bunx --bun skills add typesafe-ai/skills --skill typesafe-ai

Select your agent when prompted. For manual installation, copy the whole skill directory, including references; a lone SKILL.md is incomplete. Choose one installation method. Keep the installed skill current when request fields change. This article does not install anything into your agent configuration.

Copy this brief with the article link:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

Build one read-only Jev experiment for this repository.
Read https://docs.typesafe.ai/llms.txt and the official TypeSafe skill.
Read the current API contract for our chosen access route.

1. Identify one repeated semantic judgment with a bounded answer set.
2. Keep retrieval, exact matching, dates, arithmetic and permissions in code.
3. Define explicit criteria plus an insufficient-evidence/none outcome.
4. Keep questions and policy thresholds in reviewed, versioned files.
5. Validate response types, allowed IDs and finite probabilities in [0,1].
   Missing, malformed, timed-out or failed answers enter the review queue.
6. Save evidence IDs, input/rubric hashes, resolved model, usage and latency.
   Keep secrets and sensitive source text out of public logs.
7. Compare rules/retrieval alone, rules+Jev, and one small LLM on the same
   held-out cases. Tune thresholds on a separate development set.
8. Start in shadow mode. Report missed important cases, false escalations,
   review load, p50/p95 latency and total cost per accepted result.
9. Do not publish records, grant permissions or silently drop evidence.
   Propose promotion only after the owner reviews measured errors.

Deliver: adapter, fixtures, evaluation report, fallback and rollback switch.
Confirm the API spend cap before running paid experiments.

This is a build brief, not measured performance. For a small first evaluation, hand-label roughly 100–200 representative cases, including hard negatives, stale evidence, multilingual inputs, and “none of these” examples. Expand the set when a rare error matters; a small clean sample cannot establish a low failure rate.

Integration habits worth keeping

• Pin the model and the rubric. Record the resolved version even when experimenting with a latest alias. Rerun the evaluation before changing either.
• Bound retries and concurrency. Honor rate-limit responses and retry guidance; do not let retries create an unbounded work queue. Keep a time and cost budget for the whole workflow.
• Cache deliberately. Key judgments on the source snapshot, question/rubric version, and model version. Invalidate when evidence changes or expires.
• Keep uncertainty visible. Route malformed responses and missing evidence to review. Sample the low-priority queue too, so false negatives do not disappear from measurement.
• Preserve provenance. A model selecting an evidence ID is useful; a confidence number without the underlying passage is hard to audit.

What would make the bet fail?

TypeSafe’s Jev 1.13 limitations include literal interpretation, weak numeric precision, date comparisons, indirection, distracting context, and adversarial input. The documentation also warns that separate questions need not obey the arithmetic identities you might expect. Do not transplant a Noul threshold onto a Choice or assume two separately asked opposites sum to one.

For a hook that examines tool calls, this matters: hostile text can influence the classification. Use Jev as an advisory signal around an existing permissions system, not the sole authority that approves shell execution. For fact checking, it can judge whether supplied text supports a claim, but it cannot authenticate the source or discover omitted evidence on its own.

The economic failure mode is simpler. A cheap call that runs on every event, retrieves too much, or sends nearly everything to a larger model may save nothing. Measure the whole cascade, including human correction. Our benchmark-reading guide explains why a provider’s chosen task is useful evidence but not your acceptance test.

Our first bet would be a shadow evidence-triage queue, followed by skill selection. Both let you compare decisions with existing work and inspect misses before changing production behavior. Jev earns a permanent place only if it preserves the important cases while reducing total work.