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?

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?

We do not include:

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

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

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

Before adopting an entry, check it yourself:

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

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 — 79 entries
• Data Labeling & Curation — 4 entries
• Evaluation & Benchmarking — 58 entries
• Calibration & Research — 48 entries
• Infra / SDKs / Integrations — 249 entries
• Game & Simulation — 70 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 — 43 entries
• Domain Tools — 79 entries
• Voice & Conversation — 4 entries
• Related Practices / Discussions — 97 entries

• Scientific Pipelines — 0 entries

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.

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

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.

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.

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

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.

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.

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 research: turns open LLMs into Jev-style decision models that read typed decisions and calibrated probabilities from next-token prefill distributions with zero fine-tuning, reducing order-flip rate and calibration error.

• Verdict - Open alternative: Apache-2.0 118M multilingual bi-encoder that answers Choice, Score, and Noul questions on the same POST /v1/systemone wire format, calibrated with temperature scaling plus a split conformal abstain set with a coverage guarantee (ECE 0.01 to 0.03 on the public suites), runs on CPU or in the browser via ONNX, fits on your own labels in seconds, and its README says it loses to Laya on typed decisions (0.71 vs 0.77).

• Jev-MedQA - Medical QA: a Jev-style implementation on Qwen3.5-4B that selects answers to text and image questions in one forward pass, reporting 69.42% accuracy versus 67.41% for standard generation with a 10.37x speedup across 153,889 questions from nine medical QA benchmark sets.

• Jev Prime - Text generation: a conversational agent with no language model, where every word is picked from ~4,700 options by Jev Choice questions one at a time, with confidence driving lookahead when the top pick falls below 0.65, beam search across sentence directions, and a self-critique loop that rewrites sentences scoring below threshold; live at talktojev.com, paper at doi.org/10.5281/zenodo.22940945.

• CLM - Open alternative: an 8B System One model that answers the same Choice and Noul questions behind a TypeSafe-compatible API, matching Jev across computer-use, gaming and tool-calling with up to 9x lower latency and reporting 87.6% on Terminal-Bench 2.1 as a fine-tuned verifier.

• Bespoke Nimble - Open alternative: a LoRA on Qwen3.5-9B that scores one allowed answer token per Choice, boolean or rubric-score question, released with its data pipeline, training config and eval harness under Apache-2.0, and reporting 90.1% on its 324-example holdout against Jev's 93.2%.

• NeoHorse-Jev - Open alternative: Apache-2.0 4B decision model from TokenRhythm that answers Choice, Noul and Score questions via prefill-only inference on NeoHorse-1-4B, deployable with vLLM, SGLang or a native Python/CLI/HTTP runtime, scoring 77.70 across six text benchmark groups (highest among open-weight entries with complete results in its published comparison).

• Jeff - Open alternative: MIT-licensed Qwen3.5 and Gemma 4 fine-tunes answering choice, noul and score on the same /v1/systemone format at about 22 ms per decision, published with a panel that measures Jev itself at 0.828 accuracy and 0.053 ECE while stating it claims no statistical significance.

• AutoJev - Open recipe: a 27B multimodal decision model trained with full-weight SFT on 73,000 examples over one H200, serving choice, noul and score on /v1/systemone with per-checkpoint provenance and calibration plots released.

• Lev - Open alternative: a 4B LoRA on a Qwen backbone published as a System One decision model and tagged for calibrated decisions, classification, routing and moderation.

• openjev - Open implementation: ranks a Doom action menu with one /score call per step and supports per-task fine-tuning, released under MIT with the terminal run recorded.

• Jev-Omni - Multimodal System One: a Gemma-4-12B fine-tune that answers typed questions over text, images, audio and video, at 1,402 downloads in its first ten days.

• Bekko System One - Open decision models: independent 17M–400M English models for Choice, Noul, and Score, with public weights, training code, and an ONNX browser demo; v0 remains substantially behind Jev on the project's generalization tests.

• jevcrypto - Creative experiment: a crypto.randomUUID() look-alike npm package that writes Jev's raw Noul probabilities on 15 code-point permutations of any prompt, plus one Choice for the variant digit, into the bytes of a UUID v4-shaped string; deliberately not cryptographically random.

• Vev - Open alternative: an open-source Jev implementation with vision input, LoRA fine-tuned on Qwen3.5-4B and 9B, serving Choice, Score and Noul questions on the /v1/systemone wire format with screenshots and photos placed directly in the state so one decision can use both text and image; weights are CC BY-NC 4.0, non-commercial only.

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

• eve - Agent frameworks: Vercel's eve engine ships Jev as the default evaluation model (typesafe-ai/jev) in its experimental evaluate path.

• AI CLI - Developer tooling: Vercel Labs CLI that can run Jev as the evaluation model for its evaluate command.

• jev-mcp (jkudish) - MCP ecosystem: proof-of-concept MCP server that puts Jev claim verification, content screening, and candidate ranking behind standard MCP tools.

• jev-mcp (blakestone-x) - MCP ecosystem: MCP server exposing Jev classify, score, check, match, and screen as tools for any agent, with confidence on every answer.

• zio-typesafe-ai - Scala ecosystem: ZIO client for TypeSafe AI with a typed DSL over Jev decisions.

• TypeSafe AI Swift SDK - Swift ecosystem: dependency-free Swift 6 client for Jev Choice, Score, and Noul questions with strict concurrency, configurable authentication and retries, and offline transport tests.

• laravel-typesafe-jev - PHP ecosystem: unofficial Laravel integration for Jev with typed responses, async requests, scoped dependency injection, and testing fakes.

• advocaat - Data tooling: small type-safe client for asking Jev questions about a dataset.

• jevclient - Python ecosystem: async client for Jev published on PyPI.

• LlamaIndex Jev - Retrieval / RAG: unofficial LlamaIndex adapter where Jev Scores each retrieved passage and Choice/Noul selects the query engine, with nfcorpus nDCG@5 0.340→0.396 at about $0.0003/query.

• safer-with-jev - Cloud infrastructure: Neon Function proxy for the Neon AI Gateway that routes decisions with Jev.

• typesafe-ai/skills - Official tooling: installable agent skills package (npx skills add typesafe-ai/skills) that teaches agents the Jev workflow.

• Smithers - Agent frameworks: TypeScript workflow framework with a Jev session checker wired into its workflows.

• skillbox - Skills infrastructure: self-hosted versioned skills library that adds optional Jev recommendations using your own TypeSafe or Gateway key.

• Jevbridge - Agent bridges: ACP and MCP adapter that exposes Jev typed decisions to Codex, Claude, Grok, and other LLMs.

• jev (Elixir) - Elixir ecosystem: GenServer client that replies with Jev's answer so callers can pattern match on it directly.

• jev-go - Go ecosystem: community Go SDK for Jev.

• jev-cli - Developer tooling: small dependency-free CLI for Jev.

• decide-mcp - MCP ecosystem: configurable decision server with percentage scores and bias-profile routing on top of Jev.

• typesafe-jev-examples - Starter examples: worked ticket-triage and reranking examples runnable through OpenRouter without an early-access key, shipped with their own sample data and Makefile.

• ai-python - Python ecosystem: the official Vercel AI SDK for Python carries Jev through its evaluation operation and Gateway examples.

• Cline plugins - Coding agents: Cline's official plugin collection includes a Jev-driven browser plugin (jev-browser), so Jev arrives as a first-class Cline capability.

• hono-jev-router - Web frameworks: Hono middleware that routes HTTP requests by meaning rather than by method and path, deciding with Jev.

• rotom - Local gateways: OpenAI- and Anthropic-compatible API gateway that carries Jev through its model catalog and evaluation path.

• Jev AI - Developer tooling: public Jev playground and API that puts typed Choice, Score and Yes/No questions to the model about pasted text - ticket triage, moderation, review scoring - and returns a parsed answer with a confidence value in about 0.5 s per decision.

• jevql - Data tooling: psql-shaped CLI and Go/TypeScript/Python SDKs that run plain SQL on a vanilla Postgres (no extension) and then ask Jev Noul, Choice, or Score questions about each surviving row so the client can apply jev() filters, jev_prob sorts, and jev_choice groups.

• sqlite-jev - SQLite ecosystem: loadable C extension and Python package that expose Jev Noul, Choice, and Score judgments as SQL functions and batched virtual-table queries with confidence results.

• jevkit - Developer tooling: Rust CLI that validates Choice/Score/Noul question sets with 13 offline lint rules before any Jev call, then sends the canonical wire payload and prints parsed, confidence-bearing JSON answers to stdout using exit code 2 to reject a billed-but-useless request.

• jev-use - MCP ecosystem: Claude Code / Codex / pi plugin (MCP server + library, native pi extension) that hands agent steps needing no text output to Jev as typed judgments — untypeable and generation-needing questions are rejected before the call, low-confidence answers come back flagged as priors, and a fail-open PreToolUse gate can only deny or ask.

• huncho - TypeScript ecosystem: dependency-free SDK that turns Jev Noul, Choice and Score answers into named decisions with enter/exit thresholds (hysteresis), nested decision trees settled in one call, a JSONL journal, replay of a threshold change over recorded answers with no inference, and Brier/reliability calibration, over TypeSafe direct, OpenRouter or Vercel AI Gateway.

• jev-experiments - Demo collection: 22 latency-focused Jev applications built by Devin, each with its own README and testing notes, spanning shell guards, log sentinels, instant search, reranking, and voice turn-taking.

• ruby_decision_model - Ruby ecosystem: client for decision models such as Jev, so Ruby applications can put typed questions directly to the model.

• s1_ruby - Ruby ecosystem: makes System One measurement, and the collapse that follows it, a Ruby primitive, with a TypeSafe provider behind its own spec suite.

• kojev - Kotlin ecosystem: Kotlin Multiplatform (JVM, Android, iOS) client for Jev that answers Choice and Score questions as the caller's own enums, with one typed way to read answers, no default thresholds, and offline MockEngine tests.

• hunch - Python and TypeScript ecosystem: libraries that turn Jev Choice, Score, and Noul questions into functions over lists and DataFrames (classify, score, check, where, extract, pick, rank, verify), with request deduplication, caching, and optional escalation of unsure rows to an LLM that must pick from the same labels; TypeScript port at hunch-js.

• stuntd - Local runtime / learning proxy: Jev-compatible local server on Laya that also proxies a Jev upstream, records every Choice, Score and Noul decision, trains a head per decision site, and answers live with calibrated confidence, falling back to the upstream below its threshold.

• should-i-jev - Migration tooling: dependency-free CLI that scans LLM logs and code for decision-shaped calls, prices the Jev migration, asks a Jev endpoint which call sites to take (--jev-selfcheck), calibrates typed answers against ground truth (ECE, reliability, risk-coverage), and generates a reviewable migration PR with Choice/Score/Noul map sketches.

• vellum-assistant - MCP & Integrations: An optional Jev provider in Vellum Assistant sends conversation state and explicit questions to TypeSafe.

• typesafe-mcp - MCP & Integrations: An MCP server that lets Claude Code, Claude Desktop, Codex and Pi ask Jev typed questions.

• pi-typesafe - MCP & Integrations: A Pi Jev extension providing a decision tool, terminal playground commands and an API for other extensions.

• Jevbridge - MCP & Integrations: Exposes a shared structured-decision interface for Jev and other models through ACP, MCP and a CLI.

• synkora-ai - MCP & Integrations: Synkora includes optional TypeSafe client tools for classification, scoring and yes/no judgments.

• jev-judge-mcp - MCP & Integrations: Typed judgment tools for MCP agents. TypeSafe's Jev model as verify, screen, find, classify, rerank, decide, compare, extract, review, gate, and score: the model judges, policy decides auto, review, or escalate.

• plasmallm - MCP & Integrations: A Jev Decisions adapter in a KDE Plasma assistant widget for displaying structured judgments.

• jevwire - MCP & Integrations: Provides Jev MCP tools, an embeddable library and Claude Code hooks for Agents.

• harness-router - MCP & Integrations: Fast decision routing for agent harnesses — native MCP with Jev for tool selection and MCTS for multi-step decisions.

• jev-codex-plugin - MCP & Integrations: Open-source Codex plugin for TypeSafe Jev decision consultation, failure diagnosis, and evidence-based completion review

• jev-mcp - MCP & Integrations: An MCP server and Claude Code plugin for Jev classification, scoring, checks and batched questions.

• jev-classifier - MCP & Integrations: A local Jev tool-routing gateway for coding Agents, with an MCP suggestion interface.

• tenbin - MCP & Integrations: Documentation, an MCP server and a Skill for designing Jev judgments with question linting, batch evaluation and calibration.

• jev-agent-kit - MCP & Integrations: jevkit: fast typed decisions for agents. CLI and MCP tools (route, triage, guard, grep, rank, compact, judge) on TypeSafe Jev. Zero dependencies.

• Jev-AI-Skill - MCP & Integrations: One AI skill + MCP server for Claude Code, Codex and Hermes: Jev (TypeSafe) gates large-model turns (event triage, review verdicts, owner questions, tool choice), runs build-and-repair loops with independent review, routes models and skills, and guards Git steps. Script-only watch mode and a shared HTTP server.

• jev-as-quant - MCP & Integrations: Typed System-1 decisions (Laya/Jev) as the judgment layer of a quant research stack, with Claude as System 2. Requirements → design → code → experiments.

• jev-mcp - MCP & Integrations: An evaluation-focused Jev MCP server for individual questions, batch processing and question or threshold comparisons.

• jev-mcp-server - MCP & Integrations: MCP server for Jev (TypeSafe System One): the three official question types — choice, score, noul — plus batch classify. Calibrated probabilities, ~0.5s, <$0.001/call.

• jev-skill-router - MCP & Integrations: Keep skill catalogs outside the main LLM context. Jev selects relevant skills through one read-only MCP tool.

• jev-workbench - MCP & Integrations: Defines, tests, and publishes Jev decision functions in a local UI so backends and Agents can call fixed versions.

• jev-agent-toolkit - MCP & Integrations: Jev-first portable Agent Skill and optional MCP bridge for Claude Code, Codex, Cursor and compatible agents.

• jev-mcp - MCP & Integrations: MCP server wrapping TypeSafe's Jev System One models — typed noul/choice/score judgments for AI agents

• jev-mcp - MCP & Integrations: Local MCP server exposing TypeSafe Jev (System One decision model) as native Claude Code / Codex tools

