awesome-jev-tools

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.

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

What is Jev? Jev is not a chat model. It does not write text or hold conversations.

Instead, it takes unstructured state alongside a typed question and returns a typed decision—such as a choice, a score, or a boolean—accompanied by a confidence rating.By eliminating token-by token decoding, Jev acts as a fast, low-latency decision layer directly inside software.

Developers use it to handle classification, infrastructure routing, rubric scoring, verification gates, and autonomous agent guardrails.Goal of this ListMost discussions about Jev are scattered across launch threads, social media, and one-off prototypes.

This repository centralizes those pieces to answer two practical questions for developers:

• Production Validation: Where is Jev actively making real decisions in live production workflows?
• Transferable Patterns: Which decision architectures can be cleanly copied and applied across different industries?

Goal of this list

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?

Inclusion criteria

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.

Curation is not endorsement

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.

Current coverage

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

• Classification & Routing — 109 entries
• Adaptive & Realtime UI — 3 entries
• Verification & Guardrails — 96 entries
• Scoring & Ranking — 29 entries
• Agent Decisions — 80 entries
• Data Labeling & Curation — 4 entries
• Evaluation & Benchmarking — 58 entries
• Calibration & Research — 48 entries
• Infra / SDKs / Integrations — 249 entries
• Game & Simulation — 71 entries
• Robotics & Physical — 4 entries
• Finance & Trading — 6 entries
• Compliance & Legal — 2 entries
• Content Moderation — 7 entries
• Browser & OS Action — 48 entries
• CLI & Pipelines — 80 entries
• Code Navigation — 14 entries
• Context GC — 36 entries
• Creative Tools — 24 entries
• Data & Search — 44 entries
• Domain Tools — 79 entries
• Voice & Conversation — 4 entries
• Related Practices / Discussions — 97 entries

Open categories still being seeded

• Scientific Pipelines — 0 entries

Full list

Classification & Routing

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.

• 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.

• Codex Jev Router - Coding agents: asks Jev Choice and Noul questions to select Codex subagent model and reasoning tiers, with confidence gates and a Sol fallback.

• 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.

• Switchboard - Developer tooling: assesses a new Claude Code or Codex conversation with Jev, then local confidence policy selects and pins its model and reasoning effort through follow-ups, tool calls, and resume to avoid unnecessary prompt-cache disruption.

• 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.

• unclutter - Browser tooling: WXT extension where Jev decides per page element whether it is clutter, removing it under reusable template rules.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

• jev-tree - Classification: A hierarchical selector that asks Jev to traverse branches when a catalog has too many options for one question.

• litellm - Model Routing: LiteLLM can use Jev to classify requests for its complexity-based model router.

• oh-my-pi - Model Routing: Oh My Pi includes an optional TypeSafe judgment provider for bounded decisions in coding-agent workflows.

• jev-model-router - Model Routing: A community Claude Code Templates mod that uses Jev to suggest subagent models and reasoning levels.

• openchamber - Model Routing: OpenChamber’s optional automatic model router uses Jev to classify a message before selecting a configured model and reasoning level.

• firstmate - Model Routing: Firstmate can optionally use Jev to match task briefs to dispatch rules before local policy chooses an Agent configuration.

• hermes-jev-skills - Model Routing: Jev-powered model routing, memory, compaction, skill selection, computer and browser use for Hermes agents (also Claude Code and Codex)

• vexjoy-agent - Model Routing: An optional Jev routing path that matches VexJoy requests to specialist Agents, skills and workflows.

• WrongStack - Model Routing: An optional Jev dispatch classifier for choosing among WrongStack specialist Agents.

• jev-codex-router - Model Routing: Uses Jev to classify each Codex turn, then applies local rules to choose the model, reasoning effort, and speed mode.

• JevRouter - Model Routing: Routes among models, subagents, skills, MCP tools and CLIs using a shared candidate set.

• grok-bot-jev - Model Routing: Connect TypeSafe Jev to Grok Bot as a cheap decision layer - usage gates, skill template, examples

• loki - Model Routing: Loki optionally adds Jev typed-judgment tools and routes a new session to a model within the selected gateway.

• JevLoop - Model Routing: The agent loop where decisions don't cost a large language model call. Zero deps, runs offline, no API key needed.

• muse-jev-playbook - Model Routing: Jev decision layer for Muse: a fast, cheap TypeSafe AI gate before expensive agent work — confidence policy, recipes, reference router, honest measurement.

