yibie/awesome-jev

A curated awesome list of public projects and practices built on Jev, TypeSafe AI's System One model for typed decisions.

This README is the homepage aggregate of the current category files, so the latest accepted entries are visible here without drilling into subpages.

Jev is not a chat model. It takes unstructured state plus a typed question and returns a typed decision — a choice, a score, or a boolean, each with a confidence. That makes it a drop-in decision layer for software: classification, routing, rubric scoring, verification, and agent guardrails. This list tracks who is actually building with it, and which patterns transfer across industries.

The repository treats all categories equally — each entry lives in exactly one category, chosen by its direct Jev application domain. A dedicated Related Practices / Discussions category captures credible public practice signals — X threads, Reddit discussions, and interviews — that describe real Jev usage even when no strong standalone case page exists yet.

Most Jev discussion is scattered across launch threads, model-gateway listings, and one-off prototypes. This list answers two practical questions quickly:

• Where is Jev already making real decisions in production workflows?
• Which decision patterns transfer across industries?

This is not a comprehensive database. It is a high-signal, fast-scanning field guide.

An entry should meet all of the following:

• The source is public and citable.
• The example uses Jev (or a documented Jev port/derivative) for a concrete decision task — not a generic classifier, router, or LLM judge with no Jev involvement.
• The source explicitly names Jev/jev, cites TypeSafe AI's System One models, or shows a typed-decision loop (typed question → typed answer with confidence → accept/reject/escalate).
• The summary explains the scenario, method, and value in one sentence.

We do not include:

• Generic classifiers, routers, or research agents that merely resemble the pattern without using Jev.
• Pure theory or opinion without a concrete practice.
• Launch-hype commentary with no working artifact or reproducible result.
• Long write-ups inside the list itself.
• Sources that are private, inaccessible, or too vague to classify.

Inclusion means one thing: the entry satisfies the inclusion rules above. It is not a quality review, a security audit, or a recommendation. We do not verify that a project compiles, that its tests pass, that its published numbers reproduce, or that its license permits your use.

This matters most for projects that arrive in bulk. When one author releases several repositories on the same day, they commonly share a single scaffold — the same AGENTS.md, CLAUDE.md, STATE.md, and CHANGELOG.md — land in one or two commits each, and may ship considerably more prose than code. Such projects can be entirely legitimate; they are simply unproven. Treat them as leads, not as validated tools.

Before adopting an entry, check it yourself:

Found something wrong? Open an issue or a pull request — removal is as valid a contribution as addition. Rules for AI-assisted work, project depth, and submission rate live in CONTRIBUTING.md.

• Classification & Routing — 68 entries
• Adaptive & Realtime UI — 11 entries
• Verification & Guardrails — 53 entries
• Scoring & Ranking — 43 entries
• Agent Decisions — 62 entries
• Data Labeling & Curation — 10 entries
• Evaluation & Benchmarking — 42 entries
• Calibration & Research — 51 entries
• Infra / SDKs / Integrations — 112 entries
• Game & Simulation — 26 entries
• Robotics & Physical — 9 entries
• Finance & Trading — 8 entries
• Compliance & Legal — 2 entries
• Content Moderation — 11 entries
• Related Practices / Discussions — 105 entries

• Scientific Pipelines — 0 entries

Each entry lives in exactly one category. When a project could fit multiple categories, we choose the one closest to its direct application domain.

• Classification & Routing (source)
• Adaptive & Realtime UI (source)
• Verification & Guardrails (source)
• Scoring & Ranking (source)
• Agent Decisions (source)
• Data Labeling & Curation (source)
• Evaluation & Benchmarking (source)
• Calibration & Research (source)
• Infra / SDKs / Integrations (source)
• Game & Simulation (source)
• Robotics & Physical (source)
• Finance & Trading (source)
• Compliance & Legal (source)
• Content Moderation (source)
• Related Practices / Discussions (source)

Optional tags on an entry name the coding agent it targets and the kind of integration it is. Most entries carry none — they are added only when the source itself supports the classification.

• Multi (24) — jev-router · Harness Router · Switchboard · JevRouter · decision-router · AgentConnect · jev-guard (leepokai) · jev-axi · jev-harness · Canny · jev-lint · Perch · jev-unpack-hook · Jev-Code-Reviewer · yoshi · public-browser · jev-agent-skill · hermes-jev-skills · Jevbridge · jev-use · jev-mcp (burnigtm) · typesafe-mcp · jev-style · Building with TypeSafe Jev
• Claude Code (17) — jev-skill-router · spending-effort-with-jev · sortwell · jev-seo · Sniff Test · claude-code-templates · jev-secret-guard · jev-retrieval · fast-jev-compaction · jev-belay · jev-pruner · SkillRanker · oh-my-claudecode · jev-opus · jev-auto-approve · lossless-compaction · jev-mod
• Pi (16) — pi-jev-router · pi-jev-skill-picker · pi-gear-router · pi-jev · pi-heed · pi-verdict · Reflex · pi-subagent-jev · Jev Deep Research · pi-typesafe-jev · pi-jev (TheoOliveira) · pi-quiet-ask · pi-fast-jev-compaction · pi-typesafe-router · mu · Testing Jev for Pi extensions (r/PiCodingAgent)
• Codex (6) — Codex Jev Router · Jev Auto Router · Foreman · fast-dev-compaction · jev-desktop · jev-browser-use
• DeepSeek Harness (4) — dsh-jev-interceptor · dsh-jev-plugin · dsh-auto-mode · dsh-jev-decide
• OpenClaw (2) — openclaw-jev-leakguard · openclaw-jev-trigger
• OpenCode (2) — opencode-jev-compaction · opencode-jev-pre-llm
• Cline (1) — Cline plugins

Source file: categories/classification-routing.md

• JEV Book Tags - Library cataloguing: a calibre plugin asks Jev Noul questions about book genres and subjects, applies configurable per-tag probability thresholds, and preserves existing tags while leaving uncertain results for review.
• Diffusion Jev - Visual classification: independent Jev-style DiffusionGemma/SGLang server that selects doodle and flower labels from image pixels with typed Choice questions and displays candidate scores in a drawing playground, with public evaluation artifacts and uncalibrated probabilities.
• Notra - Marketing analytics: production GEO platform whose NOTRA_JEV_CLASSIFIERS flag routes brand-visibility classifiers off an LLM and onto Jev Boolean decisions at a 0.5 threshold, targeting 300 ms p50.
• jev-router - Developer tooling: routes Claude Code tasks to the cheapest capable model by asking Jev to choose among candidates.
• jev-router (prismhq) - LLM infrastructure: open-source LiteLLM-based router where a Jev decision picks which model serves each request.
• pi-jev-router - Coding agents: adds automatic per-request model routing to the Pi coding agent through Jev decisions on Vercel AI Gateway.
• jcm-router - Coding agents: local proxy that picks the Claude model and reasoning effort per message with a Jev decision while leaving the cached main chat untouched.
• Codex Jev Router - Coding agents: asks Jev Choice and Noul questions about a short task summary to select a Codex subagent model and reasoning effort, with confidence thresholds and a Sol fallback.
• Jev Auto Router - Coding agents: per-call Codex GPT routing where Jev makes one typed Choice over host-available (model, effort) pairs; a local Responses proxy keeps the tool loop continuous, then independent verification and Router Compass record whether the task still passed (prototype).
• Harness Router - Coding agents: framework-agnostic tool router that keeps obvious calls on a fast path, uses Jev for genuinely ambiguous choices, and can apply bounded MCTS when multi-step consequences matter, with MCP plus Codex skill and hook integrations.
• GoEventBus - Event infrastructure: high-performance Go event bus whose optional routing layer evaluates deterministic rules, reuses cached decisions, then asks Jev a typed Choice to select the event projection only for ambiguous cache misses.
• jev-agent-skill-router - Agent infrastructure: routes agent skill selection through typed, confidence-aware Jev decisions so weak matches are declined instead of guessed.
• typesafe-jev CV screener - Recruiting: screens a folder of CVs with Jev typed judgments against an editable policy, re-scoring candidates for free when the policy changes.
• Jev email intent workflow - Back-office automation: async LangGraph workflow gets a typed Jev Choice (invoice or general) and routes each inbound email to the matching handler.
• DiffJury - Code review: routes each pull request by risk with Jev before a human reviewer is assigned, doubling as a review coach.
• HA-Jev - Smart home: Home Assistant integration that answers questions about the house as a probability, a choice, or a score.
• secondlayer - Fault triage: self-hosted Stacks data service whose Slack gate and fault-triage paths both run on Jev decisions.
• jev-logtriage - On-call operations: batches collapsed Loki logs into one Jev call of Noul, Score, and Choice questions, then maps answers in code to suppress, watch, review, notify, or page, with low confidence going to review and nothing executed.
• new-api-typesafe-plugin - LLM gateway: adds a native /v1/systemone endpoint to new-api so typed decisions sit behind the same gateway as chat models.
• duet-agent - Agent harness: keeps a Jev-backed routing table for deciding which model should serve a request.
• omo-jevlike-router - Skill routing: shrinks the skill catalog in a system prompt with one forward pass over a frozen Qwen, routing each request Jev-style.
• jev-cookbook - Developer education: 15 runnable Node recipes that route support tickets, file documents, categorize bank transactions and label Gmail with Jev Choice and Noul questions, sending low-confidence answers to human review.
• flue-jev-demo - Agent routing: routes a Flue agent's work with Jev through Cloudflare AI Gateway.
• DocJev - Document pipelines: LlamaIndex's open-source library that classifies a document against natural-language category rules or finds the boundaries between sub-documents, with swappable OCR backends (liteparse or LlamaParse) and a benchmark harness whose 40-document pilot classified 40/40 originals correctly at about 182 ms Jev decision p50.
• jev-fit - Developer tooling: hosted fit checker that sends a pasted software idea and a fixed typed rubric to Jev in one call, where a Choice picks plain code, Jev or a reasoning LLM behind a Noul gate for non-tasks, code vetoes Jev when the idea needs images, and low confidence returns "not sure"; closed source, free page and API.
• jev-skill-router - Coding agents: Claude Code plugin whose UserPromptSubmit hook asks Jev one Choice over the installed skill roster plus Boolean-style gates on whether any skill is needed, suggests a skill only when the gate and the per-candidate fit both clear 0.30, and defaults to a shadow mode that logs the decision without injecting it.
• Jev Wrapped - Media analysis: reads up to 1,500 posts from the last year of a public Telegram channel and asks Jev a Choice over ten kinds of post plus three Noul questions (paid ad, clickbait, emotional pressure) about each, counting an ad from 0.7, or from 0.4 when the kind is also ad, and clickbait and pressure from 0.5, then draws the monthly mix on a shareable card that links the highest-scoring posts for a manual check.
• Jev-Mail - Email productivity: runs a 24/7 Gmail classifier on user-owned Google Apps Script where Jev scores urgency, importance, and category, routing uncertain or suspicious mail to Review without a local daemon.
• AI-decision-maker - Data cleaning: asks Jev Choice questions to classify CSV columns into a 13-code type vocabulary and each dataset into one of six scenes, then executes every write locally; measured Jev at 6.6–12.7× an LLM's token cost on this task because the output is already one character while per-question criteria repeat.
• hearth-jev-rental-search - Housing search: autonomous multi-source rental search where Jev decides which listings match the criteria.
• pi-jev-skill-picker - Coding agents: ranks the Pi agent's installed skills against the current task with Jev before any of them run.
• Jevonian - Coding agents: local OpenAI/Anthropic-compatible proxy where one Jev call picks both the model route and the thinking level for jevonian/auto from session state, quota health, candidate capabilities, and cache-switch penalties, after deterministic code has filtered candidates and while pinned models, explicit jevonian/<route> requests, and routing.mode: "off" skip Jev entirely; minConfidence marks a low-confidence route in the ledger rather than accepting it, and the ledger records the serving model and why.
• Switchboard - Coding agents: open-source System One-powered router that automatically matches each Claude Code or Codex task to an appropriate model and reasoning effort, then keeps that choice stable for the conversation to preserve prompt-cache continuity; powered by Jev today, with Laya, Kev, and Cua-S1 coming soon.
• Tab Sorter - Browser tooling: Chrome MV3 extension that groups every tab in the window into named, colored Chrome tab groups from one parallel Jev call — one Choice question per tab against user-editable group criteria — with unclassified tabs falling to a fixed fallback bucket, manual groups untouched, and the pre-grouping tab order restored on ungroup; an optional LLM engine with self-invented group names is included for comparison runs.
• Feed Lens - Social media: uses Jev Noul judgments against per-platform, user-defined topic and expression labels to annotate Weibo, Threads and X posts directly in a Chrome extension.
• jev-table-import-mapper - Data import: maps an uploaded CSV's columns onto a destination table with a strict deterministic name-equality pass, then one Jev Noul per remaining (source, destination) pair plus a guard Noul per incoming column, mapping 10 of 10 columns of a 23-column export at 253 questions in one call, 915 ms, $0.0012, unmapped fields left visible above a 0.75 threshold rather than guessed.
• jev-oncall - On-call operations: asks Jev one call of four typed questions per alert (Noul actionable, Score severity, Choice owning team, Choice duplicate-of), pages on P(SEV1)+P(SEV2) ≥ 0.80 and drops only below 0.20 when actionability agrees, sends the band between to a human who has 15 minutes to ack before it pages anyway, links duplicates into a cycle-broken incident graph so two alerts can never silence each other, and falls back to configured severity on any error or timeout; a published 300-alert run measured p50 418 ms, p95 1477 ms and $0.04 per 1,000 alerts, with the slowest call landing 151 ms short of the 2 s timeout.
• Jevidence - Developer education: Python sandbox asks Jev Choice and Noul questions about issue category and reproduction steps in opt-in live mode, then applies confidence and reproduction gates to propose a queue or review fallback without assigning the issue, with synthetic offline fixtures and policy tests.
• JevBystander - Messaging: Android accessibility app that reads the visible WeChat chat window and answers one batched request of typed Choice, Score and Boolean questions to sort the peer's message into intent (10 options), an emotion distribution (9 options), urgency (0-3 Score) and a suggested reply posture (11 options), then shows exactly three toasts and takes no other action - no generated reply, no input injection, no screenshot or OCR, with a local alias-to-relation table passed as state so the same sentence is judged differently for a partner than for a colleague.
• langchain-skill-router - Agent infrastructure: per-turn skill routing for LangChain deepagents, where Jev ranks the SKILL.md catalog against the request and the recent conversation and verifies the top candidates, so only the picked skill's instructions reach the prompt; the judge is a protocol that a self-hosted model or static rules can implement instead.
• jev-rental - Consumer rental: sorts every claim in a rental listing into verify-on-site / demand-evidence / high-risk-pitch buckets to build a pre-viewing checklist with code-templated questions; 50-sample calibration reports 0.910 gated accuracy and 0/10 injection flips.
• jev-resume-disqualifier - Recruiting: knocks a resume out of a pipeline in under 25 ms by asking Jev the disqualifying question first, so only survivors reach a full evaluation.
• Jev-IOT - Smart Utilities & Telecommunications: Ultra-low-cost, non-autoregressive AI telemetry classifier enabling sub-150ms anomaly triage and autonomic remediation across 10M+ smart meters for under $35/month.
• AgentScope - Multi-agent platforms: multi-agent platform by Alibaba implementing native TypeSafe Jev classification models for binary, choice, and score routing across agent pipelines.
• inbox-zero - Email productivity: open-source AI email assistant that uses TypeSafe Jev System One decision models to classify incoming email intent and triage action items.
• SiYuan - Knowledge management: privacy-first personal knowledge management system featuring native Jev decision model integration for high-speed document classification, flashcard intent categorization, and automated tag routing.
• Paca - Project management: self-hosted open-source Jira alternative that auto-assigns tasks with a Jev Choice over member descriptions, fills blank task fields with Choice and Score questions, and routes automation workflows on a Choice/Score/Noul condition node, applying answers only at 0.6 confidence or above and otherwise leaving the task unassigned or taking the Else branch.
• Qualm - Digital wellbeing: macOS menu bar app that reads the screen as text through the Accessibility API and asks Jev (or Kev, its local open-source counterpart) one Choice per user rule plus a Noul on whether the page is a payment, login or banking screen, stepping in with a pop-up only when a rule's probability clears its threshold and never on sensitive pages; on 119 trial pages with Kev, the short-video, feed, livestream and video rules had precision 1.00.
• Auto-optimizing Jev: half the errors, 1/7 the cost - Text classification: asks Jev a Choice over the readings of a Chinese polyphonic character while the model stays fixed and only the harness around it is optimised, ending at half the errors for a seventh of the cost.
• spending-effort-with-jev - Coding agents: Claude Code plugin whose UserPromptSubmit hook asks Jev a Choice over /effort levels (low / medium / high / max / unclear) plus a Noul on whether a hands-off request has a fuzzy spec, showing a switch tip before Claude starts only at 0.7 confidence or above, with 95% of tips pointing to the right level on a three-rater held-out set.
• tab-jev - Tabular prediction: asks Jev a Noul on the target plus Score rubrics about each row's text, turns every option's probability into a column next to the row's numeric fields, and lets a tabular foundation model such as TabPFN learn from the labeled rows in context, reaching 0.745 AUC at 256 labels on Kickstarter funding against 0.682 for Jev alone with calibration.
• tinystruct-typesafe-sdk - SDK: TypeSafe Jev integration library for building type-safe classification and routing decisions with structured outputs.
• TetraJev - General decisions: locally-deployed decision layer for complex decision problems — four readings from two frozen open-weight readers, fused fit-free and routed by agreement with calibrated release gates; benchmarked across eight decision suites plus the RAG reranking pass, including DecisionBench's 35 real-world task categories. No training; does not call the TypeSafe API.
• sortwell - Personal inbox: MCP server and Claude Code plugin that files each captured note, link or meeting line with one Jev request of Choice questions for kind, project and next action plus a Noul for duplicates, routing to a project only at 0.45 or above and marking a duplicate only at 0.70 with a specific matching item, while the text itself is stored verbatim in append-only local files.
• jev-seo - Site audit: a Claude Code skill that crawls a homepage, has Jev judge page type, search intent, importance, trust and citability, and emits ranked fixes that each carry priority, impact, effort and a source while stating that scores rank work rather than predict rankings.
• IntentSQL - Natural-language SQL: turns a question about a SQLite database into a sequence of small Jev decisions instead of one generated query, released as an experiment alongside its decision lab.
• TypeSafe Conversation - Home automation: a Home Assistant voice agent built on Jev.
• Jevvie - Web companions: a page offers its actions as WebMCP tools and one Jev Choice picks the action a visitor's request means, with a Choice per argument asked alongside, asking back when the top two options are close and gating unprompted tips with a Noul (source).
• JevRouter - Coding agents: asks Jev a typed Choice over models, subagents, skills, MCP tools, CLIs and plugins, applies availability, permission and risk policies, and returns no_decision below the configured confidence threshold while preserving the original probabilities.
• Gut Check - Smart home: Home Assistant integration whose eight install checks ask Jev a Score on each pending update's release notes and a Choice per item elsewhere, such as whether an unavailable entity is expected, worth fixing or safe to remove; answers below 0.5 confidence change nothing, and the rest that need action become Repairs cards the user must confirm.
• Vibefilter - Admin panels: Filament table filter that asks Jev a Noul per row on a plain-English statement such as "The customer is angry." and keeps the rows at or above 0.8, matching the demo's own mood labels on 861 of 1,000 reviews at about $0.003 and one second per statement, with scores cached by content.
• decision-router - Coding agents: Claude Code plugin, Pi virtual model and CLI that pick the model for each task from one Jev call, a Choice over the candidates asked in both orders plus a complexity Score that sets a minimum tier, raising accuracy on 30 agent-labeled prompts from 73% with the Choice alone to 93%, with quota-aware filtering and a fallback below 0.3 confidence.
• Jev-driven SRE diagnosis - Incident diagnosis: runs with no LLM agent at all, collecting Kubernetes evidence for Jev to pick a root cause and its supporting observations, and passes 80 of 105 diagnoses across 21 faults at a median of 14.6 seconds.
• Jev for voice agent turn detection - Voice agents: has Jev decide when a caller has finished talking, cutting the share of turns where the agent interrupts its caller from 52% to 11% over the same 100 tasks.
• Kilo Code auto-routing - Coding agents: replaces an LLM call in the auto-routing path with a System One classification, merged into the Kilo cloud monorepo.
• SAP S/4HANA procurement fraud - ERP fraud: a proof of concept that flags suspicious purchase orders in SAP S/4HANA with a Jev classification.
• pi-gear-router - Model routing: has Jev score each request from 0 to 2 and cuts that range into five bands that choose a three-gear model tier and a thinking level, so a bare "continue" is not mistaken for a new task.
• AgentConnect - Team agent platform: asks Jev a typed Choice once at session start, not per message, to pick which coding-agent runtime and model runs the session, then chains follow-up decisions and pins the winner behind a 5-second deadline that falls back to the agent's configured runtime.