• jev-mcp - MCP & Integrations: MCP server for Jev (TypeSafe AI's System One model) — give any agent typed, calibrated decisions: classify, score, check, gate risky tool calls. Try free: jevtypesafeai.com

• jev-mcp-spring - MCP & Integrations: On success each tool returns its typed result directly. On failure the tool call fails at the MCP protocol level (`isError: true`) with a short, safe message — no response body or stack trace is ever echoed back.

• jev-playwright-mcp - MCP & Integrations: Jev-augmented Playwright MCP proxy — page-state triage, prompt-injection shielding, goal-based snapshot pruning, risky-action gating. Drop-in wrapper around @playwright/mcp for any coding agent.

• jev-rust-review - MCP & Integrations: Rust-aware code review for Claude Code and coding agents, powered by TypeSafe Jev

• jev-toolkit - MCP & Integrations: MCP-first toolkit for TypeSafe/Jev — the System One decision model. One stdio server (jev mcp) serves any MCP-capable harness, backed by one local event log and Prometheus impact metrics you can scrape into your own Grafana.

• n8n-nodes-jev - MCP & Integrations: Jev by TypeSafe AI for n8n: typed decisions, probabilities, and confidence-aware workflows

• n8n-nodes-typesafe-jev - MCP & Integrations: An n8n community node for submitting typed questions to TypeSafe Jev.

• toolJev - MCP & Integrations: Code Mode for MCP, where the sub-model is a calibrated decision model (Jev), not an LLM. Benchmarked on MCPToolBench++, LiveMCPBench, When2Call and live Claude agents.

• typesafe-jev-mcp - MCP & Integrations: This repository is an MCP server for TypeSafe Jev that provides a single evaluate tool taking state plus typed questions and returning noul, choice, or score answers with probabilities.

• typesafe-jev-opencode - MCP & Integrations: Jev is not a conversational replacement for Gemini, Claude, or GPT. It evaluates application state against typed questions and returns structured answers and probabilities that an agent can use to route or gate work.

• jev_ampcode - MCP & Integrations: An Amp plugin for comparing supplied alternatives against supplied evidence and priorities.

• jev-eyes - MCP & Integrations: Also in the state: `image` (size, source), `blocks` (`[x, y, w, h]` boxes with OCR confidence) and, if installed, `labels`. `see(img, compact=True)` keeps only `image`, `text` and top label names when tokens matter more than positions.

• jev-in-mcp - MCP & Integrations: MCP relay that adds use_jev to every server: Jev picks the tool calls, the calling model writes the values Jev cannot choose, the relay executes. Built on jev-dev-kit.

• jev-mcp - MCP & Integrations: MCP local que expone Jev (TypeSafe) como herramienta para Claude Code, Codex, Hermes y cualquier agente: ask_jev y list_jev_models, sin dependencias

• jev-mcp - MCP & Integrations: A Rust MCP server for TypeSafe AI Jev structured decisions

• jev-mcp - MCP & Integrations: `jev-mcp` exposes TypeSafe AI's Jev decision model as four conservative, read-only MCP tools for **bounded probabilistic decisions**.

• jev-mcp-open-source - MCP & Integrations: Self-hosted Jev MCP on Cloudflare Workers with intent routing, retrieval reranking and batch judgments

• jev-review-mcp - MCP & Integrations: Single-purpose MCP server (one tool, one job): a code-review gate powered by TypeSafe Jev (System One decision model).

• jev-routing - MCP & Integrations: Go Jev harness for Claude Code, Codex, and Grok Build. No npx. Not an MCP server.

• jev-screen-mcp - MCP & Integrations: Single-purpose MCP server (one tool, one job): a content-moderation gate powered by TypeSafe Jev (System One decision model).

• jev-tool-search - MCP & Integrations: Tool search for LLM agents: BM25 vs embeddings vs rerankers vs Jev on 525 real MCP tools, plus an experimental Jev search engine

• jevmod - MCP & Integrations: Moderation for communities and apps: every message gets a probability for **spam, scam, harassment, nsfw, off-topic, self-harm, doxxing, sexual content involving minors**, and for **rules you write in plain English**. You set the thresholds and the actions. Every decision is logged with its numbers.

• mcp-server-jev - MCP & Integrations: Typed AI decisions for Codex, Claude and any MCP client, powered by TypeSafe Jev. Classify, score and evaluate with one generic tool.

• openclaw-typesafe-ai - MCP & Integrations: An independent OpenClaw plugin registering one explicitly invoked typesafe_decide tool.

• openrouter-jev-mcp - MCP & Integrations: A Python decision gateway and Model Context Protocol (MCP) server exposing TypeSafe's Jev model through OpenRouter's decisions endpoint to Claude Code, Codex, and Cursor agents.

• composio - SDK & Decision Frameworks: An optional TypeSafe provider for Composio that uses Jev to choose among tools and bounded argument options.

• ai - SDK & Decision Frameworks: The TypeSafe provider in AI SDK lets TypeScript applications call Jev through the shared evaluate interface.

• eliza - SDK & Decision Frameworks: An optional TypeSafe HTTP adapter in Eliza’s source, not registered with the Agent runtime by default.

• langchainjs - SDK & Decision Frameworks: An optional LangChain.js TypeSafeClassifier integration for sending state and predefined questions to Jev.

• rig-typesafeai - SDK & Decision Frameworks: An experimental TypeSafe crate in Rig for expressing Jev questions and answers with Rust types.

• jev - SDK & Decision Frameworks: jevos is an open-source, Jev-compatible alternative to TypeSafe's Jev for yes/no decisions that runs entirely on a laptop CPU. Send text plus a yes/no question over HTTP and get back P(yes) from a single forward pass of a 1B model — no text generation, no GPU required.

• req_llm - SDK & Decision Frameworks: A TypeSafe provider for calling Jev through ReqLLM’s evaluate interface in Elixir.

• simple-jev - SDK & Decision Frameworks: Adapter turning open LLM endpoints into Jev-compatible classification services without training a separate classifier head.

• jev-skill - SDK & Decision Frameworks: This project is a collection of Jev use cases, workflows, and agent skills with a stdlib-only Python decision wrapper.

• openjev - SDK & Decision Frameworks: An independent System One decision server compatible with Jev’s API, running an open DiffusionGemma model.

• instructor-php - SDK & Decision Frameworks: A TypeSafe Decision driver within Instructor PHP’s Polyglot module.

• jev-visual - SDK & Decision Frameworks: Local Jev-like visual inference experiment on Apple Silicon Mac. Scores and classifies single images across multiple questions with 3 playable game demos.

• jev-dsh-decision - SDK & Decision Frameworks: Provides Jev structured decision support for Agent Harness to recommend tools, Skills and Agents and return judgments with probabilities, with a native DeepSeek Harness plugin and an iPolloWork entry serving OpenCode, DeepSeek Harness and Codex Harness.

• pi-fabric - SDK & Decision Frameworks: Pi’s programmable runtime includes an optional Jev loop for observing state, making decisions and running bounded actions.

• typesafe-sdk-js - SDK & Decision Frameworks: The JavaScript and TypeScript SDK published by TypeSafe, with typed Jev requests and answers.

• openai-scala-client - SDK & Decision Frameworks: A dedicated TypeSafe module in a Scala client that supports multiple AI providers.

• typesafe-sdk-python - SDK & Decision Frameworks: Official TypeSafe Python SDK with synchronous and asynchronous clients for Jev System One, plus question and answer types.

• jevbench - SDK & Decision Frameworks: JevBench v1 - a benchmark for Jev-class typed decision models: smart, cheap, fast, reliable, open.

• runline - SDK & Decision Frameworks: A TypeSafe plugin exposing Jev decisions as callable actions in Runline Agent JavaScript.

• ai - SDK & Decision Frameworks: A Jev forwarding endpoint in the Hack Club AI proxy, using its authentication, limits and usage logging.

• effect-agent - SDK & Decision Frameworks: An Effect Agent TypeSafe decision provider for typed question sets and optional model selection.

• jeview - SDK & Decision Frameworks: An unofficial local visualizer for Jev (TypeSafe): a live view of every call your code makes. Not affiliated with TypeSafe AI.

• Jev - SDK & Decision Frameworks: Unofficial TypeSafe Jev showcase — System One decisions, not chat.

• solar-mini4-jev - SDK & Decision Frameworks: A drop-in wrapper that exposes Upstage **Solar Mini4** through the TypeSafe Jev System One API shape.

• ask-jev-skill - SDK & Decision Frameworks: A skill for Hermes and other agents to query TypeSafe Jev for bounded option judgments and confidence escalations.

• go-jev - SDK & Decision Frameworks: Go SDK and CLI for TypeSafe Jev: typed decisions (yes/no, choice, score) from a model

• jev-capability-atlas - SDK & Decision Frameworks: This repository collects real Jev API-call receipts, test suites, and bilingual guides to map which narrow-decision tasks suit Jev and how Agents should evaluate and report fit.

• minojev - SDK & Decision Frameworks: Decisions, not tokens: minojev reads calibrated, typed probability distributions straight from hidden states in one forward pass — zero output tokens, fully reproducible on a laptop CPU.

• jev-agent-design-with-topk-logits-choices - SDK & Decision Frameworks: Research design for a Jev-native agent system: tool integration, speculative parameter proposals, external helper logits Top-k proposals with Jev-controlled fallback ,decision-aware hierarchical memory, and dependency-aware replanning.Feature:Jev naturallanguage conversation prototype using external helper logits and dynamic Top-k token selection.

• jevalyn - SDK & Decision Frameworks: The decision layer for your Rails app. A Rails-native wrapper around TypeSafe's Jev System One API: typed, calibrated decisions in your control flow.

• jev-to-answer - SDK & Decision Frameworks: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.

• swift-jev - SDK & Decision Frameworks: A Swift client for TypeSafe AI's Jev — typed judgements, not text

• swift-typesafe - SDK & Decision Frameworks: A community Swift TypeSafe client with typed questions, dynamic questions and response parsing.

• discern - SDK & Decision Frameworks: A semantic control-flow library for Effect: Jev's `Choice` / `Noul` / `Score` answers become typed branches. Thresholds are caller-supplied, and an answer below them takes an explicit `Uncertain` branch the compiler forces you to handle rather than being rounded up to the top label. Procedure routing filters candidates with deterministic predicates first and skips the model call entirely when one candidate survives.

• jev-rs - SDK & Decision Frameworks: System One judgments (noul/choice/score) from any LLM in one prefill — a Rust, Jev-compatible /v1/systemone engine

• typesafe-ai - SDK & Decision Frameworks: A Rust TypeSafe client with asynchronous reqwest or blocking ureq backends and observable retries.

• learn-jev-end-to-end - SDK & Decision Frameworks: **Learn Jev end to end** is a free, hands-on course. In 12 short notebooks you go from *"what is Jev?"* to building **13 real AI tools** with it: an email triage job, a scam-text detector, a code vulnerability hunter, an agent safety guard and more. You need **one API key**, and running the whole course costs **less than $0.20**.

• typesafeai-dotnet-sdk - SDK & Decision Frameworks: Community .NET SDK for TypeSafe AI and Jev, providing asynchronous typed evaluation for Choice, Score, and Noul primitives.

• jev-dspy-lab - SDK & Decision Frameworks: Reproducible calibration and selective-risk benchmarks for Jev/TypeSafe decisions in DSPy workflows

• typesafe-sdk-java - SDK & Decision Frameworks: A community Java TypeSafe client with a Spring Boot Starter for configuring Jev calls.

• jev-ai-sdk-form-router - SDK & Decision Frameworks: Route form submissions to the right people with Jev and AI SDK.

• SpecPi - SDK & Decision Frameworks: A Pi configuration and extension bundle with an optional Jev advisor for capabilities and workflow checks.

• typesafe-sdk-go - SDK & Decision Frameworks: A Go TypeSafe SDK for defining typed questions and reading Jev choices, scores, and probabilities.

• zod-jev - SDK & Decision Frameworks: Adds semantic rules to Zod validation, such as checking whether text matches a description or contains personal information.

• hermes-jev-plugin - SDK & Decision Frameworks: TypeSafe Jev (System One) decision tools for Hermes Agent: jev_check / jev_route / jev_score / jev_evaluate

• jev-dsl - SDK & Decision Frameworks: An early Haskell DSL that describes labeled Jev questions, renders requests and decodes matching answers.

• jevgo - SDK & Decision Frameworks: Unofficial Go client for the TypeSafe AI System One API (Jev) — typed questions in, calibrated answers out.

• JevOps - SDK & Decision Frameworks: Jev is a **gate**, not a generator. This package does **not** write Lean. Lake (or another oracle) lives in the implementation that *uses* the kernel.

• typesafe-sdk - SDK & Decision Frameworks: A community Ruby client for TypeSafe System One, defaulting to jev-latest.

• daf-jev - SDK & Decision Frameworks: A Python toolkit for Jev requests, batch evaluation, calibration and MCP access.

• jev_jsonschema - SDK & Decision Frameworks: `probabilities` is keyed by your schema's values, not Jev's internal labels, so a score of `1`–`5` reads as `"1"`–`"5"` and not `"0"`–`"4"`. Noul questions carry no confidence of their own, so `confidence` is `None` for booleans and numbers.

• open-bonsai-jev - SDK & Decision Frameworks: openjev's mechanism, Bonsai's weights: typed decisions read straight from one forward pass of a 1.75-bit 27B model. Credit to TheoLeeCJ (SemIf/OpenJev) and PrismML.

• typesafe-ai-rs - SDK & Decision Frameworks: An independently maintained Rust SDK with async and blocking clients, retries and response metadata.

• jev-android - SDK & Decision Frameworks: A Kotlin Android SDK for UI automation powered by TypeSafe Jev, with an accessibility runtime and sample app.

• jev-go - SDK & Decision Frameworks: A Go TypeSafe System One client with typed questions, answers and batching helpers.

• jev-sdk-java - SDK & Decision Frameworks: Type-safe Java 21 client for the TypeSafe AI Jev (System One) decision API

• jevriel - SDK & Decision Frameworks: **Codex · Claude Code · Portable skill** | [Apache-2.0 code and docs](LICENSE) | Early release

• typesafe_sdk - SDK & Decision Frameworks: An Elixir TypeSafe SDK that brings Jev’s typed questions and probabilistic answers into Elixir applications.

• usejev - SDK & Decision Frameworks: Run Laya locally with Bun: native ONNX inference, a TypeSafe-compatible API, and a bilingual decision playground.

• goodall - SDK & Decision Frameworks: An optional TypeSafe package in a Go Agent library, using Jev as a tool or routing judge alongside chat models.

• jev - SDK & Decision Frameworks: A Go client for the TypeSafe AI's System One API and its model, Jev.

• jev-java - SDK & Decision Frameworks: Unofficial Java SDK for TypeSafe Jev and Vercel AI Gateway, with Spring Boot and WebClient support

• jev-pilot - SDK & Decision Frameworks: Fast System-1 Decision, Arbitration & Safety Engine for Autonomous AI Agents (Powered by TypeSafe Jev)

• jevlang - SDK & Decision Frameworks: The simplest way to write decision workflows in Python. Python with a smart if.

• questions - SDK & Decision Frameworks: A TypeScript decision library that asks typed questions via Zod or native batches, defaulting to TypeSafe Jev, with optional Vercel or generative adapters.

• ask-jev-ai - SDK & Decision Frameworks: Most AI demos generate text. Jev does not. It reads a sentence and returns typed answers with probabilities: a choice, a yes or no, a score. That makes it usable as a primitive inside ordinary code rather than a chatbot bolted onto a page.

• jev-does-not-play-dice - SDK & Decision Frameworks: Code, recorded outputs, and analysis scripts for probability-output experiments with Jev: fair random draws, Noul (Yes/No) questions, and forecast documents.

• jev-layer - SDK & Decision Frameworks: Portable System-1 decision layer for agent harnesses with host-owned routing, receipts, replay, and fail-open integrations.

• jev-numeric - SDK & Decision Frameworks: **Both are multiway decision trees; decimal-digit decoding is a ten-way instance.** On an aligned decimal grid, they can have identical branches and leaves, expressed through different prompts. The digit is a **Choice option**, not a vocabulary token; Jev returns the option probabilities directly.

• Jev4Mellea - SDK & Decision Frameworks: This is an unofficial, synchronous adapter. Jev evaluates text; it does not generate or repair it.

• jevex - SDK & Decision Frameworks: An Agent experiment where Jev directs a tool loop, a chat model fills arguments and prose, and MCP tools execute.

• typesafe-ai-rails - SDK & Decision Frameworks: Ruby on Rails integration gem for TypeSafe AI and Jev, providing model-level classification and decision policy patterns.

• typesafe-sdk-rust - SDK & Decision Frameworks: A Rust client for TypeSafe with asynchronous and optional blocking calls plus typed question and answer wrappers.

• dsh-jev-decide - SDK & Decision Frameworks: This DSH plugin registers TypeSafe Jev as an Agent tool that returns calibrated probabilities for noul, choice, and score judgments without generating text.

• everything-about-jev - SDK & Decision Frameworks: tell you everything about jev,TypeSafe AI's System One model for typed decisions.

• jev - SDK & Decision Frameworks: Ruby client for the typesafe AI Jev model

• jev-benchmark - SDK & Decision Frameworks: Rubric-Based Zero-Shot Classification Benchmark: Jev vs Claude Haiku 4.5 vs Claude Sonnet 5 vs OpenJev on rubric-conditioned classification, chained decision execution, and exam grading -- with full price tracking.

• jev-builder - SDK & Decision Frameworks: A browser form for building requests to TypeSafe's Jev: pick a template, fill in the blanks, copy the request. No JSON, no install, runs locally.

• Jev-Persian-Benchmark - SDK & Decision Frameworks: Benchmarks for **Jev** on **480 authored general Persian questions** and a **24-excerpt classical Persian poetry pilot** (48 main questions plus 48 controls). Related general questions are batched; poetry questions run individually. Raw responses are saved and answers are scored locally, without a runtime model judge. The general benchmark's historical Laya comparison is retained below.

• Jev-PhoneControl - SDK & Decision Frameworks: Visual Android automation powered by three agents: vision, a text-only supervisor, and TypeSafe JEV. Executes actions through ADB with a local web console.

• jev-skills - SDK & Decision Frameworks: Practical agent skills and examples for building with Jev. API setup, routing, ranking, and evidence checks.

• jev-web-analyzer - SDK & Decision Frameworks: See what Jev thinks about your SaaS website — powered by ReplyNodes web context and Vercel AI Gateway.

• jevclient - SDK & Decision Frameworks: An asynchronous Python Jev client that batches typed questions in one request.

• jevgo - SDK & Decision Frameworks: A community Go client with a standard-library core and optional Langfuse tracing.

• jevrag - SDK & Decision Frameworks: Replaces hardcoded RAG thresholds with explicit calibrated decision points. Five primitives (retrieval stopping, chunk splitting, context selection, answer abstention, cache trust) behind one swappable state → Decision → confidence → action interface, each evaluated on real datasets with a calibration harness that reports honestly.

• qualm - SDK & Decision Frameworks: A TypeScript wrapper for Jev decisions with an explicit unsure branch.

• typesafe-go - SDK & Decision Frameworks: An unofficial Go client without third-party dependencies for System One calls and model discovery.

• typesafe-sdk-php - SDK & Decision Frameworks: A community TypeSafe SDK for PHP 8.2+, with synchronous calls and Guzzle-based async requests.

• jev - SDK & Decision Frameworks: Unofficial Go client for TypeSafe's System One API and its model, Jev.

• jev_dart - SDK & Decision Frameworks: Jev Dart SDK to build cli, server and Flutter apps.

• jev-architecture-research - SDK & Decision Frameworks: Black-box reverse engineering research archive for the Jev decision model

• jev-by-example - SDK & Decision Frameworks: Ten runnable Jev examples for agent decisions: memory conflicts, tool-result checks, recovery, context selection, and handoffs. JavaScript, zero dependencies.

• jev-doom - SDK & Decision Frameworks: Watch Jev play Freedoom in a local dashboard. TypeSafe direct and Vercel AI Gateway, inspectable decisions, and bounded spending.

• jev-go - SDK & Decision Frameworks: A small unofficial Go SDK for Jev calls and model listing.

• jev-phone - SDK & Decision Frameworks: Drive a phone with a model that never writes a word. TypeSafe's Jev picks each action, phone-use runs it on iOS and Android.

• jev-starter - SDK & Decision Frameworks: TypeScript patterns for thresholds, fallbacks, human review and evaluation on top of the TypeSafe SDK.

• typesafe-ai-jev-example - SDK & Decision Frameworks: This repository provides six runnable Python demos and four notes covering TypeSafe Jev primitives and composition patterns, with offline mock mode and committed live samples from jev-1.13.0.

• typesafe-go - SDK & Decision Frameworks: A TypeSafe System One client that uses only the Go standard library to send Jev questions and read structured answers.

• typesafe-go - SDK & Decision Frameworks: An unofficial Go SDK with typed answers, retries and context cancellation.

• typesafe-rs - SDK & Decision Frameworks: A community Rust Jev client with async requests, an optional blocking interface and local mock testing.

• claude-jev-mod - SDK & Decision Frameworks: Typed decisions in Claude Code: adds $.jev over TypeSafe's Jev, through OpenRouter, Vercel AI Gateway, Cloudflare Workers AI, LiteLLM or the TypeSafe API.

• jev_playground - SDK & Decision Frameworks: Jev answers typed questions about a state with calibrated numbers. This repo is where we find out which of those numbers deserve to drive code, and where a regex or a constant does the job better.

• jev-go-sdk - SDK & Decision Frameworks: Dependency-free Go client for TypeSafe AI's System One API and the Jev model

• jev-is-not-odd - SDK & Decision Frameworks: A probabilistic, AI-powered utility to determine if a number is not odd (or not even) using TypeSafe's Jev model and the Vercel AI SDK.

• jev-lab - SDK & Decision Frameworks: This repository provides a single-page classifier demo that sends text with choice questions to Jev and displays the request JSON, probability distribution, confidence, latency, and token usage.

• jev-lab - SDK & Decision Frameworks: Hands-on research lab for TypeSafe's Jev (System One model): reproducible benchmarks of Noul/Choice/Score primitives, confidence gating, fan-out latency, agent control — plus a living audit of the Jev ecosystem.

• jev-labs - SDK & Decision Frameworks: Never confidently wrong: a TLA+-verified consensus kernel around TypeSafe's Jev, run through 1,680 chaos-tested pharmacy decisions with zero wrong verdicts. Film, code, and every captured call.

• jev-msw - SDK & Decision Frameworks: Mock Jev API decisions with MSW for deterministic tests without real API calls or credits.

• jev-swap - SDK & Decision Frameworks: Find the LLM calls in your codebase that are really decisions, see what they'd save on TypeSafe Jev, and prove it on live traffic before you swap. TypeScript, JavaScript, Python.

• jev-tab-order - SDK & Decision Frameworks: **Organize the entire window with a single Jev API request.** Grouping and ordering decisions are evaluated together, regardless of the number of tabs.

• jev-triage - SDK & Decision Frameworks: Automated issue & PR triage for open-source maintainers, powered by Jev (TypeSafe AI).

• jevcore - SDK & Decision Frameworks: A judgement primitive for TypeSafe **System One / Jev** — ask N things × K typed questions in bounded, cheap, fail-open requests — plus the **JEV harness**, the closed boundary in code that makes a Jev answer safe to consume. Standard library only.

• jevinf - SDK & Decision Frameworks: An inference engine for decision models of the Jev kind: each candidate path runs as segmented forwards with prefix reuse, and the Jev wire contract is served on top. NanoJev is the backend wired up today.

• jevish - SDK & Decision Frameworks: Every mode auto-curries when called with only the patterns:

• jevpolicy - SDK & Decision Frameworks: JevPolicy is an open-source TypeScript decision runtime that turns probabilistic judgments from Jev, accessed through Vercel AI Gateway, into versioned, deterministic, replayable, observable application decisions.

• Jevs-Garage - SDK & Decision Frameworks: System One turns unstructured or structured state into fast probabilistic judgments. Instead of asking for free-form prose, these demos ask `Choice`, `Score`, and `Noul` questions and receive typed values with uncertainty that application code can reason about.

• typesafe-ai-ruby - SDK & Decision Frameworks: A stdlib-only Ruby client that sends Choice, Score, or Noul questions to TypeSafe System One.

• typesafe-sdk-swift - SDK & Decision Frameworks: An experimental Swift SDK for TypeSafe using Swift Package Manager, Swift concurrency, and URLSession.

• TypeSafeSDK - SDK & Decision Frameworks: An unofficial .NET client that POSTs state and typed questions to TypeSafe /v1/systemone. The parent repo also contains unrelated SDK dumps.

• langchain - SDK Integrations: An optional Jev classifier integration for Python LangChain workflows.

• pydantic-ai - SDK Integrations: An optional TypeSafe provider and Jev model integration for Pydantic AI.

• ax - SDK Integrations: Ax provides a TypeSafe integration for boolean or finite-class signatures and native Jev answers.

• ruby_llm-typesafe - SDK Integrations: A TypeSafe provider for RubyLLM 2 that exposes Jev’s three judgment types through structured output.

• jev-resilience - SDK Integrations: A Spring WebFlux integration that detects error messages hidden in HTTP 200 response bodies.

• laya-mlx - Local runtime: independent MLX port of the Laya checkpoints that runs typed decisions natively on Apple Silicon — 13.4 ms median end-to-end per short English decision, 7.4 ms with the multilingual checkpoint, and zero output tokens, with no PyTorch, Transformers runtime, or cloud API.

• laya-Ascend - Local runtime: Ascend NPU fork of the Laya checkpoints that answers the same Choice, Score and Noul questions on Huawei 910B hardware — 37–47 ms median for a four-question request, 33.8x–70.9x faster than the same request on a single container CPU thread, with an output-equivalent SDPA decision head that avoids torch_npu's CPU fallback on aten::_transformer_encoder_layer_fwd.

• jev-trust - Python ecosystem: trust middleware for the Jev API that logs every typed decision, measures calibration in your own domain from outcomes you record (accuracy, Brier, top-label ECE, C = 1 − ECE), annotates each answer with its measured effective confidence, fires overconfidence alerts, and signs the evidence (ed25519) for independent recomputation.

• JarvisCore - Agent frameworks: Python multi-agent runtime that ships Jev natively from 1.12, where agents ask typed Choice, Score and Noul questions through a decision client separate from the text model, the Kernel picks a specialist subagent by Choice, and each retrieved RAG passage is withheld from the generating model when its prompt-injection Noul exceeds 0.70.

• hunch (carldaws) - Ruby ecosystem: turns judgment calls into control flow — if Hunch.likely?("fraudulent", given: order) reads like plain Ruby but branches on a typed Jev answer, with pick for Choice, rate for Score, and graded predicates from possibly? to almost_certainly?; a TypeScript port offers the same interface.

• Early experimentation using Jev to rethink harness UX - Harness integration: an agent platform wires Jev into its LLM harness as a callable tool for search, approvals and context, reporting 2,000 expense reports categorized in 20 seconds for five cents.

• jev-mcp (burnigtm) - MCP ecosystem: server that puts Jev into the coding loop for Cursor, Codex, and any MCP client, with 20 test files behind it.

• jev-architect - Design skill: finds, designs, and evaluates Jev decision loops, packaged as a skill with references on decision design and delivery.

• Building a Harness with Jev - Framework guide: LangChain's walkthrough of wiring Jev into an agent harness as the decision layer, from a team that then published its own evaluation of Jev as a judge.

• system-one-adapter-python - Python ecosystem: TypeSafe AI's official open-source drop-in adapter for running and benchmarking Jev System One decision evaluations across OpenAI- and Anthropic-compatible LLM APIs.

• neurolink - Provider abstraction: the pipe layer of an AI nervous system — Juspay's TypeScript interface connecting provider neurons to an application, with decide as a first-class inference type alongside generate and stream.

• jev-spring-boot-starter - Java ecosystem: Spring Boot 4 starter that puts Jev behind Spring MVC and RestClient.

• mysql-ailike - Database filtering: MySQL plugin that filters rows by a natural-language predicate instead of a literal one, powered by Jev.

• FastJev - Local runtime: self-hosted Python SDK and System One-compatible API for runtime-defined Choice, Boolean, and Score decisions on pinned open models across Torch, vLLM, MLX, llama.cpp, and WebGPU, with committed row-level benchmarks and checksums.

• Search with Jev and Milvus - Search engineering: nine runnable notebooks combine Gemini embeddings and Milvus retrieval with Jev Noul and Choice judgments, while Python applies ranking, filtering, routing, and stopping policies to synthetic examples.

• jeff (logan-markewich) - Self-hosted runtimes: self-hosted drop-in replacement for TypeSafe Jev powered by GliFormer, exposing native Choice, Score, and Noul decision endpoints without cloud API dependencies.

• CloJev - Clojure ecosystem: unofficial portable Clojure SDK for System One, so Clojure applications can put typed questions to Jev without a Java interop layer.

• spring-ai-typesafe - Java ecosystem: Java SDK for TypeSafe AI's Jev API and Spring AI integration, providing typed decisions for evaluation as a judge, guardrails, and RAG post-processing.

• JevFlow - TypeScript ecosystem: composes Jev Noul, Score, and Choice decisions into deterministic threshold workflows that batch into a single systemOne call and return an ordered, explainable action set instead of side effects, with matched rules recording the actual value behind each action and a mock provider so policy tests run without an API key.

• Jev AI Tools - Developer education: hosts six bounded recipes plus a custom builder for AI SDK Choice, Score, and Boolean evaluations; recipes display answer probabilities separately from provider confidence and use deterministic local thresholds to pause uncertain routes for review, while every configuration exports as TypeScript.

• jev-foundation-models - Apple platforms: a Swift 6 bridge that runs Jev decisions through Apple's Foundation Models on device, with a protocol-based model interface and six tests.

• cu-Jev - Inference engine: a CUDA-native implementation of the Jev System One API that keeps decisions GPU-resident, shipping a Starfighter demo and a benchmark script.

• jevcache - Cost control: memoizes Jev-class decisions so a repeated question is served from cache instead of a new call, keeping repeats deterministic and free.

• Qwev - Local inference: turns dense Qwen3 and Qwen3.5 checkpoints into a training-free Jev-style Noul, Choice, and Score service that shares one state prefill across isolated questions and, on its included 27-question Qwen3.5-9B/A100 fixture, reports 0.500 s versus 13.554 s for generated JSON.

• jev-sdk-go - Go ecosystem: dependency-free Go 1.24+ client for Jev Noul, Choice and Score questions that reads Choice and Score answers back as the caller's own types, rejecting any label or level the question never offered, with retries, OpenRouter support, and eleven examples tested against an in-process fake of the API.

• jevcompat - Interoperability: a 48-requirement spec of the POST /v1/systemone wire contract, each rule citing TypeSafe's docs, OpenAPI file or SDKs, and a suite that checks any Jev-compatible server against it (Choice probabilities keyed by option and summing to 1, Score equal to Σ i·p, 2–255 options, error shapes, answers that stay put when question ids or order change), finding 2 of the 8 most-starred open ports conformant, with a reference mock that breaks each rule on purpose and a proxy that fixes what can be fixed.

• typesafe-ai-php - PHP ecosystem: A modern TypeSafe AI client and SDK, with result classes and classic requests

• Jev - PowerShell ecosystem: PowerShell module for building Jev Noul, Choice, and Score questions and returning named answers as pipeline-friendly properties.

• djev-run - Serving: deploys DiffusionGemma-Jev behind a TypeSafe-compatible API on a Cloud Run GPU with snake, dino and tetris demos wired to the decision endpoint.

• jev-symfony-bundle - PHP / Symfony: Symfony bundle providing typed Jev clients, validation constraints (#[JevNoul], #[JevChoice]), Workflow guards, and WebProfiler panels.

• JevT++ - C++ integration: independent C++20 library with compile-time enum schemas, typed Choice/Noul/Score results and abstention, local Laya inference through ONNX Runtime or ggml, and an opt-in TypeSafe System One HTTP backend tested with mocks and loopback HTTP rather than live-provider calls.

• Sim - Agent frameworks: open-source collaborative workspace for building, deploying, and monitoring AI agents featuring native TypeSafe System One evaluation and decision provider integration.

• RubyLLM - Ruby ecosystem: official Ruby gem connecting TypeSafe judgment models to RubyLLM with a native System One protocol for typed questions, probabilistic answers, and error normalization.

• jev-style - Local runtime: pip install "jev-style[torch]" (or [mlx] on Apple silicon) serves an open 0.8B Qwen3.5 decision model behind a System One-compatible /v1/systemone API that answers Choice, Score, and Noul questions with calibrated probabilities in one pass over inputs up to 25,600 tokens (0.15–0.2 s per short request with MLX on an M1 Max, after the first call), and ships a Claude Code guard that turns four Noul checks and a risk Score into allow, ask, or deny through code-owned thresholds.

• grev - Developer tooling: grep, sort, cut and uniq that match by meaning — grev 'is a vegan meal' menu.txt keeps the lines whose Jev Noul clears 0.5, sibling filters route by Choice and rank by Score, and the output is always your own input, never generated text.

• decision-gate - Cost and rate control: npm library that every Jev request in a loop goes through, which waits for room under 80% of the account's requests-per-minute and tokens-per-second limits, pauses every caller sharing the account, across processes, for the server's Retry-After delay when the service answers 429, refuses any request that would pass a per-key daily spend ceiling (USD 0.20 by default), and keeps an opt-in cache of answer probabilities under caller-chosen keys, so a repeated question over the same state is not paid for twice.

• ollaya - Local runtime: serves open decision models behind a wire-identical /v1/systemone endpoint, so an existing Jev client only has to point TYPESAFE_BASE_URL at the daemon, and reports its recommended model at 0.722 accuracy against Jev's 0.738 on typed decisions.

• Tiltmeter - Monitoring: drop-in /v1/systemone proxy and Pydantic AI client that records every Jev answer's probabilities and alerts, without labels, when jev-latest switches versions, a question's answers drift (chi-square-tested PSI), answers crowd a decision threshold, or estimated accuracy falls.

• DecisionKit - .NET ecosystem: provider-independent .NET decision engine whose domain package holds no Jev URL, header or DTO, mapping Choice, Score and Noul questions onto POST /v1/systemone from a separate provider package, with a runnable ASP.NET ticket-triage sample that picks the owning team and escalates to a human at a normalized Score of 0.8, and 1,096 tests across net8.0 and net10.0 that run with no HTTP.

• intern-decision-mlx - Local runtime: serves Shanghai AI Lab's open Intern-Decision-0.8B vision decision model on Apple Silicon behind a /v1/systemone-shaped endpoint that also takes screenshots, so an agent can threshold the calibrated Choice, Score and Noul answers and escalate the rest — 0.9 s per 1080p screenshot downscaled to 1024 px on an 8 GB M2 MacBook Air, and the same answers as the lab's PyTorch reference on 67 of 67 fields.

Source file: categories/game-simulation.md

• typesafe-mario - Gaming: TypeSafe/Jev agent that plays Super Mario Bros. from structured emulator state, choosing each action from emulator-derived features.

• jev-drone - Robotics simulation: camera-only autonomous drone in MuJoCo that puts a Jev judgment model in the control loop at 2.5 Hz.

• tsai-sc - Gaming: drives original StarCraft shareware through keyboard and mouse with Jev action probabilities recorded per decision.

• jev-plays-pokemon - Gaming: reads Pokémon Red game state as text, answers typed questions each turn, and lets deterministic code turn the answers into moves.

• typesafe-jev-drone-demo - Simulation: Three.js drone simulator with a Python backend where Jev drives the navigation decisions.

• typesafe-playground - Interactive playground: small Jev experiments that put the decision on screen, from routing a support message to steering a car in a 3D world.

• PlayJev - Gaming: open 0.8B vision-language model that reads one 448 px game frame, returns a probability over the moves the game lists in a single forward pass with no generated text, and hands its low-confidence steps to a search program, across ten browser games.

• jev-plays-pokemon-red - Gaming: Pokemon Red on PyBoy where deterministic code owns the route and arithmetic, Jev picks only at branches, and every battle turn's faint prediction is scored by Brier against RAM state.

• jevpilot - High-Frequency / Games: A browser driving simulator where Jev chooses among locally generated paths and speeds.

• jevk5 - High-Frequency / Games: An open model that answers the same typed questions Jev answers — yes/no, choice, score — in one forward pass with zero generated tokens (~13 ms on an H100), plus a head-to-head harness that puts Jev and the open model on the identical board and question so the two can be compared directly. It serves TypeSafe's `/v1/systemone` wire format, so a Jev client can point at it unchanged.

• laya-vs-jev - High-Frequency / Games: Laya vs Jev: local MLX and hosted AI decisions playing T-Rex side by side, with live metrics and replay recording

• jev-libero - High-Frequency / Games: Two LIBERO tasks, one control engine. Each demo loads its own JSON task definition. Videos follow simulation time, with decision and physics-preview waiting omitted.

• RoboJEV - High-Frequency / Games: RoboJEV is a small, inspectable robotics laboratory. JEV receives **structured simulator state, not images**, selects an immediate intent, then selects X/Y/Z directions and a gripper command. A Cartesian controller executes the action using real MuJoCo contacts. Each task has independent physical success checks; model answers cannot declare success.

• OneVOneJev - High-Frequency / Games: A browser-based 1v1 shooter where Jev reads structured match state and chooses movement, aim, and firing.

• laya-vs-jev-arena - High-Frequency / Games: Laya (open source, local) vs TypeSafe Jev (API): two AI models race in Snake and fight in a Mortal-Kombat-style arena. Every move is a real model decision.

• jev-doom-agent - High-Frequency / Games: A browser Doom experiment comparing Jev-controlled players from the same initial state.

• typesafe-snake - High-Frequency / Games: Snake autoplayer driven by TypeSafe Jev, executing one discrete System One decision per tick with code-enforced legal moves.

• live-jev - High-Frequency / Games: A browser-based top-down driving simulator using Jev for lane and speed choices, with an optional chat-model comparison.

• jev-reflex-autonomy-lab - High-Frequency / Games: Multi-drone autonomy lab demonstrating TypeSafe Jev reflex decisions with optional System 2 strategy guidance.

• jev-askable-arm - High-Frequency / Games: Uses Jev to chain predefined skills for English-language goals in a ManiSkill robot-arm simulation.

• jevscape - High-Frequency / Games: A RuneBench extension using Jev and a bounded rs-sdk action catalog for RuneScape tasks.

• jevtown - High-Frequency / Games: A check costs from half a cent (a text that dies in the first wave) to ten cents (one that reaches all 10,000), and takes from 3 seconds to a minute. The interface comes in Ukrainian and English, and so do the personas: a text is read by the crowd that speaks its language, 10,000 Ukrainians or 10,000 English speakers, so there is nothing to choose.

• heist-one - High-Frequency / Games: Observable browser stealth game where Jev makes typed guard judgments while deterministic code owns the physics world.

• jev_deep_rl - High-Frequency / Games: This project evaluates a fixed model. It records rewards and decisions without training or updating model weights. A seeded random policy provides a local baseline.

• JevBird - High-Frequency / Games: A Python Flappy Bird game where code simulates candidate routes and Jev picks one.

• doom-jev - High-Frequency / Games: A ViZDoom Agent that uses Jev to choose movement, targets and firing from structured game state.

• jev-little-airways - High-Frequency / Games: An island-airport simulator using Jev for routes, yielding, emergency broadcasts and landing order.

• soupbase - High-Frequency / Games: Soupbase is a bilingual Chinese-English Turtle Soup game where Jev judges player questions and reconstructions, and the app checks structured Choice results and confidence to decide clearance.

• jev_vampire_survivors - High-Frequency / Games: TypeSafe's Jev model plays Vampire Survivors on Steam: BepInEx plugin + Python brain + live decision dashboard. Native Linux only.

• jev-robotics-demo - High-Frequency / Games: A MuJoCo arm demo where local code proposes candidate moves and Jev chooses the target, grasp or release, and completion.

• jev-arena-nanojev - High-Frequency / Games: Jev Arena is a fully local grid tactical game arena where NanoJev, rule agents and search algorithms make per-step move, attack, shoot, heal, dash and environment-interaction decisions across multiple levels with a Chinese Pygame interface.

• jev-flappy-bird - High-Frequency / Games: A live demo of TypeSafe's Jev model playing Flappy Bird, one flap-or-wait decision at a time.

• jev-gamepilot - High-Frequency / Games: **Jev-GamePilot** is a universal autonomous AI gaming agent powered by **Laya (local sub-30ms System One inference)** and **TypeSafe's Jev System One** (`Choice`, `Score`, `Noul`). It captures real-time gameplay at 60+ FPS, fuses instant local reflexes with high-level strategic reasoning, and executes physical hardware inputs across Windows PC games and connected Android phones.

• jev-gpt - High-Frequency / Games: Cascaded Choice questions that make Jev pick the next word from a word tree instead of generating text.

• jev_fsd - High-Frequency / Games: **An AI model drives a car through a real city, and you can watch every decision it makes.**

• jev-market-reflex - High-Frequency / Games: Fast typed AI decisions on live crypto markets using TypeSafe AI Jev.

• jev-play-ping-pong - High-Frequency / Games: Uses Jev to choose serve direction, return angle and pace in a browser table-tennis game.

• jev-rl - High-Frequency / Games: JEV Reinforcement Learning: four classic games trained with JEV-powered rewards, reproducible experiments and checkpoint replays.

• jevarena - High-Frequency / Games: Two Jev Agents play Snake in side-by-side browser panes with visible per-step choices.

• snake-jev - High-Frequency / Games: Real-time Snake game driven by parallel Jev assessments, deciding optimal turns in a single API call per tick.

• tsai-civ2 - High-Frequency / Games: An experimental harness where TypeSafe Jev plays classic Civilization II in a browser, computing live action probability distributions.

• jev-broadcast-lab - High-Frequency / Games: A Jev experiment workbench centered on chess, with additional classification and matching exercises.

• jev-chess - High-Frequency / Games: Chess moves, evaluations, persona opponents, and game classification using TypeSafe AI System One models. Resolves natural language move intents into legal moves, evaluates positional sharpness and king risk in parallel, and powers historical persona opponents (Tal, Capablanca, Petrosian).

• jev-flappy-bird - High-Frequency / Games: Jev learns to play flappy-bird game with physics based context and without it

• jevTrader - High-Frequency / Games: A High Frecuncy Trader made in Rust using Jev as a decision maker.

• mk-jev-fly-brain - High-Frequency / Games: Compares a fly-connectome spiking simulation, Jev and rule policies in the mk.js fighting game.

• can-jev-bayes - High-Frequency / Games: How well can Jev make sequential decisions under uncertainty, and how can Bayesian methods help it learn and act more effectively?

• jev-claim-vs-measured - High-Frequency / Games: A post with ~400k views says TypeSafe's **Jev** is the fastest AI model ever built for trading, makes calibrated buy/sell decisions in under 100 ms, and shows how to build an HFT system on it. The article behind it contains no backtest, no P&L and no hit rate. So I ran the tests: on the raw tape at one decision per second, and at 15–60 minute horizons. It cost **$0.97** of API credit. Everything needed to check me is in this repository.

• jev-clash-royale-test - High-Frequency / Games: A Clash Royale-style sandbox whose Jev bot decides play-or-hold, card, lane, and depth in one System One call.

• jev-experiments - High-Frequency / Games: Uses Jev to play Chrome Dino and a local shooter arena while Python executes structured decisions.

• jev-factorio-agent - High-Frequency / Games: Jev picks what, code owns how - a System One Factorio agent driven by TypeSafe's Jev on FLE

• jev-practice-speed - High-Frequency / Games: A WebGL demo where you play the card game Speed against a CPU whose brain is TypeSafe AI's Jev. The whole point of the app is to measure and show Jev's decision speed and decision accuracy in real time.

• jev-synthetic-survey - High-Frequency / Games: New to synthetic survey respondents? [Start here](#new-to-this-start-here). For the raw runs, the scored reports and the code, see [where to go](#where-to-go).

• jev-table-tennis - High-Frequency / Games: Table tennis vs. TypeSafe's Jev (System One). Every paddle move on the right is a live model decision — no local prediction, just a lookup table and a servo.

• typesafe-jev-decision-studio - High-Frequency / Games: Fast, calibrated System One decision platform powered by TypeSafe Jev via OpenRouter. Sub-second logprob scoring, transfer curves, zero hallucinations.

• typesafe-jev-traffic-demo - High-Frequency / Games: This is a **simulation**. It is not connected to, and cannot control, any real traffic signal — Hong Kong's Transport Department publishes no write API for that, only a read-only feed of sensor data. Everything downstream of that feed (the phase timing, the amber/all-red clearance, the safety limits) runs entirely in this process's own memory.

• jev-torneo-animales - Gaming: winner-stays-on tournament of up to 2,569 animals where each fight is one Jev Choice between two names under land, water or air rules held in state, asking the champion against the next K challengers in a single request and discarding the speculative answers once the champion falls — 1,999 fights in about 16 s at roughly US$0.01.

• Jev Chess - Gaming: one shared board where the internet collectively plays against Jev; every legal move is an option of a single Choice question so an illegal move is impossible, returned probabilities shade the pieces on the board, and a live calibration panel scores each claimed confidence against a one-ply material check.

• Life Chess × Jev - Experimental game design: a turn-based Conway board where each side's move is one Jev Boolean per legal cell in a single request, with no heuristic fallback and a user-set confidence threshold flagging unsure turns; the game is new, so there is no established play to copy, and its rules are not self-evident — they render from editable templates with auto-filled placeholders, so a designer can rewrite a rule and re-ask.

• kNES - Gaming: a Kotlin NES emulator whose agent plays Super Mario Bros. and Final Fantasy through SemIf, the open implementation of the Jev interface, on a local Qwen3.5-4B reading the screen itself; the goals that apply this turn become the declared options of one typed Choice, so a button the game does not offer is impossible rather than unlikely, and 900 logged decisions at ~400 ms each on an M5 Pro never once answered off the menu.

• JEV-Star - Gaming: uses Jev Choice decisions for StarCraft II macro control and micromanagement on 35 SMAC-Hard maps, validates selections against available actions, and follows optional GPT-6 plans to separate frequent action selection from longer-term strategy.

• THE HUNDRED EYES - Interactive media art: asks Jev one Choice and four Score questions per fictional observer to animate 100 eyes from a shared post, revealing four amplified voices before equal-count analytics expose the full distribution of reactions.

• jev-pilot-reflex - Autonomous vehicle simulation: Three.js autonomous driving reflex and AI safety brake simulator using Jev System 1/2 dual-brain architecture for fast emergency intervention.

• Magic Jev Ball - Gaming: a 3D Magic 8 Ball you hold, shake and let go, where one Convex action asks Jev a Choice over the 20 classic answers for the user's question and the page shows Jev's probability for every answer, displaying the highest-probability one because the rounded probabilities occasionally disagree with the reported choice.

• Jev-mice - Simulation: a mouse colony whose behaviour runs through Jev decisions on top of a deterministic engine.

• jev-plays - Gaming: Craftax (Crafter) survival agent where deterministic code lists every feasible action with its facts and Jev picks one Choice per step, optionally guided by an LLM-written objective and standing rules; 3-seed ablations compare Jev over macro and raw actions against random, an LLM choosing every step, and Jev plus the planner.

• Jev Driver - Simulation: a top-down driving game where Florence-2 captions each image dropped on the road in the browser and a Cloudflare Worker asks Jev three Choice questions (action, category, speed limit) about the caption and its lane or sidewalk, with no rule table overriding the answer; live at drive.mrza.ch, about 330 ms median and $0.00004 per decision.

• jev-goal-reflex - Simulation: a Three.js box steered by plain-language instructions, where an LLM turns each instruction into steps of simultaneous actions and every decision asks Jev two Score questions (move, turn) and one Noul (jump), with code acting on a score only past a 0.33 dead zone, jumping above 0.45, holding still any axis the current step does not use, and sending no Jev request while no step is active.

• Pacman AI Race - Gaming: browser-based Pac-Man race where deterministic three-junction simulation removes routes predicted to be fatal when a survivor exists, then Jev makes one typed Choice among the remaining route IDs while the server rejects any answer outside the supplied set, with self-hosted Laya using the same decision contract for comparison.

• 1 Million Emojis - Collaborative art: a shared 1000 × 1000 emoji canvas where, after each visitor stroke, one Jev request asks a Choice over named (emoji, square) pairs next to it and a Noul on whether the stroke is an unfinished shape, finishing the loop or line above 0.7 and otherwise sampling its pick from the returned probabilities (source).

• OmniJev - Embodied robotics: a Jev-style finite-choice interface that feeds dual-camera images and text to a self-hosted multimodal model and takes the next preset skill for a MuJoCo arm as one typed choice, where released episodes finish transfer, stack and barrier tasks in 13 decisions and 39 output tokens each, 208/208 non-audio probe requests answer correctly, unobservable inputs come back "insufficient evidence" instead of a guess, and four public benchmark pilots hold accuracy equal to a direct short answer while cutting decision latency 6.8–13.6× and total tokens 51–86% (audio input is wired in the client but rejected by the current backend).

• Jev Robot - Robotics control: a local decider-2b model picks the next skill for an AgileX PiPER arm through a Jev-style typed-choice interface while the target moves, with deterministic checks allowed to reject a choice but never to substitute another.

• Jev for Physical AI - Fleet triage: runs Jev as the decision layer for a 10,000-robot warehouse fleet over 41 bilingual incident templates and publishes 0.527 s p50 latency, $24.57 per million decisions and 91.3% agreement with template labels, alongside a crossover against a self-hosted ModernBERT.

• EmbodiedJev - Embodied robotics: MuJoCo decision workbench for a Franka Panda arm that compares TypeSafe Jev System One candidate decisions against reactive baselines and LLMs across pick, place, and obstacle tasks.

Source file: categories/finance-trading.md

• Jevinik - Stock decisions: terminal that gathers live market evidence through Valyu and asks Jev whether a stock is likely to trade higher over the next 30 days.

• jev_stock - Short-term forecasting: experimental Hong Kong stock framework that turns structured market state into a Jev decision on price direction, with a backtest script for the first trading day.

• jev-trade - Crypto trading: asks Jev for a Choice of long or short on a Hyperliquid market each round, places that order, and runs the same loop across many assets.

• Jev X Sentiment Analysis - Crypto decision support: ingests 50-1,000 tweets per request through statistical pre-processing and SQLite deduplication, then has Jev turn the surviving evidence into a decision card with entry ranges, stop losses, and targets, without executing trades.

• jev-guard (klauswg) - Exchange risk operations: screens crypto exchange deposits and withdrawals with Jev triage (risk level, behavioral pattern, freeze probability) while hard rules veto and Java composes the final action, with a published 100-sample three-column calibration against a rules-only baseline.

• Polymarket BTC 5m Jev trader - Prediction markets: a trading agent for Polymarket's five-minute BTC up/down markets that puts Jev in the decision layer behind a terminal UI.

Source file: categories/compliance-legal.md

• LegalForecast-MTD - Legal forecasting: benchmark that asks Jev to predict federal motion-to-dismiss rulings from the judge's written record and scores the calibrated probabilities with claim-defendant micro-Brier metrics.

• Jev Policy Engine - Policy conformance: universal Policy-as-Code SDK that allows DevOps and security teams to enforce deterministic AI governance rules in YAML via Jev with audit mode and fail-closed controls.

Source file: categories/content-moderation.md

• Jev Moderation Bot - Community moderation: Discord bot that scores incoming messages for phishing, spam, and social engineering with Jev and drives a four-stage escalation ladder, injecting pardoned messages back into context as verified-safe precedent.

• jev-spam-eval - Spam filtering: zero-shot spam classification with Jev Boolean questions, benchmarked against TF-IDF baselines.

• mastra-jev-moderation - AI assistants: Mastra input processor that asks Jev a Boolean "must this message be blocked?" plus a category Choice in one request, aborting the turn at 0.7 and failing open behind a deadline and circuit breaker; in production it blocked 9/9 hostile and 0/49 real messages at ~0.4 s median, about 4× cheaper than an LLM moderator.

• jev-slop-guard - Social feed filtering: bring-your-own-key Chrome extension that asks Jev one Choice (slop / not_slop) per X and LinkedIn post as it scrolls into view, blurring and stamping anything at or above a user-set threshold (default 0.7) behind a "Show the post" override, with a three-request concurrency cap and one cached verdict per post so scrolling never blocks.

• PlotVeil - Spoiler protection: Chrome extension that covers each YouTube comment while one Jev Noul question, batched 20 at a time, answers whether it reveals a concrete plot event of the video being watched or of another title the user protects, with the extension owning the 0.85 / 0.7 / 0.5 threshold and keeping the comment covered when the check fails.

• profanity-checker - Trust & safety: Cloudflare Worker that asks Jev Noul for literal profanity in text or usernames and a second Noul for phonetic or look-alike disguise (a55h0le, mike_hunt); the threshold, max() policy, JSON response, and OpenAPI schema live in Worker code and the endpoint is callable from other Workers via service bindings.

• jev_antispam_bot - Telegram moderation: minimal grammY anti-spam bot that asks Jev about each message, with ten test files behind it.

• cua - Browser & OS Action: Cua’s preview jev-use example pairs Driver observation and execution with bounded Jev browser-action choices.
• jev-desktop - Browser & OS Action: An optional Jev skill for agent-desktop that chooses controls and actions from native accessibility data.
• typesafe-computer-use - Browser & OS Action: Builds candidate actions from OCR and UI state for Jev to control macOS, calling a text model only when writing is needed.
• jev-browser-use - Browser & OS Action: A Skill for Codex browser workflows: Jev chooses navigation, clicks, and scrolling while Codex handles text input and final checks.
• Jev-cu - Browser & OS Action: A Codex Computer Use loop sending text candidates to Jev while desktop tools observe and act.
• omg.dev - Browser & OS Action: An omg.dev mobile testing script can use Jev to read the accessibility tree and choose the next interaction.
• mobile-jev - Browser & OS Action: Controls an Android phone through Mobilerun, with a web studio and CLI showing Jev decisions.
• jev-voice-browser - Browser & OS Action: Controls a Playwright browser by sending incremental speech transcripts to Jev.
• jev-use - Browser & OS Action: Voice and typed computer use for macOS. You say what you want. Jev picks the next on-screen action. macOS performs it. No screenshots: the app reads the screen through the Accessibility tree.
• jev-voice - Browser & OS Action: Talk to your Mac. Local whisper.cpp + one Jev (TypeSafe) call per command + macOS automation.
• jev-browser - Browser & OS Action: A browser library, CLI and MCP server where the caller supplies goals and text while Jev selects actions.
• JevBrowserExt - Browser & OS Action: A Manifest V3 Chrome port of jev-ultrafast: Jev picks the operation and DOM element in one request per step; a small chat model fills TYPE_TEXT.
• jev-macos-loop - Browser & OS Action: A native macOS automation loop using local OCR and accessibility information with Jev action selection.
• jevfill - Browser & OS Action: Open `test/sample-form.html` in the browser, configure the extension, and click **Autofill page**.
• jev-ego - Browser & OS Action: A browser Agent for ego lite that numbers actionable elements for Jev to choose the next step.
• CUA-JEV - Browser & OS Action: The [experimental open-task paths](docs/OPEN_TASKS.md) separate model planning from Jev's typed action selection. They discover browser DOM elements or Windows UI Automation controls dynamically and offer grounded structured-tool / physical-GUI alternatives without a site- or app-specific click sequence. A twelve-action browser-to-VS-Code research case now runs end to end with a model and Jev, but **arbitrary-task generalization is not claimed**.
• jev-browser - Browser & OS Action: Playwright browser automation with Jev decisions through a shared CLI, MCP server and TypeScript SDK.
• AskJev - Browser & OS Action: Connects Agents to a browser over MCP, using Jev to choose page actions with confirmation gates for actions such as payment or deletion.
• aside-jev - Browser & OS Action: An MCP server and skill adding Jev decisions to Aside browser Agents.
• computer-use-jev - Browser & OS Action: A Go-based macOS controller that asks Jev to choose controls and actions from the accessibility tree.
• jev-clerk - Browser & OS Action: A macOS desktop clerk that books supplier invoices: Jev picks each click from a closed action list; a deep model only rewrites the playbook.
• jev-mobile - Browser & OS Action: `jev-mobile` accepts a high-level task, persists it in SQLite, and lets one durable worker execute **observe → normalize → decide → mutate → verify** against a USB-connected Android device. Jev receives concise semantics and technically valid actions; it never generates coordinates, MCP calls, or arbitrary code.
• jev-yt-time-saver - Browser & OS Action: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
• jev-playwright - Browser & OS Action: Shrinks Playwright suites in CI by letting Jev select tests related to code diffs.
• jev-browser - Browser & OS Action: Browser automation CLI for AI agents, powered by the Jev model's millisecond decisions and near-zero inference costs
• jev-ra - Browser & OS Action: Browser use for coding agents, 3-5x faster than browser-use. MCP server + CLI; TypeSafe Jev decides every step in ~300 ms.
• jev-shield - Browser & OS Action: A Chrome ad-filtering extension that uses Jev to assess promotional intent in feed elements.
• ego-jev - Browser & OS Action: Drive the ego lite browser with Jev (TypeSafe System One): one indexed element table in, one operation + target out, single process. ~2x faster than a per-step LLM loop in our measurements.
• browser-use-with-jev - Browser & OS Action: **Keep Browser Use's execution engine. Move bounded decisions to Jev.**
• jev-2048-selenium - Browser & OS Action: Selenium 2048 player powered by expectimax search and TypeSafe Jev, with portrait FFmpeg recording.
• jev-browser-local - Browser & OS Action: Run jev-browser on a fully local JEV-style decision engine (no cloud API). Warm-browser fork, VRAM guard, measured benchmarks, run traces.
• jev-browser-pilot - Browser & OS Action: A bounded decision layer for browser and desktop automation: a decision-only model picks one next step; the code owns perception, content, actuation and verification.
• jev-browser-qa - Browser & OS Action: Browser QA where Playwright drives and films, and TypeSafe Jev judges. JSON-flow CLI for agents, run dashboard, agent skill.
• jev-browser-skill - Browser & OS Action: Let Jev, TypeSafe's ~100ms decision model, drive your browser. A plug-and-play skill for Claude Code and Codex.
• jev-mobile - Browser & OS Action: One TypeSafe Jev decision per step over the A11Y tree, executed via ADB. No screenshots and ultra fast!
• ego-jev - Browser & OS Action: Complete browser tasks with Ego Lite and actively call Jev for semantic target selection, filtering, ranking, classification and text evidence judgments.
• jev-browser-skill - Browser & OS Action: Browser use & computer use for coding agents, powered by TypeSafe Jev: calibrated judgments from a System One model, control loop in code. ego lite / Chrome / Safari · CLI + MCP
• playwright-jev - Browser & OS Action: This tool provides a Node CLI for goal-driven web E2E testing where Jev chooses the next step from a code-generated action space, playwright-cli observes and executes browser actions, and code controls inputs, deterministic assertions, and the final verdict.
• WindowsJev - Browser & OS Action: Token-efficient Windows automation and durable research MCP server for Codex and Claude Code, powered by TypeSafe Jev.
• ego-jev - Browser & OS Action: Connects Ego Lite snapshots and browser actions to a bounded Jev decision loop.
• ego-jev - Browser & OS Action: Drive ego-browser pages with TypeSafe Jev: code builds the allowed actions, Jev picks one, code acts and re-checks.
• jev-demo - Browser & OS Action: A zero-dependency local web demo for TypeSafe's **Jev (System One)** decision model: send a state plus typed questions, get choices, scores and calibrated probabilities back.
• jev-tweet-radar - Browser & OS Action: A Chrome extension that scores each X timeline post with one Jev Noul batch for engagement value and optional tags.
• jevaluate - Browser & OS Action: Jevaluate: evaluate before you trust. Field notes, runnable scripts and an agent skill for TypeSafe Jev: gated evals, a browser loop, a product walk with DeepSeek vision, a UI text judge and a first-click tree test. Co-authored with Claude Fable 5.1.
• JevFilterForX - Browser & OS Action: A browser extension that scores and filters X posts in real time with Jev, folding low-signal content while keeping it expandable. Without an API key, it defaults to local mock scoring.
• jevis - Browser & OS Action: A Flutter integration_test package that registers allowed UI actions and lets Jev pick the next action and whether the goal is done.
• pi-Jev-browser - Browser & OS Action: Browser and macOS desktop agent for pi: Jev (TypeSafe System One) chooses each action from a structured observation in a bounded, surface-agnostic loop. Isolated Playwright tools, an allow-listed accessibility-tree tool, deterministic selectors, four-tier benchmarks.
• cline-plugin-jev-browser - Browser & OS Action: A Cline plugin using an isolated Playwright browser and Jev decisions through Vercel AI Gateway.

• JevRev - CLI & Pipelines: Your LLM can imagine, write, test, and revise. It should not have to make every cheap routing decision by itself.
• jev-align - CLI & Pipelines: 1. Evaluates the configured dataset and measures uncertainty. 2. Selects ambiguous rows plus a random audit sample for you to label. 3. Uses your accumulated labels and optional rationales to run GEPA. 4. Shows the score, certainty change, and proposed definition diff. 5. Lets you accept, reject, rewind, or resume later.
• orchestkit - CLI & Pipelines: OrchestKit can optionally use Jev to classify coding sessions and set their colors when confidence meets a threshold.
• jgrep - CLI & Pipelines: Filters text, structured records, functions, and diff hunks against plain-English descriptions using Jev Noul judgments.
• jev-shell-history - CLI & Pipelines: Fish-style Zsh history suggestion tool ranked by Jev, ordering candidate commands from local history based on context.
• jev-lint - CLI & Pipelines: lint text in code by jev scorerer
• jev-pokemon - CLI & Pipelines: Jev, an AI decision model, plays Pokémon Red. It beat the game in 37h 40m.
• SemDecide - CLI & Pipelines: A Python CLI for semantic predicates, routing, scoring and filtering over text or JSONL.
• jev-rules - CLI & Pipelines: **New in 0.5.0:** [one line under each prompt](#in-the-conversation) names the rules Claude was given and Jev's score for each, and the [rules pane](#the-rules-pane) switches on with one answer: the first time Jev picks a rule, Claude asks whether you want it.
• jgrep - CLI & Pipelines: grep for what code does, not what it's called. Semantic code search powered by TypeSafe Jev.
• hey-jev - CLI & Pipelines: Open, quit, hide, minimise or switch to apps, open a new browser tab or a website ("open youtube.com in Brave"), Mac volume up / down / mute / set, Spotify volume, play / pause / next / previous, dark mode, lock or sleep the Mac. Two things in one sentence work too: "pause Spotify and open Slack".
• jev-skill-suggester - CLI & Pipelines: A Python CLI and Codex Skill that recommends a suitable installed skill for the current task using TypeSafe Jev Choice and Noul checks without executing candidate skills.
• jev-calibrate - CLI & Pipelines: Jev is the typed-decision model from TypeSafe: it takes a `state` and a set of questions (`noul`, `choice`, `score`) and returns probabilities instead of text. How well a question works depends on its wording, on your data and on the threshold you cut at, and none of the three can be read off a single good-looking answer.
• jev-test-filter - CLI & Pipelines: Score every test against a git diff with Jev, and emit the filter arguments vitest, node:test, Playwright, cargo test and go test already understand
• jsort - CLI & Pipelines: Ranks text along a plain-English criterion using pairwise Jev Noul comparisons and a locally fitted Bradley-Terry scale.
• jev-yaba-wechat - CLI & Pipelines: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
• jev-cli - CLI & Pipelines: The jevctl command-line tool connects verification, classification and scoring questions to text input and scripts.
• jev-blindspot - CLI & Pipelines: A side panel for Claude Code and Codex CLI that shows the blind spots of each prompt you submit: what the request would have needed to consider and shows no sign of. Jev decides, in one call per prompt, whether the prompt is worth a second look; only then does the agent's own headless mode read the project and return the items. Nothing blocks the prompt, nothing is added to the session.
• jev-code - CLI & Pipelines: An experimental coding CLI where Jev selects AST productions for Python or Bash, with a separate command-line decision mode.
• jevyoumean - CLI & Pipelines: Unlike an edit-distance `Did you mean?`, `jym` matches on *intent*: it hands Jev the candidate subcommand names plus their help descriptions. `remove → rm`, `list → ps`, `undo → restore` are close in meaning but far in spelling — that is the gap this experiment targets.
• rift - CLI & Pipelines: An optional TypeSafe decision client in the Rust coding terminal Rift for bounded Jev judgments.
• ego-jev - CLI & Pipelines: Jev (TypeSafe System One) inner loop for ego-browser — one ~0.4s typed decision per DOM step instead of an LLM turn. Agent skill for ego lite.
• jev-browse - CLI & Pipelines: Fast, cheap browser sub-tasks for Claude and other agents: TypeSafe Jev decisions on top of browser-harness
• pi-jev-model-router - CLI & Pipelines: Route pi prompts to task-appropriate model tiers with TypeSafe Jev typed judgments. Budget-aware, with automatic fallback.
• typesafe-jev-incident-router - CLI & Pipelines: Confidence-gated incident routing with TypeSafe Jev
• jev-oas-sentinel - CLI & Pipelines: JEV never writes a review or changes a specification. It returns typed decisions and probabilities; deterministic Python code decides whether to pass, request review, or block.
• prompt2jev - CLI & Pipelines: Agent skill and CLI that turn natural language, an LLM prompt, or the code that runs one into a TypeSafe Jev decision: typed state, Choice/Score/Noul questions, and a runnable script
• tryjev - CLI & Pipelines: A playground for Jev, TypeSafe AI's fast decision model: preset scenarios on the left, an editable state plus typed questions in the middle, typed answers with probabilities on the right. Bring your own key and pick a provider: OpenRouter (`typesafe/jev-1.13`, `alpha.decisions`), Vercel AI Gateway (`typesafe-ai/jev`, AI SDK `experimental_evaluate`) or TypeSafe's own API (`jev-latest`, `POST /v1/systemone`).
• jev-linkedin-slop-filter - CLI & Pipelines: Judges every LinkedIn post as it scrolls into view and slams a rubber stamp on it — **BAIT**, **CORP**, or **BRAG** — with the confidence score printed on the stamp. The post stays readable underneath.
• TypeSafe AI Playground - CLI & Pipelines: Rust CLI experiments for health-information screening, comment review, tone analysis and business or occupation classification.
• Jev_Onco_Statistical_Hierarchy - CLI & Pipelines: New prepares use `molecular-origin-v6`. The Choice, the two gated checks, and five boundary checks share the evidence and cannot read each other's answers. Boundary answers are reported with the result. Gates still use the leading score, its margin, sufficiency, and conflict. The parent of the leading class is a local lookup on the taxonomy. A request may use Jev's window: 64k tokens for the call, and 32k for the evidence plus the longest question.
• jev-assist - CLI & Pipelines: Don't burn your expensive main model on grep-and-guess grunt work — let jev rank the whole repo, and save the main model for reading the right files and writing the right code.
• jev-cli - CLI & Pipelines: A CLI for asking Jev classification, yes/no and scoring questions over text or JSON input.
• jev-demo - CLI & Pipelines: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
• jevopt - CLI & Pipelines: Making intelligent compiler optimisation decisions with Jev
• jev-agent-tools - CLI & Pipelines: Jev transport/provider layer: multi-provider transport layer that supports fail-closed validation. Used by jkudish/jev-browser and jkudish/jev-mcp.
• jev-cli - CLI & Pipelines: A CLI wrapper written in python for Jev
• jev-tmmluplus-eval - CLI & Pipelines: Jev is not a chat model. You hand it a `state` plus a map of typed questions, and it returns one typed answer each — with calibrated probabilities and **no generated text**.
• jev-triage - CLI & Pipelines: Message triage CLI in Go, built on the Jev decision model from TypeSafe AI. Categorizes messages, scores urgency, and flags low-confidence ones for human review.
• jevmetrics - CLI & Pipelines: Use it to assess unfamiliar instrumentation, review candidates for reduced retention, and selectively filter metrics before they reach a primary backend. Inference runs asynchronously, and cached assessments let subsequent batches use the same decision without another API call.
• pytest-jev - CLI & Pipelines: Extra state goes in `context`, such as a policy or the documents a RAG app retrieved. A claim can name it in backticks:
• typesafe-jev-calibrate-for-code-review - CLI & Pipelines: About calibrating Jev for code reviews
• claude-jev-funnel - CLI & Pipelines: Claude Code plugin + zero-dependency CLI for TypeSafe's Jev: judge items in bulk with calibrated yes/no, pick-one and rubric answers; handle the confident ends in code, review only the uncertain band.
• codex-jev-preflight - CLI & Pipelines: Fail-open Codex UserPromptSubmit hook that injects TypeSafe Jev pre-task routing metadata.
• hermes-jev - CLI & Pipelines: Hermes Agent plugin: route each turn to the one skill that fits, via TypeSafe Jev on the Vercel AI Gateway. Fail-open, opt-in, stdlib only.
• Jev_steer_or_queue - CLI & Pipelines: Let TypeSafe Jev decide whether a message you send mid-turn should steer, queue, or interrupt your coding agent. Claude Code plugin; Codex CLI in testing.
• jev-browser-skill - CLI & Pipelines: This Codex Skill lets Codex drive Chrome through Jev to complete multi-step browser tasks from a goal description with preset inputs.
• jev-mode - CLI & Pipelines: I kept watching coding agents burn context on decisions that aren't hard - triage 400 tickets, tag 600 files, route to one of six teams. jev-mode moves those verdicts to a typed-judgment model. I A/B'd it: 78% fewer tokens, 16x less work-attributable input, accuracy 96.1% vs 93.7%. Python, no deps, MIT.
• jev-model-router - CLI & Pipelines: Routes prompts to the right Claude tier (Haiku/Sonnet/Opus) using TypeSafe's Jev model
• jev-qa-demos - CLI & Pipelines: Demos for the video "Jev explained for testers": TypeSafe AI's System One model, called through **Vercel AI Gateway** with the AI SDK's `experimental_evaluate`.
• jev-router - CLI & Pipelines: Route any task to the right AI agent in under 1 second using Jev (TypeSafe System One). Supports Claude, ChatGPT, Cursor, and Antigravity with auto-launch on macOS, Windows, and Linux.
• jevcheck - CLI & Pipelines: Probabilities and model versions move. A raw `0.94` is not a release decision. jevcheck records a **production contract** (baseline model + fixtures + expected answers) and evals a candidate against that fixture.
• jevcut - CLI & Pipelines: Auto-clipper that turns long videos (podcasts, talks, essays, comedy) into short standalone clips for Shorts, Reels and TikTok. Code lists every possible cut; an AI judge picks where each clip starts and ends. Benchmarked on 38 hand-labelled videos.
• VideoAdGuard-Jev - CLI & Pipelines: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
• ask-jev - CLI & Pipelines: Ultra-fast, fail-open advisory decisions and verbatim extractive reading view for AI coding agents and CLI pipelines
• Codex-Jev - CLI & Pipelines: VS Code Codex Plugin for Jev-gated tool output integration
• cursor-clijev-compaction - CLI & Pipelines: TypeSafe Jev-scored context recovery for Cursor CLI (agent). Capture tool I/O, score keep/drop, re-inject after native compact.
• fuzzy-jev - CLI & Pipelines: Ask Jev typed questions about text and get calibrated probabilities back, then turn them into decisions with fuzzy rules (AND, OR, NOT, hedges, Mamdani outputs) and draw the rule base as SVG. A CLI and a Rust library (native and wasm32).
• here-we-go-jev - CLI & Pipelines: The smoke test and the experiments call real APIs and cost a fraction of a cent per run. The experiments need the server running.
• jev-arena - CLI & Pipelines: That's the whole bot. No code, no coordinates, no if-statements.
• jev-console - CLI & Pipelines: Jev does not generate text. You send it a **state** plus a set of **typed questions**, and it answers each one with a typed value and a calibrated probability:
• jev-frontier-100 - CLI & Pipelines: **Jev scores 77.0%; Qwen3.5 2B with a 2,048-token thinking budget scores 82.0%; Qwen3.5 4B with the same budget scores 96.7%.** This small benchmark makes Jev's observed reasoning limits tangible through nine local-model settings.
• jev-kiyafet-bul - CLI & Pipelines: Kod yerleri: `lib/filtre.ts` (Adım 1), `lib/regex.ts`, `lib/daralt.ts`, `lib/sirala.ts` (Adım 2 + sıralama), `lib/ara.ts` (hat), `lib/jev.ts` (istemci), `lib/kota.ts`, `app/api/ara/route.ts`, `components/` (arayüz).
• jev-route - CLI & Pipelines: Async, typed intent & tool routing for Python agents: Jev decides, a confidence gate stops weak decisions before they reach a privileged tool.
• jev-skill - CLI & Pipelines: Jev skill for Claude Code and Codex: TypeSafe System One guide, Python CLI, 5 tested recipes, and findings from 19,367 Jev calls.
• jev-skills - CLI & Pipelines: Claude Code & Codex skills powered by Jev, TypeSafe's System One model. 256 calibrated judgements for $0.0005 in 0.72s — 360x cheaper than Claude Opus 5. Includes the first published Jev calibration curve, measured on 4,995 real agent decisions.
• jev-switch - CLI & Pipelines: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
• jev-toto - CLI & Pipelines: Counting and comparison happen in Rust, because Jev is documented as unreliable at arithmetic. Jev receives per-number facts plus plain-English labels and answers two questions per number in one request: a yes/no probability for "drawn in the next draw" and a five-level cold-to-hot score with confidence. Module layout and commands are in `CLAUDE.md`.
• jev-zork - CLI & Pipelines: Jev (TypeSafe System One) plays Zork I: one Choice per move over Jericho's valid actions, with its confidence on display. French dashboard.
• jevcode - CLI & Pipelines: This repository provides an Astro-based multilingual documentation site explaining Jev's Choice, Score, and Noul decision primitives with architecture patterns and usage examples.
• jevgrep - CLI & Pipelines: On the bundled sample (`examples/sample.log`, 200 lines):
• jevscript - CLI & Pipelines: An early language experiment whose current implementation is a Jev request-batching spike.
• openjev - CLI & Pipelines: Turn any local LLM into a Jev-style System One decision engine: type-safe answers with raw softmax probabilities. 100% offline, zero API cost.
• paper-radar-jev - CLI & Pipelines: An automated research paper radar that fetches the latest papers from arXiv, evaluates their relevance to a configurable research profile using TypeSafe AI, and ranks them by relevance score. Designed for personalized, daily literature discovery across different research domains.
• pr-sieve - CLI & Pipelines: A GitHub Action that compiles `.jev.yml` rules into Jev questions and fails, comments, or passes from the numbers.
• r2r-jev - CLI & Pipelines: Jev turns unstructured state into typed probabilistic decisions. Evidence Admission decides which observations are eligible to enter governance. R2R turns admitted evidence and events into persistent, replayable relation state.
• typesafe-jev-plugin - CLI & Pipelines: Jev from Typesafe.ai is a "System One" AI model that returns **typed, calibrated judgments** instead of generating text. You define what to classify (a Choice), score (a Score), or verify (a Noul), and Jev returns a structured answer with a probability distribution — fast, cheap, and directly consumable by code.
• typesafe-jev-tools - CLI & Pipelines: A Claude Code hook that asks whether the decision you are writing needs a model at all. Includes a measured 149-row comparison of TypeSafe Jev against Claude Haiku 4.5.
• jev-planner - CLI & Pipelines: With **N** agents, `--mode ultra` makes **2N + 1** agent calls: drafts, reviews, and final synthesis, plus **N** if Jev requests another review. The default `balanced` makes as few as **N + 1** and never more than `ultra`; `fast` makes **N**, or **N + 1** when it merges. Each Jev evaluation is a separate TypeSafe call.
• slopcheck-jev - CLI & Pipelines: A prose linter that catches AI writing tells. Regex settles the 18 a pattern can settle. Jev takes the 15 that need reading, as 15 Nouls in one call, 604 ms median. It ships as a Claude Code `Stop` hook that scores Claude's own output after every turn and warns rather than blocks.

• jevgrep - Code Navigation: Find code by asking what it does. A CLI for coding agents that uses Jev to discover relevant files and source context with exact excerpts and line numbers.
• celesto - Code Navigation: A Celesto PR-review example prepares sandbox checks and compares a general model with Jev on candidate findings.
• neo4jev - Code Navigation: Navigates a Neo4j graph one hop at a time, asking Jev which relationship to follow next.
• jev-code - Code Navigation: Helps coding Agents locate code, check change intent, triage test failures, and organize review findings.
• Blink - Code Navigation: Finds files from a natural-language query using multiple walkers through the directory tree.
• jevgrep - Code Navigation: Jev-powered semantic code search for coding agents — find behavior across repositories via CLI or MCP, with exact source excerpts and line numbers.
• commit-miner - Code Navigation: Classifies Git commit messages and diffs with Jev for bug fixes, security fixes, CWEs, and change types.
• jev - Code Navigation: A Go Claude Code plugin using Jev to find files, answer bounded questions across code and handle large reads.
• claude-jev - Code Navigation: Adds Jev checks to Claude Code review findings, debugging hypotheses, design options and search results.
• leanest - Code Navigation: Adds Jev-based selection before an existing test runner using diffs and test source.
• PiJ - Code Navigation: A Pi-based terminal coding Agent whose main model handles reasoning, edits and tools while Jev provides advice.
• jev-review-action - Code Navigation: A configurable GitHub Action that reviews catalog submissions or classifies PRs and updates a templated comment.
• jev-graphrag - Code Navigation: Small demos + use-case backlog: TypeSafe AI's Jev as a calibrated decision layer for GraphRAG pipelines on Neo4j.
• jevex - Code Navigation: One MCP tool that returns the files a coding agent should read.

• Jev-Mem - Context GC: **Better memory for long-running AI agents—with fast decisions and focused reasoning.**
• Winnow - Context GC: A context filter for Claude Code that hides irrelevant tool-output blocks and keeps the original text available for recall.
• bluenoise - Context GC: An X/Twitter filtering extension using local rules by default, with optional Jev checks for unmatched replies.
• jev-recall - Context GC: Retrieve by relevance, not resemblance: filter an AI assistant's memories with TypeSafe's Jev
• elons-job - Context GC: Local-first Chrome extension that uses Jev to filter sexual and solicitation content in X replies with reversible hidden placeholders.
• jevlogs - Context GC: Adds Jev diagnostic-value, priority and routing signals to OpenTelemetry logs before deeper analysis.
• azdaja - Context GC: Bare, open-source RLM layer for existing coding agents
• jev-chat-for-twitch - Context GC: Filter any live Twitch chat with Jev: a bring-your-own-key Chrome extension
• omp-jev-compaction - Context GC: An Oh My Pi extension that prunes tool history verbatim and reuses decisions to limit prefix rewrites.
• pi-jev-context - Context GC: Model performance first. Token savings second. A Pi extension with freshness-aware read dedupe, Jev log filtering, and searchable verbatim recall. Keeps existing message history intact.
• jev-skill-gate - Context GC: Ranks Claude Code skills for the current project to reduce the descriptions loaded by default.
• jev-skills - Context GC: Skills without the context tax. Claude Code and Codex plugin: TypeSafe's Jev decides on every turn which skills the model sees. Always-on context cost: 0 tokens.
• deepseek-harness-jev-pre-compaction - Context GC: A pre-compaction advisor for DeepSeek Harness. Runs before the standard `compaction-basic` backend, using TypeSafe JEV to safely prune low-value tool results from model context. Original session events stay in the append-only log; only the model-visible view is replaced with compact markers or archive pointers to reduce context bloat.
• alphaoptimizer - Context GC: AlphaOptimizer is an open-source tool from AlphaTales that helps Codex work with large command and tool outputs. Instead of sending a huge log or search result straight into the context window, AlphaOptimizer keeps the useful parts visible, keeps the original output available for a limited time, and uses Jev to help rank what matters when an API key is configured.
• codex-jev-compaction - Context GC: Curates Codex handoff context by using Jev to select old tool records while retaining selected text verbatim.
• jev-compaction - Context GC: A context compactor that can only score, never write — so an agent's memory can't hold a fact the transcript never contained. Working demo, runs offline.
• jevbrief - Context GC: [Adapters](#adapters)  ·  [Quick start](#quick-start)  ·  [Game demo](#watch-jev-play-a-game)  ·  [Python](#use-it-in-python)  ·  [Viewer](#see-every-decision)  ·  [How it works](#how-it-works)  ·  [Benchmarks](#benchmarks)  ·  [Build an adapter](#build-your-own-adapter)  ·  [Contributing](#contributing)
• pi-jev-compaction - Context GC: Automatic Jev context clearing for Pi. Keep the conversation, prune stale tool output, retrieve originals without rerunning commands.
• your-signal - Context GC: A BYOK Chrome extension using Jev to score X posts against personal preferences and adjust their display.
• fast-compaction-dsh - Context GC: Verdict-based context compaction for DeepSeek Harness — replaces lossy LLM summaries with fast keep/truncate/drop decisions from jev-latest; everything kept stays verbatim. Port of tamaratran/fast-jev-compaction.
• jev-carryforward - Context GC: What your last session knew, scored against what this one is doing. MCP server: a per-project ledger written as things happen, recalled per task with TypeSafe's Jev evaluation model via Vercel AI Gateway.
• jev-skill-selection - Context GC: Pre-message hook: use TypeSafe Jev to keep/drop skills and shrink agent context
• jeverifier - Context GC: JeVerifier: cheap Jev (TypeSafe) checks that keep code maintainable and docs consistent, plus context retrieval — modest token savings
• jevskill - Context GC: Teach your coding agent to stop burning context. Jev (System One) via OpenRouter or TypeSafe: 325ms, 0.000013 USD per decision. A/B tested 99.3% fewer input tokens with accuracy up. Ships a reversible reduce and a ledger that learns when Jev pays off.
• pi-fast-jev-compaction - Context GC: Fast JEV compaction extension for pi
• pi-jev-context - Context GC: A reversible Pi context filter using Jev to judge whether older messages remain useful.
• dsh-jev - Context GC: This DeepSeek Harness plugin sends each round's latest user message to the systemone (Jev) API for emotion and intent classification and injects the result as plugin-sourced runtime context, with API Key and all parameters configured in the GUI settings page.
• jev-context - Context GC: A Codex search plugin that filters ripgrep passages through Jev before returning relevant code.
• jev-inbox-queue - Context GC: Turn an inbox into a short action queue with Jev (TypeSafe System One)
• jev-toolspace - Context GC: Jev answers yes/no (`noul`) questions about a shared state and returns an independent probability for each one. One API call scores every tool in a menu with one question per tool, and a tool's score does not compete with the others.
• openclaw-jev-compaction - Context GC: Verbatim context compaction for OpenClaw: a context engine powered by TypeSafe's Jev. Drops stale tool calls and results, never summarizes.
• pi-jev-compaction - Context GC: Extractive context compaction for Pi that keeps selected original tool records instead of generating a summary.
• pi-observational-memory-jev - Context GC: Jev decides what to keep. Compaction never rewrites the transcript.
• fast-jev-compaction-pi - Context GC: This Pi extension asks Jev whether each completed tool call and its full result should be kept, then locally retains, truncates, or drops verbatim tool evidence in the compaction summary.
• jev.tg - Context GC: Local Telegram filter stores channel messages locally and sends them in batches to Jev or a local model to keep only messages matching natural-language conditions.
• pi-jev-compact - Context GC: A Pi context-pruning extension targeting tool history by default, with optional assistant-prose pruning.

• youtube-sponsor-detection - Creative Tools: YouTube extension detecting sponsored segments from live audio and transcripts using Jev, skipping promotional blocks automatically.
• jevmeter - Creative Tools: Creates edited videos with score meters by asking Jev to rate transcript sentences against selected rubrics.
• jev-paint - Creative Tools: Requires Python 3.9+ and a modern browser with module workers and OffscreenCanvas (current Chrome, Edge, Firefox, or Safari). No packages, build step, or Node installation needed.
• vibecheck - Creative Tools: Shows a Jev scorecard before posting on X, assessing draft clarity, tone, and possible offensiveness.
• refgarden - Creative Tools: A visual-reference gallery drawing from The Met, NASA and Cosmos, with Jev in local Explore mode.
• jevthoven - Creative Tools: Turns a music prompt into editable multitrack MIDI by asking Jev to choose instruments, harmony, and bar patterns.
• slidepilot - Creative Tools: Voice-driven semantic auto-advance controller for Slidev presentations powered by Cloudflare Agents and TypeSafe Jev.
• ui-generator-instinct-jev - Creative Tools: Turns UI descriptions into selections from existing shadcn/ui components, fields and styles.
• jev-cookbook - Creative Tools: The complete cookbook for Jev by TypeSafe AI — 120+ use cases, 10 runnable examples, 4 composition patterns, and first-principles theory for the world's first System One AI model.
• jev-in-blender-experiment - Creative Tools: Blender exposes ~2,500 operators; a TypeSafe `Choice` question holds at most 255 options, so the search is hierarchical (two requests per search):
• ComfyUI-Jev - Creative Tools: Custom nodes for using Jev's text interpretation and judgments in ComfyUI. Use natural-language instructions to select candidates, evaluate conditions, score text, or extract numbers, then pass the results to other nodes. Jev judgments use the TypeSafe API by default.
• emoji-jev - Creative Tools: The app sends typed text to Jev to get parallel emoji Choice, emotion Choice, Score, and Boolean results displayed as an emoji keyboard.
• jev-got - Creative Tools: A Game of Thrones text-adventure demo where a language model writes the story and Jev labels the scene.
• jev-riffs - Creative Tools: Music pattern ripper: MIDI → interval tokens → code mines candidate motifs → Jev (TypeSafe System One) grades their significance. Web UI with piano roll, click-to-play, WAV export.
• bes-kelime-jev - Creative Tools: Jev bir sohbet modeli değil, **evaluation** modeli. Serbest metin üretmez; tipli sorulara `choice` / `score` / `boolean` cevapları döner. Bu, "sadece şu 5 kelimeden birini söyle" kısıtını *prompt'la rica etmek* yerine **tip sistemiyle garanti altına almayı** mümkün kılıyor: model 5 kelimenin dışına çıkamaz, çünkü API'nin döndürebileceği değerler bunlar.
• jev - Creative Tools: Constructors build reusable questions locally. `Ask` calls Jev; `Resolve` applies your confidence threshold locally. Choose thresholds using your own evaluation data.
• jev-music-theory-1 - Creative Tools: Explores Jev on harmony exercises and music-theory questions, alongside a piano demo driven by chord choices.
• jev-paste - Creative Tools: Contextual, inline clipboard decomposition for macOS — Tab-to-paste with full history and time-decay ranking. Powered by TypeSafe JEF.
• jev-playground - Creative Tools: Can a System One model steer music? Jev picks the plan (enums only); code renders sheet, audio and MIDI.
• jev-windows-agent - Creative Tools: Windows UI Automation extension of arc-cua: a fast, JEV-powered decision loop for desktop computer-use agents
• jevspeak - Creative Tools: Jev can't generate text. So I made it talk anyway. A conversational interface built from probabilistic decisions and a deterministic language compiler — no generative LLM.
• let-jev-speak - Creative Tools: TypeSafe's `/v1/systemone` endpoint classifies text — it returns a `choice`, a `score`, or a probability. It does not generate prose. This library makes it generate prose anyway: every word of the answer is a separate `choice` question over a vocabulary, and the loop feeds its own output back in as the prefix.
• voicevox-jev-proxy - Creative Tools: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
• 1-million-emojis - Creative Tools: A shared 1000 × 1000 emoji canvas where humans paint and Jev paints alongside them: after each stroke, one Jev request chooses which emoji goes next to it and where, from typed options named against the stroke, and says whether the stroke is an unfinished shape.

• deep-searcher - Data & Search: Open Source Deep Research alternative with Jev search-stopping evaluation.
• GPTCache - Data & Search: Semantic cache with a Jev evaluator that uses Noul judgments to check whether a cached response can serve an incoming request.
• memsearch - Data & Search: A persistent, unified memory layer for all your AI agents (e.g. Claude Code, Codex, DSH), backed by Markdown and Milvus.
• bootcamp - Data & Search: Runnable search tutorials using Gemini embeddings, Milvus retrieval, and Jev judgments for reranking, filtering, and routing.
• kody - Data & Search: Optional second-stage search: widen the hybrid pool, then Score-rerank candidates with Workers AI typesafe/jev.
• pg-jev - Data & Search: Adds natural-language filtering, classification, and ranking of rows to PostgreSQL queries.
• vector-graph-rag - Data & Search: Graph RAG with pure vector search, achieving SOTA performance in multi-hop reasoning scenarios.
• jev-semgrep - Data & Search: A semantic grep that scores each line with Jev against a meaning, including AND/OR/NOT and cross-language queries.
• pg_typesafe - Data & Search: A pre-alpha PostgreSQL C extension for calling Jev from SQL for classification, yes/no judgments, and scoring.
• jev-dataops - Data & Search: An open-source JEV-powered workbench for streaming data selection, quality evaluation, automatic LoRA training and held-out model evaluation.
• milvus-model - Data & Search: A library integrating embedding and reranker models from OpenAI, SentenceTransformers etc for semantic search in vector database.
• laya-jev-GraphRAG - Data & Search: Agentic GraphRAG engine using swappable System One decision models (local Laya / cloud Jev). Features a complete 4-phase pipeline (Ingestion, Pre-Retrieval, Traversal, Post-Retrieval) and evaluation across Neo4j, Memgraph, Apache AGE, and Kùzu driven by a custom A* traversal algorithm.
• polar_llama - Data & Search: A Polars library for parallel provider inference that also calls Jev per row as Noul, Choice, and Score questions, or as one typed contract over a document.
• duckdb-jev - Data & Search: A DuckDB extension that calls Jev from SQL and returns answers as ENUM, numeric, or STRUCT types.
• jevframe - Data & Search: Semantic AI for pandas and Polars: classify text, analyze sentiment, and score DataFrame rows with natural-language questions and full probabilities using TypeSafe Jev.
• reranker - Data & Search: A Python reranker that packs a query and up to 30 candidates into one Jev state, with one Noul relevance question per document.
• jev-search-rerank-eval - Data & Search: Retrieval evaluation system measuring Jev reranking against lexical, embedding, and fusion baselines across 9,831 query-document pairs.
• jev-bigquery-cloudrun - Data & Search: Classify support tickets in BigQuery with Jev and Cloud Run
• every - Data & Search: Ask a yes/no question of every function in a codebase. Ranked answers in seconds, for cents. Grep whose pattern is a question, powered by TypeSafe Jev.
• jev-papers - Data & Search: 1,000 arXiv AI papers classified with one Jev decision each, checked against an LLM judge. Open rebuild, MIT.
• jlink - Data & Search: The string baselines are best-match Jaro-Winkler and best-match TF-IDF cosine; the table shows the better of the two. Exact matching after normalization scores 0.26, 0.41, 0.00, 0.00 and 0.22.
• duckdb-jev - Data & Search: High-throughput, robust native DuckDB extension for batched and streaming TypeSafe/Jev classification, scoring, and semantic predicates from SQL.
• jev-search - Data & Search: Experimental semantic line search with TypeSafe Jev via OpenRouter. Python CLI with no runtime dependencies.
• jevsql - Data & Search: Adds Jev semantic judgments to SQLite for filtering, ranking, matching and tracking decision evidence.
• jev-in-codex - Data & Search: Jev-powered tool and skill selection, context search, and output triage for Codex via MCP
• JevFind - Data & Search: Fast semantic code search powered by Jev. Find the relevant files, line ranges, and snippets
• jev-reranker - Data & Search: Rerank, filter, and compress JSON search results with TypeSafe AI's Jev.
• jeveryword - Data & Search: Jev answers multiple-choice questions and does not generate text, so on its own it cannot return a name, an email address or a quote. jeveryword numbers the words of your text, offers those numbers as the answer options, and converts the numbers Jev picks back into the original substring with its character offsets.
• jevsql - Data & Search: Text-to-SQL where the model never writes SQL — typed, calibrated decisions (TypeSafe Jev) + code-assembled queries
• jselect - Data & Search: Selects source-linked evidence within a token budget using Jev Noul relevance judgments and local diversity-aware selection.
• hfjev - Data & Search: Classify Hugging Face datasets across typed semantic dimensions with TypeSafe Jev System One. Auto-adapts evaluation rubrics to dataset domains (reviews, news, LLM tuning, support) and classifies rows in a single parallel System One call with calibrated probabilities.
• jev-311-heatmap - Data & Search: The live run excluded 205 reports with missing or invalid coordinates, completed **634 API calls without retries**, and reported **539,979 input tokens**. Repeated descriptions share one evaluation.
• jev-rag - Data & Search: Local knowledge search with three modes: BM25 + Jev by default, agentic multi-query lexical search + Jev without vectors, and optional BM25 + embeddings/RRF + Jev, with grounded streaming answers.
• jev-retrieval - Data & Search: Grep-shaped Rust CLI for coding agents that finds files matching a plain-language concept: a local BM25 pass recalls candidates, Jev verifies each file window-by-window with Noul gates, and one listwise Choice per lane reranks the kept files into `path:line score` output with calibrated probabilities. (Author-submitted: I am the maintainer.)
• jev-information-extraction - Data & Search: Ask questions about a PDF. Use Jev to rank the source text that answers them. Inspect each match, its probability, and its location on the original page.
• jev-research-pipeline - Data & Search: **Code owns the loop, Jev judges, Qwen writes: a daily research monitor for standing questions.**
• jev-reviews - Data & Search: The flagship experiment in this workspace is **`jev-reviews`**: an automated pipeline that ingests Google Maps restaurant reviews from **Apify Storage**, stores and deduplicates them in **Supabase PostgreSQL**, and classifies them using **Jev (TypeSafe System One)** or traditional generative LLMs across 5 operational pillars, extracting dishes, customer highlights, and owner recommendations.
• DataJev - Data & Search: ⚡ DataJev LLM → Analyze Jev → Continue / Switch / Verify / Stop System-1 control for System-2 data agents
• jev-harness - Data & Search: A Pi agent harness built around TypeSafe's Jev (System One model): router, context picker, gate, verifier. Tested on Neon Postgres branches.
• JevDeepResearch - Data & Search: GPT directs the research; Jev uses Choice and Noul to locate evidence across document regions concurrently, and code returns original passages for GPT to verify and continue. The released integration pairs Pi-Serini BM25 search with Jev batches of 20, 40, or 60 documents.
• jevsome-projects - Data & Search: A Jev project directory and discovery pipeline that stores integration evidence and can use Jev for classification.
• jevtok-ts - Data & Search: **No Python, network calls, API keys, native extensions, or runtime dependencies.** Vocabulary and lookup tables ship inside the package. Ordinary `o200k_base` tokenization is not interchangeable with Jev: `evidence` is three tokens and `2024` is four.
• sieve - Data & Search: Sieve checks a folder of Markdown notes against itself. Crosscheck compares every note with every other, from both sides, and lists the pairs that contradict each other, the pairs that make the same point twice, and the notes that have gone stale. It also ranks the whole folder by any plain-English question, and lints notes against plain-English rules in CI. No index, no embeddings, no generated text. Node, no dependencies.

• ai-hedge-fund - Domain Tools: An educational AI hedge-fund prototype with an optional Jev adapter for structured judgments in fund decision workflows.
• jev-trader - Domain Tools: A market-making experiment on Kuru’s MON-USDC book on Monad, with optional per-block Jev buy/sell decisions.
• jev-chat-windows - Domain Tools: A Windows companion reply assistant that captures WeChat Windows 4.x windows with local offline OCR, uses Jev to judge intent and generate three candidate replies, and fills the chosen text into the WeChat input box without auto-sending.
• tax-doc-classifier - Domain Tools: A tax-document page classifier that uses Jev to choose from predefined IRS form and page categories.
• jev-seo - Domain Tools: **PDF: how the audit was made, the scorecard and the priorities**
• 332_lab-jev-chat - Domain Tools: The Windows app reads visible WeChat chat text via UI Automation or local OCR, uses Jev for structured intent judgment, and optionally uses DeepSeek to generate three copyable reply suggestions.
• Prism - Domain Tools: A Solana liquidity Agent with Jev shadow judgments compared against rule-based decisions.
• jev-eval-agent - Domain Tools: Agent tool evaluation harness comparing standard LLM tool selection against Jev routing across 100 mocked tools.
• Working-Memory-Jev - Domain Tools: Edit `.env` locally and replace the placeholder with your own key. Keep this file private; Git ignores it. Do not paste the key into frontend code, a browser field, an issue, or a command that will be saved in shell history.
• JevIntent - Domain Tools: It is a FkWeChat plugin that analyzes a long-pressed WeChat text message with the Jev model for intent, emotion, urgency and reply posture and shows the result in local Toasts.
• JevScout - Domain Tools: A demo job-search Skill for coding Agents that browses company careers pages in Chrome, uses Jev to screen AI and software-engineering roles, and saves the results.
• jev-reviewer - Domain Tools: A systematic-review tool that selects verbatim evidence from papers and supplements for human checking and export.
• Jev-Trades - Domain Tools: A dashboard combining live crypto market data with Jev-guided paper trading; no broker or live-order API is connected.
• clash-jev - Domain Tools: A Clash Royale bot with no trained policy: Jev (TypeSafe System One) makes every decision from the live game state
• jev-trip - Domain Tools: Jev Trip is an explainable day-trip planner. The LLM plans ahead; Jev chooses and checks. Deterministic code handles route facts, time calculations, validation, and versioning.
• jev-linkmap - Domain Tools: Site: www.bles-software.com, 566 pages, 8,460 link decisions (15 candidate targets per page). Run on 19 Sep 2026. Every number below is from the run files in `out/` and `runs/`.
• JEV-Paper-Radar - Domain Tools: In GitHub Actions the links point at your own repo automatically (`GITHUB_REPOSITORY`), so a fork needs no configuration. Locally, set `output.feedback_repo = "owner/name"` or run `paper-radar harvest --repo owner/name`.
• typesafe-ai-playground - Domain Tools: Community playground for TypeSafe AI and Jev featuring 110 real-world scenarios, dilemmas, and interactive experiments.
• jev-usecases - Domain Tools: Production TypeSafe Jev (System One) use-case harnesses with confidence-gated decision logic
• JevBystander - Domain Tools: This Android accessibility app reads visible WeChat one-to-one chat text and uses Jev to judge intent, emotion, urgency and reply posture, showing the result as 3 Toasts without generating or sending replies.
• jevlint - Domain Tools: Semantic lint rules for the code-review questions a deterministic linter can't express
• jev-anything - Domain Tools: Agent skill for designing, building, testing, and tuning bounded JEV decision layers
• jevernetes - Domain Tools: Live Kubernetes log analysis, contextual investigation, and agent handoff powered by Jev.
• jevmory - Domain Tools: Coding-agent memory where every fact is a verbatim quote graded by TypeSafe Jev's calibrated confidence. Local-first, SQLite receipts, zero dependencies.
• Jev_Ontology - Domain Tools: We built a working MVP that pairs an LLM-authored ontology with Jev's calibrated classification, tested it against the live Jev API on 78 unique tickets across 5 sessions (86 classifications -- Session 4 re-runs Session 2's eight tickets), closed the feedback loop, and ran a 3-iteration convergence experiment. Total cost: $0.0085.
• jev_project_context - Domain Tools: Evidence-first long-term experiment memory skill for AI coding agents, with optional Jev decision-model layers
• ask-jev - Domain Tools: Ask Jev is a Neo-Brutalism style web app where users enter everyday dilemmas and receive direct decisions from Jev.
• JevFlow - Domain Tools: A Claude Code plugin that keeps your AI agents honest. Claude plans tasks as phases with checks, and when it tries to stop, Jevflow runs them and asks Jev if the work is really done. Many agents, one plan, with a live viewer to watch it all.
• jevtest - Domain Tools: It provides a web and CLI demo that sends user text to Jev through OpenRouter for Choice, Score, and Noul probability judgments and compares the results side-by-side with a general LLM.
• jev-bot - Domain Tools: JEV-powered market decision bot for stocks, crypto and memes. State in, BUY/SELL/HOLD/AVOID out, paper by default
• jev-2048 - Domain Tools: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
• jev-for-engineers - Domain Tools: Eight mechanical and electrical engineering experiments using Jev for task routing, log checks and component selection.
• jev-music-tag - Domain Tools: A minimal FastAPI and React workbench that sends local audio tags to Jev for decisions and writes the returned metadata updates back to the audio files.
• jevchess - Domain Tools: Jev, TypeSafe's System One model, plays chess against any OpenRouter LLM, Stockfish and you. One-page web app with live moves, Jev's move probabilities, saved games and win rates.
• JevLight - Domain Tools: Jev-powered traffic signal control on CityFlow with structured phase and green-time decisions.
• openjev - Domain Tools: OpenJev: An Opencode plugin that replaces text-generation decisions with Jev (TypeSafe System One).
• cairn-jev-lab - Domain Tools: Use it to test a memory policy before letting it decide what an agent keeps. The lab includes editable cases, a reusable JavaScript entry point, and reports that retain both successful judgments and mistakes. Node.js 22+, no runtime dependencies.
• heyreach-jev-bot - Domain Tools: Signal-based LinkedIn outbound scoring for HeyReach, running on Jev (TypeSafe System One).
• JevEmon - Domain Tools: Verified milestones so far: Jev can leave the Player's House, cross Pallet Town, deliver itself through Route 1 (fighting and winning any wild encounters along the way), and reach Viridian City. Further legs of the journey (Oak's Parcel, the first Gym) aren't built yet — the walk currently ends the run once it reaches Viridian City.
• JevTools - Domain Tools: A toolkit, knowledge base, web cockpit, and reference implementation for building AI applications with **Jev (TypeSafe System One)** via **OpenRouter Alpha Decisions** and **TypeSafe Direct API**.
• work-with-jev - Domain Tools: Work with Jev is a local-first message classifier that uses Jev to sort work messages into urgent, to-do, worth-reading, and skippable groups with cross-chat to-do management and Feishu and WeCom adapters.
• dbt_jev - Domain Tools: Score a candidate pair after ordinary SQL has generated it:
• jev-fuse - Domain Tools: A governed execution layer between typed-decision models (TypeSafe Jev) and agent/AI tooling like Claude Code, MCP, and AI SDKs, turning probabilistic decisions into deterministic, policy-controlled, and auditable actions.
• jev-storyboard-lab - Domain Tools: (`agent_framework.foundry.FoundryChatClient` is a different client this repo doesn't use — its `credential` parameter only accepts Azure AD token credentials, not an API key. If you only have a key-based Azure OpenAI resource, `OpenAIChatClient` is the path that actually works.)
• jev-tab-grouper - Domain Tools: One-click AI tab grouping for Chrome — Jev typed decisions (~1s, whole window) or any OpenAI-compatible LLM that invents its own group names. Featured in awesome-jev.
• jev-trading - Domain Tools: **Jev Trading is a stock decision service that runs on your computer.** Use the web workbench or call it from your own software over HTTP. It sends market data, indicators, fundamentals, and news collected by AIStock to a model, then returns a structured decision with a record of the evidence.
• jev-wrapped - Domain Tools: The browser asks for up to four pages at a time (the plan says how many), which makes up to 24 Jev requests in flight, and shows every answer as it arrives. If a page comes back throttled, it goes to the end of the line and the run drops to three pages at a time, then two. There is no shared queue: every visitor's run is paced by their own browser, and the only shared ceilings are the daily ones below.
• jevscan - Domain Tools: An EVM Token screening tool with library, CLI and MCP interfaces for market-feature-based risk judgments.
• JevSeek - Domain Tools: Local coding workspace and agent decoupling tool routing via Jev from detailed argument generation via DeepSeek.
• jevsume - Domain Tools: A resume-review app that checks general writing and structure or compares a resume with a specific job description.
• sqlite3-jev - Domain Tools: SQLite C extension enabling TypeSafe Jev judgments as native SQL functions for semantic scoring and choices.
• jev-A-share-trader - Domain Tools: A Jev-powered technical analysis workspace for China A-shares, supporting AKShare/Tushare, market scans, and Buy/Hold/Sell assessments with time horizons and traceable evidence.
• jev-connector - Domain Tools: WordPress connector for the TypeSafe System One API (Jev): typed questions, confidence-scored answers, core Connectors API key management
• jev-geo-audit - Domain Tools: 300 public pages audited for AI citability with Jev decisions, checked against an LLM judge: agreement, cost and latency, measured
• jev-oncall - Domain Tools: Incident triage on TypeSafe Jev — the model judges, plain code decides. Routing on probability distributions with a human-review middle band and fail-open defaults.
• jev-writer - Domain Tools: Unlike generative writing assistants that flatter drafts, jev-writer enforces strict statistical safeguards: an observational power gate, date-confound controls, and Benjamini-Hochberg false-discovery corrections. It reports what it finds in plain English and refuses to state findings when sample sizes cannot support them.
• jevlint - Domain Tools: A linting tool combining static analysis and Jev queries to help improve... Jev queries
• Jevstiller - Domain Tools: Distill a repeated Jev classification task into a local model, on the fly — same answers, your hardware.
• tempo-jev-demo - Domain Tools: I created Tempo with OpenAI's Codex, using Astra and GPT-5.6 Sol, with my direction and guidance. Codex also came up with the name Tempo. I haven't personally reviewed all of the code. This is an experimental demo so don't use it for anything serious. It may contain bugs, unexpected behaviour, and issues I'm not aware of. More details on how to get started below. Have fun!
• jev-calculator - Domain Tools: Vars live in `wrangler.jsonc`: `JEV_BASE_URL` / `JEV_MODEL` (gateway), `TYPESAFE_BASE_URL` / `TYPESAFE_MODEL` (direct fallback), `TURNSTILE_SITEKEY`, `TURNSTILE_HOSTNAMES`, `JEV_DISABLED` (kill switch). Rate limits are Workers Rate Limiting bindings: `API_LIMIT` per IP and `FALLBACK_LIMIT` for the direct route as a whole.
• jev-drive - Domain Tools: Jev + autonomous driving: structured decisions, multimodal baselines, recovery research, and measured API diagnostics.
• jev-humanizer - Domain Tools: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
• jev-intent-classification - Domain Tools: JEV intent classification using Python
• jev-issue-radar - Domain Tools: Jev Issue Radar is a read-only dashboard for GitHub duplicate-issue triage. It retrieves likely candidates, asks Jev whether each pair is duplicate, related, distinct, or insufficiently documented, and shows selected passages from both original reports for a maintainer to review.
• jev-prompt-optimization - Domain Tools: automatically optimizing the instructions and decision criteria of TypeSafe Jev Choice from labeled data
• jev-resume-screening - Domain Tools: This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
• jev-stock-decision-maker - Domain Tools: JEV Decision is a live demo that turns market data into structured decisions. It pulls real-time prices, valuation ratios and sector context, then runs a 20-question against TypeSafe Jev model to score buy/sell conviction, financial health and risk
• jev-test - Domain Tools: Pre-registered benchmark: can a 2B local model (Gemma 4 E2B) answer web questions without making things up when a decision model (TypeSafe Jev) makes every call? SearXNG for search, MemPalace for verbatim memory, seven arms including open local judges. Spec and thresholds fixed before any run.
• jev-trade - Domain Tools: A simulated crypto trading loop that sends BTC and ETH market features to Jev and models execution costs and latency.
• jev-triage - Domain Tools: Near-free GitHub issue triage powered by TypeSafe AI's Jev - typed, confidence-gated labels that escalate only the uncertain cases.
• jev-xiangqi - Domain Tools: Play Chinese Chess (Xiangqi) against Jev - TypeSafe System One decision model as the AI. Score fan-out over legal moves.
• jeves-desk - Domain Tools: This repository implements a configurable customer-service platform combining ChatKit UI, Jev decision-making, generative chat, RAG knowledge lookup, plugin Tools, MCP data access, and YAML-driven Agent dispatch.
• jevextract - Domain Tools: Grounded information extraction that cannot hallucinate: code proposes spans, Jev decides. An open-source alternative to LangExtract, with a bilingual benchmark and paper.
• JevLang - Domain Tools: A policy engine for LLM decisions: declare routes, gates and actions once in TypeScript or Python, and every decision comes validated, explainable, replayable and audited.
• leadgenrationaivoiceagent - Domain Tools: An experimental TypeSafe module in a marketing and voice platform chooses specialization labels for agent roles.
• tc39-atlas - Domain Tools: Interactive semantic explorer and taxonomy for TC39 proposals. Applies TypeSafe AI System One (Jev) to classify ECMAScript proposals across adoption pathways, cognitive overhead, web-compatibility risk, and foundational intent archetypes.
• tictacjev - Domain Tools: A tic-tac-toe app where one player is Jev, TypeSafe AI's System One Model with live confidence scores and probabilities.
• cube-lab - Domain Tools: Cube Lab is an interactive 3D Rubik's Cube app that generates candidate solutions with local planners and uses Jev to select moves across seven solving stages with animations and recorded turning sounds.
• JevPulse - Domain Tools: Analyze the YouTube comments to gain insights into what the audience is saying from any video link.

• aiavatarkit - Voice & Conversation: An optional AIAvatarKit component uses Jev to judge turn endings from speech transcripts.
• OpenWhisper - Voice & Conversation: A dictation and meeting-notes app with optional Jev checks for topic changes, note-taker instructions and sensitive text.
• jev-system-one - Voice & Conversation: A terminal Q&A app where OpenAI writes answers and Jev sets response policy and reviews drafts.
• ha-conversation-jev - Voice & Conversation: A Home Assistant conversation integration routing simple lighting commands to services and other requests to Grok.

• awesome-jev-prompts - 43 field-tested Jev question patterns (Choice/Score/Noul) with templates, thresholds, and failure modes, plus 10 anti-patterns. CC0, bilingual EN/中文. Source file: categories/related-practices-discussions.md

• Introducing System One Models and Jev (Hacker News) - Hacker News: 1,800-point launch thread whose ~480 comments debate whether typed decisions replace LLM calls for classification, routing, and verification.

• Launch thread by Diogo Almeida - X: the 63k-like announcement from TypeSafe's founder arguing RLCD-trained decision models are a shorter path to economic value than chat models.

• Model router built with Jev - X: 948-like demo where Jev decides which model should serve a request before it is forwarded.

• MLP on Qwen 4B mimicking Jev - X: builder reports that a small MLP trained on top of Qwen 4B already reproduces Jev-like decision behaviour.

• Running a local Typesafe Jev - X (Japanese): attempt at running a Jev-style decision model locally, with speed noted as still improvable.

• Jev as an AI agent safety monitor - X: test report using Jev to check each agent action first, reportedly catching most attacks with almost no false blocks and much lower latency.

• Rethinking security engineering with Jev - X: argues that purely engineering decisions in security work belong to Jev rather than a chat model.

• Ask Jev anything, it will judge - X: public Convex-backed demo inviting one million judged questions instead of generated answers.

• First Jev use case in a Mac app - X: a shipped Mac app routes setup and troubleshooting questions to Jev when no language model is loaded.

• Jev 中文解读 - X (Chinese): explains the System One category to Chinese readers as a calibrated, typed decision layer for code.

• TypeSafe AI releases Jev (r/singularity) - Reddit: launch thread framing Jev as a low-hallucination, low-cost decision model for software rather than chat.

• Testing Jev for Pi extensions (r/PiCodingAgent) - Reddit: builders describe using Jev as an agent tool-use safety layer and planning a prompt-complexity model router.

• Jev "playing" Minecraft (r/accelerate) - Reddit: work-in-progress demo of Jev driving Minecraft, including fleeing zombies at night, as a test of fast structured decisions.

• Awesome Jev by TypeSafe - Curated list: a peer collection of Jev use cases, patterns, prompts, and starter code, with a video walkthrough of eight projects people already built.

• Jev on OpenRouter - X: OpenRouter ships Jev in beta, exposing the System One model through its routing layer.

• Jev on Cloudflare AI Gateway - X: Jev goes live on Cloudflare's AI Gateway, callable from Workers.

• Jev for instant compaction - X: argues agent context compaction should be a Jev decision rather than a summarization prompt.

• Reviewing unnecessary tool calls with Jev - X: a Claude plugin asks Jev to review redundant tool calls, running in about a second.

• 19 open-source Jev projects - X (Chinese): tallies 19 open-source Jev projects totalling more than 6,800 stars.

• Jev is the fish at the poker table - Blog: plays poker with Jev and uses the table to probe where a fast decision model helps and where it does not.

• Jev is about to change the AI economy - Substack: argues that cheap calibrated decisions move where inference spend goes.

• Awesome Jev by 0xLogicrw - X (Chinese): a hand-checked list of Jev projects published one day after launch, one of several community indexes that appeared within 48 hours.

• Jev repository roundup (Japanese) - X (Japanese): rounds up the Jev repositories with the most practical promise, observing that computer use and automated trading dominate the early use cases.

• Six things I'll still use Jev for - X: a practitioner lists the six Jev uses he still expects to rely on after 60 days, an early usefulness review rather than a launch reaction.

• WTF is Jev, ELI5 - X: frames Jev as "AI multiple choice, not AI essay writing", one of the clearer plain-language explanations of the System One shape.

• 深入解读 Jev 模型：毫秒级判定与工程边界 - Chinese deep-dive: examines Jev's millisecond judgments and, more usefully, where its engineering boundaries lie.

• Has anyone tried Jev as a relevance filter for RAG? - Reddit: builders ask whether Jev works as a retrieval relevance filter and reranker, probing the boundary the reported negative reranking result already hinted at.

• Can we have Jev in Devin? - Reddit: users of another coding agent ask for a Jev decision layer inside their tool, a signal that typed decisions are becoming an expected feature.

• All the coolest Jev projects on X - X: a curated thread of the strongest Jev projects posted within 72 hours of launch, by a builder who also produced the most-watched Jev tutorial.

• Full Jev tutorial - X: a walkthrough covering the API, then three demos — voice-controlled browsing, AI memory, and YouTube preprocessing.

• WTF is Jev, and the 9 things people are building with it - X: the most widely shared explainer of the launch window, framing Jev as "AI multiple choice, not AI essay writing" and cataloguing nine use patterns.

• Jev is a really smart switch statement - X: the hype-free framing from an infrastructure founder — Jev does not replace GPT or Claude, it is a very good switch statement with 2026 intelligence.

• Arbitrary classification as a type-safe primitive - X: argues the real novelty is not classification but that Jev makes arbitrary classification a runtime-defined, type-safe programmable primitive.

• This is a terrible compaction strategy - X: the strongest public pushback on the popular compaction idea, arguing compaction is reconstruction rather than filtering and that the plugin misunderstands context management.

• It is the inference technique, not the training - X: argues Jev's speed comes from parallel decoding rather than model training, and that an inference engine can expose a Jev-like API over any open-weight model.

• Jev's Architecture Unmasked - X (Japanese): notes from a technical analysis that inferred Jev's internals from roughly 10,000 API calls, concluding it keeps LLM knowledge but removes token generation entirely.

• An internal Jev study session with 50+ engineers - X (Japanese): a company ran an emergency internal study session on Jev and published the material — an early example of organisational adoption rather than individual experimentation.

• X is all over it, Reddit is not - X: observes a sharp platform divide, finding only three Jev posts on Reddit while X filled with working prototypes — a useful reminder that channel coverage changes the picture.

• Five open Jev replicas worth trying - X (Chinese): rounds up Laya 421M, Decider-2B, NanoJev 0.6B, Reflex, and System-One 4B as the most promising open decision models, two of which are Mac-friendly.

• jev(): a PostgreSQL extension for natural-language queries - X: a single SQL function that searches a whole database in natural language with no index and no embeddings, e.g. WHERE jev(people, 'could work from home').

• A DuckDB extension for row classification - X: classifies rows in any CSV, Parquet, or DuckDB table with Jev, reporting about ten seconds for a thousand rows and better ergonomics than a bespoke classifier.

• An on-chain trading bot where Jev decides - X: Jev decides buy or sell from a live price feed and the bot places real orders on Monad every 300 ms block — the clearest sign that the finance experiments are not all paper.

• Jev broke our WebMCP benchmark - X: the benchmark's own author reports that Jev plus a fast small LLM solved 100% of WebMCP tasks at roughly 112x lower model cost than a frontier model with computer use.

• Chinese notes after a day with Jev - X (Chinese): a sceptical read — Jev looks like a faster general classifier an LLM could already do, and on complex scenarios its world knowledge is the open question.

• Stagehand plus Jev browser control - X: sends the accessibility tree as state and candidate actions as questions so Jev decides each step, reporting about $0.001 and near-instant execution for one task.

• Introducing CUA-S1 - X: Cua open-sources a family of small, specialised System One models for computer use, starting with form filling and asking what the next specialist should learn.

• One 50 ms pass versus 23 turns - X: the sharpest framing of the specialist case - a 706K-parameter model fills a whole form in one 50 ms pass, while an LLM agent needs 23 turns and 39.6 seconds for the same form.

• I reviewed 287 open-source Jev projects - Reddit: a reviewer works through 287 Jev repositories and narrows them to 20 that actually explain the model, a useful counterweight to star-count browsing.

• Jev in the Wild: A Data-Driven Analysis of the Jev Model's Functionality, Applications and Ecosystem - Research paper: the first data-driven survey and analysis of Jev's application ecosystem examines 2,170 public GitHub projects, early growth, application domains, and decision-use patterns.

• TypeSafe AI's Jev Is Not an LLM - and That May Be the Point - News analysis: treats the model's refusal to generate text as the feature rather than a limitation, and follows through on what that implies for inference spend.

• Ask HN: What do you think of Noul, a new decision primitive - Hacker News: a proposal to treat Noul - the probability-of-true answer type - as a general software primitive rather than a Jev-specific one.

• Made with Jev - Directory: Jev builds, guides, and use cases with reported cost and speed, plus free Jev-powered tools.

• When a designer gets access to Jev - X: a product designer's 33-second demo in which a natural-language phrase narrows a large icon set to the matching ones with Jev deciding which - 4.8k likes and a reply thread where the author discusses the icons Jev gets wrong.

• LangChain is already using Jev inside its harness - X (Chinese): reads LangChain's adoption as confirmation that Jev fits the fixed-harness roles - agent routing, model routing - rather than open-ended generation.

• Jev is now available to everyone, no waitlist - X: TypeSafe drops the waitlist and moves Jev from early access to general availability, the change that makes every other entry in this list reproducible by a reader.

• JEV captcha arbitrage - X: works through the economics of solving CAPTCHAs with Jev at $0.0068 per hundred against a marketplace paying a cent each, a pointed illustration of what per-decision pricing does to an existing market.

• A deep dive into Jev - Blog: a veteran technical writer's walkthrough of the System One idea, useful as the explanation to hand someone who has only seen LLM marketing.

• Replacing an agentic classification loop with Jev - Blog: swaps an agent's classification loop for a single Jev call and reports the loop running 7x faster.

• Awesome TypeSafe Jev - Curated list: a source-backed field guide with SDKs and live demos, the largest of the community indexes at 423 stars.

• 60 Jev use cases in Chinese - X (Chinese): rounds up sixty cases with twelve called out as most worth studying, organised around the same division of labour - the generative model writes, Jev classifies, scores, and chooses.

• Jev Tutorial - Site: an independent multilingual implementation guide to Choice, Score, Noul, Python SDK requests, confidence thresholds, deterministic fallbacks, and human escalation.

• TypeSafe pauses Jev signups - X: days after dropping the waitlist the vendor pauses signups again to protect quality of service, an unusually direct admission that demand outran capacity.

• Jev and the System One Model (Latent Space) - Podcast: Diogo Almeida on RLCD, intelligence per dollar, reliability, and why chat-first interfaces may not be where this ends up.

• Jev vs GPT-6 Astra: when to use each - Guide: Vercel's own decision guide for choosing between a System One model and a frontier model, published alongside a companion page of seven Jev use cases.

• A Jev index rebuilt every four hours - X (Chinese): describes a multilingual Jev site that scrapes X every four hours and has accumulated more than 5,380 posts, an index maintained by machine rather than by a curator.

• Jev 1.13 jaggedness - Documentation: TypeSafe's own page on model jaggedness for the 1.13 release.

• Jev cannot emit an invalid output, but where is the reliability curve? - Reddit: argues the type-safety guarantee is real and the calibration claim is not yet backed by a published ECE or reliability curve, the sharpest form of the question this list keeps running into.

• Jev is on Workers AI as typesafe/jev - Reddit: reports the model appearing on Cloudflare's Workers AI surface as typesafe/jev, a second Cloudflare integration alongside the AI Gateway listing.

• Why I couldn't build Jev at OpenAI - Video: Diogo Almeida's talk on why this had to be a separate company, the closest thing to a design rationale for System One models.

• TypeSafe's Jev Can't See. I Made It Guess What I Drew Anyway - Blog: a drawing-guessing experiment that probes what a model with no image input can still recover from a text description of a sketch.

• Spike: Jev as a judgement layer to cut model cost - Issue: a multi-agent orchestration platform plans to move judgment out of its model-of-thought and onto Jev, framed as cutting cost while holding quality.

• Awesome Jev Robustness - Curated list: 109 independent tests of Jev's calibration, consistency, prompt injection, abstention and failure modes, grouped by what they measured, each with model version and sample size.

• jevbooks: 16 Jev design patterns - Site: a bilingual gallery of 500+ open-source Jev projects in which Jev itself gates and tags every listing from its README, plus sixteen design patterns read out of ten codebases (Thermostat, Blind review, Flight recorder), each page a problem, a solution, and the recognition question the pipeline sends.

• Jev in 25 Lines of Python - Blog + HN thread (464 points, 139 comments): builds the smallest working Jev loop in Python, and the thread argues over whether the decision step needs a dedicated model at all.

• Will OpenAI eat Jev's lunch? - Analysis + HN thread (306 points, 215 comments): argues OpenAI is best positioned to fast-follow the typed-decision shape, and the thread debates whether the interface or the model is the moat.

• Jev introduces a new shape of LLM - Blog: Simon Willison's read on what changes when a model's output is a typed decision instead of prose.

• JevBench - Benchmark + HN thread (126 points, 34 comments): a reproducible harness for comparing typed-decision models on the same questions.

• Jev in practice: typed decisions, scoped authority - Blog: pairs the typed-decision loop with scoped authority, so a confidence value only authorises the action its scope already allows.

• jevchat - Repo + HN thread (173 points, 49 comments): deliberately misuses Jev as a generator to locate where the typed-decision model stops being useful.

• Open-sourced jev architecture last year - HN thread (96 points, 11 comments): a prior-work claim for the same architecture, where the discussion turns on recognition and marketing rather than on the technical overlap.

• Jev isn't new tech - Reddit (694 upvotes, 265 comments): the largest critique thread, arguing the marketing addresses people who think AI began with chat models.

• Jev deserves hype but not the type it's getting - Hacker News: separates the technical claim from the launch framing, and argues the former stands without the latter.

• Jev Can't Be Calibrated - Blog + HN thread (59 points, 60 comments): a statistical argument that the calibration claim cannot hold, with the methods written out.

• gev beats jev and takes images as input too - Benchmark: a head-to-head eval page where a rival model outperforms Jev on the same question set and additionally accepts images.

• I benchmarked TypeSafe's JEV against LLMs, BERT and Laya - Reddit (49 upvotes): pits Jev against both generative models and a classical classifier on the same task.

• The Jev archive built by OpenChamber - X: an independent site that has crawled X every four hours and collected 5,380+ Jev posts into a classified, multilingual index.

• zsh history completion with Jev - X: picks the most likely next command from the last 100 deduplicated history entries by asking Jev, and shows it greyed out after the prompt.

• TypeSafe AI draws $10bn interest - News (Financial Times, via Traders Union): reports that TypeSafe is attracting funding approaches that could value it at $10bn or more, a week after Jev left stealth.

• Vercel and OpenRouter adoption numbers - News: Vercel reports Jev drew more than twice the interest from paid developer accounts in its first 24 hours than any previous model launch on the service, and OpenRouter reports its token volume more than tripled over one weekend.

• Jev / TypesafeAI is revolutionary as LLMs - Reddit r/ArtificialInteligence (182 upvotes, 195 comments): the largest single thread on the launch, arguing over whether a decision model changes what LLMs are for rather than merely being cheaper.

• laya.tools - Site: an independent directory of about 950 projects built on Laya, the Apache-2.0 open alternative to Jev, imported daily from GitHub, npm, Hugging Face and X and browsable by platform and use case, with a Laya vs Jev comparison page.

• Diogo Almeida with a16z on Jev - X: the founder with Ben Horowitz and Martin Casado, pitching Jev by asking where all the decisions in a software stack currently live.

• Playwright CLI + Jev vs Playwright MCP - X: reports swapping the Playwright MCP for the Playwright CLI with Jev choosing each step, at 98% lower cost and twice the speed.

• Jev in front of the HeyGen MCP - X: a lead-generation pipeline where Jev decides which leads deserve a video in milliseconds before HeyGen renders it.

• Halv cut AI agent cost by 57.1% using Jev - Blog + HN: reports a measured cost reduction from putting Jev in the agent loop, on the SWE-rebench Astra pair set.

• Jev organized 2.3K research papers for 14 cents - X: a production use case reporting that sorting roughly 2,300 AI research papers took about 83 seconds and cost $0.14 in total.

Use exactly one line per entry:

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

MIT