THE JEV ECOSYSTEM, INDEXED
Projects, demos, integrations and claims around Jev. Every entry keeps its source and evidence label attached.
A Chinese list of twenty projects for people who just got an API key: jev-ultrafast, fast-jev-compaction, json-render, typesafe-mcp, jev-mcp, SemDecide, the Codex router, winnow, jev-review, blink, Agent Desktop, typesafe-mario, jev-drone, OneVOneJev, jev-trader, prism-liquidity-agent, neo4jev, jev-curate, Canny and killmyidea.
Many RL tasks need a judge to verify pieces of outputs or trajectories, and at scale that is the bottleneck; a fast, cheap, calibrated judge could remove it. Draws on earlier work with Harvey's LAB benchmark, where harness engineering plus open models cut judging costs by orders of magnitude.
An X Article on putting Jev as a gate in front of Grok Build and measuring the cost difference on identical tasks.
A provocation with a video: if a marketplace pays $0.01 per CAPTCHA and Jev solves 100 for $0.0068, the margin is 99%; the author threatens to open-source it if the loophole is not fixed.
Transcript in, topic in, clips out: Jev picks the segments of a 90-minute video for any topic in under two seconds.
Jev as a decision layer for the Pi coding agent: a measured tool-call gate plus a jev_ask tool for typed, calibrated answers; distinct from madeye/pi-jev.
A System One style layer that returns typed, calibrated decisions from any open-weights LLM in a single forward pass (Hugging Face and vLLM), with benchmarks against Jev in the README.
Agents can write code but struggle to understand what they built at runtime; Reticle gives web and desktop apps a Jev-style runtime perception layer so agents know which interface they are looking at.
Browser automation split in two: an LLM plans the task, Jev makes the concrete in-page choices; shipped as a library, a CLI and an MCP server.
Deterministic hooks decide, Jev advises: an append-only ledger with zero runtime dependencies that blocks an agent's 'done' until there is evidence.
A high-throughput sifter for synthetic and pretraining datasets: stream Parquet and JSONL, filter and score every row with Jev.
An autonomous liquidity-provider agent with auto-rebalancing and backtested strategies (Meteora DLMM first), with Jev in the decision path.
A browser 1v1 quickscope arena built with Three.js where Jev plays the opponent's decisions in real time.
A Rust runtime that lets any agent operate desktop apps through their real UI structure (OS accessibility trees) with stable element refs, from the author of the hook-based routing demo.
An MCP connector that gives any MCP-capable agent direct Choice / Score / Noul calls to Jev; the Chinese roundups call it the first thing to install after getting an API key.
Jev as a command-line filter: classify, score and filter lines in a shell pipeline, for crawlers, CI gates and data pipelines.
Every tool result is judged by a System One model before it enters Claude Code's context, so noise never gets a chance to bloat the window.
Jev-powered model routing, memory, context compaction, skill selection and computer/browser use for Hermes agents (also Claude Code and Codex), with a routing dashboard and shadow mode that shows what Jev routing would have saved before you switch it on.
An OSS library from the LlamaIndex founder: give a document plus natural-language category rules and Jev predicts the category (classify) or the boundaries between sub-documents (split). OCR backends: liteparse (fast, free) or LlamaParse for complex layouts.
OpenRouter's founder pointing to the model page where Jev 1.13 can be tried directly in the playground.
A simple real-time bug checker built with Jev for people who still code by hand; it also underlines inaccurate English sentences.
LangChain's webinar on using Jev to build a better agent harness, with Sydney Runkle, Hunt Lovell and Allie.
A 'bouncer called Jev' added to an agent trading arena that blocks bad trades before the AI even sees them.
A trading agent guard where Jev vets trades before the LLM commits; the author says it stopped 3 ETH going into dead pools in the first five days.
Go HTTP middleware that lets Jev judge and route requests, plus a CTF-style example site inviting people to try injection attacks against it.
An extension for bentlegen's hunk that classifies the files in a diff (core, tests, docs…) with Jev and reorders the review so the important changes come first.
Split like gpu-lexer, classify every token with Jev, render Shiki-compatible tokens to HTML and ANSI — a language-agnostic highlighter, experimental only.
Tell the extension what you are working on; Jev checks every open tab at the door in a single call and shows the freeloaders out.
A Minecraft agent that plans with Astra and lets Jev control step-by-step actions, with native recording, tested routes and run verification; the Jev decision rules live in models.mjs.
A Jev-style 2B decider tested on a consumer RTX 5070 Ti under Windows 11.
Five days after launch: a Thai + English System One model on Qwen3.5-0.8B with a 256-way slot head, Apache-2.0, sized to run on a laptop.
An open reproduction that answers noul/choice/score in one non-autoregressive pass with calibrated confidence, at 150M parameters — a non-LLM route to the same interface.
Native MLX and Core ML runtimes for Laya typed decisions: `pip install 'laya-mlx[demo]'`, no text generation, no PyTorch, no cloud API. A Rubik's-cube demo runs 100 moves locally.
LangChain tested Jev against LLM judges on accuracy, repeatability, latency and cost to see whether System One models offer a new approach to online agent evaluation; evaluator code in the repository.
Upload a research-paper PDF; text is extracted in the browser, split into roughly 1,000-word passages, and a fixed set of small questions is asked per passage in parallel, then combined into weighted scores.
Scramble a Rubik's cube and watch Jev judge and solve it live, with difficulty tiers, XP and token-metered runs; labelled experimental and fan-made.
A text game where you talk your way past a border inspector whose actions are chosen by Jev from your typed replies; dialogue and consequences are authored game code, Jev only decides.
Turns Jev into a pixel-art generator by asking 256 multiple-choice questions, one per pixel, plus refinement passes.
A quick credential and secret-detection experiment with Jev; the author reports consistent results across runs.
An open-source tool that fact-checks spoken content (debates, investor calls, interviews, podcasts) live with Jev calls; demoed on an interview.
A browser extension (and web version) that classifies the news article you are reading by political framing, article type, topic and how loaded the language is, using Jev as a fast probabilistic classifier.
An experimental protocol where a worker agent sends requirements, code and test results to Jev, which returns an evidence verdict for the team-lead agent before results are accepted.
A local MCP server that runs Jev "packs" (code audit, PR review, GUI automation) for Cursor, Claude Code and Codex.
A Cloudflare Worker demo where a Flue agent uses Jev through Cloudflare AI Gateway for intent and urgency routing.
A layer that decides when an agent's stored memory should be invalidated, using Jev checks; a playground is hosted.
Adds `jev()` semantic predicates to plain Postgres through a CLI, HTTP and SDKs, with a SQLite cache and an `--explain` cost preview; a playground is hosted.
A Jev-driven recruiting agent with a local web UI that shows evidence quotes behind each decision; a short demo video is linked.
A Chrome extension that labels posts in the X timeline with Jev across five dimensions while scrolling.
A zero-dependency Ruby client for decision models supporting TypeSafe's native API and OpenRouter, with retries, timeouts and usage/cost fields.
A Claude Code and Codex CLI plugin that intercepts Bash output above roughly 10K estimated tokens, chunks it and asks Jev which lines are still needed, dropping progress logs and boilerplate.
A side-by-side of Jev and DeepSeek-flash on invoice extraction, email classification and reranking, with numbers on a hosted dashboard.
Measures on Banking77 when Jev can answer alone versus escalate to DeepSeek V4-Pro by confidence threshold, with risk-coverage calibration analysis.
Evaluates Jev reranking against bge-m3 embedding search over an Agent Skills Hub catalog, with judge-bias and robustness analysis.
A bilingual (Traditional Chinese / English) evidence map of where Jev holds up and where it breaks, with API-call receipts under suites/. Its thesis: success tracks whether the answer is derivable from the supplied state rather than from outside knowledge.
Adapts the RuneBench RuneScape agent benchmark to Jev with about fifty bounded actions, a tick-mode controller and a live dashboard.
A searchable Hugging Face Space listing open reproductions of the Jev interface.
A TypeSafe-compatible adapter running LFM2.5-1.2B through llama.cpp (about 1.25 GB download) with CUDA, ROCm and Metal builds.
`pip install von`: a non-autoregressive local decision model claiming wire-protocol compatibility with Jev (`von serve`), with ModernBERT or Laya-421M backends; Apache-2.0.
A drop-in for TypeSafe's API powered by a 400M GLiFormer model; point the official SDK's base URL at it. Deploys on Modal or CPU via ONNX Runtime and ships a bench folder.
An open typed-decision model on DeBERTa-v3-large answering Choice (up to 255 options), Score and yes/no questions from one forward pass, trained on 18K states and 42K questions.
Uptime and incident history for api.typesafe.ai and console.typesafe.ai.
A ten-point digest of codila's roadmap: LLMs create, agents act, Jev decides; three primitives; swap Jev in without rebuilding the graph; batch decisions (13 questions 10x faster and 12.2x cheaper in one test); bounded forks; benchmark the loop; rank wide, read narrow; keep Jev out of math, writing and irreversible execution.
fast-jev-compaction, jev-browser, jev-search, Reticle, NanoJev, open-alternative-jev, pi-jev and hermes-jev-skills, each with one line on what it does.
Jev does not generate text: it evaluates predefined decisions directly and in parallel. A failed-deployment example (urgent? which team? risky command? done?) shows Choice, Score and Noul, and why the probabilities matter as much as the answers — 91/9 routes automatically, 52/48 escalates.
An X Article on wiring Jev into a Claude Code workflow for cheaper, faster agents.
An X Article walking through the main Jev use-case families with examples. 160k views.
Ten-plus articles and five hours of video condensed into one X Article: how Jev works, what people are building, and a resource list (Vercel changelog, DataCamp, LangChain harness post, fast-jev-compaction, jev-ultrafast performance docs, HN, two awesome lists).
Seven ad-ops workflows on Jev: scan the whole Meta Ad Library and tag hooks/formats/offers, find formats that survive 60 days, score briefs before shooting, sort search terms by buyer intent, catch creative fatigue, check ad-to-landing-page match, score every lead 0–100. Shipped in the Ryze AI app and as an MCP / Claude connector.
One agent run that audits and fixes a client's SEO/GEO: reading Search Console and PostHog, checking what ChatGPT searches on Bing, modelling Gemini and Claude queries, scanning citations, fixing thousands of pages — the same output with Jev on the classification steps.
A hosted, fully open-source and auditable classifier the author says now outperforms Jev and is free; image support and new models promised. 480k views on the launch post.
Another curated list of Jev / System One applications, libraries and resources, linked from the 'Jev 101' article.
A computer-use assistant driven entirely by decision models: sub-second latency, near-zero cost, and it decides what to type without calling an LLM.
An open-source Codex skill: install it, set a Jev API key, and Codex drives desktop apps with Jev making the per-step calls — the author reports the biggest gains on tasks with frequent checks and tool calls.
A Chinese-language introduction to Jev with a getting-started sequence (waitlist, credit, skill), maintained by a Jev study group.
No demo: notes from three days running Jev inside production systems, misses included, organised as map → shadow → measure → promote.
A technical write-up arguing the Jev recipe was within reach of any team — the piece Eric Zhang says explained the thing he had built the day before.
A public repo collecting things built with Jev plus patterns, documented limits and a list of ideas nobody has built yet.
A Chinese aggregator of X long-form posts and demo videos about Jev, categorised with original links and authors kept; GitHub Pages site plus repository.
A vLLM pull request adding a Jev-like structured-decision path on Gemma, cited by testers comparing open alternatives on the Pareto frontier with reflex and DiffusionGemma.
A second Swift SDK, from the author of CryptoSwift — 'just leaving it for Jev enthusiasts'.
A local Markdown-vault second brain for Linux, macOS and Windows with Claude Code, Codex and Antigravity adapters and optional Mem0 / Jev; one-command setup that also installs Obsidian.
A Bloomberg-terminal-style analytical tool in the terminal (`pip install kadeconsole`) with Jev in the decision path.
`npx bev-ai`: an open-source joke-but-working classifier with bring-your-own Jev key and pluggable status lines.
A terminal art experiment where Jev makes the pixel decisions; renamed out of respect for an earlier project with the same name.
Browse YouTube transcripts by meaning with Jev analysis, subtitle export and a Vercel setup guide; Turkish UI.
A Redmine plugin that asks Jev, while you fill in the form, whether the chosen tracker matches the title and description, using the project's recent trackers as options.
Jev routes each ticket to a specialist agent (general / account / billing / technical) and decides whether a human should take it instead — all typed — while Cerebras writes the reply.
New Zammad ticket comes in, Jev decides which team owns it with a confidence score attached, and routes it.
The ielab document-ranking toolkit gained a jev module, with code that uses TREC human relevance judgments to test whether Jev's probabilities are actually calibrated.
A Python package for Jev-powered relevance filtering and reranking, with a Hugging Face blog walkthrough covering the API, filtering and evaluation results.
'jev, find me stuff in my system' — a file finder that asks Jev which files match a natural-language request.
Countable rules plus one judgment model: ten yes/no questions per paragraph flag AI-writing tells. Zero dependencies.
A Chrome extension that uses Jev to estimate a page's purpose and the writer's position (ad, testimonial, explainer…) and colour-codes Google search results accordingly.
A Chrome extension that labels every post on X (Substance, Humor, Chit-chat, Promo, Junk, AI-written) plus an AI-probability score, and folds the ones you don't want.
An open-source CLI that builds calibrated classifiers from human feedback on top of Jev, using GEPA prompt optimisation — because a foundation model still needs aligning to your own criteria.
A one-page web app where Jev plays chess against any OpenRouter LLM, Stockfish, or a human, showing live moves, Jev's move probabilities, saved games and win rates.
A multi-robot harness CLI (Microduck, Open Duck Mini, LeRobot, XLeRobot, AlohaMini and more) where each robot has an LLM brain and Jev handles the cheaper decision steps; a LeRobot SO-101 setup takes about five minutes.
An MCP server for Jev built in about four hours and paired with a local GLM 5.3 Flash model — the author's 'absolute deadly combo'.
A small plugin exposing Jev to Nous Research's Hermes Agent as tools: jev_check, jev_route, jev_score and jev_evaluate.
An autorouter that lets Jev pick both the model and the reasoning effort for each Codex turn — 'I cannot use codex the same anymore'.
Speeds up Pi coding-agent workflows by letting a decision model pick which files matter and cache requests; the author also tried DiffusionGemma in place of Jev and documents the results in VALIDATION.md.
Uses Jev to enforce the project rules linters cannot catch — the judgment calls in a style guide — on a coding agent's output.
For the Pi coding agent: every code edit is checked by Jev against the repository's Markdown rules (agents.md and friends) so the agent stops ignoring them.
Born from Claude Code changing an auth check to return true with tests still passing: eight risk axes scored by Jev in one request, with one optional re-inspection before the agent declares done.
Bounded TypeSafe Jev workflows for coding agents: small-model judgments combined with deterministic workflows so coding work stays bounded, from the author of jev-review.
Say it and the Mac does it: the loop reads the accessibility tree, asks Jev which element to act on, acts, repeats — deliberately naive, no screenshots, no vision model.
A llama.cpp fork with a `jev` branch and docs/jev.md that runs Jev-style typed decisions on local models; the author's size-by-size picks are Qwen3.8-27B, Gemma 4 12B, Qwen3.5-4B and two tuned 'jwenv' Qwen3 PoCs.
Japanese-language decision weights on a 310M ModernBERT, published 'just in case' to Hugging Face.
An attempt at a Jev-like model built on Qwen 4B, published on Hugging Face and runnable locally.
An educational experiment: one image, dozens of questions answered at once by scoring candidate outputs directly instead of generating, running Qwen3.5-0.8B on MLX.
A container recipe for structured decisions with DiffusionGemma in NVFP4 on an NVIDIA DGX Spark, offered as the 'or just use this' route to a local Jev-like.
An open, Jev-compatible System One decision server running DiffusionGemma — one of several projects named openjev.
A non-autoregressive decision engine on ModernBERT (151M) with calibrated uncertainty, an audit of the Jev benchmark, and an in-browser WebGPU playground; Apache-2.0 with PyTorch and ONNX weights on Hugging Face.
An mmBERT-based 0.3B typed decision model published a year before Jev and rediscovered during launch week; weights and a demo Space on Hugging Face, plus a multilingual variant. Ports to MLX and Core ML followed within days.
GitHub Next's 'poor man's Jev': a Jev-compatible local API built in a morning on top of DiffusionGemma (swappable via config), so team members without Jev access can run the same call shapes locally.
A community directory of Jev projects kept as one markdown file per project (TipTour was added within hours of its release).
An X Article walking through twelve real use cases tried against Jev, with the author's take on which ones held up and which did not.
A Japanese X Article with twenty demonstrated API uses and the free routes in (Vercel AI Gateway, OpenRouter), linking jev-ultrafast, typesafe-computer-use, typesafe-mario, jev-drone, jev-review, Foreman, jev-mcp and HA-Jev.
A browser skill that takes a website and a task, opens the browser and lets Jev decide every click from what is on screen. Video demo; the code is shared inside the club's community rather than publicly.
Vercel's announcement that Jev runs at no cost on the AI Gateway until 25 September, calling it the fastest-adopted model on the Gateway.
Five ways to call Jev without waiting for API access: OpenRouter, Vercel AI Gateway (free), Cloudflare, Netlify AI Gateway and OpenCode Zen, with the ~$0.042/M input price where it applies.
Notes from integrating Jev into a custom agent harness: beyond cheap classification, the interesting uses are continuous evals and monitoring, custom verifiers for long-horizon agents, and recursive self-improving harness loops; a guide is in progress.
A fully autonomous trading bot built in an evening and a morning: onchain and offchain data in, rapid Jev trade decisions out. Video demo, no token.
14 yes/no questions per post (does the hook open a loop, is there a number in the first line, is the proof real or claimed) over a 100,000-post corpus, then viral rates per hook pattern.
A personal content-research dashboard: Jev labels each saved X post across eight dimensions (topic, hook, writing style and more), then the archive is filtered by pattern and compared by engagement.
Home Assistant integration: ask the house a typed question and get a number back — Jev answers exposed as sensors, four actions for automations, and a conversation agent for Assist.
A seven-step setup that puts Jev between Grok Bot and its actions: a jev-usage-router skill is consulted before browser, research, retry or extra-bot steps; it starts in shadow mode with logs, then goes active, with a kill switch. Repository included.
An open-source macOS pointer companion driven by Jev or Gemini Live: a local OmniParser build on CoreML reads the screen, Jev picks where the pointer goes, Ctrl+K takes a typed task. Bring your own keys.
The seed-round lead on the first 72 hours: the 18-month-old pitch of a reliable, fast, too-cheap-to-meter intelligence primitive, and adoption on Vercel AI Gateway.
An X Article describing a per-block trading loop where Jev returns a calibrated buy/sell decision in under 100 ms, built on the agenkit toolkit.
A Chinese X Article sorting the early ecosystem into things that actually ship: jev-ultrafast, mobile-jev, typesafe-computer-use, AskJev, a Twitter timeline analyzer, a tax-document classifier, jevdetector and newsjack, plus the OpenRouter and DataCamp explainers.
A launch write-up covering the three primitives, RLCD training, pricing and latency, pointing to jev-ultrafast and mobile-jev as early adopters.
The browser-based Jev-like demo openjev.com reached the front page (628 points, 265 comments at fetch). The site now labels itself SemIf, "formerly OpenJev", running Qwen3 0.6B, MiniCPM5 2B and Qwen3.5 4B locally via WebGPU.
A live coding session against the Jev API framed around parallel constrained decoding.
An explainer video from a well-known hardware and software explainer channel; the title signals a caveat framing.
Describe a mood and Jev sets lighting, curtains, music, TV and other room settings; presets run without an API call and the page tracks session cost.
A narrative game where each villager decides tick by tick how to treat the player, with a view that shows what Jev read and answered; 21 tracked outcomes and per-interaction cost counters.
A 3D robot companion driven by one TypeSafe call per turn answering nine typed questions at once, with confidence gating to act, ask or do nothing; no text generation.
A comment-moderation playground that evaluates seven hazard categories plus a severity score in one parallel call, with review and action thresholds.
Submit a startup idea and get kill / fix / ship with probabilities.
A free yes / no / maybe oracle that calls jev-latest through the System One API with live search for current facts; no account needed.
56 entries in twelve use-case categories plus links to the Hacker News and Reddit launch discussions.
A curated list of official and community TypeSafe / System One / Jev resources, 50+ entries in six categories, with a GitHub Pages site; reviewed 2026-09-17 per its page.
Seven independent writing checks (hedging, filler, passive voice and more), each returning its own verdict, confidence and the driving sentence; runs simulated without a key.
A bring-your-own-key API with /v1/scan (prompt injection, jailbreak, credential leaks) and /v1/moderate (nine categories) returning calibrated probabilities; free tier live.
Sits between MCP clients and servers with three layers: structural allowlists, semantic hazard detection via Jev, and session taint tracking; targets poisoned tool descriptions, injection, exfiltration and secrets.
An OpenAI-compatible router that uses Jev to pick a model on top of LiteLLM, filtering candidates by capability and falling back to the cheapest model without a TypeSafe key.
Jev scores each request on eleven dimensions (difficulty, stakes, safety and more) and YAML thresholds map the scores to model tiers; TypeScript and Python SDKs plus an HTTP proxy.
A DuckDB extension with jev_choice(), jev_score(), jev_noul() and jev_ask() returning real SQL types, batching 16 rows per request and caching identical queries.
A pre-alpha PostgreSQL C extension exposing typesafe_noul(), typesafe_classify(), typesafe_score() and batched variants that call the API from SQL.
An async LangGraph workflow that classifies mock emails (invoice versus general) with the Choice primitive and routes them to handlers, with unit tests; pins jev-1.12.
Adds a `:typesafe` provider to RubyLLM 2 with Noul, Choice and Score primitives, schema building and validation, and an offline models catalog.
Validates state locally with Zod-style schemas, bundles all questions into one parallel Jev request and projects typed answers; built on the official SDK.
A TypeScript client for batching several typed questions about your data into one Jev request; the example triages GitHub issues.
A Rust crate with enum responses and confidence, async or blocking backends, batched questions and observable retries; examples cover PR questions and semantic search.
Uses an open diffusion language model for structured JSON judgments without fine-tuning and benchmarks against Jev's public eval cases.
State plus typed questions in, calibrated probabilities out, built on Qwen3.5-4B, with a 650 MB WebGPU browser build on Qwen3.5-0.8B.
Prefill once, broadcast the KV cache per field, evaluate all fields in one pass on Qwen 1.5B–8B models; a Hugging Face Space demo exists.
One-pass option scoring with a local Gemma 3 4B via MLX: pre-written options are batched against a cached context; implements the System One API contract and includes a Doom terminal demo.
Reimplements a System One decision model on Gemma 3 270M with a LoRA of 2.6M trainable parameters, scoring all options in one forward pass; trains in a free Colab and ships weights in the repo.
A large collection of use cases, patterns, prompts and starter code; despite the name it is a community repository.
TypeSafe's public skills repository with the `typesafe-ai` SKILL.md used by Claude Code, Codex and other agent environments to design bounded Jev decisions.
An early independent implementation of a Jev-style interface on an open model; cited as inspiration by daseinlabs/open-jev.
A mobile agent that drives a real Android device through Mobilerun with Jev choosing actions; the README states the limits of the demo itself.
Routes Claude Code tasks to a cheaper or more suitable model based on a Jev decision; listed in the Studio Yebisu roundup.
A step-by-step code-review workflow built on Jev with a local dashboard, listed in the Studio Yebisu roundup.
A browser agent where Jev picks the operation and target element from a numbered element table each step, and a small LLM is called only when text has to be typed.
A searchable site mirroring hellogumbo/awesome-jev with daily-refreshed GitHub stars; 488 projects, 406 repositories and 123 live sites at last check.
A source-backed list of 70+ Jev projects in eight categories, including open reproductions and evaluations; reviewed 2026-09-18 per its README.
A 52-page report with 50 reproducible Chinese test cases and raw API responses that re-measures TypeSafe's headline speed and cost multiples.
Benchmarks Jev as a router across 13 flagship models on LLMRouterBench and a RouterArena pilot.
An independent comparison on Banking77, SST-5 and IMDB covering accuracy, calibration, latency and cost.
A framework comparing hosted Jev with a local GLiNER2.5 on zero-shot single-label classification (AG News, Banking77, DAIR Emotion) for accuracy, calibration, selective-automation coverage and latency, with bootstrap intervals.
A layered controller: classical vision at 15 Hz, a 50 Hz reflex safety layer, and Jev at about 2.5 Hz choosing tactical maneuvers from JSON scene descriptions.
Jev picks NES controller inputs from object-centric JSON telemetry rather than screenshots, choosing among seven legal actions and logging latency and probabilities per decision.
An n8n node with Ask Yes/No, Ask Choice, Ask Score, batch Evaluate and model lookup operations, defaulting to `jev-latest`.
Two PyPI packages: a `JevRerank` postprocessor using Score and single/multi selectors using Choice for LlamaIndex routing.
A Claude Code plugin that asks Jev which standing rules and codebase maps are relevant to the current prompt or file edit, injects only those, and falls back to all rules if the API is down.
Screens agent tool calls for destructive, exfiltration, privilege-escalation and off-task actions using Jev probabilities, ships as an npm package and a Claude Code PreToolUse hook, and logs an audit trail.
A proof-of-concept MCP server exposing three tools: verify a claim against evidence, screen text for injection or relevance, and rank candidates semantically.
Jev scores file and folder names so an ensemble of walkers is allocated across the most probable paths; a Bun CLI with recursive and multi-walker modes and JSON traces.
Outgoing relationships become choices, Jev returns next-hop probabilities, and a beam search walks the graph; shipped as a library, notebooks and a Streamlit app on Neo4j's public Companies knowledge graph.
An experimental semantic router for Hono by its creator: routes are described in plain language and Jev matches incoming requests to them from method, URL, headers and body.
A WXT browser extension that asks Jev whether page elements are clutter (ads, cookie banners, upsells), then saves reusable per-template hiding rules; sends snippets rather than full pages, bring your own key.
Constrains token selection to choice indices so any open LLM answers many questions in one pass; includes Doom and Wikipedia-racing demos on Qwen models.
An open replica trained on 92 public datasets plus synthetic generators, on Gemma 4 E2B (LoRA) and Gemma 3 270M, served via FastAPI on Modal with a live demo.
SimpleJev.ai from Featherless: a fully open-source library that takes any Hugging Face model and 'Jev-ifies' it behind an API endpoint, with public no-key endpoints, vision via chat-format images (Gemma, Qwen) and an RFDT tuning recipe to distil your prompts into a smaller production model.
A server that implements the TypeSafe/Jev HTTP API on Qwen3.6-35B-A3B with SGLang: prefill-only, one extra token per question, radix caching, deployable on Modal.
A Qwen2.5-0.5B-based decision model with block-causal masking so questions run in parallel and a pointer head that scores options; the HTTP API mirrors System One, so the official SDK works with only a base_url change.
Workers AI exposes the model as `typesafe/jev` (jev-1.13.0) with `state` plus noul / choice / score questions and a 32,000-token context window.
A drop-in replacement for the TypeSafe client that answers the same state-plus-questions contract with an ordinary LLM API, useful for comparing Jev against OpenAI- or Anthropic-compatible models on identical calls.
The official TypeScript/JavaScript client, shipping ESM, CJS and type declarations for Node 20+; same ticket-classification quickstart as the Python SDK.
The official Python client (`uv add typesafe-sdk`) with sync and async variants; the quickstart classifies support tickets into billing, technical or other.
The public dashboard behind the launch numbers: four workflows (security incidents, agent-trace observability, invoice processing, customer service) and ten model configurations compared on accuracy, cost and latency.
An agent skill for finding and designing bounded Jev decisions in software.
A large, actively maintained community directory of SDKs, integrations, agent tools, games, demos and research.
A PostgreSQL extension that exposes Jev-backed categorical judgments over table rows.
Keep a bypass, decompose questions, tie confidence to actions and shadow-run before replacement.
A prototype removes text and JSON generation to return direct decisions on DGX Spark.
A community guide covers typed calls, batching, middleware, confidence gates and migration.
A 706K-parameter form-filling specialist is compared with Jev on a narrow evaluation.
Jev chooses sources and query settings, then re-ranks results returned by search engines. It does not generate an answer.
A local classifier-style model targets type-safe JSON workloads on Apple silicon.
An open Chrome extension listens to live audio and skips detected sponsor segments.
A thread connects browser, database, email, QA, drawing, games and low-level GPU experiments.
A strategy and ticker list are turned into fast decisions and a backtest view.
Per-turn routing chooses a model, reasoning depth and speed mode for Codex.
Jev picks components and actions from a fixed design system while json-render assembles the interface.
A 0.6B Qwen-based open implementation of parallel typed decisions, with training and evaluation code.
A product routes and classifies revenue-related actions with Jev and delegates generation elsewhere.
Many browser scenarios run in parallel with Jev serving as a low-cost evaluator.
Jev is framed as a constrained structured-output primitive inside a larger agent harness.
A visual comparison places Jev next to Luna, Sonnet and Flash on email classification.
Hundreds of pages are screened for internal-link fit through thousands of yes/no decisions.
Jev chooses game actions and is shown across many concurrent runs.
A pipeline ranks social mentions by intent, fit, competitor context and reach.
A Marketplace plugin connects a Cline desktop app to Jev through Vercel AI Gateway.
Speech becomes text, the DOM becomes an action catalog and Jev chooses the next click.
A Mac begins executing a selected action while the user is still speaking.
Business ideas around quotes, leads, support, clipping, applications, marketplaces and browser agents.
A platform explainer contrasts confidence-scored yes/no and multiple-choice decisions with free-text generation.
One profile is scored for fit, chance, confidence and mismatches across 400 companies.
A long tutorial covering the API, a voice browser, AI memory and a YouTube predictor.
Voice is mapped to bounded Figma actions, with Jev choosing the operation.
A calendar task compares a Jev-based action loop with built-in computer use.
A detailed guide to state, Choice, Score, Noul, probabilities, routing, confidence gates and shadow rollout.
A prompt asks coding agents to inventory every bounded semantic decision where Jev might replace a heavier model call.
Waitlist (approved same day), install the official skill in Codex, create an API key, say 'use the TypeSafe skill' — with the author's note that old scenarios are about to come back to life. 355k views.
Type 'Urgency' at the top of a column and, as you type, Jev works out you want each row rated from 'no follow-up needed' to 'urgent' — spreadsheets that recalculate meaning, not numbers.
A dynamically branching form where Jev chooses the next question, built on Vercel's json-render for generative form UI and xstate for state — replacing hand-written if/then logic.
A portable agent plugin and MCP tool for batch text classification: the agent asks Jev whether a file is worth reading, a tool worth calling, a website worth browsing — before spending tokens on it.
An LLM gateway that mimics TypeSafe's structured output so local models can be scored against Jev; Needle 3 on an M4 Pro came out worse than Jev, Qwen3.8 27B and OSS 120B.
The AX framework added Jev across its six languages: ordinary ax signatures for boolean and class decisions map straight onto Jev calls.
A port of typesafe-sdk-python to Swift.
Not Jev but Jev-shaped: a small decision model trained specifically for chess moves, built in the launch-week spirit.
A Hugging Face dataset with a RESULTS.md comparing a fine-tuned 4B model against prompting the same model on typed decisions, run against Laya.
A Jev-style decision model built on IBM Granite 4.1 3B with an RHCD training recipe — 'when's IBM or Red Hat going to build their own Jev? I got it for them.'
Bespoke Labs' open take on a Jev-like model: local typed decisions plus a contrastive data-curation recipe and evaluation code, released as data, weights and training recipe together.
Twenty practical tips, starting with 'stop treating it like an LLM: state in, typed decision out', on prompts, primitives, thresholds and where Jev belongs in a loop.
The founder's 17-minute talk, re-shared with commentary: why RLHF-era models carry a human-shaped flaw, why coding assistants are still the assistance era, and the x200 faster / x400 cheaper / zero-hallucination framing for what comes next.
A short list of first use cases — second brain, checking an agent's work, in-app decisions — with the $0.042/M input, free-output pricing as the hook.
A Chinese X Article explainer: what a System One model is, the launch figures, and a tour of the ecosystem — jev-ultrafast, LangChain, Vercel AI Gateway, Cloudflare, cobanov/awesome-jev and Foreman.
A Japanese X Article explaining the shift from chat to typed judgment for designers and non-engineers, with the launch blog and a gihyo.jp early-access write-up linked.
An X Article setup guide framed around building an agent decision layer on Jev, from account to a running loop.
Ten-minute setup (waitlist, official skill, API key, 'use the TypeSafe skill' in the prompt), then the argument: the gain comes from deleting LLM calls that only pick something — next tool, is-this-spam, is-this-chunk-relevant, needs-a-human, is-this-diff-risky — and replacing each with a typed question.
An X Article roundup of early projects: jev-ultrafast, jevlike, mini-jev, reflex, awesome-jev-by-typesafe, the Every vibe-check test and several video demos, with the official docs and use-case map linked.
A long-form X Article covering what Jev is, how the typed-question API differs from prompting an LLM, and where to slot it into existing agents.
An X Article walking from waitlist and API key through the official skill, the Python SDK, confidence thresholds and the three primitives (choice, score, noul) to a first agent loop.
A newsletter and podcast recap treating Jev as the lead story and summarising use cases seen in the first 48 hours: computer use, email classification, context compression, safety filtering.
A pull request on the TrainLCD Functions repository adds Jev-based re-ranking of suggested stations and measured spikes; the author says Jev is also going into part of the app's AI chat.
Jev hooked to a racing game through a Python API and a display UI; the author describes a trick of buying thinking time and notes the course is fixed.
Uses Jev to judge whether a speaker's turn has ended half a second after speech stops, then holds longer or shorter based on confidence; the video shows per-call timings.
Load a Telegram JSON export and Jev labels each post's type, quality, sentiment and reaction tone; runs through Vercel AI Gateway or a TypeSafe key, with label export.
A small game where you race Jev at classifying a message as spam, built to show its latency.
Tic-tac-toe and Connect Four against Jev, where the model picks the move and the code keeps the rules.
A self-driving simulation built to test Jev: structured sensor state in, typed decisions out (steer, brake, overtake, pedestrians, speed limits); the prompt is published.
Vercel's explainer frames Jev around Kahneman's System One, shows how to structure bounded decisions and separate evidence from questions, and points to the AI SDK evaluate API and the `@ai-sdk/typesafe-ai` provider.
A Python package that traces TypeSafe System One calls as OpenInference LLM spans (request, response, model, token counts) for Phoenix and compatible backends; a JS package is documented in Phoenix.
Braintrust added Jev as a scorer with a confidence-threshold pattern (accept above 0.95, route 0.70–0.95 to an LLM judge, flag below 0.70 for humans) and auto-instrumentation of TypeSafe client calls in its Python SDK.
The LiteLLM proxy scores older tool results with Jev and replaces low-relevance ones with short removal notices before the request reaches the LLM; a TypeSafe pass-through endpoint is documented too.
Pydantic AI merged a TypeSafe model provider: `TypeSafeModel('jev-latest')` with confidence thresholds, a FileUnderstanding capability and fallback to an LLM for tool calls; docs cover jev-latest, jev-preview and pinned releases.
A thorough Japanese synthesis of the official docs, the evals dashboard, third-party tests (Every, Near Here, Classmethod) and public skepticism.
Coverage of browser-use/jev-ultrafast: a numbered element table per step, Jev picks action and target, an LLM only for typed text, with the project's listed limitations.
The agentgateway proxy project ran Jev as a prompt guardrail with distributed tracing and cost tracking, with an example linked.
Near-real-time scoring of TikTok and Instagram hooks against roughly a hundred synthetic personas with Jev.
Brood War compiled to WASM and exposed as an MCP server with Jev playing; the author jokes it still loses to a Zerg rush.
A small bot trading Kalshi 15-minute and 1-hour BTC/ETH/SOL markets with Jev making the call, built with Effect-TS.
Tested Jev as a pre-action safety check for agents; the follow-up setup filters everything with Jev and escalates only suspicious cases to Gemini.
skillbox reads the query and returns the relevant agent skills immediately with Jev, instead of agents spending many turns searching for them.
Foreman watches coding agents and uses Jev to continuously assess progress, completeness, tests, drift and verification, intervening when needed.
An open-sourced decoding engine for autoregressive LLMs inspired by Jev: one output token per decision, no out-of-schema outputs, KV-cache reuse; demoed on SGLang with Qwen 27B.
A desktop writing assistant that uses Jev for fast structured judgments on text; the author notes Jev cannot generate the corrected text and that text leaves the Mac via the hosted API.
A thread testing whether many narrow Jev questions beat one direct question on a classification task with trap phrasing.
Camera and microphone feed local Moonshine, YOLO26 and DepthART inferences, Jev picks the scene decision, and lights, shadows and bloom react in real time.
A video demo of real-time processing with parallel Jev questions, referenced in Moritz Kremb's thread as voice-driven canvas drawing.
A browser extension that asks Jev, per post, whether it matches a plain-language filter and collapses the ones that do; framed by the author as a content firewall.
A predictive launcher where Jev reads intent from each keystroke (for example "the pdf I just downloaded") and surfaces the target before the query is finished.
A developer-reaction piece with named quotes, including Vercel's safety-classifier comparison and other early adopters.
A tutorial that replaces an LLM-as-judge with Jev to score Langfuse traces, with a full Python example detecting user disagreement per conversation turn.
OpenRouter's beta listing for `typesafe/jev-1.13` with a `jev-latest` alias: $0.042/M input, free output, 32K context, plus the platform's own latency and token-volume telemetry.
A Chinese-language overview of early Jev experiments and integrations.
A long-form explanation of integrating typed judgments into agent workflows.
Jev scores which tool calls and results remain relevant before context is compacted.
Independent walkthrough of the model contract and early experiments.
A Scala ZIO client for Jev with a small DSL for typed questions.
Open-source log triage for OpenTelemetry: Jev scores each log line's signal so only what matters reaches the expensive LLM analysis; a write-up covers Jev vs a fine-tuned alternative.
A hosted detector that scans text for AI-written 'slop' using Jev decisions rather than a generative model.
HiringCafe (2.5M monthly active users) scores resume-to-job-description relevance; the founder ran Jev against a human-labelled set and compared Spearman correlation and cost with three other models.
Argues general LLMs fit security engineering poorly and positions Jev as a decision engine for threat-hunting ranking, alert classification and incident-response prioritisation, which the author says he is implementing.
A web tool that runs the same task on GPT and Jev and shows money spent, time taken and tokens used side by side.
Compares one direct Jev question per row against 12–14 Jev-scored dimensions with locally fitted weights across three classification tasks.
The author trained an MLP head on top of Qwen 4B and published it on Hugging Face as an open-weights Jev-like model, with a demo video.
An official docs page listing failure modes of jev-1.13 with workarounds: literal reading of implied conditions and negations, unreliable arithmetic and counting, dates treated as text, weak multi-hop indirection, degradation with irrelevant state, prompt-injection vulnerability, and inconsistent invariants between related questions.
An architecture-focused Japanese explanation of why scoring a closed option set skips the decode phase, separating form guarantees from correctness guarantees.
3D chess where the same model plays both sides; the viewer can watch or take over one side.
Rebuilt TypeSafe's output format with Qwen 3.8 27B on Cerebras via an LLM gateway and compared the two.
A public web demo where users submit any question and Jev judges rather than answers, built on Convex with a stated goal of one million questions.
A Mac app routes setup and troubleshooting questions to the right built-in manual article with Jev when no local model is loaded, showing real docs instead of generated text.
A Doom agent with separate Jev channels for navigation (5 decisions per second) and combat (12 per second).
A text MMORPG maps player intent to typed server actions with Jev, replacing a slower LLM step.
A preview of browser automation for OpenCode powered by Jev plus its browser-use CLI, framed around speed; the demo video sits in Neriousy's post and dax's root post.
A thread cataloguing fourteen early projects, later expanded by the author into a 130+ project directory with automated scanning.
A team pointed Jev at a private benchmark and reports it came within a few recall points of their fine-tuned Qwen at matched precision, while the fine-tune remains faster and has not been replaced.
A router where Jev decides which LLM should serve each incoming request; the same author hosts a Pac-Man page where Jev chooses a direction at every junction.
A DuckDB extension that calls Jev to classify rows of any CSV, Parquet file or table from SQL.
The accessibility tree becomes the state and possible actions become questions; Jev picks the next step in a Stagehand-driven browser.
A bot that asks Jev for a buy/sell decision on every Monad block from a price feed and executes on Kuru's MON/USDC book, with a live status page.
A computer-use agent that OCRs the screen, asks Jev to pick the next action, and clicks; the author says the loop generalizes across operating systems.
Vercel benchmarked the auto-mode safety reviewer of its fx coding agent with Jev in place of GPT Luna and says it is likely to become the default.
A playable demo that runs 16 typed judgments on your text (tone, urgency, AI-written detection and more) on every keystroke with a single API call.
The most complete third-party tutorial found: installing the Python and TypeScript SDKs, calling `system_one` with Choice, Score and Noul, and a set of launch-week examples.
Uses Jev as a four-tier difficulty classifier in place of NVIDIA NeMo Switchyard's router classifiers, with code.
Netlify's changelog: the gateway injects credentials so `@typesafe-ai/sdk` runs inside Netlify Functions without managing keys; alias `jev-latest`, Node 20+.
An independent local probability-decision implementation inspired by Jev.
Jev classifies and scores a creator's own posting history across several criteria.
A conceptual map of where a low-latency decision model can sit in software.
A model or agent route is chosen from a fixed catalog based on the current task.
An early community roundup of repositories and Jev experiments.
A Cua Driver integration that uses Jev to choose bounded computer actions on macOS, Windows and Linux.
Parallel judgments score advertising creative against a fixed rubric.
Jev evaluates a pull request against bounded review questions before results reach the user.
Architecture notes on putting bounded Jev judgments inside an agent harness.
The counter-take from a well-known Brazilian developer: Jev works fine, but it is a classifier, and the revolutionary framing is marketing.
A primer with an essay and research appendix: API shape, launch pricing, founder background, co-founders and the funding round.
A thread benchmarking Jev on public prompt-injection data, thresholding calibrated probabilities in code, with a dashboard and calibration analysis in follow-ups.
A mini-site (What Shipped / The Evals / The Guarantee / Prior Art) concluding that pricing is verified, "can't hallucinate" is schema-only, and the multiples hold only against frontier reasoning models on TypeSafe's workflows.
A roundup that notes the 193.6x / 444.6x come from workflow evals whose reference answers are other models' outputs, while the demo latency comparison is a different workload.
A long explainer with a comparison table and the API shape, written from public material.
A long Chinese explainer of System One models: no text generation, parallel sampling, RLCD, use cases and trade-offs.
A Claude Code hook where Jev decides whether a task goes to Haiku, an Opus sub-agent, or an external harness such as Codex or OpenCode.
A driving simulator where Jev picks the next control action; the author frames it as rebuilding self-driving in under an hour.
An early video demo running Jev over 1,500 of the author's own emails.
A video demo classifying 500 emails in seconds.
Argues the headline multipliers are real but chosen against the slowest and priciest baselines; against TypeSafe's own intelligence peer the gains shrink.
The newsletter's lead item frames Jev as a cheap, calibrated inference engine for structured choices, complementary to System 2 LLMs.
Launch coverage that correctly notes the Doom demo runs on structured game state rather than pixels and reports the funding round.
Wires Jev into five decision points of a coding-agent harness; the main test is failure triage on 102 real provider-API failures from session logs.
A UK events platform compared three models on approving or rejecting 50 real listings (venue hire, products and cancelled events filtered out), publishing the cases as a PDF.
Vercel's changelog entry: Jev is callable through AI Gateway from AI SDK 7 (7.0.105+) via the experimental `evaluate` API as model `typesafe-ai/jev`, with Choice, Score and Noul questions.
Current product documentation for state, typed questions and the API surface.
A launch-day thread telling the founder story: two years in stealth, System One framing, and what a model that only answers typed questions is for.
The only source found with a valuation: a $40M seed at about $200M, DCVC lead, plus founder interview details (four years at OpenAI, company founded in 2024).
The launch discussion (1,889 points, 495 comments at fetch): whether "can't hallucinate" is just type safety, whether this is constrained decoding, and what the Doom demo actually shows.
An early-access test in which the author had Jev score his own writing corpus; widely cited by other write-ups as the first non-TypeSafe measurement.
The launch-day press release: a $40M seed round led by DCVC, the Jev launch, and the three co-founders (Diogo Almeida, Erik Gafni, Sasha Sheng).
The launch post and primary product video from TypeSafe's co-founder.
The launch source for Jev, its typed decision interface, pricing and TypeSafe workflow evaluations.
A pre-launch essay from the company blog that extends Sutton's bitter lesson into a hierarchy: right task, then data, then compute, then algorithms, using InstructGPT versus GPT-3 as the example.
Try a broader search or .