• sabi - Model Routing: Adaptive inference scheduling for AI agents — per-round model, effort and provider routing for coding harnesses: a Command Code mod or a local OpenAI-compatible proxy.

• typesafe-skill-router - Model Routing: An opt-in Hermes Agent plugin that asks Jev to suggest one relevant skill before a model call.

• dejevu - Model Routing: Jev? Déjà vu. Browser agents that run on instinct, no Jev needed. One look at the page, one call to any open model, one action. Faster than the Jev demo on Google Flights.

• jev-router - Model Routing: Cost-aware LLM router that picks the cheapest model capable of handling a query, using TypeSafe's Jev for fast classification instead of an LLM call.

• laya-jev-lab - Model Routing: Independent measurements of typed-decision models: Jev (TypeSafe API) vs Laya (open weights), and a local-first cascade that matches Jev's accuracy at 1.8x the speed

• Jev-Auto-Router - Model Routing: Jev Auto Router (Jev Router): experimental per-call GPT model routing for Codex via TypeSafe Jev and a local Responses proxy, with independent task verification.

• tool-prune - Model Routing: Calibrated tool selection and schema pruning for AI agents. Dual-engine: zero-dependency offline TurboQuant or TypeSafe System One (Jev). Prunes candidate MCP tools and schemas down to the relevant set before calling LLMs to eliminate hallucinations and save tokens.

• jev-for-all - Model Routing: Jev for every agentic development workflow — the System One decision model wired into whatever harness an agent codes in: OpenCode today, Claude Code and Hermes adapters next.

• Jev-Model-Router-Claude-Code - Model Routing: Begleitmaterial zum Video „Jev + Claude Code: 3 Use Cases".

• jev-opus - Model Routing: Claude Opus 5.5 with the effort level re-decided every step by the TypeSafe Jev reflex — without breaking the prompt cache. CLI + Claude Code plugin.

• jev-pilot - Model Routing: Let Jev steer Claude Code: the right reasoning effort, subagent model and skill for every prompt. A Claude Code plugin powered by TypeSafe's Jev (OpenRouter / TypeSafe).

• jev-claw - Model Routing: Typed model routing for OpenClaw agents, powered by TypeSafe Jev

• jev-model-router - Model Routing: Model router for Claude Code using Jev

• jev-router - Model Routing: Pass-through model router for Claude Code and Codex CLI that picks a model tier per human turn with Jev, TypeSafe AI's decision model

• jev-smart-router - Model Routing: JEV Smart Router — a Databricks App that uses TypeSafe JEV to pick which model answers each message, then runs inference on the chosen Databricks Foundation Model API endpoint.

• opencode-jev-orchestrator - Model Routing: An OpenCode orchestrator that keeps a cheap sticky parent model and, when Jev flags a hard turn, escalates through a child subagent.

• tiershift - Model Routing: Policy-driven model routing framework routing every LLM call to the cheapest capable tier in ~180 ms via TypeSafe Jev.

• todo-jev - Model Routing: A task-routing experiment combining skill conditions and environment checks to suggest rules, skills or a large model.

• chat2jev - Model Routing: Convert OpenAI-compatible Chat Completions requests into TypeSafe System One (Jev) **State / Questions**, compare generated text with structured judgments, and publish reusable question sets as proxy routes.

• Janus - Model Routing: Framework for measuring when to employ Jev versus generative LLMs on proprietary datasets, routing queries based on measured benchmarks.

• jev-codex-model-and-effort-router - Model Routing: Copy and paste this into your coding agent:

• jev-codex-pilot - Model Routing: A Codex overlay incorporating JEV to make the best decisions regarding model selection and depth of reasoning. All while automating the process via an automated Kanban system.

• jev-route - Model Routing: **Run it. Log it. Distill it. Own it.**

• jev-routing-experiment - Model Routing: Benchmarking TypeSafe's Jev decision model as a cost-efficient LLM router on RouterArena

• codex-jev-native-router - Model Routing: Experimental native Codex Desktop and CLI model routing with Jev and a configurable allowlist

• hermes-jev - Model Routing: Jev decision sidekick for Hermes Agent — TypeSafe and Cloudflare, explicit tools and official skill

• jev-agent-hooks - Model Routing: TypeSafe Jev hooks for Claude Code, Codex and pi: per-turn skill suggestion and subagent model routing

• jev-claude-router - Model Routing: Model router for Claude Code using Jev

