AbdelStark/awesome-typesafe-jev

Jev gives your software a typed judgment. Your code stays in charge.

A community field guide to TypeSafe's Jev: see one documented call, try live projects, copy a starter, and inspect independent tests.

Try a live build · Shape a decision · Explore projects · Add your project · Star on GitHub

One call, three typed answers. TypeSafe's documented support-ticket example shows the saved jev-1.13.0 response below. This is a published example, not a live model call. Application code still decides when to route or escalate.

Open a live build from a preview, or read its listing first.

Three additions from 22 September 2026. These are places to explore, not a ranking or endorsement; the full listings include limitations and source links.

• pg-jev — Jev judgments over PostgreSQL rows; inspect the data transfer and superuser requirements.
• Kev — Local Jev-style models with released weights and evaluation suites; compare on your own task.
• Jevals.com — Independent hosted-model benchmark with public suites and per-decision logs; read the harness limits.

Download the JSON directory · Use with a coding agent · Suggest a resource · Follow updates · Join the builder community

Independent community project. This repository is not affiliated with or endorsed by TypeSafe AI. Community entries are labeled by section; inclusion is not a claim that TypeSafe has reviewed or approved them.

Last updated: 2026-09-23. Links and project descriptions change; please report a stale entry.

• See Jev at work
• Recently curated
• Start here
  • Choose the right tool
  • Choose where to call Jev
  • Make your first decision
  • Shape a typed question
  • Try a policy threshold
  • Before you trust a decision
• Official resources
  • Product and documentation
  • SDKs and developer tools
  • Concepts, patterns, and cookbooks
  • Research and writing
  • Community and updates
• Community projects
  • Client libraries and integrations
  • Agent and developer tooling
  • Browser agents
  • Applications and workflows
  • Games and robotics
  • Evaluations and independent research
  • Showcases and field notes
• Contributing
  • Build a listing
• Contributors

• Introduction — What Jev is, how System One models differ from text-generation models, and the Choice, Score, and Noul primitives.
• Quick start — The shortest path from an API key to a typed decision in Python or JavaScript.
• How to build with TypeSafe — Design guidance for decomposing a workflow into narrow judgments while keeping policy and side effects in code.
• TypeSafe Console — Create keys and inspect live Jev requests.

In a support workflow, separate the work before choosing a model. This is a practical design rule based on the TypeSafe introduction linked above, not a performance claim:

Code still validates the answer and owns the action. Measure Jev's error and abstention rates on your own cases before automating a consequential step.

One state can answer several focused questions in the same request. Pick the answer shape your code can use directly:

Ask independent questions together. Set thresholds, fallback behavior, and side effects in application code.

The typed decision is the common idea; the client, model name, authentication, and billing depend on the route. Start with the direct API below if you want TypeSafe's documented systemOne contract, or follow the platform guide for an app already running there.

These are documented access paths, not equivalent SDKs or claims about price, latency, or reliability. Check the linked provider page before deploying because availability and terms change.

Pick JavaScript or Python. Both examples send a synthetic support ticket to TypeSafe's API and return a Choice and a Noul. Jev returns typed answers; the 0.9 routing rule is ordinary application code. It is an illustrative threshold, not a measured or recommended operating point.

Install the official JavaScript SDK with npm install @typesafe-ai/sdk (Node.js 20+), set TYPESAFE_API_KEY in your environment, save this as first-decision.mjs, then run node first-decision.mjs:

import { choice, noul, TypeSafeClient } from '@typesafe-ai/sdk';

const { answers } = await new TypeSafeClient().systemOne({
  state: { ticket: 'I was charged twice. Please refund the extra payment.' },
  questions: {
    team: choice('Which team should handle this ticket?', {
      billing: 'Payments and refunds',
      technical: 'Bugs and integrations',
      other: 'None of the above',
    }),
    refund: noul('Does the customer explicitly request a refund?'),
  },
});

const team = answers.team.choice;
const probability = answers.team.probabilities[team];
const action = team !== 'other' && probability >= 0.9
  ? `route to ${team}` : 'send to review';
console.log({ team, probability, refundProbability: answers.refund.noul, action });

Install the official Python SDK with uv add typesafe-sdk (Python 3.10+), set TYPESAFE_API_KEY in your environment, save this as first_decision.py, then run python3 first_decision.py:

from typesafe_sdk import Choice, Noul, TypeSafeClient

with TypeSafeClient() as client:
    result = client.system_one(
        state={"ticket": "I was charged twice. Please refund the extra payment."},
        questions={
            "team": Choice(
                instructions="Which team should handle this ticket?",
                criteria={
                    "billing": "Payments and refunds",
                    "technical": "Bugs and integrations",
                    "other": "None of the above",
                },
            ),
            "refund": Noul(instructions="Does the customer explicitly request a refund?"),
        },
    )

team = result.choices["team"].choice
probability = result.choices["team"].probabilities[team]
action = f"route to {team}" if team != "other" and probability >= 0.9 else "send to review"
print({
    "team": team,
    "probability": probability,
    "refund_probability": result.nouls["refund"].noul,
    "action": action,
})

Start with one state and a question whose answer your code can use. This synthetic support report can be asked as a Choice, Noul, or Score. On the live site, edit the fields and copy a JavaScript SDK call. The designer runs in your browser without making a model request; running the copied code later sends the state to TypeSafe.

Keep the state short, describe the options so they do not overlap, and include a no-match option when the task allows it. Choose thresholds and actions only after measuring your own labelled cases.

The documented support-ticket example above selects technical with probability 0.85. In this illustrative policy, a ticket routes automatically only when the selected probability reaches the application's threshold. At 0.90, it goes to review; at 0.80, it routes to technical. The model answer stays the same. These thresholds are teaching examples, not measured operating points or safety guarantees.

On the live site, move the threshold to see which action the application takes. A real threshold needs evaluation on your own labelled cases, with a review path for uncertainty.

Independent studies make five failure modes concrete. Each result below belongs to the cited task, dataset, and model run; use it to design a test for your own workflow.

These are independent, study-specific observations, not a leaderboard or a guarantee for another task. Read the linked protocols, labels, and limitations before carrying a number into a decision policy.

For a comparison across decision models, JevBench's method publishes its scoring code, frozen tasks, adapters, and result artifacts. Its composite score combines accuracy, calibration, speed, and cost; some latency and hosting costs are estimates, and a held-out set is still sent to the evaluated services. Read the per-task outcomes and assumptions before treating a rank as evidence for your workflow.

• TypeSafe AI — Official product site for System One models and Jev.
• Documentation — Guides, SDK references, patterns, cookbooks, and the HTTP API.
• HTTP API reference — Request and response contract for direct API integrations.
• Interactive demos — Official hands-on examples, including the smart-home assistant.
• Workflow evals — TypeSafe's published workflows, model comparisons, methodology, and example queries.

• JavaScript SDK — Official JavaScript and TypeScript client with inferred answer types.
• Python SDK — Official synchronous and asynchronous Python client.
• System One Adapter — Drop-in Python adapter for running the same typed interface over OpenAI, Anthropic, and OpenAI-compatible LLM APIs.
• TypeSafe Agent Skills — Official agent skill for designing TypeSafe workflows from Claude Code, Codex, and other skill-compatible agents.
• TypeSafe GitHub organization — Source repositories maintained by TypeSafe.

• Primitives — Choice, Score, and Noul, including their result shapes and when to use each one.
• Confidence — How confidence differs from answer probability and how to use it as an architectural control.
• Patterns — Confidence-gated routing, composite scoring, speculative fan-out, and intent routing.
• Example use cases — A map from real-world workflows to typed judgments.
• Cookbooks — Reproducible implementations for parallel questions, reranking, semantic search, guardrails, extraction, classification, and more.
• Agent skill guide — Installation and usage instructions for the official TypeSafe skill.

• Introducing System One Models & Jev — Launch post, product thesis, published results, and explicit limitations.
• Manifesto — TypeSafe's case for machine-native intelligence built for software rather than conversation.
• The Bitterest Lesson — Why optimizing the wrong task can dominate gains from scale.
• AI: too good to be true, too bad to be useful — The argument for moving beyond preference-optimized chat models in automation.

• Discord — Official community server for builders, support, and discussion.
• Show and Tell — Builder demos and work in progress; joining the Discord server is required.
• X — Product and research updates.
• LinkedIn — Company announcements and hiring updates.

Community projects are independent unless their repository says otherwise. Read the code, licenses, data-handling notes, and evaluation caveats before using them in a consequential system.

Browse a focused page: Client libraries and integrations · Agent and developer tooling · Browser agents · Applications and workflows · Games and robotics · Evaluations and independent research · Showcases and field notes.

On the live directory, save up to eight projects to a reading list and share its link. The selection uses the entries below; no account is needed.

Build with Jev from a language, framework, gateway, or data system you already use. Check each community client's maturity and data handling before adopting it.

