How to Use the Jev API: 20 Projects You Can Copy

What Jev is, and why it changes what a "project" looks like

TypeSafe shipped Jev on September 15, 2026 as the first "System One model." The pitch is Kahneman: today's LLMs are the slow, deliberative system, and Jev is the fast one — except "intuition" here is a calibrated probability distribution over options you defined, not prose.

That single design choice is why the projects below look nothing like the usual "AI wrapper" list:

• The output is typed. You declare Choice (pick one of your options), Score (rate against levels you name), or Noul (probability that a yes/no statement holds). There is nothing to parse and no schema to hope for.
• Every question is answered in one pass. The state is ingested once and all questions are evaluated against it together, so asking thirty questions costs barely more than asking one.
• Output is free because there is no output. No strings on the response side, no sequential structure, no output tokens — which is exactly why the price is input-only.
• The model does not act. It judges. Everything with a side effect — clicking, flying, ordering, deleting — stays in ordinary code, gated on a probability threshold.

Once you see that shape, the project space writes itself: put a Jev call wherever your program is about to make a small, high-frequency, hard-to-express-in-if decision.

The 20 projects at a glance

Star counts checked September 22, 2026.

#	Project	★	Language	What it does
1	browser-use/jev-ultrafast	16,972	Python	Browser agent where Jev picks the operation and the element; an LLM only writes text when the action is TYPE_TEXT
2	tamaratran/fast-jev-compaction	6,122	TypeScript	Claude Code plugin that replaces the compaction summary with Jev deletions — nothing is ever rewritten
3	vercel-labs/json-render	18,005	TypeScript	Generative UI framework. Not Jev-native
4	itsmostafa/typesafe-mcp	238	Go	evaluate MCP server for Claude Code, Claude Desktop, Codex and pi
5	jkudish/jev-mcp	257	JavaScript	Ten typed judgment tools exposed over MCP
6	sharziki/semdecide	32	Python	"grep for meaning, jq for judgment" — typed decisions as a Unix filter with real exit codes
7	0xNatoshi/jev-codex-router	189	JavaScript	Per-call model and thinking-effort routing for Codex, driven by Jev
8	GhalebDweikat/winnow	60	Python	Context sieve for Claude Code: stub out tool output Jev is confident you do not need
9	devagrawal09/jev-review	516	TypeScript	Staged code-review workflow with a local dashboard
10	ellipsis-dev/blink	56	TypeScript	Codebase search via an ensemble of Jev-guided walkers
11	lahfir/agent-desktop	1,454	Rust	Desktop computer use through OS accessibility trees. Not Jev-native
12	fhshaik/typesafe-mario	343	Python	Jev plays Super Mario Bros. from emulator RAM, never from screenshots
13	RomanSlack/jev-drone	122	Python	Quadrotor flies a MuJoCo obstacle course; Jev reads the situation at ~2.5 Hz
14	emrickgarrett/OneVOneJev	20	TypeScript	Server-authoritative browser FPS where you fight Jev, first to 5 kills
15	jarrodwatts/jev-trader	1,929	TypeScript	One buy-or-sell decision per Monad block on the Kuru MON-USDC book
16	irfndi/prism-liquidity-agent	71	TypeScript	Solana Meteora DLMM liquidity agent. Not Jev-native
17	jexp/neo4jev	84	Python	Graph navigation one hop at a time, with the goal check riding in the same call
18	AkashPriyadarshii/jev-curate	23	Rust	Dataset sifter for JSONL and Parquet corpora
19	qkal/Canny	32	JavaScript	A warden that will not let a coding agent finish on a claim
20	monteduro/killmyidea	82	TypeScript	Eight scored questions, weighted into KILL / FIX / SHIP

Group 1 — agents that decide instead of generate

browser-use/jev-ultrafast (★16,972) is the reference implementation, and the one to read first. A browser agent normally asks a model to emit a JSON action, which means paying for tokens on every step. Ultrafast splits the job: Jev picks an operation and an element from an indexed action space, and a small LLM is called only when the chosen operation is TYPE_TEXT — the one case that needs generated characters. The README's headline demo, a real Zürich → London search on Google Flights, completes in 7.1 seconds including text generation and page loads. If you want to understand why a decision model is worth having, this repo is the argument.

