Jev is TypeSafe AI’s “System One” model. It doesn’t generate text. You hand it unstructured state plus a typed question — a Choice, a Score, or a yes/no (Noul) — and it hands back a typed answer with a confidence number attached, in milliseconds. TypeSafe reports up to 200x faster inference and 400x lower cost than comparable LLMs on classification tasks, and LangChain’s write-up covers where it sits in the agent loop.
That’s a narrow capability. What’s interesting is how fast people found things to point it at. Below are 101 projects, grouped by what kind of decision they’re making, each with a note on what Jev replaced. Most were surfaced through awesome-jev, the community’s curated index.
Classification & Routing
1. Notra — A production generative-engine-optimization platform that moved its brand-visibility classifiers off an LLM and onto Jev Boolean decisions behind a feature flag, targeting 300ms p50. The classifiers were already reliable; the LLM was just the slow, expensive way to run them.
2. jev-router — Routes each Claude Code task to the cheapest model actually capable of handling it, using a Jev Choice over candidate models. The old approach was picking one model for everything and eating the cost, or writing heuristics that go stale the day a new model ships.
3. jev-router (prismhq) — An open-source LiteLLM-based router where a Jev decision picks the serving model per request. Routers historically used embedding similarity or hand-tuned rules; a typed decision with a confidence value is easier to threshold and audit.
4. pi-jev-router — Adds per-request model routing to the Pi coding agent over Vercel AI Gateway. Routing with a full LLM call costs more than the savings it finds, which is why most agents never bothered.
5. jcm-router — A local proxy that picks both the Claude model and the reasoning effort for each message, while leaving the cached main chat untouched. Preserving the cache is the trick: a router that rewrites the conversation blows away prompt caching and costs more than it saves.
6. jev-agent-skill-router — Routes agent skill selection through confidence-aware Jev decisions, so a weak match is declined rather than guessed at. Keyword-matched skill selection has no way to say “none of these.”
7. typesafe-jev CV screener — Screens a folder of CVs against an editable policy using typed judgments, and re-scores every candidate for free when the policy changes. With an LLM screener, every policy tweak means paying to re-run the entire pipeline.
8. Jev email intent workflow — An async LangGraph workflow that takes a Jev Choice between invoice and general and routes inbound mail to the right handler. Classic email routing ran on regex over subject lines, which fails the moment a vendor renames their template.
9. unclutter — A browser extension where Jev decides, per page element, whether it’s clutter, then strips it under reusable template rules. Reader-mode heuristics are hardcoded per site and break on redesigns.
10. typesafe-adblock — A Chrome extension that asks Jev whether each DOM element is an ad, turning ad blocking into a stream of per-element typed questions. Filter lists are a maintenance treadmill and lose to any advertiser willing to randomize class names.
11. DiffJury — Triages pull requests by risk before assigning a human reviewer, and doubles as a review coach. Most teams route PRs by file path via CODEOWNERS, which says who owns the code but nothing about whether this particular change is dangerous.
12. HA-Jev — A Home Assistant integration that answers questions about the house as a probability, a choice, or a score. Home automation has always been if-this-then-that; this lets a condition be “is anyone probably still awake” instead of a motion-sensor timestamp.
13. secondlayer — A self-hosted Stacks blockchain data service that runs both its Slack gate and its fault-triage path on Jev decisions. Alert routing by static severity labels pages the wrong person constantly.
14. new-api-typesafe-plugin — Adds a native /v1/systemone endpoint to the new-api gateway so typed decisions sit behind the same infrastructure as chat models. Otherwise teams end up running a second, parallel auth-and-billing path just for classification.
15. json-render — Vercel Labs’ generative UI framework uses Jev in its compose path to pick which components and actions a rendered interface should contain. Asking an LLM to emit a UI spec means parsing and validating JSON that may not be valid; a Choice over a known component set can’t be malformed.
16. hono-jev-router — Hono middleware that routes HTTP requests by what they mean rather than by method and path. Twenty years of web frameworks have assumed the URL tells you the intent, which stops being true when the caller is an agent.
Verification & Guardrails
17. is-malicious — Asks Jev Noul questions about source and build files, escalates suspicious chunks for a second pass, and reports the implicated files and line numbers before anything executes. Signature-based supply-chain scanners only catch malware someone has already seen.
18. jev-review — A staged code-review workflow with a local dashboard, where Jev gates each stage before a change advances. Linear LLM review produces an essay you then have to read; a gate produces a verdict the pipeline can act on.
19. pi-jev — Adds a measured tool-call gate to the Pi coding agent so risky calls get checked before execution. The incumbent is an allowlist, which is either so tight the agent can’t work or so loose it isn’t a control.
20. OpenWork — Wires Jev into its eval testkit as a verification judge, so agent-produced work is gated by typed verdicts instead of a text model’s opinion. LLM-as-judge output has to be parsed and frequently hedges; a typed verdict with confidence doesn’t.
21. jev-guard — A prompt-injection and dangerous-action guard covering Claude Code, Codex, Pi, and ACP agents, with Jev deciding what to block. Regex-based injection detection is trivially bypassed by rephrasing.
22. Foreman — Sits above Codex workers and has Jev independently judge whether an implementation is complete, whether its tests are sufficient, or whether a human is needed. Letting the agent grade its own work is the single most reliable way to ship something that doesn’t run.
23. opencompany — Runs its approval review through Jev so workspace actions are gated by a typed decision. Approval-by-keyword-rule can’t distinguish a refund of $5 from a refund of $50,000 phrased the same way.
24. jev-git — A sub-second pre-commit and pre-push gate that screens staged diffs for secrets and destructive commands. Existing secret scanners are entropy and pattern matchers, so they miss credentials that look like ordinary strings and flood you with false positives on hashes.
25. pi-heed — Checks every side-effecting tool call from the Pi agent against what the user actually asked for. Permission prompts ask “may I run this?” without any notion of whether it’s relevant to the request.
26. Hunch — Plain-English rules that Jev checks code against, locally or on every PR, picking one label per finding. Writing the equivalent as an ESLint rule or a CodeQL query requires an AST expert; here the rule is a sentence.
27. Abide — Reads every edit a coding agent makes and flags rule violations. The project reports that an independent reviewer confirmed 10 of the 39 flagged edits and 11 of the 15 flagged turns — imperfect, but the alternative is reading the diff yourself. GitHub
28. fx — Ships a typesafe_permission_reviewer builtin so the coding agent’s permission decisions run through Jev rather than another LLM call. Permission checks fire constantly, which is exactly the workload where per-call latency and cost compound.
29. Sniff Test — A prose linter that asks Jev ten Boolean questions per paragraph (stacked hedges, restating closers, naked cost figures) at a 0.7 threshold, shipped as a CLI, pre-commit hook, GitHub Action and Claude Code skill. It measured a 182ms median and flagged 1 of 54 clean paragraphs, against 37 for Haiku 4.5. GitHub
30. jev-pref — Turns the preferences written in a project’s AGENTS.md into machine-checkable rules that Jev evaluates against each diff hunk or PR, returning fix_now or advisory findings and a nonzero exit code on blockers. AGENTS.md files are currently hope-based; nothing enforces them.
31. jev-judgment — An agent skill that sends closed coding-agent judgments to Jev so verdicts stay typed, cheap, and comparable across runs. Free-form judgments from a chat model can’t be compared run to run because the phrasing drifts.
32. limpet — A Stop hook that keeps an agent from declaring victory early by judging plain-language completion rules. Agents that stop when they feel done are the most common failure mode in long-running tasks.
33. jev-mcp (jkudish) — A proof-of-concept MCP server putting Jev claim verification, content screening, and candidate ranking behind standard MCP tools. Any MCP-speaking agent gets a verification layer without a custom integration.
34. jev-mcp (blakestone-x) — Exposes classify, score, check, match, and screen as MCP tools with confidence on every answer. The alternative is each agent framework reinventing the same five primitives.
Scoring & Ranking
35. Clean Code Judge — Scores every file in a PR against 31 boolean Clean Code smells plus function size and nesting, then passes the verdicts to a writing model for the prose. Splitting judgment from writing means the review’s findings are reproducible even when the wording isn’t.
36. citation-verifier — Checks whether each cited paper actually supports the sentence citing it, with Claude locating the quote, Jev scoring the support, and a human making the call. Reference checking is currently a manual job that almost nobody does.
37. jev-bfs — Finds link paths between Wikipedia articles by having Jev rank each page’s outgoing links while Python runs the search. Embedding-based link scoring needs an index built in advance; this scores links as it encounters them.
38. Jev Search — Reranks Search1API results using Noul judgments on titles and snippets, with application code merging duplicate URLs and grouping weaker matches separately. Cross-encoder rerankers need hosting and fine-tuning for your domain.
39. pagegrade — Grades page sections for clarity, writing quality, and on-page SEO, returning per-section scores. SEO tooling has historically scored keyword density, which measures the wrong thing.
40. jev-scout — A repo and crate scout using speculative fan-out scoring to vet open-source packages in under a second. Asking an LLM which package to use gets you confidently recommended packages that don’t exist.
41. jev-seo — A zero-cost SEO and generative-engine-optimization radar CLI and MCP server built on DuckDuckGo plus Jev scoring. Incumbent rank trackers cost hundreds a month and don’t measure whether models cite you.
42. JevSlop — Scores note.com articles on eight Score axes inside one request and converts them to a 0-100 slop score in ordinary TypeScript. Batching eight axes into a single call is the part an LLM rubric can’t do cleanly.
43. SemanticSpace — Places phrases in 2D by asking Jev how strongly each relates to two chosen axis concepts, using the scores as coordinates. Embedding projections give you axes nobody can interpret; here you pick the axes.
44. LlamaIndex Jev — An unofficial adapter where Jev scores each retrieved passage and selects the query engine. Reported nDCG@5 on nfcorpus moved from 0.340 to 0.396 at roughly $0.0003 per query. GitHub
45. typeful-triage — A multiplayer triage dashboard where Jev answers a fixed set of typed questions per issue — kind, severity, urgency, duplicate, next step — and every human correction is retained and shown back on later runs. GitHub’s label bots are keyword rules with no memory of being wrong.
46. jev-curate — Sifts synthetic JSONL and Parquet rows using Noul checks and calibrated confidence, streaming passes and rejections straight to disk. Dataset filtering by heuristic drops good rows; filtering by LLM costs more than generating the data did.
Agent Decisions
47. Jev Ultrafast — browser-use’s ultrafast agent, where Jev decides each next action and element to click and a language model is called only when text must be typed. Screenshot-and-reason browser agents burn a vision model call per step.
48. Jev Browser — Drives a browser with Jev deciding each step, executing through Playwright, and careful handling of irreversible actions. The architecture cuts how much raw page content an LLM has to process at all. MCP Market
49. fastbrowse — Jev picks each action from what’s on the page while the LLM reads and plans. Splitting planning from acting means the expensive model runs once per task, not once per click.
50. public-browser — Lets Claude Code and Cursor drive a real Chrome profile with a Jev loop choosing actions, reporting roughly 30% fewer tokens and 25% lower cost. Using a real profile also sidesteps the login walls that kill headless automation. GitHub
51. Stagehand + Jev — Sends the accessibility tree as state and candidate actions as questions, so Jev decides each step. Reported about $0.001 per task and near-instant execution. GitHub
52. pi-typesafe-jev — Exposes System One judgments as five Pi tools, so the model makes narrow semantic judgments while code and users keep control of thresholds, weights, and actions. Keeping the threshold in code rather than the prompt is the whole design argument.
53. pi-quiet-ask — Gives the Pi agent a quiet decision layer for judgments it would otherwise hand to a chat model. Those judgments never needed prose, and prose is what you were paying for.
54. dsh-auto-mode — A DeepSeek Harness permission preset that has Jev answer the open questions an agent leaves in its final message, steering them back only when a Choice clears 0.6 confidence and a safety Noul clears 0.5, and handing back to the human otherwise. Auto-accept modes have no such exit ramp.
55. augustus — An agent skill mapping Choice, Score, and Noul onto classical methods, with a composition algebra, question-design diagnosis, and a validation gate requiring a falsifying experiment. This is the closest thing to a methodology in the ecosystem.
56. yoshi — A proxy for Claude Code and Codex where Jev judges which conversation history is still needed before pruning. Summarization compaction is lossy in ways you only discover three turns later.
57. fast-jev-compaction — A Claude Code plugin that replaces the compaction summary entirely, scoring each tool call and result for whether it’s still needed rather than rewriting the session. Kept content stays verbatim.
58. pi-fast-jev-compaction — Same idea for Pi: preserve conversation text exactly, prune stale tool history, and fall back to native summarization only when pruning can’t free enough room. Summarization becomes the fallback rather than the default.
59. Atomic — A coding agent runtime shipping a first-class Jev structured-output provider, so agent decisions come back typed through the same resolver as every other provider. Treating a decision model as a peer of chat models is an architectural bet worth watching.
60. robo-harness — An SO-101 robot arm workbench where a Jev decision runner picks bounded joint steps from typed candidate actions under a spend budget. Robotics can’t wait for a two-second LLM response, and unbounded action spaces break hardware.
61. jev-superpowers — A systematic development framework for coding agents with typed decisions, zero-hallucination package vetting, and completion gates. The gates are the point: agent frameworks usually have plenty of planning and no verification.
62. Jevbridge — An ACP and MCP adapter exposing typed decisions to Codex, Claude, Grok, and others. One bridge beats four vendor-specific integrations.
63. Smithers — A TypeScript workflow framework with a Jev session checker wired into its workflows. Workflow engines historically branch on exact values; this branches on judgment.
64. skillbox — A self-hosted, versioned skills library that adds optional Jev-driven skill recommendations using your own key. Skill libraries get unusable past about thirty skills without selection help.
65. typesafe-ai/skills — The official installable agent skills package that teaches agents the Jev workflow, via npx skills add typesafe-ai/skills. A vendor shipping the integration as a skill rather than a doc page is a small but real shift.
Coding, Eval & Data Infrastructure
66. eve — Vercel’s eve engine ships Jev as the default evaluation model in its experimental evaluate path. Defaulting evals to a decision model rather than an LLM judge changes the cost profile of running evals on every commit.
67. AI CLI — Vercel Labs’ CLI can run Jev as the model behind its evaluate command. Local eval loops that used to be too slow to run mid-edit become interactive.
68. ai-python — The official Vercel AI SDK for Python carries Jev through its evaluation operation and Gateway examples. Python teams get the pattern without writing an HTTP client.
69. Cline plugins — Cline’s official plugin collection includes a Jev-driven browser plugin, making Jev a first-class capability rather than a community hack.
70. rotom — An OpenAI- and Anthropic-compatible local gateway carrying Jev through its model catalog and evaluation path. Existing gateways assume every model returns a completion, which Jev doesn’t.
71. safer-with-jev — A Neon Function proxy for the Neon AI Gateway that routes decisions through Jev. Edge routing decisions are exactly where a 500ms LLM call is unacceptable.
72. jevql — A psql-shaped CLI with Go, TypeScript and Python SDKs that runs plain SQL against vanilla Postgres, then asks typed questions about each surviving row so you can apply jev() filters, jev_prob sorts, and jev_choice groups. No database extension required, which is what makes it usable on managed Postgres.
73. sqlite-jev — A loadable C extension and Python package exposing Noul, Choice, and Score as SQL functions and batched virtual-table queries with confidence results. Semantic filtering inside SQLite previously meant exporting to Python and back.
74. jev() for PostgreSQL — A single SQL function that searches a whole database in natural language with no index and no embeddings, as in WHERE jev(people, 'could work from home'). Every prior approach required building and maintaining a vector index.
75. DuckDB row classification — Classifies rows in any CSV, Parquet, or DuckDB table, reported at about ten seconds per thousand rows with better ergonomics than a bespoke classifier. The incumbent was training a small model for a one-off labeling job. GitHub
76. advocaat — A small type-safe client for asking questions about a dataset. Ad-hoc data questions usually get answered by writing a throwaway pandas script.
77. zio-typesafe-ai — A ZIO client for Scala with a typed DSL over Jev decisions. The JVM data world has been largely skipped by LLM tooling.
78. TypeSafe AI Swift SDK — A dependency-free Swift 6 client with strict concurrency, configurable auth and retries, and offline transport tests. On-device iOS classification has meant Core ML and a training pipeline.
79. laravel-typesafe-jev — An unofficial Laravel integration with typed responses, async requests, scoped DI, and testing fakes. The fakes matter: you can’t unit test against a billed LLM.
80. jev (Elixir) — A GenServer client that replies with the answer so callers can pattern match on it directly. Pattern matching on a decision is about as idiomatic as Elixir gets.
81. jev-go — A community Go SDK. Go services doing classification have historically shelled out to a Python sidecar.
82. jevclient — An async Python client on PyPI. Async matters when you’re fanning out hundreds of decisions per request.
83. jev-cli — A small dependency-free CLI. Useful for the case where the decision belongs in a bash pipeline and nothing else.
84. decide-mcp — A configurable decision server with percentage scores and bias-profile routing layered on Jev. Bias profiles let you tune conservatism without retraining anything.
85. typesafe-jev-examples — Worked ticket-triage and reranking examples runnable through OpenRouter without an early-access key, with sample data and a Makefile. Being able to try it without gated access is the difference between reading about a model and using it.
86. Jev AI — A public playground and API for putting Choice, Score and yes/no questions to the model about pasted text, returning a parsed answer with confidence in about half a second. Ticket triage, moderation and review scoring are the three demos, which tells you where the demand is.
Evaluation & Benchmarking
87. jevcal — Fits a per-question confidence threshold to a target accuracy on your own labeled data, verifies on a held-out split, reports how much traffic still has to escalate to an LLM, and fails CI when a model update breaks the locked thresholds. This is the piece most projects are missing.
88. Jev Playground — Benchmarks Jev against Luna, Haiku, and Gemini at choosing validated legal moves in explicit-state games, scoring decision quality and consistency over a move sequence. Games give you a ground truth that text benchmarks don’t.
89. Jev vs Mistral and Gemini for event validation — A head-to-head on validating local event listings against Mistral Small and Gemini Flash-Lite. Small-model classification was already the cheap option, so this is the comparison that actually matters.
90. Judge call vs dimension scores — Tests one direct question per row against 12-14 scored dimensions with locally fitted weights, reaching 0.9076 against 0.8373 on Japanese NLI but flagging roughly 25× more hard benign rows as attacks. A useful reminder that a higher headline number can hide a worse failure mode. GitHub
91. Jev Pong — Pong where the ball advances one step per model decision, putting Jev head-to-head with LLMs through Vercel AI Gateway. Latency is the whole game, literally.
92. minutes — A local-first transcription app running its live voice-path evaluations through Jev. Real-time voice has no budget for a round-trip to a chat model.
Games, Simulation & Robotics
93. typesafe-mario — Plays Super Mario Bros. from structured emulator state, choosing each action from emulator-derived features. Game-playing agents usually need RL training runs; this needs a question.
94. jev-plays-pokemon — Reads Pokémon Red state as text, answers typed questions each turn, and lets deterministic code turn answers into moves. Keeping the game logic in code and only the judgment in the model is the cleaner split.
95. tsai-sc — Drives original StarCraft shareware through keyboard and mouse, recording action probabilities per decision. Logged probabilities give you something to debug, which screenshot-based agents don’t.
96. jev-drone — A camera-only autonomous drone in MuJoCo with a Jev judgment model in the control loop at 2.5Hz. Closing a control loop at all is the part LLMs can’t do.
97. typesafe-jev-drone-demo — A Three.js drone simulator with a Python backend where Jev makes the navigation decisions. Worth reading as the simplest end-to-end example of a model inside a control loop.
Finance, Legal & Moderation
98. jev-trade — Asks for a long-or-short Choice on a Hyperliquid market each round, places the order, and runs the same loop across many assets. Fanning the same decision across dozens of markets is only affordable at this price point.
99. On-chain trading on Monad — Jev decides buy or sell from a live price feed and the bot places real orders every 300ms block. That block time is shorter than a single LLM call’s latency.
100. LegalForecast-MTD — A benchmark asking Jev to predict federal motion-to-dismiss rulings from the judge’s written record, scored with claim-defendant micro-Brier metrics. Calibrated probability is the correct output for legal prediction, and it’s what chat models refuse to give you.
101. mastra-jev-moderation — A Mastra input processor asking a Boolean “must this be blocked?” plus a category Choice in one request, aborting at 0.7 and failing open behind a deadline and circuit breaker. In production it blocked 9 of 9 hostile and 0 of 49 real messages at around 0.4s median, roughly 4× cheaper than an LLM moderator. GitHub
The honest caveat
Not every substitution wins. A graded relevance evaluation over 33,047 catalog entries, 164 real queries and 9,831 labelled pairs put Jev up against BM25, bge-m3 and OpenAI embeddings. The verdict: “Jev as a standalone reranker does not beat a good embedding ranker.” — jev-search-rerank-eval (https://github.com/zhuyansen/jev-search-rerank-eval). Fused on top of semantic candidates it does earn its keep, adding +0.06 to +0.09 NDCG@10 for roughly $0.0002 a query. Standalone, it loses. That sharpens the pattern across all 101: Jev wins where the decision is bounded, high-volume, and latency-sensitive — routing, gating, per-element classification, control loops. It does not replace retrieval, reasoning depth, or prose. Also worth saying out loud: this ecosystem is weeks old. A lot of these repos share a scaffold, landed in one or two commits, and ship more README than code. Treat the list as leads, not endorsements. More Sources: awesome-jev, the jev GitHub topic, Jev AI Community, LangChain on Jev.