• Advocaat — Small TypeScript client with ergonomic tagged helpers for typed chances, choices, and scores.
• AnyDecisionModel — Swift 6.2 package with typed sessions, enum-backed choices, and ordered scores over either TypeSafe's Jev API or a local MLX language model on Apple silicon; the local backend reads answer-token probabilities without generating text, and its calibration is caller-configured rather than established for every task.
• Ax TypeSafe integration — Ax's TypeScript provider supports required Boolean and class signatures and a native Jev client for Noul, Choice, and Score questions with probabilities and criteria; free-form text and numeric signature fields are not native Jev outputs, so use its explicit native interface for scoring rather than treating a bounded number as a Score rubric.
• DuckDB Jev — Native DuckDB extension for Jev predicates, Choice classification, Score rubrics, and streaming batched judgments over SQL rows, with per-query budgets, caching, and request telemetry; published live throughput uses a repeated synthetic ticket corpus and does not measure classification accuracy, and binaries must match the DuckDB version and platform.
• grounded-ai — MIT Python evaluation library whose JevEvaluator asks hosted Jev or a local Strands Decider Noul, Choice, and Score questions, and whose CascadeEvaluator keeps confident answers and sends the rest to an LLM judge (OpenAI, Anthropic, Bedrock, or Hugging Face). Hosted mode sends inputs to TypeSafe; escalated questions go to the judge's provider even when the first judge is local. Its tool-call benchmark has 200 items labelled by another model's choices.
• Hunch — Ruby gem that turns judgment calls into control flow: if Hunch.likely?("fraudulent", given: order) 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; not affiliated with TypeSafe AI.
• Hunch for Python — Python library (pip install hunch-jev) that maps Jev Choice, Score, and Noul to functions over strings, lists, and DataFrames, deduplicates per-row requests, and keeps thresholds in caller code; selected rows and context go to TypeSafe or a configured gateway, and optional LLM escalation sends uncertain rows to that provider. A TypeScript port offers the same interface.
• Jev for Apple Foundation Models — Swift 6 bridge that translates Apple @Generable Boolean, enum, and bounded score fields into one Jev question set, then decodes the typed answers through LanguageModelSession; ships mock-transport tests and two demos, but requires iOS, macOS, or visionOS 27 and an API key kept on a backend or trusted machine rather than in a mobile app.
• jev-acp — Standalone ACP agent for Jev Choice, Score, and Noul decisions, with guided input, reusable templates, and probability displays; requires a TypeSafe API key and sends decision inputs to TypeSafe.
• Jev-Switch — Rust gateway with a React console and Windows Tauri app that serves a Jev-shaped /v1/systemone endpoint and routes each request through an editable graph of upstream routes with failover; v0.1.0 adapters cover only Vercel AI Gateway and Laya, not TypeSafe's own API, request state goes to the selected upstream, and the README is in Chinese.
• jev.zig — Zig client with compile-time typed answers, retries with per-attempt timeouts, and diagnostics. Questions are fixed at compile time.
• Jevelry — Early-stage TypeScript CLI, library, and coding-agent skill for reusable Jev question templates: it maps typed answers to act, mark, or fall back, and keeps a local decision/outcome log for review. Question state goes to TypeSafe; the log keeps a state hash by default but can opt into full state, and configured run commands may execute locally without per-action confirmation when confidence is high.
• jevframe — Early Python library adding async Jev Noul, Choice, Score, and multi-question evaluation to pandas and eager Polars, with full Choice and Score probability distributions, bounded row concurrency, and opt-in memory caching; each uncached row sends selected context to TypeSafe, and LazyFrame expressions are outside v0.
• jevql — psql-shaped CLI and Go/TypeScript/Python SDKs that let you write WHERE jev(alias, 'condition'), jev_prob, jev_choice, and jev_score against a vanilla Postgres with no extension: it runs the plain SQL on the server, judges the surviving rows with Jev in batches (cached in local SQLite), and applies filter, sort, and group in the client; every row that survives the SQL filters is sent to TypeSafe and judged, so put cheap predicates in SQL first.
• jevsearch — shadcn/ui registry block for ⌘K site search: a local keyword pass streams hits on the first keystroke, then the top 20 go to Jev in one request (a Noul per page, a Choice for the single best answer, and a Noul for whether any page answers) and code re-orders or drops them; with no embeddings or vector database it only re-ranks what the keyword pass retrieves, and keyword order stands if TypeSafe is slow or down.
• Jevstiller — Apache-licensed self-hosted proxy for repeated Jev Choice and Noul calls: point TYPESAFE_BASE_URL at it, and it trains a small local head on Jev's own answers and answers locally only within a target agreement checked by a Clopper–Pearson bound and a permanent audit slice. Callers' keys are forwarded and never stored; request text is kept locally for training unless disabled. Score questions are forwarded, while the default local encoder sees only the first 256 tokens of a state, limiting coverage on long inputs.
• json-render — Generative UI framework with an experimental Jev composer that selects components and layout from application-supplied candidates through Vercel AI Gateway. The Jev API is unreleased and requires a source build; application code owns components, actions, and side effects.
• Laya for Node.js — MIT TypeScript client that runs the independent, Jev-compatible Laya Choice, Score, and Noul model locally through ONNX Runtime, batching a question set in one call; first use downloads about 1.7 GB of weights, and its reference-output test runs only when that model bundle is present.
• LlamaIndex Jev — Unofficial LlamaIndex reranker and query-engine selector on the official Python SDK: Jev scores retrieved passages and chooses which tool handles a query; score mode is a 0–3 rubric, not cosine similarity.
• Milvus Model — Python reranker adapter that sends a query and candidate documents to TypeSafe as batched Jev Noul questions, then sorts the scores while preserving original document indices; the current prompt is claim/evidence-specific, requires a TypeSafe API key, and is confirmed in source but not yet in a verified package release.
• mysql-ailike — Native MySQL plugin that adds an AILIKE predicate for natural-language row filters in WHERE and a three-argument ailike(left, right, prompt) for semantic JOIN ... ON conditions, powered by Jev; it is a preview release, each uncached evaluation is an API request, and evaluated values and prompts are sent to TypeSafe.
• NeuroLink — TypeScript SDK that exposes decide as a third inference type alongside generate and stream, backed by TypeSafe's Jev or the open-weights Laya, declared per provider through an inferenceKinds field rather than inferred from behaviour, and consumes it internally for model routing, context compaction, MCP tool selection, and RAG planning; every internal caller uses a fail-open wrapper that returns null on any failure, so with no key configured the library behaves exactly as it did before, and it is not affiliated with TypeSafe AI or Convai Innovations.
• OCaml SDK — Unofficial eio-based client.
• pg-jev — PostgreSQL extension for Jev-powered WHERE predicates, probabilities, Choice, and Score over table rows; it batches rows, caches answers per session, and offers optional query spend caps. Every judged row goes to TypeSafe, and installation needs plpython3u and superuser access, which many managed Postgres hosts do not provide.
• pi-typesafe — Pi extension and library that gives the agent and other extensions one consented, key-managed TypeSafe client with a batched typesafe_evaluate tool and offline-testable transport; requests are billable and opt-in per user.
• RubyLLM TypeSafe — TypeSafe provider for RubyLLM 2 with offline model metadata and typed responses.
• s1-rs — Rust derive layer for Choice, Score, Noul, typed question sets, confidence gates, and network-free testing.
• scala-jev-sdk — Community Scala 3 client for TypeSafe's System One API with typed Noul, Choice, and Score questions whose answers are retrieved with the question value itself, no effect system of its own so the same code runs on any sttp backend from Future to blocking, cats-effect, or ZIO, retries that honour Retry-After, and local validation that rejects a malformed question set before it costs a round trip; every call returns an Either rather than throwing, effects other than Future and the blocking Identity must supply a one-line sleeper for the retry timer, Scala 2.13 is not supported, and it is not affiliated with TypeSafe AI.
• SemanticPolicy — Alpha .NET 10 library (Apache-2.0) that writes application and agent decisions as Boolean, Choice or Score rules Jev answers, turns the probability into a verdict with thresholds measured on labelled examples by an evals CLI run from a clone, and adds checks before the model call, before a tool runs and after it returns in Microsoft Agent Framework agents; the evaluated text goes to Jev through OpenRouter or TypeSafe's endpoint and the library does not log it, and a rule is a signal, not a security boundary.
• Swift SDK — Unofficial, experimental Swift client with typed answers, async/await, and Swift Package Manager support.
• TypeSafe AI for Rust — Rust client with asynchronous and blocking transports, typed responses, observable retries, and inspectable errors.
• TypeSafe AI Swift SDK — Dependency-free Swift 6 client for Choice, Score, and Noul questions with strict concurrency, configurable retries, and network-free transport tests; production Apple apps should proxy requests through a backend.
• TypeSafe SDK for Go — Community Go 1.23 client for TypeSafe's System One API with typed Noul, Choice, and Score questions in a single request, options-over-environment configuration, retries that honor Retry-After, an errors.Is-matchable error tree, and log/slog logging that redacts credential headers but logs request bodies at debug level; answer types the client does not model are dropped with a warning rather than failing, and the module has no tagged release yet, so go get resolves a pseudo-version.
• TypeSafe SDK for Java — Community Java 17 client for TypeSafe's System One API with typed Noul, Choice, and Score questions, lambda-style builders for nested criteria, retries matching the official SDKs, status-specific exceptions, and a Spring Boot starter; depends only on Jackson and is not affiliated with TypeSafe AI.
• TypeSafe SDK for Kotlin — Community Kotlin port of the official JavaScript SDK covering TypeSafe's System One API with typed Noul, Choice, and Score questions, a retry policy matching upstream, status-specific exceptions, HTTP and SOCKS5 proxy support, and runtime checks that each answer matches the question that produced it; targets Android and the JVM only, is distributed through JitPack rather than Maven Central, and is not affiliated with TypeSafe AI.
• TypeSafe SDK for PHP — Community PHP 8.3 client for TypeSafe's System One API with typed Noul, Choice, and Score questions, a one-call switch between TypeSafe and OpenRouter's decisions endpoint, retries and per-call overrides, any PSR-18 transport, and a Laravel service provider; calls are synchronous, model listing works only on TypeSafe, and it is not affiliated with TypeSafe AI.
• typesafe-ai-rails — Community Rails integration for TypeSafe's System One API, built on typesafe-sdk, with Rails configuration, persisted usage and cost telemetry, and opt-in confidence policies for Choice and Score answers.
• typesafe-rs — Latency-focused Rust transport SDK designed around behavioral parity with the official clients.
• typesafe-sdk — Community Ruby client for TypeSafe's System One API with typed Noul, Choice, and Score questions, retries, model listing, and thread-safe pooled HTTP connections; requires Ruby 3.1 or newer and has no async client.
• typesafe_sdk — Elixir SDK for TypeSafe AI and Jev with typed Choice, Score, and Noul structs, configurable retries, and upstream API parity.
• TypeSafeAI.Net — .NET client for TypeSafe's API with Noul, Choice, and Score question sets, HttpClientFactory and dependency injection support, plus Microsoft.Extensions.AI guardrail, routing, tool, and evaluator adapters.
• Vercel AI Gateway — Third-party hosted gateway entry for calling Jev through Vercel's AI SDK and gateway.
• Vercel AI SDK for Python — Vercel's public-beta Python SDK includes an experimental evaluate operation that asks typed Choice, Score, and Boolean questions through AI Gateway using typesafe-ai/jev; the evaluation API is still experimental and requires Gateway access.
• vgi-typesafe — DuckDB integration, loaded through the community VGI extension, that exposes Choice, Noul, and Score as SQL table functions to LATERAL join against a table, returning typed columns with confidence, probabilities, and per-row token usage, plus an is_true() scalar for WHERE clauses; several questions share one request per row and repeated values are asked once per batch, but every other non-null row is a billable request that sends its content to TypeSafe's API.

These tools use typed judgments to search, route, review, or gate developer work. Inspect each tool's action policy, fallback behavior, and request costs.