• jev-model-router - Model Routing: Cost-optimized OpenRouter model router using TypeSafe's Jev, with a live full-catalog scorer instead of a hardcoded model list

• jev-router-playground - Model Routing: A model-routing playground where Jev picks a candidate and users compare the resulting answers.

• jevbus - Model Routing: A streaming event bus whose routing, subscription and consumption are decided by a probabilistic judge. The reference judge is TypeSafe AI's Jev (System One) model: send it a payload and a set of typed questions, get back calibrated probabilities instead of prose.

• openclaw-jev-plugin - Model Routing: A silenced message never reaches the language model, so it costs one Jev call and no model tokens. Direct messages always get an answer unless you choose to gate them too.

• stuntdouble - Model Routing: Drop-in /v1/systemone proxy that shadows Jev with local decision models (Kev, Laya) and reports whether you can swap

• hermes-jev-router - Model Routing: Hermes Agent plugin: TypeSafe Jev model routing + trim-then-compress

• jev-lab - Model Routing: Open lab: Jev (TypeSafe System One) routing in front of Claude Code - measured bugs, patch, and a hard fallback with alerts

• jev-research - Model Routing: A Jev and Herdr integration guide with a prototype for routing tasks to different Agents.

• JudgeJev - Model Routing: The public site replays **17 real, recorded Jev evaluations** of fictional support cases. It starts with a false shipping guarantee that scored **15.1%**, alongside a correct control that scored **95.5%**. You can inspect raw requests and responses, adjust decision rules, and see why a five-pair candidate fails a release gate.

• omp-plugin-jev-router - Model Routing: Route Oh My Pi prompts between simple and advanced models with TypeSafe AI's Jev classifier.

• jev-cc-codex-router - Model Routing: Per-turn model routing proxy for Codex: asks Jev which tier each task needs, rewrites the model, retries flaky upstream errors.

• jev-decision-gateway - Model Routing: A gateway that asks Jev continue / tool / verify questions and invokes a generative LLM only when policy says generation is needed.

• jev-demo - Model Routing: A customer-service routing demo that batches Jev questions before following the resulting route.

• jev-gateway - Model Routing: Session-aware OpenAI-compatible model-routing gateway powered by JEV

• 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.

• 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.

• 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-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.

• 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.

• 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.

• 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.

• 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.

• 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).

• 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.

Adaptive & Realtime UI

• 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.

• 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.

Verification & Guardrails

Source file: categories/verification-guardrails.md

• GeekLink Jev Subtitle Translator - Media localization: reviews source–translation SRT pairs with one Jev Noul decision per cue and flags suspected omissions or meaning changes for human review.

• 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 - 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 - 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, OpenRouter-only and experimental.

• 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.

• 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.

• 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.

• agentgateway - Security & Guardrails: A Jev guardrail example in Agentgateway using a webhook to inspect model requests and responses.

• Agent - Security & Guardrails: An optional Jev command-risk advisor inside a native macOS Agent, with a TypeSafeKit client.

• interlinked-cli - Security & Guardrails: Interlinked adds optional Jev judgments and evidence checks to local coding-agent checks.

• pi-warden - Security & Guardrails: Adds checks for project rules, out-of-scope actions, repeated failures, and completion claims to Pi Agents.

• building-with-typesafe-jev - Security & Guardrails: Unofficial skill that teaches coding agents to build with TypeSafe AI's Jev: typed decisions, calibrated confidence, and prior art from 150+ community projects.

• jevals - Security & Guardrails: Agent evals and guardrails as Jev decisions: one request per trace, a fraction of a cent, fast enough for the agent loop. Runs locally with Kev or Laya.

• captaincore - Security & Guardrails: Jev commands in the WordPress toolkit CaptainCore answer structured questions and prioritize malware scanner findings for review.

• jev-kit - Security & Guardrails: Everything you need to run TypeSafe's Jev with Claude Code: a tool-call guard, tier guard, file search, browser agent, review, belay, compaction and installers.

• jev-edge - Security & Guardrails: Typed-judgment admission control at the traffic edge: three-layer prompt-injection and abuse filter for nginx/OpenResty, powered by TypeSafe Jev. Fail-open, cached, hot-reloadable.

• pi-jev-auto-mode - Security & Guardrails: Adds rule checks to Pi commands and file operations, then uses Jev to assess cases that need further judgment.

• jevvy - Security & Guardrails: Jev-powered plugins for coding agents