lahfir/agent-desktop (★1,454) is the desktop analogue — and it is not Jev. It is a Rust CLI and C-ABI library that reads an app's real UI structure through the OS accessibility tree instead of guessing from pixels, with 54 operational commands and snapshot refs that stay stable across calls. Its own README claims 78–96% token reduction on dense apps through skeleton traversal. It was created in February 2026, long before Jev, and it does not depend on it. It earns a place here for one reason: if you are building the desktop version of Ultrafast, this is the perception layer you would put a Jev call on top of.

Group 2 — coding-agent plumbing

This is where the ecosystem is thickest, because coding agents produce the two things Jev is best at judging: is this still relevant? and is this actually done?

fast-jev-compaction (★6,122) takes the most common pattern — summarise old context with an LLM — and rejects it. A summary is lossy; a file path or an exact error can vanish. This plugin never rewrites anything. It shows Jev the whole conversation, asks which tool calls and results are no longer needed, and deletes only those. User and assistant text stays verbatim and in order.

winnow (★60) applies the same idea to individual results rather than history. Every large Read, Bash or Grep output is judged before it enters context; blocks Jev is confident you do not need are replaced by a three-line stub with a cheap-model summary and a key that restores the full text on demand. Nothing is lost, it just stops costing tokens until you ask. Winnow is also the cleanest example of a graceful fallback: its adapter can answer the same questions with Claude Haiku 4.5 when Jev is unavailable — uncalibrated, but it keeps the pipeline running.

Canny (★32) attacks the opposite failure. Agents claim success. Canny hooks into Claude Code and Codex CLI, keeps a ledger of what the agent actually did, and refuses to let it finish on a claim — judging tool output, diffs and test results against the completion statement.

jev-review (★516) runs before a human sees the diff: a Noul risk matrix first, then Choice and Score calls for file profiles, evidence selection, mechanism classification and severity, with reviewer routing decided by conditional Choice. Thresholds and policy stay in code, and results land in a local dashboard.

blink (★56) uses Jev as a codebase navigator: walkers descend the file tree and ask, at each level, which files matter for the query. Note the licence — the repository has no licence file, which matters if you plan to ship it.

jev-codex-router (★189) is the one that touches your bill. It embeds a Codex Router fork and lets Jev choose a model and a thinking effort for each model call, including continuations after tools. The README reports a historical simulation of roughly −60% versus running full Astra across 237 turns — and is careful to say that this is not measured Codex quota saved and does not describe the current policy. Treat it as a method, not a guarantee.

Group 3 — MCP servers, if you just want the tools

jkudish/jev-mcp (★257) registers ten judgments as MCP tools: jev_verify (claims against evidence), jev_screen (content before it enters context), jev_find and jev_rerank (candidate selection and sorting), jev_classify, jev_decide, jev_compare, jev_extract, jev_review, and more. Any MCP client can call them.

itsmostafa/typesafe-mcp (★238) is the smaller, more opinionated option: a single evaluate server in Go, with a one-command setup — evaluate setup mcp wires it into Claude Code, Claude Desktop and Codex if it finds them, and evaluate setup pi covers pi. Start here if you want a working tool in five minutes rather than a toolbox to configure.

TypeSafe ships no MCP server of its own; both of these are community work.

Group 4 — shell, CI and data pipelines

semdecide (★32) is the most Unix-shaped project in the set, and the description is exact: grep for meaning, jq for judgment. Pipe text or JSONL in, get a predicate, a route, a score, a filtered stream and a real process exit code out — without writing prompt, parsing, retry or confidence-handling glue. Its README example asks whether a login from a new country followed by payout changes "describes a plausible account takeover" and gets back TRUE probability=0.860 threshold=0.700. That is a thing you can put in a shell script, a GitHub Action or a cron job today.