• Augustus — Independent augustus and augustus-train agent skills for placing and building application-specific decision models: primitive, base-model, and method selection, data assembly, fitting, export/reload, bounded improvement, and offline evaluation. TypeSafe Jev is the default hosted exemplar, not a model this project reproduces, and rules-only or no-training outcomes are valid results.
• Beacon — Cross-harness agent memory tool with an explicit beacon memory evaluations run command: Jev judges bounded, redacted trace projections for reusable lessons, which a person reviews before adding to project memory or installing as a skill. Hooks and dry runs do not call Jev; normal capture can retain sensitive session text locally, so inspect retention before enabling it.
• Bicameral — Pi coding harness where an LLM writes while Jev supplies typed reflexes for policy, loop detection, and review; explicitly not a sandbox.
• Building with TypeSafe Jev — Unofficial agent skill for Claude Code, Codex, and Antigravity CLI that holds the Choice, Score, and Noul API shapes, cookbook thresholds, community failure modes, and 150+ community projects sorted by implementation shape, each with a code sketch; it is Markdown only and sends nothing itself, but it is a 2026-09-25 snapshot of the docs and tells the agent the live docs win on any conflict.
• Canny — Claude Code and Codex hooks that record edits and checks in an append-only ledger, flag a "done" claim without a passing check after the last code edit, and use optional Jev Noul judgments for advisory rule checks or to recognize a non-completion message; its default gate allows a repeated stop after warning, the author has not measured project-wide quality gains, and enabling Jev sends clipped diffs, project rules, and final messages to TypeSafe.
• Codex Jev Router — Instruction-driven Codex subagent router that asks Jev Choice and Noul questions about a short task summary, applies confidence thresholds in code, and falls back to Sol when the decision fails; hosted Jev receives the summary, while local compatible backends are optional. Its installer changes local Codex configuration with a backup, but routing is not enforced at the tool boundary.
• DGP — Experimental decision-based agent protocol with a Jev adapter, immutable evidence frames, typed assessments, and application-guarded commits; the local reference app simulates domain effects, and opt-in live mode sends decision evidence to TypeSafe.
• Distill — Coding agent harness that can use Jev to select a model and effort, route bounded utility tasks, and judge what context to retain. Code constrains the choices and validates utility results; failed or low-confidence decisions leave the normal path in place. Jev does not decide tool permissions, and routing can send the user's request and recent steps to the configured endpoint.
• Every — Semantic code search CLI that asks a yes/no question of every function and ranks the resulting probabilities.
• evoke — Rust CLI and TypeScript SDK that ask Jev to select an installed reflex and bounded arguments, then gate the outcome in code as run, confirm, ask, or abstain. Reflexes fetched from Git run as your user without a sandbox, so inspect them before installing.
• fast-jev-compaction — Claude Code function-hook plugin and npm library that asks Jev which older tool calls and results to keep, truncate, or remove without rewriting user and assistant messages; it sends a bounded version of the conversation and tool inputs to TypeSafe, and its relevance probabilities do not guarantee safe deletion.
• Foreman — Experimental Codex/OpenCode supervisor that sends bounded job, output, and diff context to Jev for progress checks; workers run locally without isolation, and judgment accuracy is unproven.
• fx — Experimental Zig coding agent with an optional Jev permission reviewer: setting review_model to typesafeai/jev sends the composed policy, context, and pending action to TypeSafe directly or through Vercel AI Gateway, then maps Jev's Choice to a permission decision; recorded probabilities and confidence are not threshold gates.
• Hermes Jev Skills — Python toolkit and nine agent skills for Hermes, Claude Code, and Codex: Jev can route models, filter retrieved passages, select skills, and choose bounded computer or browser actions. The installer has a dry run and routing offers shadow mode; enabled features send redacted prompts or excerpts to TypeSafe, so read the per-feature data disclosure before use.
• Hermes JIT Context OS — Coding-agent context runtime with an optional Jev Noul ranker for candidate facts: it sends a bounded query and fact excerpts to OpenRouter, caches scores, and labels deterministic token-overlap fallback when the remote path is unavailable. Its published ten-task live-call record uses small SWE-bench-style fixtures built from inline files, not full repository checkouts or a SWE-bench score.
• Hippo Memory — Local agent memory system with an opt-in Jev reranker that batches Noul judgments over the top 40 recalled memories and falls back to a local cross-encoder on errors. The author's published study found better ranking on two corpora but no demonstrated answer-quality gain over the cross-encoder; enabling Jev sends the query and candidate memories to TypeSafe.
• hush — GitHub Action for issue triage that abstains: label, spam, needs-more-info, and possible-duplicate in one call, each applied only above a threshold the maintainer sets, and nothing at all below it.
• is-malicious — CLI that scans source, configuration, build, and CI files with Jev, reports suspicious behavior with file and line pointers, and sends scanned file contents to TypeSafe's API.
• jeff — Go CLI with noul, choice, score and eval commands that map a threshold to an exit code, plus a rank command that sends one Score per item per weighted dimension of a YAML spec in a single request and computes the composite order in code; the state goes to TypeSafe, and the weighted sum is the tool's own arithmetic rather than a Jev feature.
• Jev Clean — Experimental CSV cleaning tool that computes repair candidates locally and uses Jev Choice, Noul, and Score judgments to gate changes, with audit and rollback records; it sends bounded candidate details and data samples to TypeSafe, and currently limits inputs to 10,000 rows and 30 columns.
• Jev Codex Router — Local Codex Router extension that asks Jev for a model tier and thinking depth on each model call, including tool continuations, then relays the native Responses request; it needs a local routing stack, and its published savings backtest simulates an older policy rather than measuring current quota saved.
• Jev Cookbook — Fifteen runnable OpenRouter recipes for support triage, data cleanup, search, browser actions, and Gmail labeling, with small labelled samples and saved live results; the examples keep action thresholds in code, and their sample results do not establish production accuracy.
• Jev MCP — Python MCP server exposing classify, score, check, match, and screen tools to MCP-compatible agents.
• Jev MCP by jkudish — Node MCP server with ten bounded Jev tools for checking claims against supplied evidence, screening content, choosing candidates, reranking, extraction, and patch review; it can use TypeSafe or configured gateways, but its judgments do not run tests or independently establish factual truth.
• Jev Review — Staged code-review workflow and local dashboard that follows structured signals through focused Jev calls.
• jev-align (Sutro) — Experimental active-learning CLI that evaluates CSV, Parquet, and JSONL data with Jev, asks people to label uncertain and randomly audited examples, and uses GEPA to propose improved definitions while keeping labels and proposal acceptance under human control.
• Jev-assisted shell — When built with --assisted-shell and ran with --advise, the kamchatka agent classifies shell commands, providing the user with a quick, color-coded safety rating for each command that a model wants to run.
• jev-axi — Agent-ergonomic CLI following the AXI conventions that gives coding agents Jev judgments for blocking risky tool calls, screening fetched content for prompt injection, triaging build logs, flagging risky diffs, and filtering or ranking many items; its own benchmark found agents using it read fewer files but cost the same, so it is meant for judgments rather than as a substitute for reading code.
• jev-belay — Claude Code Stop hook that checks the transcript for evidence before trusting a "done" claim, spending one four-question Jev call only when files changed with no passing check since, and failing open on every error path.
• jev-cli — TypeScript CLI (npm install -g jevctl) that turns Jev judgments into pipeable, exit-code-gated shell commands: verify claims against evidence, screen text for prompt injection before an agent reads it, classify, extract, match, route, find and rerank up to 250 candidates, compact agent transcripts by dropping stale tool calls verbatim, and batch any of them over JSONL with a concurrency pool; thresholds and --fail-on policy live in code, not prompts, it works over TypeSafe, OpenRouter, or Cloudflare Workers AI, and it ships as a Claude Code plugin with a compaction hook.
• jev-commit — 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 when it detects a credential.
• jev-engineering — Decision layer for coding agents: deterministic rules run before any model call, then one Jev request, shipped as a Claude Code PreToolUse hook, an MCP server, a loopback service and a team policy where personal overrides may tighten thresholds but never loosen them. Includes an adversarial kit and its published results: over 300 calls, blunt injections moved 0 of 30 dangerous commands but caused 10% false denials on safe ones, while authority framing moved 3 of 30.
• jev-graphify — Python CLI that names and classifies graphify code-graph communities by having Jev pick from candidate names built from the graph, then routes a developer question to the community and symbol to read first; sends symbol names, file paths and short code comments (not source bodies) to TypeSafe, and has only been tested on one codebase.
• jev-lint — MIT-licensed fuzzy linter that uses Jev to flag team-rule violations as Claude Code and Codex edit, with configurable rules and local thresholds; added code goes to TypeSafe and API errors fail open.
• jev-logtriage — CLI that asks Jev Noul, Score, and Choice questions of collapsed Loki log batches and maps answers in code to suppress, watch, review, notify, or page; remediations stay candidates and nothing is executed.
• jev-mobile — Experimental Android agent that uses Jev for bounded, per-step choices over prevalidated UI actions, with confidence gates, pagination, escalation, and optional LLM planning; currently a proof of concept tested mainly against Android Settings.
• jev-pref — CLI and GitHub Action that turn project-defined semantic preferences into Jev Noul or Choice checks over code changes, then map results to advisory or blocking outcomes in code; supports tuning on labelled diffs, and sends reviewed change text to TypeSafe.
• jev-pruner — Claude Code plugin and opt-in Codex wrapper that use Jev to trim long Bash output before the main model sees it, while preserving diagnostics and archiving the full output locally for recovery; scoring sends command output and session history to TypeSafe, and its retention rules are heuristics rather than guarantees.
• jev-router — Claude Code and Codex wrappers that ask Jev to choose a model tier for each fresh user turn while retaining the native CLI sessions and authentication; prompt text goes to TypeSafe, and the documented compatibility testing is on Windows with specific CLI versions.
• jev-semgrep — Node CLI (@uehaj/semgrep) that batches Jev Noul questions per line for multilingual grep by meaning and combines queries with AND, OR, and NOT in code. Every searched line goes to TypeSafe, repeated searches pay for the corpus again, and its semgrep command name collides with the static-analysis tool.
• jev-skill-router — Claude Code plugin that ports the skill-suggestion cookbook to a UserPromptSubmit hook over user, plugin, and project skills; it sends the prompt text and skill descriptions to TypeSafe, starts in a log-only shadow mode, and ships thresholds that are not yet calibrated on its own data.
• jev-unpack-hook — MIT Codex and Claude Code Stop hook that sends sufficiently long assistant messages to TypeSafe's Jev to count asks and list points, then prompts the agent to handle a multi-ask, multi-point handover one issue at a time above confidence thresholds; short messages are skipped, and API/key failures block the stop with a warning.
• jev-use — Claude Code, Codex, and pi plugin that hands the steps needing no text output to Jev: jev_judge batches typed noul, choice, and score questions about one state into a single call, jev_gate is an opt-in PreToolUse gate that can only deny or ask, and a typed escalation contract (writing, open_ended, oversized, unsure, unreachable) returns every other step to the LLM rather than guessing — an unreachable backend escalates instead of allowing, so a gate that cannot be judged never waves a command through. Interchangeable TypeSafe, OpenRouter, and Vercel AI Gateway backends, a routing skill, and a native pi extension; its own live benchmarks, including the runs where Jev did worse, are published in the repo.
• jev.nvim — 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 the quickfix window.
• jevcal — CLI that fits a per-question confidence threshold to a target accuracy on your own labeled data, verifies it on a held-out split, estimates how much traffic still needs a fallback model, and re-checks the locked thresholds in CI; publishes no Jev results of its own, and thresholds fitted on fewer than about 100 labeled rows should not be trusted.
• JevDroid — Experimental Python framework that uses Jev to choose Android actions from accessibility trees and executes them through ADB or UIAutomator2, with explicit action permissions and per-run budgets; goals and visible UI text are sent to the selected TypeSafe or Vercel provider.
• jevgrep (allebee) — Streaming grep-by-meaning CLI (jevgrep-cli on PyPI) for logs and other text, including tail -f: it batches one Jev Noul per line and prints lines above a code-set threshold. Its hand-labelled, 195-line synthetic-log benchmark compares Jev with Claude; every judged line goes to TypeSafe or OpenRouter, and optional --explain sends selected lines to Anthropic through OpenRouter.
• Jeview — Experimental unofficial loopback proxy and live map of Jev calls, grouping decisions by project and linking later calls to earlier answers; it forwards requests to TypeSafe and stores requests, responses, and the API key in local SQLite (the key in plaintext), so keep it off public addresses.
• JevLoop (Python) — Experimental Python agent runtime where Jev selects typed actions and targets, low-confidence decisions can trigger LLM arbitration, and a shared guarded kernel executes file and shell operations in Docker sandboxes; task and tool context are sent to the configured model providers.
• Jevonian — Experimental local proxy for coding agents using OpenAI, Anthropic, or Responses-compatible APIs. The jevonian/auto route asks Jev to choose a model and thinking level after deterministic compatibility and quota filters; explicit routes skip Jev. The ledger records the serving model, route reason, token usage, and estimated cost. Jev receives recent messages and tool results, and the optional fullPrompt setting can send the whole conversation. Low confidence is flagged rather than automatically rerouted; costs and cache savings are estimates.
• jevr — Rust CLI for semantic code and document search: a local BM25 pass recalls candidate files, Jev Noul questions judge bounded windows, and a Choice reranks the survivors into grep-style path:line results; the query and selected source excerpts go to TypeSafe in requests containing up to 24 KB of source text.
• JevRouter — Routes models, skills, MCP tools, CLIs, and plugins through Jev's typed choices while code enforces availability, permissions, risk, and confirmation; it includes an offline demo mode and append-only decision receipts.
• jgrep — Semantic grep CLI (npm install -g jevgrep) that splits files or git diff hunks into 5–60 line chunks, packs several chunks into one request with a Noul question per chunk, and prints file:line hits above a probability threshold with grep-style exit codes, so a diff can be linted in CI against rules written in English; ships an interactive jgrep init and an opt-in Claude Code and Codex skill; chunks are judged in isolation so cross-file questions do not match, and every chunk's text is sent to TypeSafe's API.
• langchain-skill-router — Per-turn skill routing for LangChain deepagents: a Jev adapter or another configured judge ranks and verifies candidates before middleware loads one skill or offers a shortlist; the request, recent conversation, and skill text go to that judge, and the published evaluation uses one generated testbed and one agent model.
• mintocode — Context compiler for Claude Code, Codex, OpenCode, and ZCode that compiles a repository once and sends the agent only the code paragraphs a question needs, with optional Jev Noul judgments ("is this paragraph needed?") over candidate paragraphs; enabling Jev sends the question and up to 4,000 characters of each candidate's text to TypeSafe, and the Jev path is implemented but not yet benchmarked, so the project's published results use other selectors.
• Mobile Jev — Local Android agent and studio using Mobilerun: Jev selects operations and observed targets, code rejects stale actions, and the included dark-theme demo checks the resulting switch; it needs a device plus Mobilerun and TypeSafe keys, while CI tests do not control a live phone.
• mu — Pre-release coding agent and desktop app built on Pi that sends the routine calls of its loop to Jev as typed questions at 38 decision points (what enters the context, whether a flagged command was asked for, prompt-injection screening of fetched pages and MCP output, whether "done" was verified, what passes between sub-agents), each switchable between active, shadow and off and logged to a local ledger; the judge receives only the fields a question needs, which go to OpenCode Zen when no key is set, and a local judge or any LLM can take a decision point instead.
• Oko — Local MCP code search for Codex, Claude Code and OpenCode that reranks a keyword shortlist with Jev Noul judgments and returns whole-function excerpts; sends the question and up to 90 code chunks per search to TypeSafe, and a keyword-only mode works without a key.
• oxlint-plugin-jev — Experimental Oxlint plugin that asks Jev Noul questions about functions, calls, JSX elements, or files and reports matches above a chosen cutoff. It sends matched snippets to TypeSafe; API failures skip checks by default, so set ci: "fail" in CI. Keep it out of editor linting because edits can trigger paid calls.
• patdown — CLI, GitHub Action, and agent hooks that judge files or changes against Markdown rules with a provider-swappable Jev backend and configurable probability threshold; it sends matched file content to TypeSafe, has no request budget or result cache yet, and its semantic verdicts need human review for consequential gates.
• perch — Code scanner that parses methods and their call graph, asks Jev typed questions about each method in scope, and ranks potential defects and security findings; --since scopes CI runs. It sends method source to TypeSafe and reads every method in scope, so review request cost and findings before using it as a gate.
• pi-heed — Pi extension that turns constraints stated in conversation (English and Chinese) into a scoped, replayable policy (deny, allow, exceptions, once/run permissions, ask-first, tests-before-push) and checks side-effecting tool calls against it before they run; rules handle side effects and paths while Jev only classifies how each message changes the policy, re-checks exceptions and skips tools a free-text rule cannot concern; ships a replayable benchmark and an experiment log on Jev calibration and question design; experimental, shadow mode by default, fails open, and the benchmark is scripted rather than drawn from real sessions.
• pi-jev — Pi extension with a shadow-mode tool-call gate, output judge, and a general typed jev_ask tool.
• pi-jev-compaction — Pi extension that asks Jev which older tool results to hide after context pressure rises, retains the original session messages, and exposes a jev_read tool to recover an output without rerunning its command; it protects recent results and leaves context unchanged on API failure, but Jev sees bounded conversation and tool-output excerpts that may contain private data, and tests do not establish live relevance quality or cost savings.
• pi-jev-context — Pi extension that shortens long tool output before it enters the context, so no cached prompt prefix is invalidated: Jev gives every block of the output a probability that the current request needs it, only blocks it is confident are unneeded are hidden, code guarantees that failure lines, request terms and the top-ranked blocks survive, kept lines stay verbatim, and a context_recall tool returns the original; ships experiment reports and a findings log with pre-registered synthetic sets and weakly labelled replays of real sessions, including a negative result (Jev-judged pruning of old context dropped information needed later, so that part stays shadow-only); experimental, shadow mode by default, and the real-session replays come from one user's sessions.
• pi-verdict — Pi permission gate that first applies deterministic rules (danger floor, user allow/deny, protected-path prompts) for clear decisions, then routes gray-zone cases to a fail-closed enforcing classifier (configurable via classifierModel to point at Jev: allow/ask/deny); the Jev backend is experimental — served through OpenRouter or TypeSafe's direct API, it ignores protected-path hints and can be swayed by adversarial transcript content; transcripts are sent to whichever classifier backend is configured.
• pi-warden — Pi guardrails built on pi-typesafe that return Jev's verdict to the agent as a held tool result or a short steer instead of a dialog, check writes against a project rules file, and grade their own holds against the user's next message on recorded sessions; the action guard is calibrated on one user's 17k calls, the other guards on synthetic cases only.
• pytest-jev — pytest plugin for semantic assertions about LLM output: jev.expect batches Noul claims about one text, reports each probability, and by default fails uncertain claims (holds needs at least 0.8, lacks at most 0.2); Choice checks the selected option and Score checks probability mass across ordered levels. It caches answers in .pytest_cache, skips Jev tests without a key by default, and sends tested text and context to TypeSafe or OpenRouter.
• reasoning-router — MIT OpenCode plugin, Pi extension, and local Responses/Messages proxy for Codex CLI and other clients that asks a classifier (Jev by default; Clef, Laya, Kev, OpenAI Decisions, and CLM also work) to pick the reasoning effort for each model request, then adds it as an OpenAI configuration_update item or an Anthropic effort-only system message so the cached prompt prefix still matches; the classifier receives bounded excerpts of recent conversation and up to eight recent tool results, the published eval covers one GPT-6 Astra task mix (Jev routing and fixed high effort each solved 44 of 44, routed used about 14% fewer output tokens), and the project is alpha.
• Second Thought — Python SDK, CLI, and optional local dashboard that captures typed decisions from Laya, Jev, or a custom classifier, measures calibration, and routes uncertain cases to human review; its dataset export excludes Jev decisions in code, and its reported Laya result comes from a 24-ticket example run.
• Skillbox — Self-hosted agent skill library with opt-in Jev recommendations over task text and authorized active skill descriptions, using an owner-provided TypeSafe, OpenRouter, or Vercel AI Gateway key. Failed, oversized, or rate-limited evaluations fall back to deterministic search rather than returning a partial model ranking.
• SkillRanker — Rust CLI that uses Jev Choice and Noul judgments to shortlist and rerank agent skills against the current task, with a real none option, local replay, and opt-in network disclosure; fresh ranking sends redacted session context and skill excerpts to TypeSafe, and its license includes an OpenAI/Anthropic rider rather than plain MIT.
• slop-grader — CLI tool that grades markdown and text files against custom rulesets for AI slop, grammar, and documentation quality using Jev scores and flags, then guides an AI agent to auto-fix violations.
• Sniff Test — Prose linter with local countable rules and opt-in Jev Noul judgments over individual paragraphs, available as a CLI, pre-commit hook, and GitHub Action; its author-published comparison uses a small seeded corpus, with some judgment rules tuned on those same seeds.
• Supercov — Code quality for coding agents: Jev scores each source file so the agent knows what to fix first.
• Switchboard — Local Claude Code and Codex wrapper that assesses a new conversation's task with Jev, applies local confidence policy to choose the model and reasoning effort, and pins that route through follow-ups, tool calls, and resume to avoid unnecessary prompt-cache disruption. It preserves native authentication and sends task text to the configured TypeSafe, Vercel, or OpenRouter Jev endpoint; raw prompt history is stored only when explicitly enabled.
• System One-assisted compaction — Rust example that asks a configured OpenRouter decision model to score which tool outputs are worth keeping during context compaction; it compares the ordering with an age-based policy on a synthetic session, not a live-agent outcome.
• toolgate — MIT TypeScript tool-call firewall for Claude Code (PreToolUse hook) and MCP servers (stdio proxy): static rules first, then seven Jev Noul risk questions per action mapped to allow, ask, or deny by policy thresholds, with an action ledger, key-aware redaction, and a local JSONL audit log. Sends redacted tool input, cwd, and recent prompts to TypeSafe, OpenRouter, or Vercel AI Gateway (owner's key); in one author's 1,369-decision window on 0.9.1, blind second labeling of 150 sampled allows found no permissive misses, while 21% of decisions required an ask, mostly from one axis. Version 0.11.0 addresses that axis but has not been re-measured. Heuristic redaction and model judgments are defense in depth, not a sandbox.
• TypeSafe MCP — Go CLI and single-binary MCP server with setup for Claude Desktop, Claude Code, and Codex.
• Vercel Eve — Agent framework whose auto model router defaults to Jev through Vercel AI Gateway and whose evaluate helper asks typed Choice, Score, and Boolean questions inside tools; the underlying AI SDK evaluation model specification is experimental, and the caller owns routing and effects.
• VexJoy Agent — Cross-harness coding-agent toolkit whose /d path uses up to two Jev evaluations to select agents, skills, and a pipeline, then checks the proposed intent before dispatch; deterministic force-route rules bypass Jev. Request text goes to TypeSafe or Vercel AI Gateway, and the installer changes local agent configuration and hooks.
• wakegate — Experimental TypeScript gate for long-running agents on Workers, Durable Objects, and Node: before a sleeping agent's LLM is resumed on a timer or incoming event, Jev answers one Choice (wake, not yet, unrelated) against the agent's own sleep note, and code skips the wakeup only below 0.2 on wake while always waking on user messages, bare timers, a skip limit, errors, and timeouts; its eval is 21 hand-written scenarios, not a benchmark.

Browser projects put Jev between page observations and bounded actions or use it to classify page content. Check permissions and human review points before automating clicks.

• Cline Jev Browser — Cline plugin that delegates bounded Playwright browser steps to Jev through Vercel AI Gateway using structured DOM observations; a separate text model fills form values, page text and field values go to Gateway, and its review instruction is model guidance rather than an enforced safety boundary.
• fastbrowse — Pre-alpha browser agent where Jev picks actions from observed controls, an LLM plans and reads, and code requires page quotes for answer claims; a classifier stops before consequential actions unless the operator passes --authorize, but that gate is not a guarantee. Browser Use Cloud is the default browser, with local Chrome optional. Page observations go to the selected Jev provider and planner model; its author publishes versioned per-run comparisons, not an independent benchmark.
• Jev Browser — MIT-licensed Playwright navigator with MCP, CLI, and library interfaces: Jev chooses DOM actions and judges goal/stuck state from page excerpts sent to TypeSafe, OpenRouter, Cloudflare, or Vercel; an optional separate model generates typed text. Code bounds the loop and returns a trace, final page, and screenshot, but does not require human approval for each action; iframe, shadow-DOM, and file-input controls are unsupported.
• Jev Browser Use — Codex Computer Use skill that sends an accessibility snapshot to TypeSafe or OpenRouter for Jev to choose among host-allowed clicks and scrolls while Codex handles typing and verifies outcomes; browser execution is validated only in Codex, page text leaves the browser, and the author's approximate speedup is not an independent benchmark.
• Jev for Chrome — Unofficial Chrome extension (Manifest V3) port of Jev Ultrafast: Jev picks the operation and DOM element, and a separate text model writes typed values in the user's own tabs. The selected OpenRouter, TypeSafe, or Cloudflare provider receives the goal, URL, visible page text, and control labels/values; the text model also receives page text when typing. Step and Stop allow manual oversight, but Run executes steps without per-action human approval; includes a 17-task headless-Chromium suite with recorded traces.
• Jev Social — Local Instagram, TikTok, and LinkedIn research app where Jev makes confidence-gated choices over observed, bounded socai CLI operations. The goal and captured result excerpts go to OpenRouter; local code validates choices and stops at access gates. Browser capture is read-only except for an optional TikTok media download when explicitly requested; there is no per-step human approval.
• Jev Ultrafast — Browser Use agent with a dynamic indexed action space, batched operation and target decisions, traces, and a measured Google Flights demo.
• jev-agent-browser — Delegated browser execution for parent agents: Jev selects bounded typed actions, agent-browser performs them, and ambiguous or blocked flows escalate back to the parent.
• jev-skip — Browser extension that reads the YouTube caption track and paints a per-segment sponsor probability on the seek bar before the intro ends, with no crowd database; reports catching 77% of SponsorBlock's sponsor seconds across 23 videos at $0.0008 a video.
• Jevvie — Page companion: the 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 are close; a voxel character then hops to the button and does it (source). The visitor's request and offered tool descriptions go to Vercel AI Gateway or TypeSafe for the judgment.
• PlotVeil — Chrome extension (Manifest V3) that covers a YouTube comment while one Jev Noul question decides whether it reveals a concrete plot event, fate, ending or result of the video being watched or of any other title the user chose to protect; the typed question lives in the extension, application code owns the 0.5 / 0.7 / 0.85 threshold, and a failed or quota-rejected check leaves the comment covered rather than revealed. Requests go through the author's Cloudflare Worker, which forwards comment text, video title and channel but not the anonymous install ID; the committed evaluation is a 10-sample hand-written regression set across English, Chinese, Japanese and prompt injection, not a production accuracy measurement. Install PlotVeil.
• Sedum — Experimental Playwright test tool: in goal mode one Jev Choice per turn picks the next operation (click, type, done or blocked) and its target among the page's elements, authored plain-English steps use a Choice to resolve each element, and a test passes only when a separate authored verify claim clears two Jev Nouls (holds, contradicted) against configurable thresholds. It sends step sentences, bounded element descriptions and page text to TypeSafe or a compatible endpoint you configure (opt-in vision sends screenshots), and its docs note that the scores are not yet calibrated against real pass rates.
• unclutter — Chrome/Firefox extension that uses Jev through TypeSafe or Vercel AI Gateway to classify bounded page-element snippets, then stores reusable local hiding rules by page template. Paid analysis is manual by default; optional on-visit analysis sends snippets to the selected provider. The API key stays in unencrypted local extension storage.
• voice-browser — Local voice-controlled Playwright browser: Jev chooses a typed intent and target from speech and a bounded page snapshot, while code applies confidence gates and asks for confirmation before actions it classifies as destructive. The Web Speech API sends audio to Google, and transcripts, page context, and recent actions go to TypeSafe; the author's 34-case integration result uses captured fixtures, not arbitrary websites.

End-user apps and workflow prototypes show where typed decisions can help with real tasks. Their source availability, evaluation depth, and data paths vary.

• AI Slop Detector — Free web tool: headless Chrome measures a page's rendered styles, a vision model describes the screenshot, and Jev answers 35 yes/no questions in one call (one per tell, plus one for the whole page) to produce a slop score; closed source, 2 free scans a day, reports are public.
• BTK audit studies — Production SEO studies driven by Jev striking-distance triage: 1,204 pages judged per run, 4,816 typed judgments in under 3 minutes, $0.0048 per 12-query batch (jev-1.13.0).
• discoprint — CLI that fetches an artist's discography and available lyrics, asks Jev five typed questions per song about theme, mood, complexity, explicit content, and perspective, then draws a terminal dashboard; full lyrics go to TypeSafe, missing lyrics are skipped, and the classifications are model judgments rather than verified music metadata.
• DocJev — Python library, CLI, and local app that uses LiteParse for document text and Jev to classify PDF, DOCX, and PPTX files or split mixed packets; optional LlamaParse provides cloud OCR. Its published 40-document, eight-packet comparison includes raw results but no human label review; normalized page text goes to the decision provider.
• Formanator — CLI and MCP client for Forma benefit claims: with merchant and description supplied, optional Jev Choice selects from the account's valid benefit/category pairs, then code falls back to an LLM for no match or low confidence. Jev receives merchant and description, not receipt images; CLI submission asks for confirmation by default, while --yolo and the MCP create_claim tool can submit without that prompt.
• GeekLink Jev Subtitle Translator — Open-source SRT translator and quality-control tool that sends each source–translation pair to Jev as a Noul decision, then flags suspected omissions or meaning changes for human review without automatically rewriting subtitles.
• HA-Jev — Home Assistant integration that turns typed questions about entity state into sensors and automation actions, with entities reporting daily calls, tokens, and estimated cost and a token budget that halts evaluation; answers carry no explanation, so it is not suitable for safety decisions.
• Jev Chat Assistant — Android overlay that reads visible WeChat, QQ, and X conversations through accessibility, asks Jev for typed intent and action judgments, has a text model draft three replies, and can fill a selected reply without sending it; device tests are author-reported, Lark capture is partial, and chat content goes to the configured model APIs.
• Jev Search — Web search demo using Jev's typed Choice and Noul judgments to select sources, time ranges, and query candidates, then rank results retrieved through Search1API; relevance scores are model judgments, not verified accuracy.
• Jev Trade — Live Hyperliquid desk across five isolated wallets: each tick packages book, tape, and position as state, Jev answers Choice questions for long/short, open/close/hold, and leverage, and application code places or pulls the quote (hold sends no order). Documents a dry-run path; a configured live key sends real testnet or mainnet orders. Live demo.
• Jev Trader — Monad/Kuru MON-USDC bot that packages order-book and trade data for an opt-in Jev buy/sell Choice while code places post-only quotes; the default model and public demo use a mock dry-run, and configuring a private key can place real orders and consume gas. The stated block-time latency is measured with the mock model, not Jev.
• Jev Wrapped — Live X-ray of a public Telegram channel: code reads up to 1,500 posts of the last twelve months from Telegram's public web preview, sampled evenly across the months when there are more, Jev answers a Choice over ten kinds of post and three Noul questions (paid ad, clickbait, emotional pressure) about each, and code applies fixed thresholds and draws the shares month by month on a shareable card that links the highest-scoring posts for a manual check; only public post texts are sent to Jev, the shares are model judgments that can misread partner promotions as ads, no sign-in, open source (MIT).
• jev-fit — Hosted fit checker and public API: paste a software idea, and one Jev call over a fixed typed rubric returns plain code, Jev, or a reasoning LLM with probabilities, while application code adds an image veto and a low-confidence "not sure" state; closed source, and the pasted text is sent to TypeSafe's API.
• jev-research-pipeline — Experimental daily research monitor: deterministic Python owns the loop, Jev screens each fetched source against each open research question (Noul gates, then Score dimensions, via Pydantic AI's typesafe: model) and Qwen writes a question-centric Obsidian note only for what code keeps; source text goes to TypeSafe and kept text to DashScope, thresholds are still the cookbook starting values (pilot: 5 of 7 goal conditions met), MIT.
• jevmeter — Local video editor that transcribes speech, asks Jev preset Noul questions for each sentence, and renders a shareable debate, earnings, podcast, or sales meter; its probabilities are model judgments rather than fact checks, and its 200-sentence authored evaluation does not establish accuracy on real video.
• JevNoiseGate — Android app that asks Jev whether each incoming notification or SMS is noise and suppresses only what Jev explicitly flags, with a local pre-filter for verification codes that never reaches the API and a fail-open default on every uncertain path; experimental and developed against a single device, message bodies are sent to the API except when that local gate matches, and credentials are stored unencrypted in app-private storage.
• Jevometry — Alpha Python toolkit for offline analysis of Jev-like output distributions, parameter sensitivity, and Fisher geometry, with an optional TypeSafe SDK adapter that sends experiment states and questions to the provider. System-information and Cramér–Rao results require explicit statistical assumptions; its first live smoke test captured responses but did not yield stable Fisher estimates.
• JevPDF — Browser PDF viewer for finding passages when you do not know the exact words: pdf.js extracts lines locally, each line gets one Jev Noul on whether it answers the query (batched with the page text as shared state), and lines above a code-owned threshold light up ranked by probability; only extracted text is sent to TypeSafe, never the PDF, and the API key stays behind a server-side proxy.
• JevSpan — Zero-shot named entity recognition for Chinese and English text: code splits the text at punctuation and enumerates candidate windows with exact character offsets, Jev answers Choice questions that nominate, verify, and fix the boundary of each entity, and every result keeps its probability and a decision trace (CLI, Python library, and local web UI; MIT). Its authors report 73.7 average strict F1 on 200-sentence samples of 12 public NER benchmarks with jev-1.13.0, with aggregate results committed; input text is sent to TypeSafe, and an entity that no candidate window covers cannot be found.
• Jevtown — Town of 10,000 computed personas that reads a post, listing, product, or headline: one opening request scores the text against about 60 audience attributes, 83 for a listing or a product, plus seven moderation questions, and plans the first wave of 600 readers; batched Choice questions then return each persona's reaction, and the text reaches the next wave only while glad reactions outweigh sorry ones. Also returns the audience by interest, job, age, city, and budget, the question buyers would ask a listing first, and a demand curve over an author-set price ladder. Personas are computed from their id rather than written by a model, and each reaction is sampled from the returned probabilities with a fixed seed, so the result is a simulation of a typed audience and not a forecast of real behaviour; open source (MIT), no sign-in, runs on a TypeSafe or OpenRouter key.
• Lossless Rewrite — Helps AI say the same thing in fewer words: choose which ideas must stay, let your model rewrite, and use Jev to check for lost meaning and guide repairs; available as a local editor and CLI; MIT licensed.
• Paper Radar — GitHub Action that sends paper titles, abstracts, and categories from arXiv, bioRxiv, or RSS to Jev for interest and contribution-type judgments, then applies code-owned thresholds to publish a page and RSS feed; a committed 50-paper run reports 5 seconds and $0.001957 with jev-1.13.0, while calibration requires the reader's own labels and the judgments do not inspect full papers.
• Paper Trellis Citation Verifier — Human-reviewed manuscript citation checker: code verifies retrieved passages, Claude proposes evidence, and Jev scores whether the cited passage supports the claim; citation text and paper content go to the selected providers, and the model verdicts have no labelled biomedical validation set yet.
• QuantDinger — Self-hosted quantitative trading platform that uses Jev System One as an optional, auditable PASS / REJECT gate for strategy and Quick Trade entry orders, with LLM fallback and deterministic bypasses for exits and protective orders; enabling the filter sends its prepared decision context to the configured AI provider.
• Refix — Slack-native product assistant that, according to its author, scores product signals with Jev and waits for human review before shipping changes; the Jev integration is not independently inspectable, and public materials do not specify what data it sends to Jev.
• Ring Zero Security — Apache-2.0 userspace and GPL-2.0 kernel runtime security for AI coding agents: deterministic Linux BPF LSM policy enforces protected-file boundaries while optional Jev checks can only raise a finding from scored tool calls or selected instruction-bearing files. Checks are off by default; enabling the hosted provider sends redacted tool arguments or file content to TypeSafe, and the repository does not measure whether model scoring improves detection.
• Slop Filter for LinkedIn — Chrome extension that judges each LinkedIn post as it scrolls into view and stamps engagement bait or corporate marketing onto the post, leaving it readable, with the probability printed on the stamp; two Noul questions and a Choice category run per post, local keyword rules settle obvious cases before any API call, and verdicts are cached per post. Post text goes to TypeSafe through a local proxy that holds the key so the extension never receives it, and a proxy or model error leaves every post visible. Thresholds (is_slop 0.60, is_corporate 0.70) are fitted to the bundled 14-post labelled set, which is too small to characterise precision beyond that sample; English and text only, and the LinkedIn DOM selector will need updating when LinkedIn rebuilds its feed.
• sortwell — MCP server and Claude Code plugin that files each captured note, link, or meeting line: one Jev request answers Choice questions for kind, project, and next action plus a Noul for duplicates, and code applies fixed thresholds (0.45 to route to a project, 0.70 plus a specific matching item to call a duplicate) before appending the text verbatim to local JSONL files that are never rewritten. Item text, project scopes, and recent items go to TypeSafe; the author's own claude plugin eval found agents did not call capture unprompted, so capture needs an explicit request while the session-start shortlist hook always runs; MIT.
• Tax Document Classifier — Apache-licensed, text-only classifier for 261 federal tax forms that sends PDF text to Jev; the author reports no wrong labels on two test corpora but 38 low-confidence pages, without committed page-level results.
• TypeSafe Conversation — Experimental Home Assistant Assist conversation agent: each command sends the utterance and every Assist-exposed entity (names, areas, current states) to Jev in one call of about twenty typed questions, and code routes on the answers, acting only when the chosen answer is confident and clear of the runner-up; it asks before unlocking or disarming when Jev's separate risk score crosses a configured threshold, so this is not a deterministic safety gate. An optional Ollama or OpenAI-compatible LLM handles multi-part requests and general questions; the routing thresholds are fitted to a small set of recorded answers. MIT licensed.
• TypeSafe Typewriter — Live Val Town demo that updates 16 typed judgments as text changes.

Playable and physical-world experiments pair Jev judgments with deterministic environments. A successful run demonstrates that task and setup, not general reliability.

• 1 Million Emojis — Shared 1000 × 1000 emoji canvas, live for everyone: visitors paint strokes, and after each one Jev chooses a square next to it and its emoji as one Choice over named (square, emoji) pairs, its pick sampled from its probabilities (source).
• Chess with Jev — Browser chess and Chess960 where code works out every legal move's facts (exchanges, mates, threats) and Jev picks one per turn as a single Choice, with its candidates drawn as arrows (source).
• EmbodiedJev — MuJoCo decision workbench for a Franka Panda arm that compares TypeSafe Jev candidate decisions against rule baselines and other models across pick, place, and obstacle tasks; structured simulator state goes to TypeSafe when Jev is selected, and simulated task completion is not physical-robot reliability.
• HEIST//ONE — Observable browser stealth game where Jev supplies batched typed judgments for six guards while deterministic code owns the simulation and validates every proposal; includes a Decision Lens, scripted offline mode, evidence traces, tests, and one documented live sandbox extraction.
• Jev Chess — Anyone can play Jev on a shared chessboard. One Choice question covers every legal move; probabilities shade the board. Its confidence panel uses a narrow, one-ply material check. Source is closed.
• Jev Driver — Browser driving demo where Florence-2 captions each image you drop on the road locally, and a Cloudflare Worker sends only the caption and its lane or sidewalk to Jev, asking three Choice questions (action, category, speed limit) whose answer drives the car with no rule table overriding it, and code falls back to fixed per-zone behavior only when captioning or the request fails; live at drive.mrza.ch, with a ~357 MB first-visit model download and WebGPU recommended.
• Jev Drone — MuJoCo quadrotor stack that keeps control and safety in code while using Jev for slower tactical judgments.
• Jev Minecraft Agent — Astra plans while Jev selects bounded actions from structured Minecraft state through Mineflayer. The author reports an 8-minute-43-second dragon kill and exit in Survival/Peaceful mode on a preselected seed with a naturally active End portal; source and local tests are public, but the recording and per-run event log remain local, so that run is not independently replayable from the repository.
• Jev Plays Pokémon — A Pokémon agent that lets you emulate GBA games and has Jev make the battle decisions based on the current stats, state, moves, and Pokémon.
• Jev plays Snake — Browser Snake demo where code computes legal moves, food distance, and reachable space, then asks Jev to choose one move per tick through a server-side SDK call; a late answer leaves the snake going straight. Requires an API key; the public source has no license.
• Jev Plays StarCraft — Structured-state harness, verified run, probability trace, and evidence bundle for the original StarCraft shareware campaign.
• jev-physical-ai — Reproducible warehouse-fleet triage demo with 300 Jev calls, raw results, and a local-model cost comparison; incidents are simulated from templates, and no robot hardware or production accuracy was tested.
• jev-plays-pokemon-red — Pokémon Red on PyBoy where deterministic code owns the route and arithmetic and Jev picks only at branches, with every battle turn's faint prediction scored by Brier against the emulator's RAM state.
• Magic Jev Ball — Playable 3D Magic 8 Ball whose Convex backend sends a question to Jev through Convex AI Gateway as a Choice over the 20 classic answers, then displays the full probability distribution and highest-probability answer; the question and result are stored in the app's Convex database, and users do not supply an API key.
• PlayJev — Open 0.8B model that plays ten browser games from the frame alone, one forward pass per move, with public weights and a browser demo.
• quackd — Robot orchestration CLI with an optional Jev stepper for choosing among permitted discrete calls while an LLM still writes poses and prose and the executor enforces safety gates; one arm has run on hardware under the LLM pilot, but the Jev stepper has not been measured on a physical robot.
• TypeSafe Mario — NES controller experiment that turns emulator telemetry into structured state and has Jev choose legal actions.

Independent tests and open decision-model alternatives provide methods and results to inspect. Compare task data, calibration, and costs before carrying a result into your own workflow.

• Awesome Jev Robustness — Curated index of independent Jev tests grouped by calibration, consistency, perturbation, injection, abstention, failure modes, and language; it links original sources, reports their numbers as author findings, and keeps task benchmarks without a robustness angle in a separate data file.
• blink — Self-hosted typed-decision models with Apache-2.0 code that return Choice, Noul, and Score option probabilities in one forward pass per batch through a TypeSafe-compatible API; the weights are non-commercial research and evaluation only, and there is no hosted TypeSafe-compatible endpoint.
• Bosun v3.1 — Apache-2.0 open-weight Qwen3 decision model family with released 0.6B and 1.7B weights and shipped choice, score, and noul inference; a separate Jev-style alternative, not hosted Jev.
• Confident Where People Disagree — Preregistered, bias-corrected test of whether jev-1.13.0 lowers its confidence where people disagree, scoring Choice and Noul answers against the share of ChaosNLI's 100 annotators who chose the model's label on 750 low- and 750 high-disagreement items, with the paper and preregistration on Zenodo; Choice was close to calibrated on the agreed items but overconfident on the contested ones (bias-corrected ECE gap 0.264), Noul's gap was inconclusive, and only aggregate results are committed, with ChaosNLI text fetched separately.
• Convex Decision Evals — Convex-run leaderboard comparing Jev with structured-output LLMs on 108 four-option questions about the Convex platform; its open runner sends questions and shuffled options to OpenRouter, uses native Jev Choice, and publishes per-answer evidence. This tests one platform's API knowledge, not whether a model can write working code.
• DecisionBench — Open benchmark runtime for document-grounded decision models, with pinned tasks and a native OpenRouter adapter for Jev.
• Janus — Independent calibration measurement of Jev on two labelled datasets, Banking77 and Web of Science, with a Jev to frontier cascade priced per row from measured tokens, now also packaged as an installable tool (pip install janus-decide) that measures a threshold on your own data and ships none by default; the protocol was frozen before any result and the raw JSONL and figures are committed, and no routing parameter transferred between the two datasets, as the optimal threshold, the sign of the accuracy gap between the two models, and whether routing paid for itself all changed; the Web of Science labels come from publication metadata rather than per-document annotation, so part of the error measured there is label ambiguity.
• jeff — Self-hosted GLiFormer 400M server for Choice, Score, and Noul through a Jev-compatible API, with public benchmark code and per-item results. Its documented JevBench comparison finds weaker accuracy than Jev on reasoning-heavy items; hosted cost figures are estimates and depend on deployment throughput.
• Jev Capability Atlas — Bilingual English and Chinese map of Jev use cases and failure modes that separates the author's small, raw-response API suites from cited third-party results and TypeSafe claims; its case studies help frame task-fit questions, but they do not establish population-level accuracy or a reusable confidence threshold.
• Jev Enterprise Decision Fabric — Experimental .NET decision architecture with a 111-case Jev-versus-Claude agent-action evaluation, public labels and raw JSONL, report-rebuild tooling, and a decision inspector; one annotator revised labels after reviewing a Jev pilot.
• Jev IDS — MIT-licensed intrusion-detection prototype that asks Jev one Noul and one five-way Choice per network flow, comparing it with GPT-5.6 Luna and a Random Forest on NSL-KDD; it publishes run records and evidence limits, but the reported results are a 300-flow pilot and the gateway masks Jev's exact version.
• Jev in Search: Three Practical Evaluations — Engineering report on search stopping, coding-memory reranking, and multi-hop relationship selection in DeepSearcher, MemSearch, and Vector Graph RAG, linking implementation and evaluation artifacts; some datasets are private, some comparisons use different sample counts, and the animated speed illustration is simulated.
• Jev in the Wild — Data-driven survey of 2,170 public GitHub Jev projects, mapping early ecosystem growth, application domains, and decision-use patterns; it measures repository activity rather than production use.
• Jev Judge vs Dimension Scores — Independent measurement on three classification tasks: one direct Jev question per row against 12–14 Jev-scored dimensions with locally fitted weights, 5,477 test rows and 34.1M input tokens for $1.43; decomposition reached 0.9076 against 0.8373 on Japanese NLI but flagged about 25× more hard benign rows as attacks, and four repair attempts failed, on dimensions the author wrote himself.
• Jev Rerank Bench — Reranking comparison with raw provider responses, scoring code, dataset-level results, uncertainty intervals, and documented limitations.
• Jev Spam Eval — Exploratory zero-shot spam study against trained TF-IDF baselines, including results and explicit post-hoc-tuning caveats.
• jev-calibration-audit — Independent Jev-1.13.0 audit with reproducible code and per-call JSONL: tests abstention options, matched Korean and English items, question-shape interference, and option order; its strong abstention finding is on the KoBBQ dataset, not a universal calibration guarantee.
• jev-certify — Early Python toolkit and CLINC150 study of conformal routing thresholds and prediction-powered audits over Jev 1.13 through OpenRouter, with request plans, 2,412 journalled answers and usage records, analysis code, and tests; its per-incoming-query risk bound depends on matching calibration and deployment traffic, and the study shows the scope gate missing its target after out-of-scope prevalence shifts while fallback accuracy remains unmeasured.
• jev-does-not-play-dice — Calibration check on inputs whose true probability is fixed by construction (hidden fair dice, coins, four-way spinners) and on synthetic forecast documents, with raw responses and offline recomputation; Choice put 82.9% on face 1 across all 400 rolls at 19.0% accuracy and turned a stated 30% risk into 5.3%, while Noul stayed near the truth for 2 to 4 options and reported 15 to 17% for 8 to 20 options; no comparison with other models and no realistic task set, so it shows how far the probabilities can drift when the input carries no evidence rather than how Jev ranks against alternatives, run in launch week against jev-1.13.0.
• jev-fanout-bench — Billing study comparing batched and one-question-per-call Jev requests through OpenRouter's TypeSafe-compatible endpoint, with synthetic English tickets sent to the provider, raw responses and charge records, and repeated requests to measure answer stability; the tickets are unlabelled, and separate-call latency was measured serially.
• jev-measured — Reproducible OpenRouter measurements of Jev's response shapes, cost, and latency across eight use cases, plus a small head-to-head on 27 author-written support tickets; the author publishes raw data and corrections to earlier comparison errors.
• jev-ood-calibration — Independent Jev calibration study with raw Gateway responses from three public benchmarks and 900 rule-generated support tickets; probabilities were near calibrated on the public sets but overconfident on an unseen priority rule, while the Boolean question showed a different error direction. The synthetic task is one family and the Gateway did not expose a fixed model version.
• jev-orderby-bench — Independent measurement of whether ORDER BY over a Jev probability is defensible, with a pre-registered gate on pairwise inversion, Score ordinality against a graded target, calibration, and negation and paraphrase invariants; jev-1.13.0 passes on 20 Newsgroups topic membership and fails four of six conditions on Amazon ESCI human-graded product relevance, the DuckDB integrations' request shapes are shown to change the numbers (a 40-row batched state fails the ranking gate that one row per request passes), and two-decimal output leaves 53 of 360 rows tied at the top so LIMIT k cuts inside a tie; one seed and 30 ESCI queries, aggregates committed, corpus and cached responses regenerated locally for about a cent.
• jev-sec-bench — Blind Jev-1.13.0 security evaluation with Go runner, raw per-sample results, and a TUI: 662 public prompt-injection messages and 200 matched vulnerable-code pairs; its reported classification scores use the study's stated context and a fixed 0.5 threshold, so deployment policy and corpus labels matter.
• Jevals.com — Independent benchmark of hosted Jev and six LLMs on PubMedQA, Banking77, and HelpSteer2, with human labels, proper scores, calibration, cost, and latency; suite files and per-decision logs and the methodology are public, while the run harness is not published, LLM probabilities come from a prompt adapter, and the Gateway does not expose Jev's exact version.
• JevBench — Independent cross-model benchmark for typed decisions with 534 frozen cases per complete entrant, source adapters, scoring code, public per-task outcomes, and aggregate result artifacts. Its four-axis score includes accuracy, calibration, latency, and cost; some self-hosted latency is adjusted by assumption, hosting costs can be estimates, and withheld cases are exposed to the services being measured.
• jevmlx — MIT-licensed local decision layer for Apple Silicon that scores constrained Boolean, enum, and multi-select fields from MLX model logits in one prefill, returns schema-valid JSON, and offers a System One-compatible endpoint and benchmark runner; probabilities are over the supplied options and need calibration against labeled task data.
• jevos — MIT-licensed 1B yes/no model released as a q4_k_m GGUF that runs on CPU with llama.cpp behind a Jev-compatible /v1/systemone endpoint; it answers only Noul questions, and Choice and Score requests return 422. The authors report 0.815 accuracy against 0.927 for hosted Jev on 2,000 questions from unseen policies, but the training code and evaluation set are not published, so that result cannot be reproduced from the repository.
• Kev — Apache-licensed, locally runnable Jev-style Choice, Score, and Noul models at 0.8B, 4B, and 9B, with released weights, training code, a System One-compatible server, frozen evaluation suites, and a playground. Its author reports a 0.822 new-source development accuracy for Kev-9B against 0.857 for hosted Jev on that suite, but Jev's training data is unknown, so this is not a controlled architecture comparison; test calibration and option order on your own data before setting a decision threshold.
• Laya — Open local Choice, Score, and Noul decision models with published checkpoints and a router for English and multilingual inputs; its Jev comparisons use different prompts and sample sizes rather than a controlled head-to-head, and raw calibration and some languages remain weak.
• LeJudge — MIT-licensed PushT study and cost module that turns LeWorldModel's imagined latents into closed-vocabulary facts, asks Jev typed questions about natural-language constraints, and adds the probabilities to a CEM planner's cost; ships oracle and keyword baselines, cached responses, and an offline paper rebuild; live runs send constraint text and probe facts to TypeSafe, and results cover one world model and twelve constraints, with near-miss false positives and rollout drift as material limitations.
• LLM Memory Audit: Jev earnings test — Pre-registered test of whether jev-1.13-20260917 remembers how 12,533 US earnings announcements turned out, comparing each company only with itself; it found no detectable memory (within-company AUC 0.506 on beats, against 0.587 pooled for Claude Sonnet 5 as a positive control) and publishes code, per-call probabilities and a freeze proof, but withholds the licensed FMP earnings and price data, and the verdict stays provisional until 757 prospective announcements are scored in January 2027.
• LLM2Jev — Apache-licensed local toolkit that reads causal-model logits for Choice, Score, and Noul answers through Transformers or SGLang, with a System One-shaped HTTP endpoint, web and Snake demos, and shared-prefix cache measurements. Its published performance benchmark compares cache modes on one model and GPU, not decision quality against Jev.
• Love-Language Arena — Experimental local reproduction of the Choice, Score, and Noul pattern on Ollama logprobs, with order-reversed and negated re-asks to expose position bias, used to test three open models as fully crossed judges of Chinese and English rewrites, with self-preference correction, per-judge Platt calibration, dev/holdout prompt selection, and raw per-call JSONL. It does not call Jev, and its validation labels are Claude-generated rather than human, so the judge pass rates and model ranking show that the pipeline runs, not that the judges are valid.
• Luce — Open recipe for Jev-style decision models: a task description, an LLM teacher that writes the data, then LoRA plus a decision head on Qwen3-4B-Base returning calibrated choice, score, and boolean probabilities on a 12 GB GPU; the README reports accuracy and ECE against Jev on identical test items, including where training does not help, with a GPU-free replay demo.
• NanoJev — Open 0.6B Jev-style model for one-pass action probabilities in Maze, Snake, and ViZDoom, with public checkpoint, training data, and replayable game comparisons; it is specialized to those games and is not a general Jev API replacement.
• OneJev — Apache-2.0 open multimodal System One models in four sizes (0.8B to 27B, plus a 27B FP8 build) that answer choice, score, and noul about screenshots, photos, video, and text in one forward pass through a /v1/systemone-compatible server; independent of hosted Jev.
• Open Alternative to Jev — Apache-licensed Python library that reads option-token probabilities from open models through Transformers or vLLM, with packed and separate question modes, temperature scaling, benchmark scripts, and raw result files; its measurements compare modes of the same open model rather than Jev, packed answers can change with question order, and the package is not a drop-in System One API server.
• Open Medical Jev — MIT-licensed independent reproduction of the Jev decision loop with two frozen open-weight readers, a fit-free confidence gate, and split-conformal candidate sets; its four-reading configuration lands within 2 points of hosted Jev 1.13.0 on three 600-item medical licensing papers without training anything, running locally on one 24 GB GPU; only the China paper is a real exam (the US and India papers are fixed-seed draws), the exam items are not redistributed, and its coverage–accuracy curve still trails hosted Jev at the highest precision tiers.
• OpenJev (DiffusionGemma) — Apache-licensed decision server that reads Choice, Score, and Noul probabilities from DiffusionGemma 26B through a System One-shaped API, with NVIDIA and Apple silicon backends plus optional image input. Its NVIDIA path pins an unmerged vLLM branch, some limits differ from Jev, and answer quality needs evaluation on the reader's own tasks.
• poorjev — Open, local reproduction of the Choice/Score/Noul interface on commodity zero-shot NLI models with temperature scaling and conformal abstention; ships a reproducible calibration eval (ECE 0.170 to 0.071 on its own small labelled set, cross-validated) and runs offline with no API key.
• Rizzo Flow — Local, open-model decision server that reads answer-token probabilities instead of generating text, with a Jev-compatible Choice, Score, and Noul API plus its own numeric primitive. Its authors explicitly make no quality-parity claim with Jev; probabilities need calibration on the user's own data.
• RSI-Jev — Jev-like 4B and 27B open models (v6.1-VL) from a self-improving research loop with published version notes and failed-experiment summaries (MIT code, Apache-2.0 weights; some training-source rights unclear); they return choice, score, and noul probabilities about text and images in one forward pass through a /v1/systemone-compatible server, with auto effort choosing depth per question. The authors report 50.98 (4B, pre-release kit) and 65.64 (27B, auto) on Decision Index 0.3's public set, with an official full score pending; the 27B was selected using that benchmark, needs a 96 GB GPU in bf16, and its training corpora are not public.
• ruling — MIT-licensed System One-compatible server for Apple Silicon that scores typed questions from a stock model's logits with no training, accepts the official SDK unchanged, and re-scores the 256 public judgments that carry Jev's own answers (231 vs 238, no significant difference); serves MLX checkpoints or any OpenAI-compatible endpoint, with no native CUDA path.
• SemIf (formerly OpenJev) — Independent open-model research baseline for direct typed option scoring; it reproduces the interface pattern, not Jev's undisclosed model or training.
• Simple Jev — Apache-licensed local server that scores Choice, Score, and Noul with open-model logits; tokenizer support and decision calibration vary by model.
• stuntd — Experimental local Jev-compatible proxy on Laya that records typed decisions in local SQLite, trains a head per decision site, and forwards uncertain requests to a configured upstream; its reported demos use rule-based teachers rather than hosted Jev, and proxy mode sends requests to the chosen upstream.
• TetraJev — MIT-licensed, locally-deployed decision layer for complex bounded decisions: two frozen open-weight readers, four readings (letter + per-candidate yes/no) fused fit-free and routed by agreement into auto-release vs human review; eight decision suites and the RAG reranking pass benchmarked — including DecisionBench's 35 real-world task categories — with coverage–accuracy curves. It does not call the TypeSafe API, and its equal-weight fusion still trails the strongest single reading at some high-precision operating points.
• TypeSafe AI Benchmark — Side-by-side Jev and Qwen-on-Cerebras comparison with raw exports, cost accounting, methodology, and task-specific limitations.
• Verdict — Apache-2.0 118M multilingual bi-encoder for Choice, Score, and Noul on a System One-compatible endpoint, with temperature scaling and optional split-conformal abstention whose coverage depends on its calibration assumptions; it can run locally on CPU or in a browser through ONNX, and the author's reported calibration and typed-decision results are task-specific, including a lower score than Laya on the published typed-decision suite.
• Vev — Independent Jev-style decision server with vision input, fine-tuned from Qwen3.5 4B and 9B, that answers Choice, Score, and Noul questions about text, JSON, and images, with screenshots or photos placed directly in state, through a /v1/systemone-compatible server; the repository has Apache-2.0 code and per-set results on public text and image judgment sets, requests are processed on your own GPU after the weights download from Hugging Face, and the weights are CC BY-NC 4.0, for non-commercial use only.
• Von — Open local Choice, Noul, and Score model with public weights, training code, and a System One-shaped API. Benchmark comparisons are author-reported: its README gives a 91.23% accuracy headline without a matching result artifact in the repo, while its 49-task table reports 71.5% macro accuracy.
• WaterSheep — Apache-2.0 open-weight decision model, fine-tuned from ModernBERT-base, that answers Noul, Choice, Score, and multi-label questions with a probability for every option; after downloading the weights it can run inference locally in Python or a browser through ONNX, and its local /v1/systemone server works with TypeSafe's Python SDK via TYPESAFE_BASE_URL. It is English-only, and its author reports 61.2% accuracy on held-out datasets, with rating-scale answers weaker than the other types.
• WebJev — Apache-2.0 open-weight decision model for browser agents (a Qwen3.5-35B-A3B fine-tune) that answers Choice, Noul, and Score through a Jev-compatible /v1/systemone API and ships its training recipe, live-web training data, and a deterministic-verifier evaluation on 125 hand-picked real-website tasks. Its authors report 47/122 gradable successes versus 20/120 for Jev 1.13 inside the same agent, and 83.72% versus 84.70% mean accuracy on eight single-step typed-decision benchmarks; the live-web runs happened on different days and had different gradable subsets. It is a separate Jev-style alternative, not hosted Jev: self-hosting the weights needs one 80 GB GPU, and page observations go to the configured decision endpoint and text model.
• When a Judgment Layer’s Self-Reported Fields Lie — Independent measurement of Jev’s typed decisions as one of three judgment layers run on identical items (Laya locally, Jev and a frontier model remotely), with per-call ledger-based cost accounting and Murphy/Brier/ECE calibration against binary ground truth; the Jev-specific findings are a verdict vocabulary reaching three values where six are documented, and a sufficient field that does not separate thin evidence from contradictory evidence, and the claim about contradiction rests on seven live readings that have no JSON artifact behind them, which the write-up states in its own errata rather than leaving to be discovered.

Short demos, guides, and builder reports show what was tried and observed. Treat reported numbers as starting points for your own tests.

• A SQL WHERE Clause for Taste — Worked DuckDB/VGI example ranking Hacker News stories with Jev Noul judgments, including SQL, result distributions, and token usage; story titles and URLs are sent to TypeSafe, and the reported timing and cost describe one run rather than an accuracy evaluation.

• awesome-jev-prompts — Independent bilingual (English/Chinese) CC0 catalog of 43 Jev Choice, Score, and Noul question-design patterns plus 10 anti-patterns, with templates, sources, threshold notes, and failure modes; examples and thresholds still need evaluation on your own data.

• Browser Use + Jev — Gregor Zunic's real-time flight-search demo and short description of the dynamic DOM action space.

• Free JEV API Guide — Independent first-request walkthrough with runnable examples of typed JEV decisions; example calls send supplied state through BeatAPI, while the guide itself runs no inference.

• Internal classifier field note — A builder's early matched-precision comparison against a private fine-tuned Qwen classifier; useful anecdotal evidence, not a reproducible benchmark.

• Jev by Example — Ten MIT-licensed JavaScript exercises for decisions between agent steps, pairing Jev Choice, Score, or Noul questions with explicit application policies, hand-authored response fixtures, and simple baselines; offline demos need no key, while opt-in live runs send case state to TypeSafe, and the project has not yet verified live Jev outcomes or accuracy.

• Jev Typewriter launch post — Steve Krouse's playable 16-judgment demo and video.

• Jev Web Analyzer — Inspectable Next.js demo that fetches public webpage Markdown, sends bounded state to Jev through Vercel's hosted Gateway, and exposes Boolean, Choice, Score, probability, and streaming results; live analysis requires both configured credentials.

• jev-agent-skill — Claude Code / ZCode skill that offloads small judgments (classify/route, batch screening, scoring, compliance pre-checks) from the main model to Jev on OpenCode Zen's free /v1/systemone endpoint; bundles a zero-dependency jev.py caller with retries for the gateway's transient 500s, a WAF-safe User-Agent, GBK-pipe-safe stdin handling, SKILL.md auto-trigger rules so agents invoke it unprompted, and a production e-commerce comment-triage case study; adapted from the official typesafe-ai/skills SKILL.md (MIT).

• jevbooks — Bilingual gallery of open-source Jev projects in which Jev itself gates and tags every listing from the README, with the probabilities printed on each project page, plus sixteen design patterns read out of ten codebases, each with the recognition question the pipeline sends; the site’s own source is not public, pattern tags are README-based rather than hand-verified, and the ask box sends your text to Jev and a DeepSeek model.

• laya.tools — Independent directory of projects built on Laya, the Apache-2.0 open typed-decision model, imported daily from GitHub, npm, Hugging Face, and X, moderated, and browsable by platform and use case; unofficial and not affiliated with ConvAI Innovations or TypeSafe, it covers the Laya ecosystem rather than Jev itself apart from a Laya vs Jev comparison page, and the site promotes a hosted Laya API.

• Learn Jev end to end — MIT-licensed course of 12 Python notebooks that puts Jev inside a hand-rolled LLM agent loop as router, tool-call guard, done gate, and judge across 13 use cases checked against labeled fixtures, and compares Jev with two LLMs asked the same typed questions through system-one-adapter; tools are read-only or dry-run, and results come from one committed run, including the cases where the LLMs did better.

• Milvus Search with Jev — Nine runnable Python notebooks combining Gemini embeddings, Milvus retrieval, and Jev decisions for reranking, filtering, search stopping, routing, cache reuse, curation, guardrails, and evaluation; examples use synthetic data, send embedding inputs to Gemini and judgment text to TypeSafe, and are not quality benchmarks.

• Qwen on Cerebras comparison — Shannon's video and source-backed comparison of a structured-output LLM baseline with Jev.

• Typed Decisions, Not Chat — Independent technical walkthrough that distinguishes TypeSafe's published claims from what the public evidence establishes.

• typesafeai.app — Independent directory of public Jev capabilities: each record states what Jev was shown doing, links to its public sources, and carries an evidence level (author-reported to editor-reproduced) and an Official or Community label; unofficial, not affiliated with TypeSafe, and metrics remain as their authors reported.

Contributions are welcome. Please read the contribution guide before opening a pull request.

The short version: submit a public, directly useful resource; describe what it actually does; put it in one category; and include limitations when a result depends on a private dataset, a single run, or an unverified claim.

To propose one, edit only the README entry and open a pull request. CI validates the derived directory and images; a maintainer commits them before merging.

First contribution? Pick a good first issue, fix a stale link with its source, or add a project you have actually tried. A one-entry README pull request is enough; no generated pages, images, or local Python setup are required. Include the project's license, what data it sends off-device, and a limitation worth knowing. See the contribution guide for an example and review criteria.

Listed here? Your project page has a direct link, a README badge, and a downloadable image for sharing your entry.

Use the live listing builder to draft one entry and find its alphabetical position. It runs in your browser and does not submit anything. Copy the result into README.md on GitHub, then open a pull request. If you cannot send a pull request, suggest the resource in an issue.

Thanks to everyone who has improved the list. The portraits below are generated from All Contributors; contribution types reflect work in this repository.

Aaddrick 📖	AbdelStark 💻 📖	AboveColin 📖	Alibi Serikbay 📖	Amp 📖	Argon 📖	Arpit Khandelwal 📖
Austin Choi 📖	Bartlomiej Tyrpien 📖	Basit Mustafa 📖	BladeDev 📖	Brad 📖	Cheney Zhang 📖	Chris 📖
Claude 📖	Dearest 📖	DevMortimer 📖	Dharun Prasanth 📖	Eliot5566 📖	Eugen Soloviov 📖	Federico 📖
Fei.Chen 📖	FeiLiuEM 📖	FirasSX914 📖	Flora Wang 📖	Fox-Islam 📖	Francesco Dettori 📖	Friedjof 📖
Gautam Khosla 📖	GenieRobot 📖	Govind Kamtamneni 📖	Guoming Ling 📖	Harsh Joshi 📖	Harshith Sunku 📖	Hawxy 📖
IRONICBo 📖	Ibrahim Ibrahim 📖	Ignacio Gutierrez 📖	Ivan Deyna 📖	JANANI-RS06 📖	Jake Knowlton 📖	Jevals.com 🤔
Jon Kraayenbrink 📖	KKKK 📖	Kanta Hayashi 📖	Karthik Nambiar 📖	Kunyanli230 📖	Lasse-numerous 📖	Li Zhuojun 📖
Lison Allen 📖	Lu Chong 📖	Luca Minudel 📖	Maayan Levy 📖	Manav Arya Singh 📖	Marcelo Romero 📖	Mohammed Nabil 📖
Nasrallah-AL 📖	Nedomas 📖	Negmus 📖	Nyarlathoteppppp 📖	Patryk Wikłacz 📖	Paulo Silas Severo de Souza 📖	PerryLink 📖
Reinhard 📖	Robert 📖	Robert Soriano 📖	Ruban 📖	Sachin Sharma 📖	Samrat Dutta 📖	SergeAx 📖
Shanghua Gao 📖	Shenton YAN 📖	Sofiane Ghadab 📖	Spearmint.AI 📖	Stas Kulesh 📖	Stephen Solka 📖	Steven Shoemaker 📖
WiktorB2004 📖	Wu Shuwen 📖	Xiaooolong 📖	Xinyao 📖	Yifan Lan 📖	abhixhek 📖	antiyro 📖
anxkhn 📖	aoright 📖	aowang-ai 📖	brokermr810 📖	carldaws 📖	christiina02 📖	chy4pro 📖
copyboy 📖	cryptojaz 📖	dependabot 💻	devx-opensource 📖	emreozyoruk 📖	eugeniughelbur 📖	fatwang2 📖
formulahendry 📖	forvela 📖	gaborishka 📖	garretpremo 📖	ikkun1222 📖	jesset 📖	jiaqiangbandongg 📖
jlonge4 📖	jonesmelton 📖	jyatesdotdev 📖	kylemclaren 📖	kyu1204 📖	ljedrz 📖	luantak 📖
lukstei 📖	lzq-0529 📖	marandaneto 📖	mastryhub-dev 📖	nshkrdotcom 📖	qybaihe 📖	roadtogideon222-byte 📖
rubenroques 📖	rupeshpoojary9 📖	rustyconover 📖	scienthoon 📖	sensahin 📖	sethkimmel3 📖	shiftynick 📖
shimo4228 📖	shitianfang 📖	ticofab 📖	tomerglick57 📖	ufec 📖	unikcc 📖	valentynkit 📖
xianghuisun-svg 📖	yodablocks 📖	yuyang2230 📖

To add someone or update their contribution type, see the contribution guide.

MIT. Individual projects and linked content retain their own licenses and terms.