Source file: categories/adaptive-realtime-ui.md

• typesafe-adblock - Browser tooling: Chrome extension that asks Jev whether each DOM element is an ad, turning ad blocking into a stream of per-element typed questions.
• unclutter - Browser tooling: WXT extension where Jev decides per page element whether it is clutter, removing it under reusable template rules.
• sift - Content labelling: Chrome extension that labels every post in an X timeline - substance, humour, chit-chat, promo, junk, or AI-written - with Jev decisions.
• json-render - Generative UI: Vercel Labs' UI framework uses Jev in its compose path to pick which components and actions a rendered interface should contain.
• PlotVeil - Spoiler protection: Chrome extension that covers each YouTube comment while one Jev Noul question, batched 20 at a time, answers whether it reveals a concrete plot event of the video being watched or of another title the user protects, with the extension owning the 0.85 / 0.7 / 0.5 threshold and keeping the comment covered when the check fails.
• jev-canvas - Multimodal UI: draw on a tldraw canvas by voice while pointing a webcam-tracked finger; on every partial transcript Jev answers eight typed questions (is it a command, is the sentence complete, action, shape, colour, target, place, size) and plain code gates them with thresholds, in English and Ukrainian, 300–550 ms per decision.
• DWIM - Desktop productivity: a macOS command palette that reads the frontmost app's menu tree through the accessibility API, asks Jev one Noul per menu item against the user's plain-language request, and presses the top match when it clears a probability threshold, falling back to a ranked list otherwise and never auto-running destructive items.
• SemanticSpace - Semantic mapping: places phrases in 2D by asking Jev how strongly each one relates to two chosen axis concepts and using those scores as coordinates.
• shapeshift - Input: one text box that morphs into the right UI as you type, asking Jev which control the sentence calls for, and running offline.
• Jevcast - Desktop productivity: native macOS launcher and window manager that uses Jev to match natural-language window and action commands to known application workflows with local response caching.
• Laser - Focus mode: blocks distractions on an Omarchy/Hyprland desktop, using Jev to decide what to block.

Source file: categories/verification-guardrails.md

• jev-risk-check-provider - Agent payments: an x402 risk-check provider where Jev scores agent counterparties as typed Noul/Choice/Score questions into a code-controlled 0-100 score, issuing an ES256-signed attestation per verdict; 540-call scale run (99.76% at threshold 65-75, 0 false positives) and a 5-iteration 1,500-case adversarial red-team loop (100% adversarial accuracy) with ~$0.00005/decision at p50 ~400ms.
• Edward - Agent operations: one batched Jev Choice over the cross-turn coding-agent trajectory decides continue, pause, or escalate, with low-confidence verdicts routed to a human while deterministic code keeps dangerous-command blocking, budget caps, and an Ed25519-signed receipt chain.
• is-malicious - Software supply-chain security: asks Jev Noul checks about source and build files, escalates suspicious chunks for a second pass, and returns implicated files and lines before execution.
• jev-review - Software engineering: staged code-review workflow and local dashboard where Jev gates each review stage before a change advances.
• pi-jev - Agent safety: adds a measured tool-call gate to the Pi coding agent so risky calls are checked by Jev before execution.
• OpenWork - Engineering workflow: wires Jev into its eval testkit as a verification judge so agent-produced work is gated by typed verdicts rather than a text model.
• jev-guard (leepokai) - Agent security: prompt-injection and dangerous-action guard for Claude Code, Codex, Pi, and ACP agents, with Jev deciding what to block.
• Foreman - Software factory: sits above Codex workers and has Jev independently judge whether an implementation is complete, its tests sufficient, or a human is needed.
• stanley-code - Coding agents: bounded Jev workflows that keep agent judgments typed instead of free-form.
• opencompany - Agent workspace: runs its approval review through Jev so workspace actions are gated by a typed decision.
• jev-git - Developer tooling: sub-second Git pre-commit & pre-push reflex gate that screens staged diffs for secrets and destructive commands using Jev.
• pi-heed - Runtime constraints: checks every side-effecting tool call from the Pi agent against what the user actually asked for.
• Hunch (Kelbie) - Code review: plain-English rules that Jev checks code against, locally or on every pull request, with Jev picking one label per finding.
• Abide - Agent supervision: reads every edit a coding agent makes and has Jev flag rule violations, with the project reporting that an independent reviewer confirmed 10 of the 39 flagged edits and 11 of the 15 flagged turns.
• fx - Coding agent: ships a typesafe_permission_reviewer builtin so the agent's permission decisions run through Jev rather than an LLM call.
• Sniff Test - Writing: prose linter that asks Jev ten Boolean questions per paragraph (stacked hedges, restating closers, not-X-but-Y turns, naked cost figures) at a 0.7 threshold; CLI, pre-commit hook, GitHub Action and Claude Code skill; measured 182 ms median and 1 of 54 clean paragraphs flagged against 37 for Haiku 4.5.
• jev-pref - Code review: turns the preferences in a project's AGENTS.md into jev-pref.json rules that Jev checks against each diff hunk, staged file set, or pull request, returning fix_now or advisory findings to the coding agent and a nonzero exit code on blocking ones.
• jev-axi - Agent safety: PreToolUse gate for Claude Code and Codex that has Jev score each shell command for destructiveness, exfiltration, remote code execution, and security weakening, deciding routine commands locally so nothing is sent for them, and scoring 44/44 on the 44 labeled tool calls in its repository.
• pi-verdict - Agent safety: Pi permission gate where Jev answers one Choice (allow/ask/deny) per gray-zone tool call — deterministic rules settle clear cases first, deny blocks, ask escalates to a human confirm, and errors or timeouts deny; Jev is an optional backend, experimental, reached through OpenRouter or TypeSafe's direct API.
• jev-commit - Developer tooling: pre-commit hook where one Jev call judges whether the commit message matches the staged diff, flags debug leftovers and unmentioned work, and blocks only on a detected credential.
• Blink - Code review: CLI that coding agents run after every change, with Jev checking the diff near-instantly in place of an LLM reviewer.
• hermes-jev-approvals - Agent approvals: proof of concept that puts Jev in front of Hermes Agent's command approvals, reporting 8.7x faster decisions and 4.4x fewer prompts to the user.
• taste-lint - Writing / UI: CLI that uses Jev probabilities on semantic taste checks to catch AI slop in UI, copy, and agent instructions before ship; measurable rules stay local and active findings can fail a run.
• jev-engineering - Agent safety: gates coding-agent tool calls with deterministic rules first and one typed Jev call second, then publishes a rerunnable 300-call injection test showing what the gate catches and what walks past it.
• jev-harness - Developer tooling: System 1.5 quality gate and token optimizer for AI coding agents that triages test failures in < 500 µs to resolve missing dependencies without frontier LLMs, aborts circular doom loops, and modulates reasoning effort across Python, TypeScript, and Rust.
• Reflex - Coding agents: Pi-based coding agent that sends each state-changing tool call through one Jev request of five Noul risk checks plus a risk Score, maps the answers in code to allow, ask or block by the user's risk setting (protected paths always ask), and also uses Jev to pick the model tier per prompt and to send back "done" claims that ran no verification, at about 400 ms per decision.
• r2r-jev - Agent governance: asks Jev two Noul checks per tool call (beyond scope, destructive) and admits each judgment as Evidence that can degrade Trust, Delegation, and Authorization until a human override repairs the relation, so later calls inherit the history; includes a stateless-vs-stateful comparison with a scenario adversarial to persistence.
• GeekLink Jev Subtitle Translator - Subtitle translation: asks Jev a Noul review question for each translated subtitle line to flag omissions, changed meaning, names, numbers, negation, or other defects for human review before export.
• TryJevAI - Scheduling: public Jev playground uses a typed Choice with an explicit Unresolved option to distinguish a mentioned arrival time from an agreed meeting time, showing the returned probabilities and prompting for missing agreement before treating a time as settled.
• Agent Chaperone - Agent safety: MCP proxy plus hooks that screen a tool call before it runs and a tool result before the agent reads it, with 45 test files behind it.
• jev-proof - Creator sponsorship: verifies each sponsored ad segment in video subtitles against acceptance rules with one Jev Noul+Choice call per fact while deterministic code keeps the confidence gate; 90-sample calibration reports 0.922 gated accuracy and 0/15 injection flips.
• jev-fidelity - Editorial QA: asks Jev per fact unit whether an edit preserved the original (preserved / equivalent / drift / lost) behind a 0.70 confidence gate in code, degrading to human review rather than pass; 55-sample calibration on real Wikipedia revision diffs reports 91/92 gated judgments correct and 0/20 injection flips.
• approval-judge-bridge - Agent safety: OpenAI-compatible /v1/chat/completions proxy that gates an agent's shell commands through a calibrated Jev Choice decision with fail-closed semantics.
• Dub - Link safety: calls typesafe-ai/jev in malicious-link-check.ts before a short link is created, so the URL is gated by a typed verdict rather than a blocklist.
• Canny - Agent verification: stops AI coding agents from claiming work is done without evidence by using deterministic hooks and TypeSafe's Jev advisor to evaluate test results, file diffs, and verification logs.
• JevGate - Code review: CI and coding-agent gate that parses code locally and asks Jev Noul, Choice and Score questions about one function, file outline, candidate copy pair or test at a time, turns answers at 0.80 into review or consider findings with file and line, fails the build on review, and keeps undecided files as uncertain instead of clearing them.
• dsh-jev-interceptor - Coding agents: DeepSeek Harness plugin where a Jev Choice risk class plus Noul irreversibility, task-match, and injection checks gate every non-read-only tool call (deny confident high-risk, ask ambiguous, delegate the rest), Noul scope and reversibility questions auto-approve clearly-granted calls behind argument-evidence gating, and a per-message Score re-ranks what a referenced session keeps instead of oldest-first dropping — fail-closed to stock behavior, shadow mode with a /jev-stats command, 64 tests.
• claude-code-templates - Agent safety: CLI configuration suite for Claude Code featuring a jev-guardrails mod that screens prompts and turns against jailbreaks, harm, and policy breaches via TypeSafe System One.
• jevci - Quality gate: asks four typed questions about each change — three Score lenses and one Noul — and blocks a diff, commit message or doc set that falls below the resulting quality score, from the terminal, a pre-commit hook or a GitHub Action.
• pi-subagent-jev - Agent governance: when the Pi main agent dispatches a subagent, evaluates the task text against configurable rule sets in one typed Jev call (per-rule probability questions with below/above thresholds), blocks the dispatch with per-rule reasons on any hit, and fails open to allow on errors.
• jev-lint - Software engineering: uses Jev Noul judgments and local thresholds to flag team-rule violations as Claude Code and Codex edit, helping agents fix them before code review with configurable rule packs and repository-specific rules.
• jev-secret-guard - Agent security: Claude Code PreToolUse hook that blocks known key formats locally and sends unknown high-entropy strings to Jev only in masked form for a Noul on whether they are real credentials, blocking at 0.80 and asking the human from 0.30 or whenever Jev is unavailable; 6 of 6 secrets and 0 of 6 benign strings were blocked in its published calibration.
• Perch - Code linting: semantic code linter that asks Jev about each method with its callers and callees in view, a Noul for whether it has a bug, a Choice for which kind and which line, and a Score for severity, plus language-filtered CWE Noul checks and custom rules written as sentences at repository, file or method level, failing CI on any answer over its floor.
• semcheck - Code review: Go linter whose rules are plain-English questions such as "does this log call write personal data?", asking Jev one Noul for each piece of code a rule applies to and reporting it above the rule's threshold; its two shipped rules were right on 12 of 12 sampled findings in three open-source projects.
• Cribrix - Retrieval / RAG: filters retrieved chunks with a Jev Score plus Noul checks for answer evidence and prompt injection, then withholds any draft whose claims fail a batched per-claim Noul or cite numbers absent from the sources; on its replayed 62-question golden set it answered 0 of 22 unanswerable questions, against 4 of 22 for naive top-5 RAG.
• Skill Scanner - Agent security: Cisco's scanner hunts prompt injection and exfiltration in agent skills, and ships a System One analyzer as a deliberately advisory tier that cannot emit a finding or change a severity.
• openclaw-jev-leakguard - Agent security: OpenClaw plugin that checks every outgoing agent message against where it is going, running local key-format and term rules and then five Jev Noul questions in one call (credential, where credentials are kept, client name, internal infrastructure, confidential business information) through OpenClaw's decisionModel, hosted Jev or a local Kev, and blocking, asking or holding it back by the channel's public, shared or private tier; with Jev it missed 0 of 56 synthetic leaks, 30 of which no regex or term list could see, with 4 false alarms on 57 ordinary messages at 223 ms p50.
• jev-runtime-security - AI security: asks Jev a Choice on tool-call argument risk and a Noul on sensitive-data exposure for AI coding agents, where the model answer can only raise severity and the kernel still decides the syscall.
• NucleiSniper - Security triage: prioritises Nuclei vulnerability templates by fingerprinting the target first, so a scan spends its budget on templates that can actually match.
• local-decider - Agent safety: a pre-action gate for a tool-using browser agent that runs a deterministic rule chain first and only asks Jev where no rule decides — anything a rule can settle is never sent to weights — emitting allow / confirm / block and swapping between hosted jev-latest and a local Jev-compatible port by one environment variable; on 112 labelled cases the rules alone resolve 61 and are correct on 58 (95.1%) with 0 false allows on irreversible tools, and the end state is read from the DOM rather than from the agent's own report.
• jev-unpack-hook - A Jev System One hook for CodeX & Claude Code that detects overloaded multi-topic multi-ask agent messages and paces conversations one ask at a time, adding useful context and info.
• Lisa - Code review: GitHub Action that asks Jev four Noul questions about each chunk of a pull request diff (adds a secret, introduces a vulnerability, adds unneeded complexity, tries to manipulate an AI reviewer) plus a Noul on whether look-alike files duplicate each other, failing the check at a configurable threshold (default 0.5) and commenting on the exact line, with repository-defined Noul, Choice, and Score questions in .lisa.toml.
• Using Jev in Domain Abuse Review - Production workflow: asks one Noul whether a domain name refers to a protected brand, keeping the TLD out of the input so it cannot skew the answer and scoring a second-level domain once even when it spreads across TLDs.