• jev-safety-gateway - Security & Guardrails: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.

• jev-security-scan - Security & Guardrails: Reviews Agent Skills and MCP configurations and source code with local static checks and TypeSafe Jev before installation or execution, reporting file and line evidence, risk categories, model probabilities, and coverage gaps.

• jev-enforce - Security & Guardrails: 📏 Claude Code plugin that makes Claude follow your CLAUDE.md: every reply and edit checked by TypeSafe Jev ✅

• jev-engineering - Security & Guardrails: Jev Engineering: Typed Decision Systems for Reliable Agent Workflows. Paper, diagrams, and companion examples by Av1dlive.

• JevPR - Security & Guardrails: PR Risk review, automated by Jev

• pi-jev-sentinel - Security & Guardrails: Open-source Pi coding-agent extension that uses Jev to check tool calls before they run, scan files for prompt injection, flag risky replies, and keep secrets out of what it sends.

• dsh-jev - Security & Guardrails: Jev (System One decision model) plugin suite for DeepSeek Harness (dsh)

• jev-auto-approve - Security & Guardrails: Jev is a decision model: it answers a typed question with a calibrated probability rather than prose. This action asks it one yes/no question per thing worth being sure about — answered in parallel in a single call — and approves only when every one of them clears your threshold:

• jev-block-android-ad - Security & Guardrails: An Android notification and SMS filter that applies local OTP rules before asking Jev whether a message is advertising noise.

• jev-guard - Security & Guardrails: Probability-scored guardrails for Claude Code: deny rule-breaking edits and unasked-for deploys, route your docs into each prompt, and check the final answer against the turn's own evidence.

• jev-phishing-bench - Security & Guardrails: The signal result above was challenged on three points: no non-AI baseline, selection and evaluation on the same emails, and no equivalent decomposition for the LLM. Three controls were added (`bench/heuristics.py`, `bench/protocol.py`, `run_llm_signals.py`); nothing above was changed. Full tables in `results/report.md`, chart in `results/controls.png`.

• jev-tool-permissions - Security & Guardrails: Adds tool-call approval and tool-list pruning to the Vercel AI SDK.

• pi-jev-guard - Security & Guardrails: Check Pi code edits against repository Markdown rules with TypeSafe Jev

• agi-jev-containment - Security & Guardrails: **Open-source AI agent monitoring, malicious-agent detection, and escalate-only containment** for sandboxed LLM agents. Local HackSpain 2026 stack (AngryRobot dashboard): FastAPI, React/Vite, Neo4j. Classifies a *chain of actions*, not a single tool call. A model never pulls the plug.

• jev-baselines-eval - Security & Guardrails: Every latency number here is **wall-clock duration of one API call** measured in the client: a timestamp before the request, another after the full response body is read ([`code/run_b1.py:32`](code/run_b1.py), [`code/common.py:50`](code/common.py)). Non-streaming on both sides, so these are completion times, not time-to-first-token.

• jev-model-tokengate - Security & Guardrails: An OpenAI-compatible proxy that sits between your LLM and your users. It evaluates each sliding window of tokens **while the response is still streaming** and cuts the stream **before** a violating token can reach the screen.

• open-jev-approvals - Security & Guardrails: Binary approval gate for Codex and Claude Code — every intercepted tool call is reviewed by TypeSafe JEV and composed through a versioned local policy, with scoped authorization.

• reflex - Security & Guardrails: A coding agent and personal assistant built on the Pi coding agent. Jev checks every tool call, turn and voice transcript, and code decides what happens next: allow, ask or block an action, which model tier to use, and whether a "done" was actually verified.

• ego-jev-ultrafast - Security & Guardrails: Jev drives your Ego Lite browser: one typed-choice request per step. Single-file, zero-dependency port of browser-use/jev-ultrafast with multi-model benchmarks and extra guardrails. Unofficial.

• jev-decisions - Security & Guardrails: Jev Decisions Plugin for Hermes (and other AI Agents): tool risk reviews, human approval recommendations, evidence checks, and a local decision journal.

• jev-guard - Security & Guardrails: High-speed, cross-agent safety gate plugin for **Claude Code**, **Codex CLI**, and **Antigravity**.

• jev-secret-detection - Security & Guardrails: Benchmark and tool evaluating how well TypeSafe Jev identifies real secret credentials in file snippets.

