Awesome Jev / TypeSafe

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.

See Jev at work

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

Recently curated

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-22. Links and project descriptions change; please report a stale entry.

Contents

• 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

Start here

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

Choose the right tool

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.

Choose where to call Jev

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.

Make your first decision

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.

JavaScript

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 });

Python

Install the official Python SDK with python3 -m pip install 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,
})

Shape a typed question

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.

Try a policy threshold

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.

Before you trust a decision

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.

Official resources

Product and documentation

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

SDKs and developer tools

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

Concepts, patterns, and cookbooks

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

Research and writing

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

Community and updates

• 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

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.

Client libraries and integrations

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.
• 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 definitely?; not affiliated with TypeSafe AI.
• 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.
• 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.
• 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.
• NeuroLink — TypeScript SDK that exposes Jev as a third inference type alongside generate and stream, 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.
• 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.
• 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.

Agent and developer tooling

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 — Agent skill for choosing where typed judgments fit beside code, policy, and generation, with Jev examples on question design and abstention plus an offline probability/threshold evaluator.
• 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.
• 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.
• 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.
• 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.
• 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 compaction — A simple example of how Jev can be used for content-aware compaction in the kamchatka agent.
• 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-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-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.
• 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.
• 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.
• 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.
• 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.
• 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 agents

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 and explicit authorization for consequential actions; its author publishes per-run comparisons, but the 14-task head-to-head used an earlier build and its success count varied on a same-day repeat.
• Jev Browser — MIT-licensed Playwright navigator with MCP, CLI, and library interfaces: Jev chooses DOM actions and judges goal/stuck state while code bounds the loop and returns a trace, final page, and screenshot; early software without iframe, shadow-DOM, or file-input support.
• 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 in one request, a small text model writes typed values, and it runs in the user’s own tabs through OpenRouter, TypeSafe or Cloudflare; includes a 17-task headless-Chromium suite with recorded traces.
• Jev Social — Local Instagram and TikTok research app where Jev makes confidence-gated typed choices over the platform and next socai operation, deterministic Node code validates each decision, and the local socai CLI performs read-only browser capture.
• 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.
• 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.
• 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.

Applications and workflows

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

• 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).
• Crowdcheck — Live demo that tests a 144-character post on 10,000 persistent synthetic personas: code decides who sees it, and batched Jev calls return read, like/dislike, agreement, repost, follow, and block probabilities per persona group; posting requires Google sign-in, post text is sent to Jev through Vercel AI Gateway, and the simulated reactions are not a forecast of real audience behavior.
• 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.
• 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.
• 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.
• 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 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.
• 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.
• 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 Typewriter — Live Val Town demo that updates 16 typed judgments as text changes.

Games and robotics

Playable and physical-world experiments pair Jev judgments with deterministic environments. A successful run demonstrates that task and setup, not general 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 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.
• 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.

Evaluations and independent research

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.

• 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 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-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.
• 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.
• 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.
• 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.
• 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.
• 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.
• TypeSafe AI Benchmark — Side-by-side Jev and Qwen-on-Cerebras comparison with raw exports, cost accounting, methodology, and task-specific limitations.
• 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.

Showcases and field notes

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

• Browser Use + Jev — Gregor Zunic’s real-time flight-search demo and short description of the dynamic DOM action space.
• 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 Typewriter launch post — Steve Krouse’s playable 16-judgment demo and video.
• 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).
• 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.

Contributing

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.

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

Build a listing

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.

Contributors

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

AbdelStark 💻 📖	AboveColin 📖	Alibi Serikbay 📖	Basit Mustafa 📖	Dearest 📖	DevMortimer 📖	FirasSX914 📖
Fox-Islam 📖	Friedjof 📖	GenieRobot 📖	Hawxy 📖	IRONICBo 📖	Jevals.com 🤔	Lasse-numerous 📖
Lu Chong 📖	Mohammed Nabil 📖	Nasrallah-AL 📖	Nedomas 📖	Nyarlathoteppppp 📖	Paulo Silas Severo de Souza 📖	Robert Soriano 📖
Ruban 📖	Sachin Sharma 📖	SergeAx 📖	Stas Kulesh 📖	WiktorB2004 📖	Xinyao 📖	abhixhek 📖
antiyro 📖	anxkhn 📖	aowang-ai 📖	brokermr810 📖	carldaws 📖	chy4pro 📖	copyboy 📖
dependabot 💻	devx-opensource 📖	emreozyoruk 📖	eugeniughelbur 📖	fatwang2 📖	formulahendry 📖	forvela 📖
gaborishka 📖	garretpremo 📖	ikkun1222 📖	jesset 📖	jonesmelton 📖	jyatesdotdev 📖	kylemclaren 📖
kyu1204 📖	ljedrz 📖	luantak 📖	lukstei 📖	marandaneto 📖	nshkrdotcom 📖	roadtogideon222-byte 📖
rubenroques 📖	rupeshpoojary9 📖	rustyconover 📖	scienthoon 📖	sensahin 📖	sethkimmel3 📖	shiftynick 📖
shimo4228 📖	shitianfang 📖	ticofab 📖	ufec 📖	unikcc 📖	valentynkit 📖	yodablocks 📖
yuyang2230 📖

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

License

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