Source file: categories/scoring-ranking.md

• Clean Code Judge - Code quality: scores every file of a pull request on 31 boolean Clean Code smells plus function size and nesting, then hands the verdicts to a writing model for the review prose.
• citation-verifier - Academic publishing: 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 final call.
• jev-assist - Coding agents: ranks every tracked file by relevance to a one-line task description — Jev asks each file the same typed question in parallel batches, so an agent in a 600-file repo starts from the handful it actually needs — with a validate command that grades the ranking against past commits.
• jev-ai-detector - Writing analysis: Chrome extension which gives readers an instant, uncertainty-aware signal for how strongly selected webpage text resembles AI-generated writing, using Jev inline in Chrome without interrupting reading.
• jev-bfs - Search tooling: finds link paths between English Wikipedia articles by having Jev rank each page's outgoing links while Python controls the search.
• Jev Search - Web search: uses Jev Noul judgments on result titles and snippets to rank Search1API results by relevance, with application code merging duplicate URLs and grouping lower-scoring matches separately.
• Tweet Radar - Social reading: uses Jev Noul to score already-loaded X posts against a reader's goal and profile, then pairwise Choice judgments to rank eligible matches and surface up to three for review.
• pagegrade - Content quality: grades page sections for clarity, writing, and on-page SEO with Jev and returns per-section scores.
• jev-scout - Developer tooling: sub-second zero-hallucination open-source repo and crate scout using TypeSafe Jev speculative fan-out scoring.
• jev-seo - Zero-cost, agent-first SEO & Generative Engine Optimization (GEO) search radar CLI suite and MCP server powered by DuckDuckGo and TypeSafe Jev System One.
• JevSlop - Writing quality: scores public note.com articles on eight Jev Score axes inside a single systemOne request and turns them into a 0-100 Slop Score in ordinary TypeScript.
• Supercov - Code quality for coding agents: Jev answers twelve Noul properties per source file so the agent knows what to fix first.
• jev.nvim - Developer tooling: Neovim plugin that splits the buffer into functions with Treesitter, scores each against a plain-language question with Jev, and ranks answers by probability in quickfix.
• Jev RAG - Retrieval and RAG: shortlists local document passages with BM25, reranks up to 30 candidates through one batched set of Jev Noul relevance questions with an optional threshold, and passes the strongest evidence with source citations to a configurable answer model, backed by a runnable local demo and a public 323-query NFCorpus benchmark.
• jev-reranker - Retrieval and RAG: uses Jev Noul judgments to assess retrieved documents for relevance and usefulness as answer evidence, then sorts results and optionally filters them using a configurable threshold.
• Jev Reranker (Rust CLI) - Retrieval and RAG: JSON-in/JSON-out CLI that uses separate Jev Noul checks to rank candidates, apply evidence thresholds, or extract source text while keeping those decisions independent.
• jev-skip - Media: browser extension that reads the YouTube caption track and scores each segment's sponsor probability on the seek bar before the intro ends, reporting 77% of SponsorBlock's sponsor seconds caught over 23 videos at $0.0008 a video.
• jev-semgrep - Semantic search: greps by meaning across languages, having Jev score every line against a meaning and letting meanings combine with AND, backed by a 13-file test suite.
• nlgrep - Developer tooling: uses Jev Noul judgments to find code, docs, logs, and text satisfying natural-language conditions, with a configurable probability threshold and ranked file results linked to source lines.
• JevPDF - Document search: in-browser PDF viewer that extracts each page's lines locally with pdf.js and asks Jev one Noul per line on whether it answers the query (16 lines per request, sharing the page text as state), highlighting lines at or above 0.55 page by page and ranking them by probability.
• slop-grader - Content quality: CLI tool that grades text files against custom rulesets for AI slop, grammar, and technical doc quality using Jev scores and line-level flags, then guides an AI agent to auto-fix violations.
• jselect - Research and retrieval: selects source-linked evidence within a token budget using Jev Noul relevance judgments and local diversity-aware selection.
• Jev Deep Research - Evidence retrieval: uses Jev Choice to locate source lines and Noul to check evidence presence across document regions in parallel, then returns original passages to a GPT research agent through Pi-Serini with 20/40/60-document batch limits.
• jsort - Text measurement: ranks text along a plain-English criterion using pairwise Jev Noul comparisons and a locally fitted Bradley-Terry scale.
• jgrep (kyu1204) - Developer tools: semantic grep that asks Jev one Noul per 5-60 line code chunk, diff hunk or CSV row (16 per request) and prints grep-style file:line hits above a threshold, so English sentences work as CI lint rules.
• jev-resume-screening - Recruiting: screens one resume against a JD in a single request of five Noul evidence gates, four Score dimensions, and one background-routing Choice, with criteria hardened v1→v3 against negative-control resumes (a glossy-trap CV's self-described "AI heavy user" fell 0.95→0.49) and any low-confidence answer escalated to human review.
• hippo-memory - Agent memory: a biologically-inspired memory store whose optional Jev reranker lifts recall R@1 from 0.41 to 0.62 on a private 300-query developer store.
• MemSearch Jev reranking - Coding-agent memory: an optional Jev reranker asks Noul questions about retrieved Markdown chunks and sorts them by relevance to the query, with bilingual evaluation results.
• Oko - Developer tooling: local code search for coding agents that shortlists function-level chunks with ripgrep and BM25, asks Jev a Noul relevance question per chunk across three parallel requests, and returns the accepted ones as excerpts through MCP; the cutoff and excerpt selection live in code.
• grokbot-jev-jobs - Job search: a daily Vercel cron that scores public job postings against one resume with Jev through the Vercel AI Gateway, so only the plausible matches surface.
• jeff - Developer tooling: Go CLI whose rank command asks one Jev Score per item per weighted dimension of a YAML spec in a single request and sums weight times score in code to order the items, with noul, choice and score commands that turn a threshold into exit code 10 for shell scripts and CI.
• Paper Radar - Research: scores every new arXiv and bioRxiv paper against plain-English interests with one Noul each and publishes the top picks as a daily page and RSS feed.
• Refix - Growth: asks Jev a Score over each experiment result to decide whether it clears the promotion bar, and a Choice over candidate plays to decide what to run next in SEO, content, and ads.
• OpenViking - Reranking: Volcengine's agent context database ships a Jev rerank client that scores each candidate document with jev-latest against api.typesafe.ai and treats the returned probability as relevance, because TypeSafe exposes no native rerank endpoint.
• jevsearch - Site search: shadcn/ui command-palette block that streams keyword hits on the first keystroke, then sends the top 20 to Jev in one request (a Noul per page on whether the visitor would be glad to land there, a Choice for the single best answer, and a Noul on whether any page answers at all) and re-orders or drops hits in code, with the repo's own benchmark over the 109-page TypeSafe docs reporting Hit@1 of 83% against 41% for its keyword pass alone.
• jev-retrieval - Coding agents: Rust CLI (jevr) that turns a natural-language query into grep-style path:start-end targets — a stateless local BM25 pass proposes candidates, Jev Noul membership questions score their 100/20-line windows (kept at 0.90 for code, 0.60 for docs), and one listwise Choice per lane orders the keepers — ships as a Claude Code skill and plugin, and placed 2nd of 90 models on the HAKARI-Bench NanoRTEB reranking leaderboard.
• Vector Graph RAG - Multi-hop retrieval: uses Jev Noul judgments to select graph relations and rerank full source passages alongside vector-search candidates, achieving 86.07% average Recall@5 across 1,000 MuSiQue and 1,000 2Wiki queries in the two-stage evaluation.
• Jev-Code-Reviewer - Code review: asks Jev for a priority score per changed unit and returns a priorityGap that a local uncertainty policy turns into the order a human should read the hunks in, while OpenAI explains the ones that surface.
• WorldMonitor - Geopolitical intelligence: real-time global intelligence dashboard using TypeSafe Jev questions to score news headline severity into 5 threat levels and categorize events across 14 conflict, cyber, and infrastructure domains.
• LinkScout - Web search: browser extension that asks Jev, in one request per result, for relevance and depth Scores, Nouls on SEO filler and sales pages, a page-type Choice and a Choice over pre-split paragraphs for the key passage, then combines them in code into a 0–100 badge that re-ranks Google, Bing and DuckDuckGo results.
• Chem Autocomplete (ChemIllusion) - Chemistry: uses Jev to rank which RDKit-validated sketcher structure candidates to show as autocomplete cards and in what order (~0.2s per request).
• dsh-jev-plugin - Coding agents: asks Jev a Noul for each skill summary or original glob path, orders candidates by the returned relevance probability, and supplies the selected skills or ranked paths to DeepSeek Harness, with all features disabled by default.
• JevRanker - Retrieval and RAG: an open-source port of Jev's typed-decision format (NanoJev's Qwen3-0.6B, trained on T2Ranking, no hosted API call) that replaces the LLM comparator inside two published search rerankers, BlitzRank's tournament graph and Reranker-Guided Search, where each match is one Choice scored over k candidate paths in a single forward pass with zero decoded tokens, reaching 0.6309 nDCG@10 on T2Ranking dev against 0.2162 for the same 0.6B decoding a RankGPT listwise prompt, at 34 ms instead of 752 ms per match and 8.6-9.4x lower per-query latency inside RGS.

Source file: categories/agent-decisions.md

• Learn Jev end to end - Developer education: a 12-notebook Python course whose hand-rolled agent loop asks Jev a Choice (allow / ask / block) with Noul irreversibility and exfiltration checks before every tool call, sends ask verdicts to a human and fails closed on errors, and adds a Choice model router with a confidence fallback and a Noul "am I done?" gate, each measured against labeled fixtures.
• Hermes JIT Context OS - Coding agents: uses Jev as a sub-millisecond System 1 Epistemic Gate and Domain Router to score AST relevance, test proofs, and tool targets, cutting autonomous agent turns by 31.3% and blind file exploration by 52.6% on SWE-bench with fail-open circuit-breaker resilience.
• Jev by Example - Agent development: runnable JavaScript lessons use Jev Choice, Score, and Noul judgments for memory reconciliation, recovery proposals, and handoff checks, with explicit application policies, offline fixtures, and opt-in live calls.
• jev-social - Social media research: uses a Jev Choice at each step to select a concrete socai CLI operation and observed post or profile target on Instagram, TikTok, or LinkedIn, rejecting malformed or low-confidence decisions before execution.
• Jev Ultrafast - Browser automation: browser-use's ultrafast agent where Jev decides each next action and element to click, calling a language model only when text must be typed.
• jev-agent-browser - Browser agents: a parent agent delegates bounded tasks to a Jev loop that selects typed browser actions, validates them through agent-browser, and escalates ambiguity or stuck states back to the parent.
• pi-typesafe-jev - Coding agents: exposes System One judgments as five Pi tools so a model makes narrow semantic judgments while code and users keep control of thresholds, weights, and actions.
• jev-judgment - Coding agents: agent skill that sends closed coding-agent judgments to Jev so verdicts stay typed, cheap, and comparable across runs.
• limpet - Coding agents: Stop hook that keeps an agent from finishing too early by judging plain-language completion rules with Jev.
• dsh-auto-mode - Coding agents: DeepSeek Harness permission preset whose end-prompt step 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 an autonomy-safety Noul clears 0.5, and returning the turn to the human otherwise.
• augustus - Coding agents: independent augustus and augustus-train skills for application-specific decision models, covering primitive/base-model/method selection, data assembly, fitting, export/reload, bounded improvement and independent evaluation, with TypeSafe Jev as the default hosted exemplar.
• yoshi - Context management: proxy for Claude Code and Codex where Jev judges which conversation history is still needed before pruning.
• pi-jev (TheoOliveira) - Coding agents: semantic tool routing and typed System One decisions for the Pi coding agent.
• pi-quiet-ask - Coding agents: gives the Pi agent a quiet Jev decision layer for judgments it would otherwise hand to a chat model.
• fastbrowse - Browser agents: Jev picks each action from what is on the page while an LLM reads and plans.
• super-jev - Decision harness: turns a Jev answer into a bounded action instead of leaving the caller to interpret it.
• jev-superpowers - Coding agents: software development framework for AI coding agents that hands package vetting and completion gates to Jev typed decisions.
• Jev Browser - Browser automation: drives a browser with Jev deciding each step, pitched as fast and very cheap next to LLM-driven browsing.
• pi-fast-jev-compaction - Context management: Pi extension that keeps conversation text verbatim while pruning stale tool history with Jev, falling back to Pi's own summarization only when pruning cannot free enough room.
• Atomic - Coding agent runtime: ships a first-class Jev structured-output provider so an agent's decisions come back typed, through the same decision resolver as its other providers.
• fast-jev-compaction - Context management: Claude Code plugin that replaces the compaction summary with Jev decisions, scoring every tool call and result for whether it is still needed instead of summarizing the session.
• fast-dev-compaction - Context management: Codex port of the Jev-guided compaction idea, restoring context verbatim around a session compaction rather than summarizing it.
• public-browser - Browser control: lets Claude Code and Cursor drive a real Chrome profile, with a Jev loop deciding the actions, reporting roughly 30% fewer tokens and 25% lower cost.
• pi-typesafe-router - Coding agents: routes Pi's work through typed Jev decisions.
• wakegate - Long-running agents: before a sleeping agent's LLM is resumed on a timer or incoming event, Jev answers a Choice (wake, not yet, unrelated) against the agent's own sleep note, and code skips the wakeup only when wake is below 0.2 while always waking on user messages, bare timers, a skip limit, errors, and timeouts; one run passed 21 of 21 hand-written scenarios, which the README calls a smoke test rather than a benchmark.
• BrowserClaw - Browser automation: Zero-lock, session-preserving Chrome MCP server that couples a local Jev System One semantic micro-loop (chrome_act_toward_goal) with an 85%+ pruned DOM tree (Shadow DOM & iframe pierced), dispatching native CDP events (isTrusted: true) on active logged-in sessions without focus theft.
• jev-belay - Coding agents: Claude Code Stop hook that reads the transcript for evidence and spends one four-question Jev call only when files changed with no passing check since, failing open on any error.
• Jev for Chrome - Browser automation: unofficial Chrome extension port of Jev Ultrafast where a Jev Choice picks the operation and DOM element each step and two Noul checks (goal reached, stuck) veto a premature DONE or BLOCKED, with a small text model used only when text must be typed.
• jev-pruner - Context management: Claude Code plugin that trims long Bash output with Jev before the model ever sees it, keeping terminal noise out of the window.
• jev-desktop - Computer use: supplies Jev action selection inside Codex Computer Use, choosing among desktop actions rather than asking a language model at every step.
• jev-agent-skill - Developer tooling: Claude Code/ZCode skill that offloads classify/route, batch-screen, score, and compliance-check judgments to Jev via OpenCode Zen's free tier, bundling a zero-dependency jev.py caller (transient-500 retry, WAF-safe UA, GBK-pipe-safe stdin) and a production Taobao-shop comment-triage pipeline that keeps raw items out of the agent context.
• Yappy - Computer use: macOS voice agent that asks Jev one Choice per step (operation and target control) over the front window's accessibility table, executes only validated high-confidence answers, and escalates to a full LLM agent on low confidence, no-effect actions, or unknown field values; author-reported 275–690 ms per decision.
• JevLoop (zjunlp) - Agent harness: routes the loop's own judgements to Jev, where a Choice picks the next tool from candidates rebuilt every step, a Score grades the call's risk, and a Noul decides whether it needs authorisation, while plain code acts on the answers so a high risk score forces human authorisation that no probability can override (7.7% of wall clock with the offline judge, 79% over the hosted API).
• JevLoop (parkavenue9639) - Agent runtimes: a Python runtime where Jev Choice decisions select tools and targets, uncertain decisions escalate to an LLM, and a shared guarded kernel supports isolated Docker workspaces and paired LLM-only comparisons.
• DataJev - Data analysis agents: an LLM performs Python-based analysis while Jev reads the compressed analytical state and decides whether the agent should continue the current direction, switch to another one, verify a finding, or stop and synthesize the answer.
• jev-mobile - Mobile control: fast structured Android control loops that route each step through Jev alongside Mobile MCP, with 35 test files.
• GUI JEV Harness - Computer use: recursive screenshot grounding where Jev returns a Choice over grid-tile candidates at each level, and local probability and margin gates decide whether to descend or refuse, emitting only a raster point and bounding box and never clicking.
• jev-compaction - Context management: standalone agent context compactor where Jev only scores transcript segments — kept lines stay verbatim, low scorers move to a store behind an expand() pointer instead of being deleted, and the append-only frozen prefix keeps the prompt cache valid; runnable offline demo, no API key needed.
• Visual-JEV - Multimodal models: Jev-style model built on Qwen3.5-4B that takes images directly, without first converting them to text.
• DeepSearcher stopping-policy experiment - Agentic search: a standalone evaluation uses Jev Noul judgments on accumulated evidence to decide whether to stop or continue within a search-round budget, comparing stopping behavior, evidence recall, and decision cost.
• neo4jev - Graph navigation: navigates a Neo4j knowledge graph hop-by-hop using Jev Choice over candidate outgoing relationships and Noul to detect goal completion, using beam search over answer log-probabilities.
• jev-chat - Messaging: an Android accessibility service reads the visible QQ, X, Feishu/Lark or WhatsApp conversation, one Jev request asks Choice questions on intent, needs and next action, a Score for danger and Noul checks on subtext, substance and tension, then one more Choice ranks three replies drafted by a separate chat model, and the app fills the pick into the input box while sending stays manual.
• hermes-jev-skills - Agent runtime: a Jev-powered skill suite that decides model routing, memory, compaction, skill selection, and computer or browser use for Hermes agents, and also installs under Claude Code and Codex.
• jev-browser-use - Browser automation: lets Jev pick the click while Codex thinks and verifies, reporting 5-10x faster browser operations behind four CI-run contract tests on the bridge.
• mobile-jev - Mobile agents: puts Jev into on-device screen-aware action selection for the Droidrun loop, with a Jev Studio web app streaming live device and decision telemetry.
• Jev-cu - Computer use: drives a GUI through Jev decisions with a jev-decide script and ships a P0 case set taken from accessibility-tree snapshots of a calculator, a calendar, and the NetEase home screen.
• SkillRanker - Coding agents: standalone Rust CLI that uses Jev to rank candidate skills against live session context, advising the next step through a Claude Code UserPromptSubmit hook.
• AutoGPT - Autonomous agents: open-source autonomous agent platform featuring first-class TypeSafe Jev decision blocks for typed routing, filtering, scoring, and confidence-gated next-action dispatching.
• dsh-jev-decide - Coding agents: DeepSeek Harness plugin whose single jev_decide tool lets the agent ask a Noul, Choice, or Score question about any state — urgency triage, intent routing, guardrail checks — and gate on the returned probability or confidence in code instead of trusting the chat model's guess.
• jev-browser-bridge - Browser agents: plugs any CDP browser into a Jev loop, where a Jev Choice picks the operation and its target element each step from candidates read off the DOM rather than the layout, so the same agent runs on Chrome and on engines that never draw a page (Moli, Lightpanda, Kitesurf), passing at least 90% of runs on each of fourteen browsers tested.
• Eliza - Autonomous agents: multi-agent framework integrating TypeSafe System One decision services for sub-100ms intent classification, action dispatching, and confidence-gated tool execution.
• oh-my-claudecode - Coding agents: multi-agent team orchestration for Claude Code featuring opt-in Jev hooks for sub-millisecond judgment points, decision caching, and per-point egress controls.
• jcode - Agent runtimes: RAM-efficient autonomous agent harness implemented in Rust with native TypeSafe Jev typed decision transport for memory pruning, browser navigation, and voice interaction routing.
• opencode-jev-compaction - Replaces OpenCode compaction summaries with Jev keep/drop judgments that prune stale tool calls while preserving everything kept verbatim.
• jev-opus - Coding agents: runs Claude Code on Opus 5.5 and asks Jev a Choice, a Score and a Noul on each prompt and after every tool batch to pick the next API call's reasoning effort (low/medium/high), sent as a per-message statement so the prompt cache never breaks.
• jev-auto-approve - Coding agents: Claude Code PreToolUse hook that asks Jev a Noul on whether a shell command is strictly read-only, auto-approving at 0.95 and otherwise falling back to the normal permission prompt without ever denying, while a local hard-no list and injection filter keep risky commands from reaching Jev; 0 of 8 state-changing commands were approved in its published calibration.
• WebJev - Browser agents: open-weight Apache-2.0 decision model (a Qwen3.5-35B-A3B fine-tune) that answers jev-ultrafast's per-step Choice questions for the next operation and its target element behind the same /v1/systemone API, completing 38.5% of 125 hand-picked real-website tasks graded by deterministic verifiers versus 16.7% for Jev 1.13 in the same agent.
• laya-browser-agent - Browser agent: derives each step from a Jev-shaped model — Laya through MLX or PyTorch, any duck-typed backend, or an arbitrary System One HTTP endpoint.
• openclaw-jev-trigger - Agent automation: OpenClaw plugin and CLI that turn a plain-language --when / --not-when condition into a scheduled trigger script, asking Jev one Noul per tick through OpenClaw's decisionModel and waking the conversation model only when the condition becomes true at 0.7 or above; on 76 synthetic watcher ticks Jev was right on 75 with 0 false wake-ups at 231 ms p50 and about $0.000016 per check, against 87% for first-try JavaScript rules.
• Sedum - Browser end-to-end testing: in goal mode each turn asks one Jev Choice for the next operation (click, type, done or blocked) plus a speculative target among the page's offered elements, capped at 24 requests, 18 actions and 120 s, and the test passes only when an independent verify claim clears two Nouls (holds ≥ 0.75, contradicted flagged at ≥ 0.5), since the planner's done is never a verdict; authored-step tests reuse the same Choice to resolve each plain-English step, and with your own API key a 20-person team's PR suite costs $38–$91 a month vs $4,875 on a per-step AI platform.
• mu - Coding agents: a pi-based coding agent and desktop app that asks Jev Noul, Choice and Score questions at 38 decision points inside its loop, such as which chunks of a long tool output enter the context, whether a rule-flagged command was actually asked for, whether a fetched page or MCP result carries instructions aimed at the model, and whether a "done" was verified, with each point set to active, shadow or off and every verdict written to a local ledger; in the repository's replay benchmark, goal-aware test-log selection by Jev cut 40-46% of the log without losing a required line.
• lossless-compaction - Context management: Claude Code plugin that compacts by moving old tool results to local files with no summary, and asks Jev a Choice over what was moved out to fetch one back by a question in words.