• jevshield - Security & Guardrails: Sub-100ms security gate for AI agent tool calls, powered by TypeSafe's Jev (System-1) decision model. Single-request Choice/Noul/Score evaluation, dual-factor blocking matrix, calibrated-confidence routing, fail-closed parsing, zero-config local fallback. LangChain-ready.

• oc-plugins - Security & Guardrails: The oc-auto-perms plugin in an OpenCode plugin collection uses Jev to check tool intent against natural-language rules.

• actiongate-jev - Security & Guardrails: Open-source Jev tool-calling authorization gateway for AI agents: deterministic policy, exact-action single-use permits, MCP and HTTP enforcement.

• antivirus - Security & Guardrails: A file scanner that sends extracted features to Jev for a verdict, a 0–4 severity score, and Noul indicators, then applies local quarantine or review rules.

• claude-jev-plugin - Security & Guardrails: TypeSafe Jev semantic guardrails for Claude Code

• dsh-jev-verify - Security & Guardrails: Jev (TypeSafe System One) decision tools + live verification benchmark for DeepSeek Harness: jev_decision (choice/score/noul) and jev_verify, honest by design.

• grok-jev-guard - Security & Guardrails: `grok-jev-guard` sits immediately before a meaningful Grok Bot tool sequence. It receives a compact description of the pending operation and returns one explicit action:

• jev-cvss - Security & Guardrails: Scripts that use Jev to select CVSS metrics from vulnerability descriptions, then compute v3.0, v3.1 or v4.0 scores in Python.

• jev-pii-checker - Security & Guardrails: A CLI that sends text to TypeSafe Jev for PII category Nouls and a sensitivity Score, then locates spans with regex and segmentation.

• jev-risk-check-provider - Security & Guardrails: x402check — LIVE payer-intent risk checks for x402 agent commerce: typed decisions (TypeSafe Jev), ES256-signed attestations, mainnet USDC settlement. did:web:x402check.xyz

• opencode-jev-guard - Security & Guardrails: When FarHand is active, the agent's commands run on a remote host through the `farhand_remote_shell` MCP tool instead of `shell`. OpenCode's permission request for an MCP tool carries no arguments, so the plugin takes the command (and its `cwd`) from the `execute.before` hook, which OpenCode runs first.

• claude-jev-warden - Security & Guardrails: Real-time quality gate and Art Director Warden for Claude Code powered by TypeSafe Jev 1.13 non-autoregressive decision model

• guardrail-chatbot-jev - Security & Guardrails: It is a library, not a service. You call it, you get a verdict, and your code decides what to do. It runs in **Python and TypeScript**, both reading the same policy file, so the two sides of your stack cannot drift apart. Neither package has a third-party dependency.

• jev-chrome-extension - Security & Guardrails: 1. Open any website. 2. Click the Jev icon. The side panel opens on **Drive**. 3. Type a goal, e.g. *Search Wikipedia for "espresso" and open the article*, and press **Run**.

• jev-preflight - Security & Guardrails: A bounded Jev risk check for Claude Code: eight risk axes, one request, one optional reinspection.

• jev-reasoning-navigator - Security & Guardrails: En lugar de depender de heurísticas matemáticas frágiles o distancias vectoriales locales de coseno, `JEV-Reasoning-Navigator` utiliza **TypeSafe AI (`typesafe-sdk`)** como motor único y autoritativo de decisión cognitiva:

• jev-test - Security & Guardrails: Prototype: AI-assisted NZQA marking from rubric criteria alone, using TypeSafe Jev for guardrails, criterion scores and confidence-based triage. NOT ENDORSED BY NZQA - CONCEPT ONLY

• momus-review - Security & Guardrails: Code review on rust and javascript (+languages soon) applications. Following lenses correctness, security, reliability, compatibility and testGap.

• pkg-gate - Security & Guardrails: Pre-install security gate for npm lifecycle scripts using TypeSafe System One. Evaluates preinstall, install, and postinstall hooks across intent, threat severity, secret access, and remote execution to intercept supply-chain attacks before execution.

• traffic-guard - Security & Guardrails: High-throughput traffic and attack defense gate for incoming HTTP traffic with zero required dependencies, wire-order header validation, and TypeSafe System One acceleration for bot mitigation, exploit detection, and risk scoring.

• laya-browser-guard - Security & Guardrails: A passive, privacy-first Chrome security copilot that combines deterministic browser-visible checks with local Laya and official Jev typed decisions. It evaluates redacted evidence from scripts, resources, forms, headers, and DOM signals, then explains investigation priority without attacking the target.