jev-curate (★23) is the batch version for training data: stream JSONL and Parquet corpora through typed Choice / Score / Noul decisions with speculative fan-out. The README targets 1,500+ records per second; it is a design target, not an independently reproduced number, so benchmark it on your own data before trusting the throughput.

Group 5 — real-time, physical and adversarial systems

These are demos, and they are the best proof that the architecture holds: in each one the hard, safety-critical loop stays in ordinary code and Jev only answers a small question.

typesafe-mario (★343) never shows Jev a screenshot. The harness converts emulator telemetry and RAM into compact JSON — motion, jump trajectory, upcoming enemies, terrain, measured input delay, recent control outcomes — and Jev picks from a small legal action set (noop, right, right_jump, right_run, right_run_jump, jump).

jev-drone (★122) flies a real airframe model (the Skydio X2 from MuJoCo Menagerie) around a five-station obstacle course using only its onboard camera. The layering is explicit: a 500 Hz geometric controller flies, a 50 Hz guidance layer always owns safety, and Jev sits at roughly 2.5 Hz deciding what the situation means. The README says it plainly — Jev is not a vision model and cannot run at control rate.

OneVOneJev (★20) is a server-authoritative browser FPS where Jev is the opponent: queue up, fight it in a Rust-like industrial yard, first to 5 kills, spectators watching from the sidelines. Every decision tick has to answer movement, aim, fire and jump.

jev-trader (★1,929) posts one post-only limit order per Monad block on the Kuru MON-USDC book, one tick inside the touch, replacing the previous one. With no PRIVATE_KEY it dry-runs against the real book with simulated fills — and note that the default model is mock, a momentum heuristic stand-in, so the bot runs before you have a key at all.

prism-liquidity-agent (★71) is the third non-Jev-native project: a rule-based agent that rebalances concentrated liquidity positions on Solana's Meteora DLMM every ten minutes through a recall → observe → reason → simulate → decide cycle. It was created in June 2026 and does not use Jev. It is included because it is the clearest published example of the shape — deterministic loop, bounded decision at the end — that a Jev call would slot into.

Group 6 — graphs, structure and ideas

neo4jev (★84) navigates a Neo4j graph one hop at a time. At each node the outgoing relationships become Choice options with their properties, and a Noul question — "has the goal been reached?" — rides in the same systemone call, so each hop costs exactly one round-trip no matter how many questions you ask. Top-k selection over the returned probabilities turns it into a beam search ranked by summed log-probabilities. If you want to see parallel questions used well, read this one.

json-render (★18,005) is the biggest repo in the table and the least related: Vercel Labs' generative UI framework, created in January 2026, which renders dynamic interfaces from predefined components and actions instead of raw JSON. It is not Jev-native. The connection is conceptual — the pitch is "let a model choose among safe, predefined options rather than emit free-form output", which is Jev's pitch applied to UI. It appears in a lot of Jev roundups for that reason; do not expect a TypeSafe dependency in package.json.

killmyidea (★82) is the smallest complete product here: describe a startup idea, and Jev answers eight indie-hacker questions scored 0–4 plus category and clarity in a single parallel request. Each score is multiplied by 25, weighted into an average, passed through a clarity gate, and returned as KILL IT, FIX IT or SHIP IT. No generative LLM anywhere in the loop.

Your first request

Get a key, then call the native contract — not Chat Completions:

curl -X POST "https://apimaster.ai/v1/systemone" \
  -H "Authorization: Bearer $APIMASTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": "Help! My payouts have been failing for 3 days.",
    "model": "jev-latest",
    "questions": {
      "is_urgent": { "type": "noul", "instructions": "Does this convey urgency?" },
      "category":  { "type": "choice", "options": ["billing", "technical", "other"],
                     "instructions": "Which team should handle this?" }
    }
  }'

Then pick a project from the table, read its README, and start with the smallest integration on the list — semdecide if you live in a terminal, jev-mcp if you live in an agent. Keep thresholds and side effects in your own code, and treat the returned probability as the thing you gate on rather than the thing you obey.

Before you install any of these