Source file: categories/data-labeling-curation.md

• jev-align (Sutro) - Dataset engineering: evaluates CSV, Parquet, and JSONL rows with Jev Choice, Score, or Boolean decisions, sends ambiguous and audit samples to a human, and uses accepted human labels to optimize the saved definition with GEPA.
• jev-curate - Dataset engineering: sifts synthetic JSONL and Parquet rows using Jev Noul checks and calibrated confidence scores, streaming passed records and rejections straight to disk.
• typeful-triage - Open-source maintenance: multiplayer triage dashboard where Jev answers a fixed set of typed questions per issue — kind, severity, urgency, duplicate, and next step — and every human correction is kept and shown back to the model on later runs.
• jlink - Research data: links records under a plain-English match rule using Jev Noul pair judgments, with local candidate blocking and match resolution.
• jgrep - Data filtering: filters text, structured records, functions, and diff hunks against plain-English descriptions using Jev Noul judgments.
• jevgrep (allebee) - Log triage: filters logs and other text streams, including live tail -f output, by asking Jev one Noul per line against a plain-English question and printing lines at or above a probability threshold, with a hand-labelled benchmark against Claude in the repository.
• jev-research-pipeline - Research monitoring: asks Jev Noul gates and Score dimensions per (paper, research question) on each daily fetch through Pydantic AI's typesafe model, keeps sources above a code-side threshold, and hands them to Qwen for question-centric Obsidian notes; offline tests replay recorded cassettes.
• GroundingJev - Visual annotation: a Jev-inspired Qwen3.5-0.8B model that maps an image and referring expression to four bounding-box coordinates in one forward pass, reporting an 8.61× inference speedup over its autoregressive base model.
• jevextract - Information extraction: LangExtract alternative where code proposes candidate spans with exact offsets and Jev answers one Choice per span (a schema class or none) plus a Noul per sentence-level class, keeping answers above a per-class threshold and flagging close calls for review, with a published benchmark measuring 10–26× lower cost than LangExtract on Gemini 3.5 Flash but lower F1 (84.2 vs 88.5 on its bilingual jx-bench).
• JevSpan - Information extraction: zero-shot named entity recognition that splits text at punctuation, asks Jev one Choice over every candidate window per entity type, verifies each nominee with a second Choice (the type, none, mixed or partial) and settles its boundary with a third, averaging 73.7 strict F1 across 12 Chinese and English NER benchmarks against 72.1 for direct extraction with Qwen3.8-27B.

Source file: categories/evaluation-benchmarking.md

• Jev Web Analyzer - Product evaluation: analyzes a public SaaS landing page as clean Markdown and asks Jev ten bounded Choice questions about first-visit understanding, returning inspectable findings for the first change to make.
• Jev Playground - Model evaluation: benchmarks Jev against Luna, Haiku, and Gemini at choosing validated legal moves in explicit-state games, scoring decision quality and consistency across a sequence of moves.
• Jev vs Mistral and Gemini for event validation - Event discovery: head-to-head test of Jev against Mistral Small and Gemini Flash-Lite at validating local event listings.
• jev-research-eval - Research automation: reproducible eval harness plus field note for Jev Ultrafast research-browser tasks, with QC'd cases, a suite runner, and a report generator.
• Jev judge call vs dimension scores - Model evaluation: tests one direct Jev question per row against 12–14 Jev-scored dimensions with locally fitted weights on three classification tasks, reaching 0.9076 against 0.8373 on Japanese NLI but flagging about 25× more hard benign rows as attacks.
• Jev Pong - Model comparison: Pong where the ball advances one step per model decision, putting Jev head-to-head with LLMs through Vercel AI Gateway.
• Jev reranking is not a free win - Search reranking: a measured run over 33,047 catalog entries, 164 real queries, and 9,831 graded pairs reports that Jev reranking alone did not beat vector retrieval.
• An early-access test of TypeSafe's Jev - Independent trial: measures calibrated judgments on early-access Jev and reports the resulting cost per decision.
• jevcal - Model evaluation: fits a per-question confidence threshold to a target accuracy on your own labeled data, verifies it 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.
• WindTunnel - Browser-agent benchmark: measures WebMCP against other browser-agent interfaces, with Jev appearing as one of the compared configurations.
• jev-eval - Third-party check: compares Jev against GPT-4o-mini and Claude Sonnet 4.5 under identical conditions on the same judgment task.
• minutes - Meeting notes: local-first transcription app whose live voice path runs its evaluations through Jev.
• jev-orderby-bench - Model evaluation: measures whether a SQL ORDER BY over a Jev probability is defensible (pairwise inversion, Score ordinality against a human grade, calibration, wording invariants, sort-key ties) under a pre-registered gate that jev-1.13.0 passes on 20 Newsgroups topics and fails four of six conditions on Amazon ESCI product relevance, and shows a DuckDB extension's default 40-row batching fails the ranking gate that one row per request passes.
• jev-ood-calibration - Model evaluation: independent calibration test of Jev on 900 rule-generated support tickets it cannot have seen plus three public benchmarks, publishing every raw response, ECE against a simulated noise floor, temperature refit, and the per-type sign of miscalibration (Choice and Score overconfident, Boolean underconfident).
• ASSAY-001 - Independent pre-registered check of Jev calibration and type safety on Banking77 / CLINC150, with a split verdict and full logs, written up at donttrustme.ai.
• BTK audit studies - Content & growth: Jev striking-distance triage ranks SEO fixes and drives study pages; 1,204 pages judged per run, 4,816 judgments in under 3 minutes, $0.0048 per 12-query batch.
• Can Jev Be a Better Agent Evaluator? - Agent evaluation: LangChain compares Jev against LLM judges on accuracy, repeatability, latency and cost, concluding Jev is the cheaper and more consistent judge for online evals.
• jev-acento - Language evaluation: pre-registered paired audit of Jev on Spanish over 3,200 human-labelled items, finding that a Spanish state costs 3.0-6.4 pp of accuracy and roughly doubles ECE on XNLI and PAWS-X while writing instructions in Spanish changes nothing, and shipping a CLI to rerun the same comparison on your own labelled data.
• Jev vs GPT-4.1 on a synthetic survey - Survey research: runs Jev and GPT-4.1 as the same 300 synthetic respondents over 24,596 paired Twin-2K-500 cells under criteria fixed in advance, finding that asking a yes/no item as Noul rather than Choice moves the result more than the gap between the two models, at a thirty-fourth of the cost, written up at jjd-lab.github.io.
• pytest-jev - LLM app testing: a pytest plugin that asks one Jev Noul per plain-English claim about a reply (all claims in one request), passes a claim at p ≥ 0.8 and fails anything unsure, and adds Choice and Score checks; on its 12 example tests it matched Claude Sonnet 5's verdicts in 5.3 s vs 27.1 s at $0.00017 vs $0.0192 per run.
• Jevals.com - Model evaluation: independent leaderboard that asks Jev and six LLMs the same Noul, Choice and Score questions and grades every answer against human labels (PubMedQA, Banking77, HelpSteer2; 300 items × 5 runs each), finding Jev tied for first on PubMedQA yes/no at 1/28 of the top LLM's price, tied for second on Banking77 and no model beating the label base rates on HelpSteer2, with every per-decision probability published as CC BY 4.0 data.
• Jev IDS - Network security: an Intrusion Detection System prototype that takes the metadata of a network flow and returns a verdict on whether it is an attack plus its threat category with probabilities, and on the NSL-KDD benchmark was 4.8× faster and 3.8× cheaper than a state-of-the-art LLM (GPT-5.6 Luna) while raising 15× fewer false alarms than a Random Forest model.
• jev-test - Model benchmarking: reproducible test harness evaluating TypeSafe Jev Noul, Choice, and Score decisions via OpenRouter's Decisions API, comparing latency and accuracy against LLM prompt-and-parse baselines.
• Jev vs Fable on 520 real social posts - Social media: a scheduler's pre-publish check asks Jev four Noul questions per caption (spam, clear opening, stands alone, promotional) as advisory signals, never a gate; on 100 posts labelled blind by Fable the two agreed 94/100 on promotion and 85/100 at a 0.65 spam threshold (Jev the stricter one 12 times to 3), and scoring all 520 posts cost $0.011 at a 341 ms median.
• Jev Does Not Play Dice - Model evaluation: asks Jev a Choice over the six faces of a hidden fair die 400 times; Jev selects face 1 on all 400 trials with 82.9% mean reported probability and 19.0% accuracy, then tests whether stated probabilities survive in synthetic forecast documents, where a 30% shortage risk comes back as 5.3% via Choice and 26.7% via Noul; raw responses and analysis code on GitHub.
• DecisionBench - Model evaluation: scores Jev Noul, Choice, and Score answers on pinned document-grounded tasks, counting malformed probability distributions as misses so model comparisons remain reproducible.
• jev-regress-bench - Agent regression testing: after a config edit, one Choice (same / fact_differs / action_differs / specificity_differs) decides which of an agent's approved answers changed meaning rather than wording, and on 109 before/after pairs whose ground truth is derived from what each config rule does to the answer, Jev catches all 19 real changes with 13 false alarms against 33 for a markers-then-embeddings-then-LLM stack and 19 for the LLM judge alone.
• jev-fanout-bench - Model billing: compares batched with one-question-per-call requests across 2,976 calls to jev-1.13-20260917 through OpenRouter's TypeSafe-compatible /systemone endpoint, reporting about 261 fixed input tokens per request, zero spread in the implied per-request cost across question counts, batched-vs-single answer differences comparable to repeat-request noise, and median input-token savings of 76–86% at eight questions.
• SystemOneHarness - Model evaluation: execution harness and dual-loop test framework that compiles goals, browser environments, and MCP servers into bounded System One reflexes, evaluating Jev against deterministic baselines.
• judgekit - Model evaluation: runs declarative YAML judgment tasks natively on Jev Choice/Score/Noul or any OpenAI-compatible backend (with a free rules fallback), gates low confidence at 0.7 (caught 3/3 misjudgments at 9% escalation, n=130), and publishes Chinese-scenario cost-accuracy numbers — 97.7% @ ¥0.105/1k decisions and 60.0% → 68.3% on a frozen 120-item human-labeled spam set at τ=0.10.
• Convex Decision Evals - Model evaluation: asks Jev a Choice on 108 verified four-option questions about the Convex backend platform (no docs or tools in the prompt, each asked 3 times with shuffled options, random guessing 25%) alongside 14 LLMs, where jev-1.13 scores 84.6% at a 199 ms median and $0.0088 per full run against 98.0% at 2.12 s and $1.59 for the top model, with every answer, probability and raw request/response in a public explorer and the runner in get-convex/convex-evals.
• jev-medhallu-benchmark - Medical AI: pre-registered test of Jev as a hallucination check on Stanford MedHELM's MedHallu (1,000 test items), asking one Noul on whether an answer misrepresents its PubMed abstract; Jev scored 92.9% against 92.4–95.1% for four fast LLMs at a 204 ms median and USD 0.03 per 1,000 checks, and letting Jev settle the 37% of items where it was at least 90% sure kept each LLM's accuracy with 37% fewer LLM calls.
• zh-decision-bench - Benchmarking: first Chinese-language calibration benchmark for Jev-class decision models (378 items / 5 models incl. NeoHorse-Jev-4B; accuracy, ECE, option-order and zh-CN/zh-TW robustness; CC BY 4.0 dataset on Hugging Face).
• jev vs. open alternatives - Document pipelines: compares Jev against open models and specialised tools on five chores — language detection, orientation, RVL-CDIP classification, bundle splitting and parse-tier triage — asked as Choice(2) up to Choice(16).
• S1MB - Decision-model evaluation: compares Jev and open decision models across 137 English Choice, Noul, and Score benchmarks, including six synthetic generalization probes, with public evaluation data, recorded results, and an interactive leaderboard.
• jev-judge - CI/CD & LLM evaluation: runs declarative YAML/JSON/JSONL test suites natively on Jev Noul, Choice, and Score decisions for RAG faithfulness, hallucination detection, and agent safety with watch mode, parallel batching, and GitHub Actions PR reporting in sub-100ms at $0.00004 per decision.
• Vals AI's independent evaluation of Jev - Independent benchmark: matches GPT-6 Astra's 97.5% on 400 claim-verification questions at roughly a five-hundredth of the cost, yet ranks last on a 12-task LegalBench slice and lands at 1.6% error when tuned to a 1% budget.
• System-One Control Bench - Model evaluation: steers an agent through 100 key-and-door grid puzzles with one Jev Choice per move, scoring every pick against an exact BFS solver, and finds that Jev picks an optimal move in 90% of 495 fixed positions yet finishes only 57 of 100 games (Gemma 4 26B 61, DeepSeek V4.1 Flash 60, with reasoning 80; the open decision models GLiClass 13 and Laya 12), so strong single decisions do not add up to a finished task; report and recorded games at socb.dev.
• Decision Models Showdown - Head-to-head: puts OpenAI Decisions and Jev on the same questions in two demo apps, a support ticket router over 20 labelled tickets and a cloud alert triage over 15 labelled alerts, where the code acts on the typed answers.
• classifier-bench - Head-to-head speed: benchmarks Jev against OpenAI Decisions and an LLM over a frozen corpus of 2,321 labelled cases across 31 tasks, reporting latency and registry-priced cost, and running offline in dry-run mode without API keys.
• A Thermometer, Not an Analyst - Working paper: puts a text judge next to a live trading system only as a reader that never prescribes, and compares Jev with Claude as a blind headline judge behind six gates before either can act.
• Microsoft-Decision-1 - Competitor benchmark: Microsoft's hosted decision model claims the top accuracy across 36 benchmarks and uses 35x lower P50 latency than GPT-6 Sol, and flips its decision on only 1.3% of eight perturbation styles, in a post later updated to add Jev's accuracy and calibration numbers.