• 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.

• 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-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.

• 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.

• 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.

• 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.

• 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.

Scoring & Ranking

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-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.

• 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.

• 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.

• 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-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-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.

• Refix - Growth: AI that helps your product grow faster on autopilot by running product experiments, SEO, content, and ads.

• jevsearch - Site search: shadcn/ui ⌘K search block that streams local keyword hits, then sends the top 20 to Jev in one request (a Noul per candidate, a Choice for the best page, a Noul for whether any page answers) to re-order or drop hits, reporting Hit@1 of 83% versus 41% for keyword search alone on 41 labelled queries over the TypeSafe docs (author's benchmark).

• JevPDF - Document search: browser PDF viewer that extracts each page's lines with pdf.js, asks Jev one Noul per line ("does this line answer the query?") in batches of up to 16 lines sharing the page text as state, and highlights lines ranked by probability as each page returns; only text reaches Jev, through a key-holding proxy.

• 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.

• jevseo - SEO and AI-answer visibility: a deterministic crawler extracts every page of a business site, Jev answers a narrow typed Choice/Score/Noul question set per page, and application code turns those probabilities into ranked findings under three confidence bands with the grey zone routed to a needs-a-human pile rather than acted on; it runs locally on one port with no API key through the keyless Zen tier, publishes no search-volume numbers at all because Jev carries no index or volume data, and its source is UNLICENSED (all rights reserved) - unrelated to the other jev-seo entry above.

• 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.

• 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.

• 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.

• 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.

• 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.

• 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.

Agent Decisions

Source file: categories/agent-decisions.md

• 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.

• robo-harness - Robotics: SO-101 arm workbench where a Jev decision runner picks bounded joint steps from typed candidate actions under a spend budget.

• 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: agent skill that maps Choice, Score, and Noul onto classical methods so an agent can place typed judgment in software, with a composition algebra, question-design diagnosis, and a validation gate that requires a falsifying experiment.

• 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 - Systematic software development framework for AI coding agents upgraded with TypeSafe Jev System One typed decisions, zero-hallucination package vetting, and completion gates.

• 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-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.

• 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.

• Jevonian - Coding agents: local OpenAI / Anthropic / Responses-compatible proxy where one Jev call answers both the model route and the thinking level for jevonian/auto from session state, quota health, candidate capabilities, and cache-switch penalties; deterministic code filters candidates and owns every threshold first, a pinned model or explicit jevonian/ skips Jev entirely, and each decision lands in a local ledger with the serving model, reason, real token usage, and estimated cost.

• 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-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.

• 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.

• killmyidea - Decision Tools: A startup-idea evaluation demo assigning KILL, FIX or SHIP labels from Jev scores.

• jevify - Decision Tools: An Agent Skill for finding suitable Jev decision points and designing questions and comparison experiments.

• hermes-jev - Decision Tools: An asynchronous Jev companion for Hermes Agent covering relevance, completion, recovery and optional admission decisions.

• claude-jev - Decision Tools: Claude Code plugin: Jev for rule checks, verbatim compaction, and prompt routing

• wechat-jev-assistant - Decision Tools: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.

• jev-chat-windows-deepseek-jev - Decision Tools: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.

• Jev-chat-assistant - Decision Tools: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.

• jev-skill-router - Decision Tools: Claude Code plugin: asks TypeSafe Jev which installed skill fits each prompt and logs the answer (shadow-first). A working reference for the skill-suggestion cookbook on Claude Code — the README records why it is unlikely to help a strong model as a router.

• jev-apply - Decision Tools: In Codex, Claude Code, or another CLI agent:

• jev-bot - Decision Tools: Self-hosted Jev decision workbench and Feishu bot: automatic choices, probabilities, and experimental word/character writing.

• dsh-jev - Decision Tools: DSH bundle that registers jev_ask for TypeSafe Jev noul, choice, and score answers.

• jev-chat-windows-laya - Decision Tools: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.

• jev-demos - Decision Tools: Every demo lives in its own folder with its own README, dependencies and instructions. Most run without an API key in a clearly labelled `SIMULATED` mode; put `TYPESAFE_API_KEY=...` in the demo folder's `.env` for live results.

• Jev-in-the-Loop - Decision Tools: Researching how Jev can accelerate tasks that rely on LLM decision-making.

• jev-laya-benchmark - Decision Tools: Speed and accuracy benchmark: TypeSafe's Jev API vs the local Laya MLX typed-decision model on synthetic tasks

• jev-predict-skill - Decision Tools: An Agent skill recipe that predicts another skill’s closed-set outcome from its rules and evidence.

• astra-jev-harness - Decision Tools: The default `batch` policy retains an entire batch when any judgment is uncertain. The experimental `select --policy per-file` retains uncertain/unjudged files while omitting confidently irrelevant siblings. Dependencies and the global no-match fallback still apply. Compare before changing policy; fewer bytes alone do not establish correctness.

• jev-codex-router-skill - Decision Tools: Portable Codex Skill for Jev model and reasoning-effort routing, with safe installation and Chinese usage guides

• jev-playground - Decision Tools: A web playground for entering state and decision questions, then inspecting Jev answers and probability distributions.

• fake-real-jev - Decision Tools: See link entry, the live scan timer, JEV's evidence-checking role, a saved REAL example, a saved FAKE example, and the linked sources. The live documentation scan shown ended without a verdict; its credit was returned. The coffee reports are clearly labeled saved examples, with their original analysis times.

• jev_projects - Decision Tools: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.

• jev-crawlers - Decision Tools: Jev learns your repo's decision norms, then adversarially judges past decisions against them. Unix-style primitives (seed, expand, judge, verify, report, norms) with per-node typed judgments from typesafe-ai/jev.

• jev-linter-action - Decision Tools: `glob` accepts one pattern or a newline-separated list. All matched files are reviewed together by default; `per-file: true` reviews each file independently. Missing inputs, malformed questions and ambiguous combinations fail before calls.

• jev-no-enem - Decision Tools: Reproducible benchmark evaluating TypeSafe AI's Jev (System One paradigm) on Brazil's ENEM 2025 standardized exam. Evaluates typed decision-making, domain-specific accuracy, and RLCD uncertainty calibration against open LLM baselines with an interactive GitHub Pages dashboard.

• jev-triage - Decision Tools: Millisecond-class test-failure triage for coding agents: RETRY / FIX_CODE / FIX_ENV, powered by TypeSafe Jev.

• Jevatar - Decision Tools: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.

• jevchat - Decision Tools: A chat-style Jev demo whose answers are selected from predefined or custom options rather than generated prose.

• JevCode - Decision Tools: JevCode - Jev can code. We want to dogfood JevCode

• typesafe-jev-ruby - Decision Tools: Ruby client for Jev, TypeSafe's System One model: typed questions, probabilistic answers. Zero runtime dependencies.

• xjevboost - Decision Tools: Add as much tabular data as you want to Jev models using adaptive ensembles that learn to query only the rows and columns needed.

• turing-jail - Decision Tools: Interactive three-level AI interrogation game powered by TypeSafe Jev; write responses and pass plea, logic, and paradox verdicts to earn release.

• 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-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 (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.

• 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.

• 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.

• jev-chat - Messaging: an Android accessibility service reads the conversation in WeChat, QQ, X, or Feishu, asks Jev Choice over candidate replies, and fills the draft box while sending stays manual; a Windows port does the same from offline OCR of the WeChat window.

• 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.

• 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-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.

• 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.

• 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; each point acts on its verdicts by default, can be switched to shadow or off, and writes every verdict to a local ledger, and in the repository's replay benchmark goal-aware test-log selection by Jev cut 40-46% of the log without losing a required line.

Data Labeling & Curation

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

• 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.

• 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.

• 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.

Evaluation & Benchmarking

Source file: categories/evaluation-benchmarking.md

• 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).

• Odin R&D: Jev vs open-weight Laya - Model evaluation: runs the same 48 hand-written choice/score/noul rows through Jev's hosted /api/v1/systemone and a pinned open-weight Laya on a Mac (MLX, checked row-by-row against Laya's own reference code) under pre-registered refutation criteria, publishing the raw results record, 46/48 vs 39/48 accuracy, and a reproduce command.