• Age is the risk, not the idea. Fifteen of twenty repos were created between September 16 and 18, 2026. They are days old, mostly single-author, and some have not been touched since the day they were published.
• Stars measure attention. A 16,972-star repo created six days ago has had enormous visibility and almost no production exposure. Read the code before it touches a wallet, a repo you care about, or a customer.
• Three are not Jev-native. json-render (January 2026), agent-desktop (February 2026) and prism-liquidity-agent (June 2026) all predate Jev and run without it.
• Check licences. Most are MIT, json-render and agent-desktop are Apache-2.0, and blink has no licence file at all.
• Nothing here is official. The only TypeSafe-published integration is the agent skill, typesafe-ai/skills. Every project in this list is community work.
• Financial and physical demos are demos. jev-trader defaults to a mock model and dry-run fills; jev-drone is a simulation. Do not read either as a signal about live performance.

Which one should you actually try

If you want to…	Start with	Why
Understand what a decision model is for	jev-ultrafast	The 7.1-second Google Flights demo makes the split obvious
Cut agent context cost today	fast-jev-compaction or winnow	Install-and-measure, no architecture change
Get Jev into your agent in five minutes	typesafe-mcp	One command wires up three clients
Use Jev from a shell or CI	semdecide	Real exit codes, no glue code
Stop agents lying about being done	Canny	Ledger plus a refusal to accept a claim
Control model spend per turn	jev-codex-router	Routing is where Jev pays for itself
See parallel questions used properly	neo4jev	Choice and Noul in one call, one round-trip per hop

FAQ

What is the Jev API? Jev is TypeSafe AI's System One model. The API is one endpoint, POST /v1/systemone: send a state plus a map of typed questions, and get back calibrated probabilities as Choice, Score and Noul answers. It never generates text.

What is the Jev model ID and price? jev-1.13.0, with jev-latest and jev-preview as aliases. Pricing is $42 per billion input tokens — $0.042 per 1M — and output is free, because there are no output tokens.

Are these projects official TypeSafe projects? No. All twenty are community work. The only officially published integration is the TypeSafe agent skill, typesafe-ai/skills.

Which of these can I use without a Jev key? json-render, agent-desktop and prism-liquidity-agent, because they are not Jev-native. jev-trader also runs keyless in dry-run mode with its default mock model.

Can I use Jev with Claude Code or Codex as the model? No. Both CLIs speak their vendor's wire format, and Jev has no OpenAI-compatible or Anthropic-compatible endpoint. What works is putting Jev inside the agent — as an MCP tool, a hook, or a router — which is what the projects in groups 2 and 3 do.

How much does a Jev call actually cost? Billing is input-only at $0.042 per 1M tokens, and every question in a request is evaluated against the same state in one pass. Asking thirty questions costs a little more than asking one, not thirty times as much — that ratio is the whole point of the architecture.

Is Jev available on APIMaster? Yes, as jev-latest, on the native POST https://apimaster.ai/v1/systemone contract at $0.042 per 1M input tokens with free output (one active route, checked September 22, 2026). Pair it with a text model on the same key when a step needs generated text.

Sources and verification

• Repository metadata, star counts, languages and licences for all twenty projects — GitHub API and repository READMEs, checked September 22, 2026
• TypeSafe — Models — model ID, aliases, $42/Btok pricing, rate limits and context budget
• TypeSafe — API reference and Quick start — endpoint, request and response shapes
• TypeSafe — Jev 1.13 scope — the areas TypeSafe itself scopes out, with the recommended pattern for each
• typesafe-ai/skills — the only officially published integration

APIMaster's jev-latest route and the companion text-model prices were checked on September 22, 2026. Project status, star counts and pricing change — verify on the live card and the repository before you commit a workload.

Start with the key

Create an APIMaster account, add pay-as-you-go credit from $1, and create a key in the console. Point your client at https://apimaster.ai/v1 and send your first request to POST https://apimaster.ai/v1/systemone with model jev-latest — $0.042 per 1M input tokens, free output, and the same key covers the GPT, Claude, GLM, DeepSeek and Gemini tiers you will pair it with. Check the Jev card for live availability before production traffic, and use the model tester to confirm a route behaves as expected.