Source file: categories/calibration-research.md

• decider - Open models: reproduces the System One shape with a Qwen3.5-2B fine-tune that emits typed decisions with calibrated probabilities in one pass.
• openjev - Open research: independent local preview that answers bilingual probability questions from context, questions, and candidate answers, inspired by TypeSafe Jev.
• Parallel Constrained Decoding (Qwen2.5-1B-RLCD) - Open research: RLCD-trained Qwen2.5-1B demo exploring open-source parallel constrained decoding as an alternative to Jev.
• NanoJev - Open replica: a 0.6B parallel decision model that returns full probability distributions with no output-token decoding, shipped with its training pipeline, weights, and dataset.
• open-alternative-jev - Open alternative: runs a Jev-shaped decision model locally on your own GPU.
• mini-jev - Local reproduction: implements Jev's typed-decision interface on top of a local LLM.
• Laya - Open alternative: non-autoregressive decision model that answers choice, score, and noul questions with RLCD-trained calibrated probabilities in a single ~35 ms forward pass, published on PyPI and Hugging Face.
• Jev-compatible public API - Open research: a public Jev-shaped API backed by an open Qwen3.6-35B-A3B model so anyone can try the typed-decision interface.
• kev - Trainable replica: a family of small Jev-like decision models on Qwen2.5 at 0.6B, 4B, and 8B that train and run on a MacBook, shipped with their own research runs and evaluation scripts.
• jev-paint - Creative experiment: paints images by having Jev predict every pixel's colour in parallel, with predicted confidence deciding how wide each stroke is drawn.
• jev-local - Local reproduction: Jev-compatible POST /v1/systemone server answering typed Choice/Score/Noul questions with confidence from open weights, verified as an official-SDK drop-in with temperature-fit calibration (set3 n=1316, 0.83 overall).
• LitJev - Local reproduction: a reproduction of Jev that turns any Qwen model into a fast decision model, serving the same /v1/systemone schema (Choice, Score, Noul) with no training and no generated answer text.
• ruling - Local reproduction: Jev-compatible POST /v1/systemone server that reads typed Choice/Score/Noul answers from the logits of any MLX checkpoint or OpenAI-compatible endpoint with no training, works as a drop-in for the official SDK, and replays Jev's published answers on 256 public judgments (231 vs Jev's 238, McNemar p = 0.21).
• CUA-S1-FORMS - Specialist decision model: a 706,048-parameter, 2.8 MB jev-like option scorer that rates FILL / CHECK / CLICK / SKIP for each form field in one parallel pass, reporting 99.7% on its own form-filling eval against Jev's 83.6% - a specialist on home turf rather than a general win.
• jevlike - Training library: build a small model that chooses among a changing list of text options and returns one probability per option in a single pass - the base CUA-S1-FORMS was built on.
• jevbetter - Improved scorer: a stronger one-pass scorer over a variable list of text options, using a hashed n-gram encoder, rival-aware attention, and gated heads.
• jevlike-esp32 - Edge deployment: exports a jevlike scorer as ESP32 firmware with a C scorer and a host-side check, putting one-pass decisions on a microcontroller.
• von - Open alternative: a 395M non-autoregressive System One model that answers typed questions with calibrated probabilities in under 15 ms, positioned as a local drop-in replacement for Jev.
• JevForge - Open research: an end-to-end stack for auditable data construction, Qwen3.5-0.8B training, fixed Mind2Web and OOD evaluation, local serving, and a preliminary RLCD baseline.
• minojev - Open replica: a 547k-parameter model that answers runtime-defined Choice (2-255 candidates), Boolean, and Score questions with dev-calibrated distributions in one forward pass and zero output tokens, trained from scratch on CPU with committed datasets, predictions, and ECE results (maze 0.016).
• Luce - Open recipe: describe the decision task in a sentence, an LLM teacher writes the training data, a LoRA + decision head on Qwen3-4B-Base answers choice/score/boolean questions with calibrated probabilities in one forward pass; trains on a 12 GB card, and reports accuracy and ECE next to Jev on identical test items (rule-generated tickets 91.1 vs 75.1, phishing 97.4 vs 62.6, GitHub issue priority 41.1 vs 37.5) with a browser replay demo that needs no GPU.
• poorjev - Local reproduction: implements Jev's typed Choice/Score/Noul interface on commodity zero-shot NLI models and makes the confidence honest with temperature scaling and conformal abstention, shipping a reproducible calibration eval (ECE 0.170 to 0.071, cross-validated) that runs offline with no API key.
• openJev-verdict-2.0 - Open decision engine: a calibrated 151M non-autoregressive model that reports beating both TypeSafe Jev and Laya on typed-decision benchmarks, shipped with its own test suite.
• OpenDecision - Open alternative: a local semantic decision engine that describes itself as the open-source equivalent of Jev, answering Choice, Noul, and Score questions from structured state and documents without a hosted call.
• TinyJev - Open alternative: a 596M pointer-head model that answers Choice, Score, and Noul in a single forward pass and returns calibrated confidence meant to be thresholded, so cases it is unsure about escalate to a human instead of being guessed; MLX-first on Apple Silicon, with a System One endpoint and weights on Hugging Face and ModelScope.
• When a Judgment Layer’s Self-Reported Fields Lie - Independent measurement: tests Jev’s self-reported access-layer fields against ground truth rather than trusting them, reporting a verdict vocabulary reaching three values where the description lists six and a sufficient field that does not separate thin evidence from contradictory evidence; the contradiction reading has no JSON artifact behind it and the write-up says so in its own errata.
• Jev calculator - Model exploration: a calculator with no arithmetic in it, asking Jev one Choice over 13 options (0–9, ., -, END) per answer character given the expression and the digits so far, appending whatever it picks and showing each step's full probability distribution and confidence, with a Rerun that exposes call-to-call jitter on identical inputs, live on Cloudflare Workers.
• SemIf - Independent replication: reproduces Jev's typed-decision interface on open models, including an MLX backend on Apple silicon, and measures that typed decisions arrive together while a JSON answer streams token by token.
• jev-verify - Developer tooling: recomputes Jev's confidence and expected-score identities against outputs published in public repositories rather than live API calls, separating vendor-channel examples (10/10) and recorded responses (843/854) from hand-authored fixtures (115/296), where all 121 outputs whose confidence equals the fractional part of their score are concentrated.
• AnyJev - Open research: turns open LLMs into Jev-style decision models that read typed decisions and calibrated probabilities from next-token prefill distributions with zero fine-tuning, reducing order-flip rate and calibration error.
• JevK5 - Open alternative: an open-weight model answering yes/no, choice and score questions with a probability per option in one forward pass, reporting about 13 ms on an H100 and 33.1% against Jev's 36.7% on 308 sealed decisions.
• Verdict - Open alternative: Apache-2.0 118M multilingual bi-encoder that answers Choice, Score, and Noul questions on the same POST /v1/systemone wire format, calibrated with temperature scaling plus a split conformal abstain set with a coverage guarantee (ECE 0.01 to 0.03 on the public suites), runs on CPU or in the browser via ONNX, fits on your own labels in seconds, and its README says it loses to Laya on typed decisions (0.71 vs 0.77).
• Jev-MedQA - Medical QA: a Jev-style implementation on Qwen3.5-4B that selects answers to text and image questions in one forward pass, reporting 69.42% accuracy versus 67.41% for standard generation with a 10.37x speedup across 153,889 questions from nine medical QA benchmark sets.
• Jev Prime - Text generation: a conversational agent with no language model, where every word is picked from ~4,700 options by Jev Choice questions one at a time, with confidence driving lookahead when the top pick falls below 0.65, beam search across sentence directions, and a self-critique loop that rewrites sentences scoring below threshold; live at talktojev.com, paper at doi.org/10.5281/zenodo.22940945.
• RSI-Jev - Jev-like model built by an RSI system: an autonomous AI-scientist research loop that proposes, runs and judges every experiment and publishes all of them (496 experiments, 8 releases in 13 days) — whose open models answer Noul, Choice and Score about text and images on the same POST /v1/systemone wire format, returning a calibrated probability for every option from one forward pass; v6.1-VL 4B scores 50.98 and v6.1-VL 27B 65.64 on the Decision Index 0.3 public set, the 27B with effort auto, which picks its depth per question.
• CLM - Open alternative: an 8B System One model that answers the same Choice and Noul questions behind a TypeSafe-compatible API, matching Jev across computer-use, gaming and tool-calling with up to 9x lower latency and reporting 87.6% on Terminal-Bench 2.1 as a fine-tuned verifier.
• Bespoke Nimble - Open alternative: a LoRA on Qwen3.5-9B that scores one allowed answer token per Choice, boolean or rubric-score question, released with its data pipeline, training config and eval harness under Apache-2.0, and reporting 90.1% on its 324-example holdout against Jev's 93.2%.
• Open Medical Jev - Medical evaluation: two frozen local readers answer one Noul-style yes/no probability per exam option, a fit-free router auto-releases items above the combined-confidence gate and escalates the rest, and a split-conformal candidate set bounds the error - landing within 2 points of hosted Jev on three 600-item national licensing exams with no fine-tuning, no distillation and no corpus.
• Jebadiah - Open replica: Apache-2.0 decision models (27B, 9B, 4B on Qwen bases; bf16, GGUF and MLX) that answer Choice, Noul and Score questions with a probability for every option from one forward pass, and run anywhere: a standalone server with Jev's /v1/systemone wire and a playground, a llama.cpp script for the GGUF builds, or AINode (open-source local AI platform).
• jevos - Open alternative: MIT-licensed 1B model (MiniCPM5 cut to 17 layers with a one-logit head, GGUF q4_k_m at 619 MB) that answers only Noul yes/no questions on Jev's own /v1/systemone wire format, running CPU-only via llama.cpp at 54 ms short / 220 ms long on a laptop Core Ultra 7 255H against Jev's hosted 344/345 ms; Choice and Score return 422, and it scores 0.815 accuracy on 2,000 unseen policy yes/no questions against Jev's 0.927.
• NeoHorse-Jev - Open alternative: Apache-2.0 4B decision model from TokenRhythm that answers Choice, Noul and Score questions via prefill-only inference on NeoHorse-1-4B, deployable with vLLM, SGLang or a native Python/CLI/HTTP runtime, scoring 77.70 across six text benchmark groups (highest among open-weight entries with complete results in its published comparison).
• Jeff - Open alternative: MIT-licensed Qwen3.5 and Gemma 4 fine-tunes answering choice, noul and score on the same /v1/systemone format at about 22 ms per decision, published with a panel that measures Jev itself at 0.828 accuracy and 0.053 ECE while stating it claims no statistical significance.
• AutoJev - Open recipe: a 27B multimodal decision model trained with full-weight SFT on 73,000 examples over one H200, serving choice, noul and score on /v1/systemone with per-checkpoint provenance and calibration plots released.
• Lev - Open alternative: a 4B LoRA on a Qwen backbone published as a System One decision model and tagged for calibrated decisions, classification, routing and moderation.
• openjev - Open implementation: ranks a Doom action menu with one /score call per step and supports per-task fine-tuning, released under MIT with the terminal run recorded.
• Jev-Omni - Multimodal System One: a Gemma-4-12B fine-tune that answers typed questions over text, images, audio and video, at 1,402 downloads in its first ten days.
• Bekko System One - Open decision models: independent 17M–400M English models for Choice, Noul, and Score, with public weights, training code, and an ONNX browser demo; v0 remains substantially behind Jev on the project's generalization tests.
• jevcrypto - Creative experiment: a crypto.randomUUID() look-alike npm package that writes Jev's raw Noul probabilities on 15 code-point permutations of any prompt, plus one Choice for the variant digit, into the bytes of a UUID v4-shaped string; deliberately not cryptographically random.
• Vev - Open alternative: an open-source Jev implementation with vision input, LoRA fine-tuned on Qwen3.5-4B and 9B, serving Choice, Score and Noul questions on the /v1/systemone wire format with screenshots and photos placed directly in the state so one decision can use both text and image; weights are CC BY-NC 4.0, non-commercial only.
• WaterSheep - Open alternative: an Apache-2.0 ModernBERT fine-tune that answers Noul, Choice, Score and multi-label questions with a probability for every option, serves Jev's POST /v1/systemone locally so TypeSafe's Python SDK runs against it unchanged, and reports 0.026 expected calibration error on its test split.
• Gutsy - Local decisions: an Apache-2.0 model that answers typed questions with calibrated probabilities on CPU, with no GPU and no hosted API.

Source file: categories/infra-sdks-integrations.md