• latitude-llm - Evaluation & Observability: Latitude includes an optional Jev preclassifier for conversation checks and their selection records.

• jev-review - Evaluation & Observability: A local MCP code-quality reviewer returning structured scores to coding Agents.

• taskuary - Evaluation & Observability: An optional Jev judgment module in Taskuary for checking user-defined conditions on task state.

• Canny - Evaluation & Observability: Keeps an execution ledger for Claude Code and Codex CLI to check for passing validation after edits.

• jev-playground - Evaluation & Observability: A MoonBit and TypeScript Jev playground covering games, browsers, command risk and small languages.

• typesafe-ai-benchmark - Evaluation & Observability: Compares Jev with other structured-output models on shared application tasks, recording errors, latency, Tokens, and estimated cost.

• goodwatch-monorepo - Evaluation & Observability: A film-and-TV attribute-scoring experiment inside GoodWatch comparing Jev question designs and batch sizes.

• jev-benchmarks - Evaluation & Observability: A benchmark comparing Jev and GLiNER on text classification, probability calibration and selective automation.

• jev-rerank-bench - Evaluation & Observability: Compares Jev, dedicated rerankers and chat models on the same retrieved passages.

• jev-benchmark - Evaluation & Observability: Benchmarks Jev on chess moves and identifying which game NPC a player addresses.