• eve - Agent frameworks: Vercel's eve engine ships Jev as the default evaluation model (typesafe-ai/jev) in its experimental evaluate path.
• AI CLI - Developer tooling: Vercel Labs CLI that can run Jev as the evaluation model for its evaluate command.
• jev-mcp (jkudish) - MCP ecosystem: MCP server exposing eleven Jev judgment tools (verify, screen, noul, find, rerank, classify, decide, compare, extract, review, gate) behind fail-closed handling, with an agent skill shipped in the npm package so coding agents get judgment policy out of the box.
• jev-mcp (blakestone-x) - MCP ecosystem: MCP server exposing Jev classify, score, check, match, and screen as tools for any agent, with confidence on every answer.
• zio-typesafe-ai - Scala ecosystem: ZIO client for TypeSafe AI with a typed DSL over Jev decisions.
• laya-mlx - Local runtime: independent MLX port of the Laya checkpoints that runs typed decisions natively on Apple Silicon — 13.4 ms median end-to-end per short English decision, 7.4 ms with the multilingual checkpoint, and zero output tokens, with no PyTorch, Transformers runtime, or cloud API.
• laya-Ascend - Local runtime: Ascend NPU fork of the Laya checkpoints that answers the same Choice, Score and Noul questions on Huawei 910B hardware — 37–47 ms median for a four-question request, 33.8x–70.9x faster than the same request on a single container CPU thread, with an output-equivalent SDPA decision head that avoids torch_npu's CPU fallback on aten::_transformer_encoder_layer_fwd.
• Sezika - Local inference: an independent, Jev-inspired non-autoregressive C#/.NET 10 engine that runs a pinned Laya/mmBERT checkpoint locally through C# CPU/CUDA kernels, with documented Native AOT validation, and returns its own typed Choice, Score, and Boolean answers to .NET applications; probabilities remain uncalibrated and multilingual quality is still under evaluation.
• TypeSafe AI Swift SDK - Swift ecosystem: dependency-free Swift 6 client for Jev Choice, Score, and Noul questions with strict concurrency, configurable authentication and retries, and offline transport tests.
• laravel-typesafe-jev - PHP ecosystem: unofficial Laravel integration for Jev with typed responses, async requests, scoped dependency injection, and testing fakes.
• advocaat - Data tooling: small type-safe client for asking Jev questions about a dataset.
• jevclient - Python ecosystem: async client for Jev published on PyPI.
• jev-trust - Python ecosystem: trust middleware for the Jev API that logs every typed decision, measures calibration in your own domain from outcomes you record (accuracy, Brier, top-label ECE, C = 1 − ECE), annotates each answer with its measured effective confidence, fires overconfidence alerts, and signs the evidence (ed25519) for independent recomputation.
• LlamaIndex Jev - Retrieval / RAG: unofficial LlamaIndex adapter where Jev Scores each retrieved passage and Choice/Noul selects the query engine, with nfcorpus nDCG@5 0.340→0.396 at about $0.0003/query.
• safer-with-jev - Cloud infrastructure: Neon Function proxy for the Neon AI Gateway that routes decisions with Jev.
• typesafe-ai/skills - Official tooling: installable agent skills package (npx skills add typesafe-ai/skills) that teaches agents the Jev workflow.
• Smithers - Agent frameworks: TypeScript workflow framework with a Jev session checker wired into its workflows.
• skillbox - Skills infrastructure: self-hosted versioned skills library that adds optional Jev recommendations using your own TypeSafe or Gateway key.
• Jevbridge - Agent bridges: ACP and MCP adapter that exposes Jev typed decisions to Codex, Claude, Grok, and other LLMs.
• jev (Elixir) - Elixir ecosystem: GenServer client that replies with Jev's answer so callers can pattern match on it directly.
• jev-go - Go ecosystem: community Go SDK for Jev.
• jev-cli - Developer tooling: small dependency-free CLI for Jev.
• decide-mcp - MCP ecosystem: configurable decision server with percentage scores and bias-profile routing on top of Jev.
• typesafe-jev-examples - Starter examples: worked ticket-triage and reranking examples runnable through OpenRouter without an early-access key, shipped with their own sample data and Makefile.
• ai-python - Python ecosystem: the official Vercel AI SDK for Python carries Jev through its evaluation operation and Gateway examples.
• Cline plugins - Coding agents: Cline's official plugin collection includes a Jev-driven browser plugin (jev-browser), so Jev arrives as a first-class Cline capability.
• hono-jev-router - Web frameworks: Hono middleware that routes HTTP requests by meaning rather than by method and path, deciding with Jev.
• rotom - Local gateways: OpenAI- and Anthropic-compatible API gateway that carries Jev through its model catalog and evaluation path.
• Jev AI - Developer tooling: public Jev playground and API that puts typed Choice, Score and Yes/No questions to the model about pasted text - ticket triage, moderation, review scoring - and returns a parsed answer with a confidence value in about 0.5 s per decision.
• jev4pg - PostgreSQL: evaluates row-level predicates with Jev Noul questions, retains the returned probabilities for explicit decision thresholds, and leaves joins and aggregation to SQL.
• jevql - Data tooling: psql-shaped CLI and Go/TypeScript/Python SDKs that run plain SQL on a vanilla Postgres (no extension) and then ask Jev Noul, Choice, or Score questions about each surviving row so the client can apply jev() filters, jev_prob sorts, and jev_choice groups.
• sqlite-jev - SQLite ecosystem: loadable C extension and Python package that expose Jev Noul, Choice, and Score judgments as SQL functions and batched virtual-table queries with confidence results.
• duckdb-jev - DuckDB ecosystem: native extension that applies Jev Noul, Choice, Score, and multi-question decisions directly to structured SQL rows, measuring 1,943 rows/s for 1,000 Choice classifications with confidence and bounded concurrency.
• jevkit - Developer tooling: Rust CLI that validates Choice/Score/Noul question sets with 13 offline lint rules before any Jev call, then sends the canonical wire payload and prints parsed, confidence-bearing JSON answers to stdout using exit code 2 to reject a billed-but-useless request.
• jev-use - MCP ecosystem: Claude Code / Codex / pi plugin (MCP server + library, native pi extension) that hands agent steps needing no text output to Jev as typed judgments — untypeable and generation-needing questions are rejected before the call, low-confidence answers come back flagged as priors, and a fail-open PreToolUse gate can only deny or ask.
• huncho - TypeScript ecosystem: dependency-free SDK that turns Jev Noul, Choice and Score answers into named decisions with enter/exit thresholds (hysteresis), nested decision trees settled in one call, a JSONL journal, replay of a threshold change over recorded answers with no inference, and Brier/reliability calibration, over TypeSafe direct, OpenRouter or Vercel AI Gateway.
• jev-experiments - Demo collection: 22 latency-focused Jev applications built by Devin, each with its own README and testing notes, spanning shell guards, log sentinels, instant search, reranking, and voice turn-taking.
• ruby_decision_model - Ruby ecosystem: client for decision models such as Jev, so Ruby applications can put typed questions directly to the model.
• s1_ruby - Ruby ecosystem: makes System One measurement, and the collapse that follows it, a Ruby primitive, with a TypeSafe provider behind its own spec suite.
• JarvisCore - Agent frameworks: Python multi-agent runtime that ships Jev natively from 1.12, where agents ask typed Choice, Score and Noul questions through a decision client separate from the text model, the Kernel picks a specialist subagent by Choice, and each retrieved RAG passage is withheld from the generating model when its prompt-injection Noul exceeds 0.70.
• hunch (carldaws) - Ruby ecosystem: turns judgment calls into control flow — if Hunch.likely?("fraudulent", given: order) reads like plain Ruby but branches on a typed Jev answer, with pick for Choice, rate for Score, and graded predicates from possibly? to almost_certainly?; a TypeScript port offers the same interface.
• Early experimentation using Jev to rethink harness UX - Harness integration: an agent platform wires Jev into its LLM harness as a callable tool for search, approvals and context, reporting 2,000 expense reports categorized in 20 seconds for five cents.
• jev-mcp (burnigtm) - MCP ecosystem: server that puts Jev into the coding loop for Cursor, Codex, and any MCP client, with 20 test files behind it.
• jev-skill-suggester - Coding agents: recommends which installed skills apply to a request, keeping the recommendation bounded and letting Jev decide.
• grok-bot-jev - Agent bridges: connects Jev to Grok Bot as a cheap decision layer, with usage gates, a skill template, and worked examples.
• jev-architect - Design skill: finds, designs, and evaluates Jev decision loops, packaged as a skill with references on decision design and delivery.
• Building a Harness with Jev - Framework guide: LangChain's walkthrough of wiring Jev into an agent harness as the decision layer, from a team that then published its own evaluation of Jev as a judge.
• openrouter-jev-mcp - MCP ecosystem: Python decision gateway and stdio MCP server exposing TypeSafe's Jev model through OpenRouter's alpha decisions endpoint.
• system-one-adapter-python - Python ecosystem: TypeSafe AI's official open-source drop-in adapter for running and benchmarking Jev System One decision evaluations across OpenAI- and Anthropic-compatible LLM APIs.
• neurolink - Provider abstraction: the pipe layer of an AI nervous system — Juspay's TypeScript interface connecting provider neurons to an application, with decide as a first-class inference type alongside generate and stream.
• jev-spring-boot-starter - Java ecosystem: Spring Boot 4 starter that puts Jev behind Spring MVC and RestClient.
• jevify - Agent skill: finds where a codebase could hand a decision to Jev, designs the typed questions for it, and learns from recent community usage.
• mysql-ailike - Database filtering: MySQL plugin that filters rows by a natural-language predicate instead of a literal one, powered by Jev.
• jev-usecases - Reference harnesses: a set of production-shaped use-case harnesses built around confidence-gated decision logic.
• FastJev - Local runtime: self-hosted Python SDK and System One-compatible API for runtime-defined Choice, Boolean, and Score decisions on pinned open models across Torch, vLLM, MLX, llama.cpp, and WebGPU, with committed row-level benchmarks and checksums.
• kojev - Kotlin ecosystem: Kotlin Multiplatform (JVM, Android, iOS) client for Jev that answers Choice and Score questions as the caller's own enums, with one typed way to read answers, no default thresholds, and offline MockEngine tests.
• ask-jev - Python ecosystem: zero-dependency CLI that routes small semantic judgments — Choice, Noul, Score, batch questions, and verbatim passage extraction — to Jev for AI agents and CLI pipelines.
• Search with Jev and Milvus - Search engineering: nine runnable notebooks combine Gemini embeddings and Milvus retrieval with Jev Noul and Choice judgments, while Python applies ranking, filtering, routing, and stopping policies to synthetic examples.
• discern - TypeScript ecosystem: Effect library where a Jev Choice, Noul or Score answer becomes a typed branch under caller-supplied thresholds, anything below them takes an Uncertain case the compiler forces you to handle, and procedure routing skips the model call entirely when deterministic predicates leave one candidate.
• jeff (logan-markewich) - Self-hosted runtimes: self-hosted drop-in replacement for TypeSafe Jev powered by GliFormer, exposing native Choice, Score, and Noul decision endpoints without cloud API dependencies.
• CloJev - Clojure ecosystem: unofficial portable Clojure SDK for System One, so Clojure applications can put typed questions to Jev without a Java interop layer.
• hunch (steven-shoemaker) - Python and TypeScript ecosystem: libraries that turn Jev Choice, Score, and Noul questions into functions over lists and DataFrames (classify, score, check, where, extract, pick, rank, verify), with request deduplication, caching, and optional escalation of unsure rows to an LLM that must pick from the same labels; TypeScript port at hunch-js.
• typesafe-mcp - MCP ecosystem: Go-based CLI and MCP server exposing an evaluate tool that routes typed decisions to Jev with automatic configuration for Claude Code, Claude Desktop, Codex, and pi.
• spring-ai-typesafe - Java ecosystem: Java SDK for TypeSafe AI's Jev API and Spring AI integration, providing typed decisions for evaluation as a judge, guardrails, and RAG post-processing.
• JevFlow - TypeScript ecosystem: composes Jev Noul, Score, and Choice decisions into deterministic threshold workflows that batch into a single systemOne call and return an ordered, explainable action set instead of side effects, with matched rules recording the actual value behind each action and a mock provider so policy tests run without an API key.
• stuntd - Local runtime / learning proxy: Jev-compatible local server on Laya that also proxies a Jev upstream, records every Choice, Score and Noul decision, trains a head per decision site, and answers live with calibrated confidence, falling back to the upstream below its threshold and demoting itself on drift; measured 22 ms per decision and 90% of support-triage questions answered locally at a 0.99 agreement target.
• Jev AI Tools - Developer education: hosts six bounded recipes plus a custom builder for AI SDK Choice, Score, and Boolean evaluations; recipes display answer probabilities separately from provider confidence and use deterministic local thresholds to pause uncertain routes for review, while every configuration exports as TypeScript.
• Jeview - Developer tooling: zero-dependency local proxy and live visualizer that intercepts Jev API calls, logs decisions to SQLite, and renders real-time decision flows in a browser dashboard.
• SemDecide - Developer tooling: Unix CLI for semantic decisions in shell pipelines and CI, evaluating Jev predicates, routes, and scores with predictable exit codes.
• jev-foundation-models - Apple platforms: a Swift 6 bridge that runs Jev decisions through Apple's Foundation Models on device, with a protocol-based model interface and six tests.
• simple-jev - Serving: turns any open model into a Jev-compatible classifier endpoint, so a self-hosted model answers the same typed questions as the hosted API, with 27 tests.
• cu-Jev - Inference engine: a CUDA-native implementation of the Jev System One API that keeps decisions GPU-resident, shipping a Starfighter demo and a benchmark script.
• jevcache - Cost control: memoizes Jev-class decisions so a repeated question is served from cache instead of a new call, keeping repeats deterministic and free.
• jev-switch - Local gateways / cloud relay: dual-mode Rust router for typed Jev decisions — tokenless local multi-upstream routing (Vercel, TypeSafe, local Laya) with noul/boolean translation and DAG failover, or token-gated cloud relay aggregating Jev endpoints behind one API, proven by 155 workspace tests plus end-to-end smoke over Choice/Score/Noul round-trips.
• Qwev - Local inference: turns dense Qwen3 and Qwen3.5 checkpoints into a training-free Jev-style Noul, Choice, and Score service that shares one state prefill across isolated questions and, on its included 27-question Qwen3.5-9B/A100 fixture, reports 0.500 s versus 13.554 s for generated JSON.
• jev-sdk-go - Go ecosystem: dependency-free Go 1.24+ client for Jev Noul, Choice and Score questions that reads Choice and Score answers back as the caller's own types, rejecting any label or level the question never offered, with retries, OpenRouter support, and eleven examples tested against an in-process fake of the API.
• typesafeai-dotnet-sdk - .NET ecosystem: community .NET SDK for the TypeSafe AI System One API with strongly-typed Noul, Choice, and Score questions and structured answers.
• jevcompat - Interoperability: a 48-requirement spec of the POST /v1/systemone wire contract, each rule citing TypeSafe's docs, OpenAPI file or SDKs, and a suite that checks any Jev-compatible server against it (Choice probabilities keyed by option and summing to 1, Score equal to Σ i·p, 2–255 options, error shapes, answers that stay put when question ids or order change), finding 2 of the 8 most-starred open ports conformant, with a reference mock that breaks each rule on purpose and a proxy that fixes what can be fixed.
• typesafe-ai (Rust) - Rust ecosystem: typed TypeSafe AI client with async (reqwest) and blocking (ureq) backends, deserializing Noul, Choice, and Score responses into Rust enums with observable retry streams.
• typesafe-ai-php - PHP ecosystem: A modern TypeSafe AI client and SDK, with result classes and classic requests
• Jev - PowerShell ecosystem: PowerShell module for building Jev Noul, Choice, and Score questions and returning named answers as pipeline-friendly properties.
• Pydantic AI - Python ecosystem: official Pydantic AI agent framework shipping first-class TypeSafeModel integration to map Pydantic schema fields into typed Jev System One questions with confidence scoring.
• Milvus Model - Search infrastructure: batches candidate-document Noul questions through Jev and returns score-sorted results with original indices through a Python reranker adapter.
• djev-run - Serving: deploys DiffusionGemma-Jev behind a TypeSafe-compatible API on a Cloud Run GPU with snake, dino and tetris demos wired to the decision endpoint.
• GPTCache - Semantic caching: Zilliz semantic cache integrates TypeSafe Jev Noul checks to evaluate cache hit freshness and time-dependent query validity.
• jev-symfony-bundle - PHP / Symfony: Symfony bundle providing typed Jev clients, validation constraints (#[JevNoul], #[JevChoice]), Workflow guards, and WebProfiler panels.
• JevT++ - C++ integration: independent C++20 library with compile-time enum schemas, typed Choice/Noul/Score results and abstention, local Laya inference through ONNX Runtime or ggml, and an opt-in TypeSafe System One HTTP backend tested with mocks and loopback HTTP rather than live-provider calls.
• Sim - Agent frameworks: open-source collaborative workspace for building, deploying, and monitoring AI agents featuring native TypeSafe System One evaluation and decision provider integration.
• RubyLLM - Ruby ecosystem: official Ruby gem connecting TypeSafe judgment models to RubyLLM with a native System One protocol for typed questions, probabilistic answers, and error normalization.
• jev-style - Local runtime: pip install "jev-style[torch]" (or [mlx] on Apple silicon) serves an open 0.8B Qwen3.5 decision model behind a System One-compatible /v1/systemone API that answers Choice, Score, and Noul questions with calibrated probabilities in one pass over inputs up to 25,600 tokens (0.15–0.2 s per short request with MLX on an M1 Max, after the first call), and ships a Claude Code guard that turns four Noul checks and a risk Score into allow, ask, or deny through code-owned thresholds.
• grev - Developer tooling: grep, sort, cut and uniq that match by meaning — grev 'is a vegan meal' menu.txt keeps the lines whose Jev Noul clears 0.5, sibling filters route by Choice and rank by Score, and the output is always your own input, never generated text.
• decision-gate - Cost and rate control: npm library that every Jev request in a loop goes through, which waits for room under 80% of the account's requests-per-minute and tokens-per-second limits, pauses every caller sharing the account, across processes, for the server's Retry-After delay when the service answers 429, refuses any request that would pass a per-key daily spend ceiling (USD 0.20 by default), and keeps an opt-in cache of answer probabilities under caller-chosen keys, so a repeated question over the same state is not paid for twice.
• ollaya - Local runtime: serves open decision models behind a wire-identical /v1/systemone endpoint, so an existing Jev client only has to point TYPESAFE_BASE_URL at the daemon, and reports its recommended model at 0.722 accuracy against Jev's 0.738 on typed decisions.
• pg-jev - PostgreSQL: extension that filters, ranks and classifies rows by plain-language conditions, so WHERE jev(people, 'the name is European'), jev_prob and jev_choice each put one Jev judgment per row with calibrated probabilities.
• Tiltmeter - Monitoring: drop-in /v1/systemone proxy and Pydantic AI client that records every Jev answer's probabilities and alerts, without labels, when jev-latest switches versions, a question's answers drift (chi-square-tested PSI), answers crowd a decision threshold, or estimated accuracy falls.
• Building with TypeSafe Jev - Agent skill: a plugin published to both the Claude Code and Codex marketplaces that teaches a coding agent to reach for typed Jev decisions, with a setup walkthrough for each host.
• Jev Showcase - Pattern gallery: a runnable app with four agent skills that put Choice, Score and Noul next to parallel fan-out, a router and a guardrail in one codebase.
• DecisionKit - .NET ecosystem: provider-independent .NET decision engine whose domain package holds no Jev URL, header or DTO, mapping Choice, Score and Noul questions onto POST /v1/systemone from a separate provider package, with a runnable ASP.NET ticket-triage sample that picks the owning team and escalates to a human at a normalized Score of 0.8, and 1,096 tests across net8.0 and net10.0 that run with no HTTP.
• intern-decision-mlx - Local runtime: serves Shanghai AI Lab's open Intern-Decision-0.8B vision decision model on Apple Silicon behind a /v1/systemone-shaped endpoint that also takes screenshots, so an agent can threshold the calibrated Choice, Score and Noul answers and escalate the rest — 0.9 s per 1080p screenshot downscaled to 1024 px on an 8 GB M2 MacBook Air, and the same answers as the lab's PyTorch reference on 67 of 67 fields.
• Decision Models in llama.cpp - Local inference: llama.cpp adds a /v1/systemone endpoint that takes a state, questions and candidate answers and returns the chosen option with a probability for each, in Jev's own wire format, with official tests from 144M up to 27B models.
• Databricks AI Decide - Data platform: Databricks ships ai_decide, an AI Function that classifies, scores and chooses over governed data, and says it built it because demand for fast structured decisions followed the Jev launch.
• metajev - Decision infrastructure: keeps the full distribution behind each Jev Noul, Choice, or Score answer under a key of state, question, and model, so an accept boundary can be moved across the whole recorded history with no further Jev calls.
• holon - Agent workbench: keeps decisions in their own crate and notes in the adapter for its first backend, Cloudflare's Clef, that "Clef uses the System One-shaped state/questions request" — the interface being borrowed rather than reinvented.
• jev-bisect - Numeric search: turns Jev into a bisection oracle, halving a range with typed yes/no answers to home in on a number instead of asking a model to guess it.
• TypeSafe Jev + ComfyUI - Image generation: routes a prompt to one of three ComfyUI workflow templates with a Jev decision rather than a keyword match.
• system_one_client - Elixir ecosystem: one client that speaks to several System One decision models, Jev among them, behind a single interface.
• Bud-Decision-Studio - a cross-platform desktop app (macOS, Windows, Linux) that runs laya, kev, laya-typed-decisions etc locally behind the Jev API (POST /v1/systemone), with a Playground, versioned templates with decision history, and a Train page for LoRA fine-tuning on your own labelled decisions.
• OpenJevSwift - Local runtime: native Swift port of OpenJev that answers Choice, Score and Noul questions behind a Jev-compatible POST /v1/systemone endpoint on Apple silicon Macs (DiffusionGemma and JevK5 on MLX; Verdict and Laya on Core ML, with upstream's top answer on all 666 compared items) and inside iPhone apps through its Swift libraries, with a CI job that runs TypeSafe's Python and TypeScript SDKs against it unchanged.
• jev-mod - Claude Code mod: adds $.jev to the engine so other mods can ask typed Choice, Score and Noul questions and get calibrated probabilities back.
• opencode-jev-pre-llm - Coding agents: an OpenCode V2 plugin that classifies a prompt with Jev before the LLM starts reasoning, so the expensive model only sees requests that need it.
• pydecide - Python ecosystem: one client that sends the same typed Choice, Score and Noul questions to hosted Jev, OpenRouter, OpenAI's Decisions API, laya and laya-mlx, or any sentence-transformers reranker, walking an ordered fallback chain when a backend errors or answers a Choice or Noul question below a configured confidence threshold (Score answers are not gated, since there is no single confidence number for them), and recording on each response which backend answered and why; it also ships a client class matching typesafe_sdk.TypeSafeClient's constructor and system_one call for existing code, without response_model or the per-call overrides, and a /v1/systemone server their SDK parses unchanged.
• Clef-omni - Competitor update: Cloudflare's decision model now takes text, images, audio and video in one request, and the cheaper Clef-flash tier had its price cut at the same time.

Source file: categories/game-simulation.md

• typesafe-mario - Gaming: TypeSafe/Jev agent that plays Super Mario Bros. from structured emulator state, choosing each action from emulator-derived features.
• tsai-sc - Gaming: drives original StarCraft shareware through keyboard and mouse with Jev action probabilities recorded per decision.
• jev-plays-pokemon - Gaming: reads Pokémon Red game state as text, answers typed questions each turn, and lets deterministic code turn the answers into moves.
• typesafe-playground - Interactive playground: small Jev experiments that put the decision on screen, from routing a support message to steering a car in a 3D world.
• PlayJev - Gaming: open 0.8B vision-language model that reads one 448 px game frame, returns a probability over the moves the game lists in a single forward pass with no generated text, and hands its low-confidence steps to a search program, across ten browser games.
• jev-plays-pokemon-red - Gaming: Pokemon Red on PyBoy where deterministic code owns the route and arithmetic, Jev picks only at branches, and every battle turn's faint prediction is scored by Brier against RAM state.
• Soupbase - Gaming: uses Jev Choice judgments to answer lateral-thinking puzzle questions and assess proposed solutions, with application code requiring supported facts, a coherent explanation, and sufficient confidence before marking a puzzle solved.
• jev-torneo-animales - Gaming: winner-stays-on tournament of up to 2,569 animals where each fight is one Jev Choice between two names under land, water or air rules held in state, asking the champion against the next K challengers in a single request and discarding the speculative answers once the champion falls — 1,999 fights in about 16 s at roughly US$0.01.
• 2048 × Jev - Gaming: a 2048 board where every move is a Jev Choice over four directions with no heuristic fallback, gated by a user-set confidence threshold that pauses play for human review, with editable prompts and board rules, bring-your-own-key backends, and archive import/export.
• Jevtown - Audience simulation: a town of 10,000 personas computed from their id reads a post, listing, product or headline; one request asks Jev about 60 Score questions on who would care plus seven Noul moderation checks (0.5 keeps the text out of the public feed, 0.85 blocks it), batched Choice questions then return each persona's reaction in waves of 600, 1,500 and 3,000, and code sends the text to the next wave only while glad reactions outweigh sorry ones by at least 0.1 of the wave.
• Jev Chess - Gaming: one shared board where the internet collectively plays against Jev; every legal move is an option of a single Choice question so an illegal move is impossible, returned probabilities shade the pieces on the board, and a live calibration panel scores each claimed confidence against a one-ply material check.
• Life Chess × Jev - Experimental game design: a turn-based Conway board where each side's move is one Jev Boolean per legal cell in a single request, with no heuristic fallback and a user-set confidence threshold flagging unsure turns; the game is new, so there is no established play to copy, and its rules are not self-evident — they render from editable templates with auto-filled placeholders, so a designer can rewrite a rule and re-ask.
• kNES - Gaming: a Kotlin NES emulator whose agent plays Super Mario Bros. and Final Fantasy through SemIf, the open implementation of the Jev interface, on a local Qwen3.5-4B reading the screen itself; the goals that apply this turn become the declared options of one typed Choice, so a button the game does not offer is impossible rather than unlikely, and 900 logged decisions at ~400 ms each on an M5 Pro never once answered off the menu.
• Laya vs Jev arena - Model comparison: races an open local model against Jev through Snake and a Mortal-Kombat-style arena, the same game code driving both.
• JEV-Star - Gaming: uses Jev Choice decisions for StarCraft II macro control and micromanagement on 35 SMAC-Hard maps, validates selections against available actions, and follows optional GPT-6 plans to separate frequent action selection from longer-term strategy.
• THE HUNDRED EYES - Interactive media art: asks Jev one Choice and four Score questions per fictional observer to animate 100 eyes from a shared post, revealing four amplified voices before equal-count analytics expose the full distribution of reactions.
• jev-pilot-reflex - Autonomous vehicle simulation: Three.js autonomous driving reflex and AI safety brake simulator using Jev System 1/2 dual-brain architecture for fast emergency intervention.
• Magic Jev Ball - Gaming: a 3D Magic 8 Ball you hold, shake and let go, where one Convex action asks Jev a Choice over the 20 classic answers for the user's question and the page shows Jev's probability for every answer, displaying the highest-probability one because the rounded probabilities occasionally disagree with the reported choice.
• Jev-mice - Simulation: a mouse colony whose behaviour runs through Jev decisions on top of a deterministic engine.
• jev-plays - Gaming: Craftax (Crafter) survival agent where deterministic code lists every feasible action with its facts and Jev picks one Choice per step, optionally guided by an LLM-written objective and standing rules; 3-seed ablations compare Jev over macro and raw actions against random, an LLM choosing every step, and Jev plus the planner.
• Jev Driver - Simulation: a top-down driving game where Florence-2 captions each image dropped on the road in the browser and a Cloudflare Worker asks Jev three Choice questions (action, category, speed limit) about the caption and its lane or sidewalk, with no rule table overriding the answer; live at drive.mrza.ch, about 330 ms median and $0.00004 per decision.
• jev-goal-reflex - Simulation: a Three.js box steered by plain-language instructions, where an LLM turns each instruction into steps of simultaneous actions and every decision asks Jev two Score questions (move, turn) and one Noul (jump), with code acting on a score only past a 0.33 dead zone, jumping above 0.45, holding still any axis the current step does not use, and sending no Jev request while no step is active.
• Pacman AI Race - Gaming: browser-based Pac-Man race where deterministic three-junction simulation removes routes predicted to be fatal when a survivor exists, then Jev makes one typed Choice among the remaining route IDs while the server rejects any answer outside the supplied set, with self-hosted Laya using the same decision contract for comparison.
• 1 Million Emojis - Collaborative art: a shared 1000 × 1000 emoji canvas where, after each visitor stroke, one Jev request asks a Choice over named (emoji, square) pairs next to it and a Noul on whether the stroke is an unfinished shape, finishing the loop or line above 0.7 and otherwise sampling its pick from the returned probabilities (source).
• FlightBench - Flight simulation: a fixed-wing landing simulator and benchmark where you can compete with Jev in landing a plane, mapping four Jev Choice decisions to aircraft controls in JSBSim and benchmarking landings against human-pilot, baseline, and LLM controllers, with planned support for open-source Jev-like decision models.
• AI Hold'em - Gaming: browser-based Texas Hold'em where a TypeSafe Jev bot receives structured hand state and a typed Choice over complete legal moves and bet sizes, with the poker engine validating the selected action before it is applied (source).

Source file: categories/robotics-physical.md

• robo-harness - Robotics: SO-101 arm workbench where a Jev decision runner picks bounded joint steps from typed candidate actions under a spend budget.
• OmniJev - Embodied robotics: a Jev-style finite-choice interface that feeds dual-camera images and text to a self-hosted multimodal model and takes the next preset skill for a MuJoCo arm as one typed choice, where released episodes finish transfer, stack and barrier tasks in 13 decisions and 39 output tokens each, 208/208 non-audio probe requests answer correctly, unobservable inputs come back "insufficient evidence" instead of a guess, and four public benchmark pilots hold accuracy equal to a direct short answer while cutting decision latency 6.8–13.6× and total tokens 51–86% (audio input is wired in the client but rejected by the current backend).
• Jev Robot - Robotics control: a local decider-2b model picks the next skill for an AgileX PiPER arm through a Jev-style typed-choice interface while the target moves, with deterministic checks allowed to reject a choice but never to substitute another.
• jev-drone - Robotics simulation: camera-only autonomous drone in MuJoCo that puts a Jev judgment model in the control loop at 2.5 Hz.
• typesafe-jev-drone-demo - Simulation: Three.js drone simulator with a Python backend where Jev drives the navigation decisions.
• jev-reflex-autonomy-lab - Drone autonomy: a multi-drone lab where Jev supplies the reflex decisions, with an optional slower strategy layer guiding them.
• RoboJEV - Robotics simulation: uses two-stage Jev Choice decisions over structured state to select intent and Cartesian motion/gripper commands for a Franka Panda in MuJoCo, rejecting malformed responses and checking task success independently through physics.
• Jev for Physical AI - Fleet triage: runs Jev as the decision layer for a 10,000-robot warehouse fleet over 41 bilingual incident templates and publishes 0.527 s p50 latency, $24.57 per million decisions and 91.3% agreement with template labels, alongside a crossover against a self-hosted ModernBERT.
• EmbodiedJev - Embodied robotics: MuJoCo decision workbench for a Franka Panda arm that compares TypeSafe Jev System One candidate decisions against reactive baselines and LLMs across pick, place, and obstacle tasks.

Source file: categories/finance-trading.md

• Jevinik - Stock decisions: terminal that gathers live market evidence through Valyu and asks Jev whether a stock is likely to trade higher over the next 30 days.
• jev_stock - Short-term forecasting: experimental Hong Kong stock framework that turns structured market state into a Jev decision on price direction, with a backtest script for the first trading day.
• jev-trade - Crypto trading: asks Jev for a Choice of long or short on a Hyperliquid market each round, places that order, and runs the same loop across many assets.
• Jev X Sentiment Analysis - Crypto decision support: ingests 50-1,000 tweets per request through statistical pre-processing and SQLite deduplication, then has Jev turn the surviving evidence into a decision card with entry ranges, stop losses, and targets, without executing trades.
• jev-guard (klauswg) - Exchange risk operations: screens crypto exchange deposits and withdrawals with Jev triage (risk level, behavioral pattern, freeze probability) while hard rules veto and Java composes the final action, with a published 100-sample three-column calibration against a rules-only baseline.
• jev-trader - Trading: watches the Kuru MON-USDC book on Monad and asks Jev for a Choice between buy and sell every block, publishing 81 ms decision latency and $0.000004 of Jev cost per call from a live dry run.
• ai-hedge-fund - Quantitative finance: multi-agent AI hedge fund trading system featuring native JevLLM integration to execute fast typed decisions without parsing fragility.
• Polymarket BTC 5m Jev trader - Prediction markets: a trading agent for Polymarket's five-minute BTC up/down markets that puts Jev in the decision layer behind a terminal UI.

Source file: categories/compliance-legal.md

• LegalForecast-MTD - Legal forecasting: benchmark that asks Jev to predict federal motion-to-dismiss rulings from the judge's written record and scores the calibrated probabilities with claim-defendant micro-Brier metrics.
• Jev Policy Engine - Policy conformance: universal Policy-as-Code SDK that allows DevOps and security teams to enforce deterministic AI governance rules in YAML via Jev with audit mode and fail-closed controls.

Source file: categories/content-moderation.md

• Jev Moderation Bot - Community moderation: Discord bot that scores incoming messages for phishing, spam, and social engineering with Jev and drives a four-stage escalation ladder, injecting pardoned messages back into context as verified-safe precedent.
• jev-spam-eval - Spam filtering: zero-shot spam classification with Jev Boolean questions, benchmarked against TF-IDF baselines.
• mastra-jev-moderation - AI assistants: Mastra input processor that asks Jev a Boolean "must this message be blocked?" plus a category Choice in one request, aborting the turn at 0.7 and failing open behind a deadline and circuit breaker; in production it blocked 9/9 hostile and 0/49 real messages at ~0.4 s median, about 4× cheaper than an LLM moderator.
• Jev Chat for Twitch - Live chat filtering: bring-your-own-key Chrome extension that reads a Twitch channel's chat over the anonymous IRC WebSocket, asks Jev one category Choice per message in batches of 20, and shows a second column of only the messages matching a chosen intent (helpful, questions, funny, feedback); about 504 input tokens per message, roughly $0.15 per hour on a 2-message-per-second chat and $0.76 per hour at 50 per second.
• profanity-checker - Trust & safety: Cloudflare Worker that asks Jev Noul for literal profanity in text or usernames and a second Noul for phonetic or look-alike disguise (a55h0le, mike_hunt); the threshold, max() policy, JSON response, and OpenAPI schema live in Worker code and the endpoint is callable from other Workers via service bindings.
• jev_antispam_bot - Telegram moderation: minimal grammY anti-spam bot that asks Jev about each message, with ten test files behind it.
• jev-slop-guard - Social feed filtering: bring-your-own-key Chrome extension that asks Jev one Choice (slop / not_slop) per X and LinkedIn post as it scrolls into view, blurring and stamping anything at or above a user-set threshold (default 0.7) behind a "Show the post" override, with a three-request concurrency cap and one cached verdict per post so scrolling never blocks.
• jev-screen-mcp - Moderation: a single-tool MCP server that gates screen content through Jev, exposing noul, choice, and score as first-class question types alongside a deterministic mock mode and three tests.
• Rot Guard - Digital wellbeing: bring-your-own-key Chrome extension that asks Jev a content-category Choice, a Noul on whether the page serves the user's written goals and a 0–4 waste-of-time Score for every YouTube video, X, Reddit or LinkedIn page and article, plus a Choice and Noul per X post and YouTube tile in batches of 10, then blocks or collapses in code with thresholds that tighten at 2, 10 and 20 minutes of engaged time, and grades a one-shot appeal with three Nouls that earn 15 minutes or lock the page until midnight.
• social-risk-qwen-jev - Chinese moderation: pairs a Qwen3-VL LoRA with a Jev decision model to judge multimodal social-risk content.
• HN Jev Sorter - Reading aid: a Chrome extension that sorts Hacker News comments into buckets you choose while you read, with Jev classifying each comment in about a second.

Source file: categories/related-practices-discussions.md

• Introducing System One Models and Jev (Hacker News) - Hacker News: 1,800-point launch thread whose ~480 comments debate whether typed decisions replace LLM calls for classification, routing, and verification.
• Launch thread by Diogo Almeida - X: the 63k-like announcement from TypeSafe's founder arguing RLCD-trained decision models are a shorter path to economic value than chat models.
• Model router built with Jev - X: 948-like demo where Jev decides which model should serve a request before it is forwarded.
• MLP on Qwen 4B mimicking Jev - X: builder reports that a small MLP trained on top of Qwen 4B already reproduces Jev-like decision behaviour.
• Running a local Typesafe Jev - X (Japanese): attempt at running a Jev-style decision model locally, with speed noted as still improvable.
• Jev as an AI agent safety monitor - X: test report using Jev to check each agent action first, reportedly catching most attacks with almost no false blocks and much lower latency.
• Rethinking security engineering with Jev - X: argues that purely engineering decisions in security work belong to Jev rather than a chat model.
• Ask Jev anything, it will judge - X: public Convex-backed demo inviting one million judged questions instead of generated answers.
• First Jev use case in a Mac app - X: a shipped Mac app routes setup and troubleshooting questions to Jev when no language model is loaded.
• Jev 中文解读 - X (Chinese): explains the System One category to Chinese readers as a calibrated, typed decision layer for code.
• TypeSafe AI releases Jev (r/singularity) - Reddit: launch thread framing Jev as a low-hallucination, low-cost decision model for software rather than chat.
• Testing Jev for Pi extensions (r/PiCodingAgent) - Reddit: builders describe using Jev as an agent tool-use safety layer and planning a prompt-complexity model router.
• Jev "playing" Minecraft (r/accelerate) - Reddit: work-in-progress demo of Jev driving Minecraft, including fleeing zombies at night, as a test of fast structured decisions.
• Awesome Jev by TypeSafe - Curated list: a peer collection of Jev use cases, patterns, prompts, and starter code, with a video walkthrough of eight projects people already built.
• Jev on OpenRouter - X: OpenRouter ships Jev in beta, exposing the System One model through its routing layer.
• Jev on Cloudflare AI Gateway - X: Jev goes live on Cloudflare's AI Gateway, callable from Workers.
• Jev for instant compaction - X: argues agent context compaction should be a Jev decision rather than a summarization prompt.
• Reviewing unnecessary tool calls with Jev - X: a Claude plugin asks Jev to review redundant tool calls, running in about a second.
• 19 open-source Jev projects - X (Chinese): tallies 19 open-source Jev projects totalling more than 6,800 stars.
• Jev in the Wild - Research paper: surveys 2,170 public Jev GitHub projects to map early ecosystem growth, application domains, and decision-use patterns.
• Jev is the fish at the poker table - Blog: plays poker with Jev and uses the table to probe where a fast decision model helps and where it does not.
• Jev is about to change the AI economy - Substack: argues that cheap calibrated decisions move where inference spend goes.
• Awesome Jev by 0xLogicrw - X (Chinese): a hand-checked list of Jev projects that has since grown into a navigation site indexing 287 of them, published one day after launch.
• Jev repository roundup (Japanese) - X (Japanese): rounds up the Jev repositories with the most practical promise, observing that computer use and automated trading dominate the early use cases.
• Six things I'll still use Jev for - X: a practitioner lists the six Jev uses he still expects to rely on after 60 days, an early usefulness review rather than a launch reaction.
• WTF is Jev, ELI5 - X: frames Jev as "AI multiple choice, not AI essay writing", one of the clearer plain-language explanations of the System One shape.
• 深入解读 Jev 模型：毫秒级判定与工程边界 - Chinese deep-dive: examines Jev's millisecond judgments and, more usefully, where its engineering boundaries lie.
• Has anyone tried Jev as a relevance filter for RAG? - Reddit: builders ask whether Jev works as a retrieval relevance filter and reranker, probing the boundary the reported negative reranking result already hinted at.
• Can we have Jev in Devin? - Reddit: users of another coding agent ask for a Jev decision layer inside their tool, a signal that typed decisions are becoming an expected feature.
• All the coolest Jev projects on X - X: a curated thread of the strongest Jev projects posted within 72 hours of launch, by a builder who also produced the most-watched Jev tutorial.
• Full Jev tutorial - X: a walkthrough covering the API, then three demos — voice-controlled browsing, AI memory, and YouTube preprocessing.
• WTF is Jev, and the 9 things people are building with it - X: the most widely shared explainer of the launch window, framing Jev as "AI multiple choice, not AI essay writing" and cataloguing nine use patterns.
• Jev is a really smart switch statement - X: the hype-free framing from an infrastructure founder — Jev does not replace GPT or Claude, it is a very good switch statement with 2026 intelligence.
• Arbitrary classification as a type-safe primitive - X: argues the real novelty is not classification but that Jev makes arbitrary classification a runtime-defined, type-safe programmable primitive.
• This is a terrible compaction strategy - X: the strongest public pushback on the popular compaction idea, arguing compaction is reconstruction rather than filtering and that the plugin misunderstands context management.
• It is the inference technique, not the training - X: argues Jev's speed comes from parallel decoding rather than model training, and that an inference engine can expose a Jev-like API over any open-weight model.
• Jev's Architecture Unmasked - X (Japanese): notes from a technical analysis that inferred Jev's internals from roughly 10,000 API calls, concluding it keeps LLM knowledge but removes token generation entirely.
• An internal Jev study session with 50+ engineers - X (Japanese): a company ran an emergency internal study session on Jev and published the material — an early example of organisational adoption rather than individual experimentation.
• X is all over it, Reddit is not - X: observes a sharp platform divide, finding only three Jev posts on Reddit while X filled with working prototypes — a useful reminder that channel coverage changes the picture.
• Five open Jev replicas worth trying - X (Chinese): rounds up Laya 421M, Decider-2B, NanoJev 0.6B, Reflex, and System-One 4B as the most promising open decision models, two of which are Mac-friendly.
• jev(): a PostgreSQL extension for natural-language queries - X: a single SQL function that searches a whole database in natural language with no index and no embeddings, e.g. WHERE jev(people, 'could work from home').
• A DuckDB extension for row classification - X: classifies rows in any CSV, Parquet, or DuckDB table with Jev, reporting about ten seconds for a thousand rows and better ergonomics than a bespoke classifier.
• An on-chain trading bot where Jev decides - X: Jev decides buy or sell from a live price feed and the bot places real orders on Monad every 300 ms block — the clearest sign that the finance experiments are not all paper.
• Jev broke our WebMCP benchmark - X: the benchmark's own author reports that Jev plus a fast small LLM solved 100% of WebMCP tasks at roughly 112x lower model cost than a frontier model with computer use.
• Chinese notes after a day with Jev - X (Chinese): a sceptical read — Jev looks like a faster general classifier an LLM could already do, and on complex scenarios its world knowledge is the open question.
• Stagehand plus Jev browser control - X: sends the accessibility tree as state and candidate actions as questions so Jev decides each step, reporting about $0.001 and near-instant execution for one task.
• Introducing CUA-S1 - X: Cua open-sources a family of small, specialised System One models for computer use, starting with form filling and asking what the next specialist should learn.
• One 50 ms pass versus 23 turns - X: the sharpest framing of the specialist case - a 706K-parameter model fills a whole form in one 50 ms pass, while an LLM agent needs 23 turns and 39.6 seconds for the same form.
• I reviewed 287 open-source Jev projects - Reddit: a reviewer works through 287 Jev repositories and narrows them to 20 that actually explain the model, a useful counterweight to star-count browsing.
• TypeSafe AI's Jev Is Not an LLM - and That May Be the Point - News analysis: treats the model's refusal to generate text as the feature rather than a limitation, and follows through on what that implies for inference spend.
• Ask HN: What do you think of Noul, a new decision primitive - Hacker News: a proposal to treat Noul - the probability-of-true answer type - as a general software primitive rather than a Jev-specific one.
• When a designer gets access to Jev - X: a product designer's 33-second demo in which a natural-language phrase narrows a large icon set to the matching ones with Jev deciding which - 4.8k likes and a reply thread where the author discusses the icons Jev gets wrong.
• Made with Jev - Site: a directory of Jev builds, guides, and posts with reported cost and speed, plus free Jev-powered tools such as an AI slop detector.
• LangChain is already using Jev inside its harness - X (Chinese): reads LangChain's adoption as confirmation that Jev fits the fixed-harness roles - agent routing, model routing - rather than open-ended generation.
• Jev is now available to everyone, no waitlist - X: TypeSafe drops the waitlist and moves Jev from early access to general availability, the change that makes every other entry in this list reproducible by a reader.
• JEV captcha arbitrage - X: works through the economics of solving CAPTCHAs with Jev at $0.0068 per hundred against a marketplace paying a cent each, a pointed illustration of what per-decision pricing does to an existing market.
• A deep dive into Jev - Blog: a veteran technical writer's walkthrough of the System One idea, useful as the explanation to hand someone who has only seen LLM marketing.
• Replacing an agentic classification loop with Jev - Blog: swaps an agent's classification loop for a single Jev call and reports the loop running 7x faster.
• Awesome TypeSafe Jev - Curated list: a source-backed field guide with SDKs and live demos, the largest of the community indexes at 423 stars.
• 60 Jev use cases in Chinese - X (Chinese): rounds up sixty cases with twelve called out as most worth studying, organised around the same division of labour - the generative model writes, Jev classifies, scores, and chooses.
• Jev Tutorial - Site: an independent multilingual implementation guide to Choice, Score, Noul, Python SDK requests, confidence thresholds, deterministic fallbacks, and human escalation.
• TypeSafe pauses Jev signups - X: days after dropping the waitlist the vendor pauses signups again to protect quality of service, an unusually direct admission that demand outran capacity.
• Jev and the System One Model (Latent Space) - Podcast: Diogo Almeida on RLCD, intelligence per dollar, reliability, and why chat-first interfaces may not be where this ends up.
• Jev vs GPT-6 Astra: when to use each - Guide: Vercel's own decision guide for choosing between a System One model and a frontier model, published alongside a companion page of seven Jev use cases.
• A Jev index rebuilt every four hours - X (Chinese): describes a multilingual Jev site that scrapes X every four hours and has accumulated more than 5,380 posts, an index maintained by machine rather than by a curator.
• Jev 1.13 jaggedness - Documentation: TypeSafe's own page on model jaggedness for the 1.13 release.
• Jev cannot emit an invalid output, but where is the reliability curve? - Reddit: argues the type-safety guarantee is real and the calibration claim is not yet backed by a published ECE or reliability curve, the sharpest form of the question this list keeps running into.
• Jev is on Workers AI as typesafe/jev - Reddit: reports the model appearing on Cloudflare's Workers AI surface as typesafe/jev, a second Cloudflare integration alongside the AI Gateway listing.
• Why I couldn't build Jev at OpenAI - Video: Diogo Almeida's talk on why this had to be a separate company, the closest thing to a design rationale for System One models.
• TypeSafe's Jev Can't See. I Made It Guess What I Drew Anyway - Blog: a drawing-guessing experiment that probes what a model with no image input can still recover from a text description of a sketch.
• Spike: Jev as a judgement layer to cut model cost - Issue: a multi-agent orchestration platform plans to move judgment out of its model-of-thought and onto Jev, framed as cutting cost while holding quality.
• Awesome Jev Robustness - Curated list: 109 independent tests of Jev's calibration, consistency, prompt injection, abstention and failure modes, grouped by what they measured, each with model version and sample size.
• jevbooks: 16 Jev design patterns - Site: a bilingual gallery of 500+ open-source Jev projects in which Jev itself gates and tags every listing from its README, plus sixteen design patterns read out of ten codebases (Thermostat, Blind review, Flight recorder), each page a problem, a solution, and the recognition question the pipeline sends.
• Jev in 25 Lines of Python - Blog + HN thread (464 points, 139 comments): builds the smallest working Jev loop in Python, and the thread argues over whether the decision step needs a dedicated model at all.
• Will OpenAI eat Jev's lunch? - Analysis + HN thread (306 points, 215 comments): argues OpenAI is best positioned to fast-follow the typed-decision shape, and the thread debates whether the interface or the model is the moat.
• Jev introduces a new shape of LLM - Blog: Simon Willison's read on what changes when a model's output is a typed decision instead of prose.
• JevBench - Benchmark + HN thread (126 points, 34 comments): a reproducible harness for comparing typed-decision models on the same questions.
• Jev in practice: typed decisions, scoped authority - Blog: pairs the typed-decision loop with scoped authority, so a confidence value only authorises the action its scope already allows.
• jevchat - Repo + HN thread (173 points, 49 comments): deliberately misuses Jev as a generator to locate where the typed-decision model stops being useful.
• Open-sourced jev architecture last year - HN thread (96 points, 11 comments): a prior-work claim for the same architecture, where the discussion turns on recognition and marketing rather than on the technical overlap.
• Jev isn't new tech - Reddit (694 upvotes, 265 comments): the largest critique thread, arguing the marketing addresses people who think AI began with chat models.
• Jev deserves hype but not the type it's getting - Hacker News: separates the technical claim from the launch framing, and argues the former stands without the latter.
• Jev Can't Be Calibrated - Blog + HN thread (59 points, 60 comments): a statistical argument that the calibration claim cannot hold, with the methods written out.
• gev beats jev and takes images as input too - Benchmark: a head-to-head eval page where a rival model outperforms Jev on the same question set and additionally accepts images.
• I benchmarked TypeSafe's JEV against LLMs, BERT and Laya - Reddit (49 upvotes): pits Jev against both generative models and a classical classifier on the same task.
• The Jev archive built by OpenChamber - X: an independent site that has crawled X every four hours and collected 5,380+ Jev posts into a classified, multilingual index.
• zsh history completion with Jev - X: picks the most likely next command from the last 100 deduplicated history entries by asking Jev, and shows it greyed out after the prompt.
• TypeSafe AI draws $10bn interest - News (Financial Times, via Traders Union): reports that TypeSafe is attracting funding approaches that could value it at $10bn or more, a week after Jev left stealth.
• Vercel and OpenRouter adoption numbers - News: Vercel reports Jev drew more than twice the interest from paid developer accounts in its first 24 hours than any previous model launch on the service, and OpenRouter reports its token volume more than tripled over one weekend.
• Jev / TypesafeAI is revolutionary as LLMs - Reddit r/ArtificialInteligence (182 upvotes, 195 comments): the largest single thread on the launch, arguing over whether a decision model changes what LLMs are for rather than merely being cheaper.
• laya.tools - Site: an independent directory of about 950 projects built on Laya, the Apache-2.0 open alternative to Jev, imported daily from GitHub, npm, Hugging Face and X and browsable by platform and use case, with a Laya vs Jev comparison page.
• Diogo Almeida with a16z on Jev - X: the founder with Ben Horowitz and Martin Casado, pitching Jev by asking where all the decisions in a software stack currently live.
• Playwright CLI + Jev vs Playwright MCP - X: reports swapping the Playwright MCP for the Playwright CLI with Jev choosing each step, at 98% lower cost and twice the speed.
• Jev in front of the HeyGen MCP - X: a lead-generation pipeline where Jev decides which leads deserve a video in milliseconds before HeyGen renders it.
• Halv cut AI agent cost by 57.1% using Jev - Blog + HN: reports a measured cost reduction from putting Jev in the agent loop, on the SWE-rebench Astra pair set.
• Jev organized 2.3K research papers for 14 cents - X: a production use case reporting that sorting roughly 2,300 AI research papers took about 83 seconds and cost $0.14 in total.
• Jev in production at treg - X: the team behind treg, a 4,034-star agent-tool project, reports running Jev in production for web-traffic classification, onboarding and reranked search, at roughly 10x cheaper and 18x faster.
• Nine jobs where Jev replaces a pricey LLM call - X: lists nine places where a typed decision call can stand in for a full model call, as a starting set for scoping a migration.
• Jev explained for people who still do not get it - X article: written for readers who have gone through everything published about Jev and still find the point of a decision model opaque.
• Measuring what Jev does in a RAG pipeline - X (Chinese): instead of repeating the unsupported claims about Jev in RAG, builds a pipeline over 42 pages of the official docs and reports that the answer ranked first among 20 answerable questions went from 7 to 17, with none of the unanswerable ones handed to the model.
• Jev Decision Index - Index: an independent Space tracking 70 open reproductions of TypeSafe Jev as of version 0.2.1, the reference list for the replication wave.
• Deciding when work is finished with typed questions - X (Chinese): a practitioner's workflow for the wrap-up judgment, asking Jev yes/no, either-or and score questions from a local CLI when the machine is on and from a cloud SDK script when it is not.
• Can Jev save my inbox from the Democrats? - Write-up: a Hugging Face post on using a local decision model to clear a real inbox of political fundraising mail.
• Mastering TypeSafe Jev - Book: a hands-on engineering playbook for decision engines whose thesis is that code computes, LLMs create, Jev decides, and fresh state proves the result, with working Python and a mini-project in every chapter.
• Build your own decision model - Tutorial: explains that a System One model answers every allowed option with a calibrated probability in a single pass, where a language model constrained to emit the same JSON took 11 passes in the worked example.

Use exactly one line per entry:

- [Name](URL) - Industry: one-sentence description of the Jev use case.

1. Pick the category that best matches the direct Jev application domain.
2. Add a single-line entry in the required format to the category file, not directly to the README aggregate.
3. Keep the summary concrete and scannable.
4. Prefer examples that clearly show scenario + typed decision + value.

See CONTRIBUTING.md for details.

MIT