• jev-lm - Evaluation & Observability: A word-level generation experiment that asks Jev to select words or verify locally drafted continuations.

• jev-chat - Evaluation & Observability: A research chat decoder that repeatedly asks Jev to choose words or phrases and assembles them in code.

• jev-frontend-qa - Evaluation & Observability: Frontend QA that uses Jev to choose browser actions and checks contracts through DOM, HTTP and database evidence.

• jev-behavior-study - Evaluation & Observability: An independent Jev 1.13.0 behavior study recording successes and failures across question framing, input conditions and games.

• jev-exploration - Evaluation & Observability: A research repository tracking Jev claims and limitations, with calibration experiments and runnable examples.

• jev-gomoku - Evaluation & Observability: A nine-board, 15×15 Gomoku workbench comparing how two Jev players respond to different input representations.

• jev-agent-failure-benchmark - Evaluation & Observability: A benchmark using Jev to attribute multi-Agent failures to an Agent, step and error type.

• ask-jev - Evaluation & Observability: A Windows PowerShell tool for auditing recorded Codex execution evidence with :jev.

• jev-synergy-screening - Evaluation & Observability: A Jev title-and-abstract screening experiment compared with Cohen Abstract Triage labels for an ADHD review.

• hermes-jev-north-star - Evaluation & Observability: A Hermes goal-checking skill that saves requirements, creates a run prompt and checks completion evidence.

• jev-calibration-audit - Evaluation & Observability: Audits Jev calibration, option-wording effects and Korean judgments through public APIs and datasets.

• jev-demos - Evaluation & Observability: Maze experiments comparing Jev single-step choices with multi-step lookahead.

• jev-eval - Evaluation & Observability: Compares Jev and OpenRouter models on labeled tasks for accuracy, calibration, latency and cost.

• jev-flash-review - Evaluation & Observability: An MCP review engine that evaluates Agent-supplied diffs against explicit rules.

• foreman-jev - Evaluation & Observability: An experimental Jev supervisor for Codex workers with programmer-selected acceptance commands.

• 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.

• 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.

Calibration & Research

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 tiny Jev-like model on top of Qwen2.5-0.5B that trains and runs on a MacBook, shipped with its own research runs and evaluation scripts.

• jevinci - 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.

• RSI-Jev - Trainable replica: an open 2B model answering Noul, Choice and Score on the same POST /v1/systemone wire format in one forward pass, over text or, since v4.0-VL, up to four images, researched and trained by a recursively self-improving AutoScientists loop that publishes every experiment it ran — 86.6 AUROC zero-shot on 2,162 VisA inspection photos (Jev-Omni 81.1, Gemma 4 12B 82.9) and 80.3% on five held-out image benchmarks.

• 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.

• OneJev - Open models: multimodal System One model in four sizes (0.8B to 27B); typed questions about a screenshot, photo, video or text get a calibrated probability for every option in one forward pass.

• TetraJev - General decisions: two frozen open-weight readers give four readings per item (letter + per-candidate yes/no), fused fit-free and routed by agreement into auto-release or human review; evaluated across eight decision suites and a RAG reranking pass with published coverage–accuracy curves; no training, and it does not call the TypeSafe API.

• 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).

• WebJev - Specialist decision model: Apache-2.0 open-weight Qwen3.5-35B-A3B fine-tune for browser agents, served by vLLM behind the same POST /v1/systemone and /api/alpha/decisions routes so a Jev client switches by changing only the base URL and key; inside the unchanged jev-ultrafast agent it completes 38.52% of 125 hand-picked real-website tasks graded by deterministic verifiers, against 16.67% for Jev 1.13.

• 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.

• 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.

• 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 r