Skip to content
BranchesTags

Latest commit

 

History

62 Commits

Folders and files

NameName
Last commit message
Last commit date
.github
.github
 
 
data
data
 
 
scripts
scripts
 
 
.gitignore
.gitignore
 
 
.lycheeignore
.lycheeignore
 
 
CONTRIBUTING.md
CONTRIBUTING.md
 
 
LICENSE
LICENSE
 
 
README.md
README.md
 
 

Repository files navigation

Awesome Jev Awesome

Entries Last reviewed Links Project health

A curated list of projects, integrations, and resources for Jev, TypeSafe AI's System One model: typed decisions with calibrated confidence instead of text.

Jev answers structured questions (Choice, Score, Noul) about program state in a single fast pass. The projects below use it for the questions that come up again and again in real software: should we, which one, how much, what next? Open-ended generation and deep reasoning still go to a conventional LLM.

391 entries · every one checked to actually call Jev · last reviewed 2026-09-28

There are over a thousand Jev repositories on GitHub, and most of them only mention it. This list is selective, and the bar is written down:

  • Jev is central. Someone opened the code and confirmed the project calls Jev (or reproduces it), rather than naming it in a README.
  • 10+ stars, so a day-one burst of near-identical repositories does not fill the list. Official projects and notable teams can arrive earlier.
  • It runs. A README that explains what it does and how to run it.
  • Numbers carry a source. Speed, cost and accuracy figures come from the project itself and are marked as author-reported.

Listing is not endorsement, and a description is not a safety review. Several entries here send code, prompts or screen contents to a third party; some have no licence. Read what a tool sends before you install it — what each tool sends says so for every project we have run.

Browse and filter this list, and read guides on getting started and pricing, at mrjev.com.

This is an unofficial, community-maintained list. It is not affiliated with or endorsed by TypeSafe AI. Performance numbers quoted here are reported by each project's author unless noted otherwise.

Contents

Trending

Stars gained in the last 7 days, from our own daily snapshots. Updated 2026-09-28.

Project Stars This week
browser-use/jev-ultrafast 20,870 +8,372
jaredpalmer/kev 7,448 +6,301
tamaratran/fast-jev-compaction 7,037 +1,695
jarrodwatts/jev-trader 2,615 +1,041
TianyuCodings/NanoJev 2,360 +855
bespokelabsai/nimble 1,873 +668
kerpopule/hermes-jev-skills 875 +590
wfzyx/von 730 +492
awlevin/typesafe-computer-use 1,036 +384
lahfir/agent-desktop 1,687 +340

New to this list this week: NandhaKishorM/laya, TheoLeeCJ/SemIf-OpenJev, Contrastive-LM/CLM, feder-cr/jev, deepopen-com/deepopen and 202 more.

Sortable, with hands-on reviews: mrjev.com/projects.

Recent Developments

The Jev ecosystem is days old and moving; these are the changes that affected the projects below.

Date What changed Source
2026-09-18 Python SDK 0.7.0. Breaking: Pydantic replaces msgspec, and system_one() gains response_model to parse answers into your own model. Release notes
2026-09-18 Jev on OpenRouter: typesafe/jev-1.13 plus a latest alias, at TypeSafe's own price. Model page
2026-09-16 Jev on Vercel AI Gateway as typesafe-ai/jev, through AI SDK 7's experimental evaluate API, with zero-data-retention and no-training as provider options. Announcement
2026-09-15 JavaScript SDK 0.6.0. Breaking: Score criteria became an ordered array. Release notes

Dated timeline with sources: mrjev.com/changelog.

What We Found Running These

Every project we review is run in a container with a real Jev key. A sample of what that turned up, and what came of it.

Project What running it turned up Review
pi-warden Redaction missed the password in a postgres:// URL, and the holds database failed on a fresh machine. Fixed by the maintainer the same day. Read
jev-router v0.3.0 left recent prompts in /tmp readable by other users on Linux. Fix merged upstream. Read
jev-browser Every typing step presses Enter, so filling a contact form submits it. Read
tax-doc-classifier Right on every IRS page we tried, but result.form still names a form for a page that is not a federal form at all; gate on gated. Read
abide The README promised zero data retention on every call; on the direct-key path it was never requested, as we confirmed on the wire. README fixed. Read
Jev-cu The policy gate matches a label already truncated to 120 characters, so a long label can hide the word 'delete'. Read
typesafe-computer-use The README said no screenshot is sent; the final answer includes one. Read
Foreman Codex ran with the Jev key in its environment; since v0.3.0 the key is stripped first. Read
jeff jeff check . sent a .pem private key and a config file with a password, whole. Fixed in v0.1.0; we re-ran the harness to confirm. Read
Von The published weights lost their classification head, so the default install answered at random. Restored by the author the same day. Read

All 143 reviews, with what each tool sends and where: mrjev.com/best-jev-tools.

Running Without Jev

Jev is a paid API, so a fair question is which of these still work if you would rather not pay for it (#17). Two things get mixed up in that question, and they are worth separating.

Routing Jev through OpenRouter or Vercel's AI Gateway is not an alternative model. It is the same paid model with a different bill and an extra hop. Many entries offer it, and it changes nothing about cost per decision or licensing.

Pointing a tool at a different model is the question people are actually asking. The table below is only what we checked ourselves, by running each tool against a server of our own. A project missing from it means we have not checked, not that the answer is no.

Tool Points at a non-Jev endpoint? How we know
Jevvy Yes — provider: "custom", any endpoint, optional key We ran its Claude Code hook against a local server of ours
jev-use Yes — TYPESAFE_BASE_URL, and JEV_BACKEND=mock for a keyless dry run We ran its PreToolUse hook adapter against a local server of ours
JCR Yes — the SDK's own TYPESAFE_BASE_URL We ran the resolver against a local server of ours
hermes-jev-approvals Yes — a custom base_url with an optional key_env Read in its code and covered by its own boundary test; we did not drive that path
Jev Skills No — an allow-list of exactly two endpoints, both Jev routes We tried a third and it was refused, by design
Jev Agent Skill Router No — one hardcoded endpoint We had to patch the constant to test it
Jev DSH No — endpoint constant, no override We injected a fetcher to test it
jev-seo No — hardcoded constant, no override We patched the line, then reverted and diffed
jevscan-evm No — endpoint constant, no override Same

For tools that need no Jev at all, the whole Open Models & Reproductions section below is that answer: those projects replace the model rather than the route. Two things to check before picking one. First, the weights' licence, not just the repository's — most are MIT or Apache-2.0 on the code, while the weights vary: OpenThai-SystemOne and PlayJev are Apache-2.0 on both with the base model credited, Von's published weights carry no licence tag at all, and NanoJev declares none on either the model or the dataset. Second, what shape it is: several are a library rather than an API, so choosekit reads probabilities out of a backend you already run and ships an MCP server rather than an HTTP one, while OpenThai-SystemOne and others speak POST /v1/systemone, which existing SDK code reaches with a base-URL change.

Official Resources

Community SDKs

  • Spring AI TypeSafe - Java client for the System One API on Spring RestClient, plus Spring AI integrations that use it as a judge, a guardrail, a RAG post-processor and a tool index.
  • typesafe_sdk - Elixir SDK for the System One API.
  • typesafe-sdk-java - Zero-dependency Java client (Java 21+).
  • typesafe-go - Go client.
  • kunobi-jev - Rust client, published on crates.io.
  • typesafeai-dotnet-sdk - .NET SDK.
  • TypeSafe Swift SDK - SwiftPM client whose behaviour follows the official JavaScript SDK.
  • swift-typesafe - Unofficial Swift SDK following the Python SDK's API, for Apple platforms and Linux.
  • go-jev - Go SDK with a jev-cli built on it, shaped for UNIX pipelines.
  • swift-jev - Swift library and CLI for the three primitives.
  • PHP SDK for Jev - PHP client for the three primitives.
  • AnyDecisionModel - Swift package with one typed-decision protocol over two backends: Jev's /v1/systemone, or a small model running locally on Apple silicon through MLX.

Libraries & Integrations

  • pijev - Drop-in wrapper for the official Python SDK that asks each question in several option orders and averages the answers, so a decision does not move when the options are shuffled.
  • system-one - Provider-neutral TypeScript runtime for typed decisions: the same call runs against Jev, a local implementation, or any /v1/systemone endpoint. No licence file.
  • Jev-Mem - Memory layer for long-running agents that routes the frequent memory-management decisions to Jev and leaves the deeper reasoning to the LLM. Comes with a paper.
  • typesafe.pro - The full server behind api.typesafe.pro, a free anonymous front door that speaks Jev's request shape and forwards to TypeSafe on the operator's own key. AGPL-3.0, so you can run it yourself.
  • jev-cookbook - Fifteen runnable recipes calling Jev through OpenRouter - support triage, dedupe, PII column scanning, reranking, moderation and more - each shipping the output it produced beside it.
  • Advocaat - Small type-safe TypeScript client for asking Jev about your data, with an agent skill for designing questions.
  • jev-harness - TypeScript library that wraps Jev answers in policies, confidence gates, shadow mode, and reusable recipes.
  • zod-jev - Adds Jev semantic checks to Zod 4 schemas. Zod validates the shape; Jev validates the meaning.
  • ruby_llm-typesafe - TypeSafe provider for RubyLLM 2.
  • hono-jev-router - Experimental Hono router that matches requests against plain-language descriptions instead of paths.
  • jev-tree - Recursive Choice over a taxonomy, for picking among more options than a single Choice question allows.
  • n8n-nodes-typesafe - n8n community node for asking typed questions inside workflows.
  • Jev for Home Assistant - Home Assistant integration that turns Jev's answers about your house into entities.
  • jevcache - Local decision cache keyed on (model, schema, state), with redaction and canonicalisation before hashing, for cheaper repeats and deterministic replay in CI. No license file at the time of writing.
  • invalidate - Gives every remembered fact a lease and asks Jev whether new evidence ends it, so an agent's memory can be made to go stale on purpose.
  • System One Harness - Turns a decision model into an agent loop: it compiles the environment's finite action space into typed questions, gates each step by confidence, and records the trace.
  • Hunch - Probabilistic control flow for Ruby and Rails, with predicates that read like ordinary conditionals.
  • Jevalyn - Rails-native decision layer with typed results, guardrails, a router and test helpers.
  • feelings - BAML language support for an AI if-statement: .feels() as a real, typed method backed by a decision model.
  • MetaCog - Wraps a language model in a metacognition loop where a System One judge, Jev or the open Reflex model, picks which branch of reasoning continues.
  • vibecheck - Drops a decision model into ordinary Python code, so a judgement call is a function call rather than a prompt.
  • Discern - Semantic control flow for Effect: patterns, policies and routable procedures built on typed decisions, where an uncertain answer is a branch you must handle.
  • ALGAL - A language and VM for agent programs that wait for approval, resume after a crash and replay what they did, with typed decisions at the branch points.
  • Truffler - Intent search for Rails: the typed questions you declare about a record are asked when it is saved and the answers stored, so the query at read time is ordinary SQL.
  • Gut - Elixir DSL that picks an Elixir value for a subject and a question, with a Jev backend among the LLM ones. On Hex.
  • jev-feels - Ruby and Rails: email.feels?(:urgent) as a named question on a field, with decide and score beside it and validations that use them.
  • Jev Recipes - Two hundred small decisions as installable TypeScript, each a typed question with its options, for routing, grading, gating, comparing and labelling.
  • jev-demo - Worked examples of every question type against the TypeScript SDK, written to be read in order.
  • MorrowCache - OpenAI-compatible proxy that asks a System One model whether a new question is the same one it has already answered, and replays the cached reply when it is. Not the same project as the jevcache above.
  • J++ - Experimental language in which a question is a value and methods compose them, with a Python foundation and a Rust runtime, both speaking /v1/systemone. Every demo replays a recorded run and says what is unsettled. Chinese and English.

Agent Integrations (MCP & Skills)

  • TypeSafe skill router - Hermes Agent plugin that names the one skill worth loading before the model call. Off by default, injects nothing when nothing fits, and does not spend its second request when the first gate is not cleared.
  • jev-mcp - Proof-of-concept MCP server with ready-made tools for fact checking, prompt-injection detection, and semantic ranking.
  • askjev - MCP server published on npm, with setup instructions for Claude Code, Claude Desktop, Cursor, and Codex.
  • jev-eval-mcp - Eval-first MCP server that focuses on knowing whether Jev's answers can be trusted for your task.
  • Building with Jev - Agent skill for writing programs that call Jev: question design, state structure, confidence thresholds, and diagnosing wrong answers.
  • Jev Sift - MCP plugin that asks Jev which files, web pages, or text snippets are relevant to a query, so the agent reads selectively.
  • Jevbridge - ACP and MCP adapter that pairs Jev with any LLM agent, including Codex, Claude, Grok, and OpenCode, for typed decisions and computer use.
  • Hermes Jev Skills - Bundle of skills that hand an agent's small decisions to Jev: model routing, skill selection, retrieval filtering, compaction, and computer use, with a routing dashboard. Works with Hermes, Claude Code, and Codex.
  • jev-mcp (burnigtm) - MCP server whose tools route the next step and decide whether a partner model is needed, for Cursor, Codex, and any MCP client.
  • jevwire - An MCP server, an embeddable decision library, and an escalate-only Claude Code plugin in one repository.
  • pi-jev - Semantic tool routing and skill discovery for the Pi coding agent: Jev picks which inactive tools to activate for the prompt at hand.
  • Awesome Jev Skills - Nine installable agent skills — triage, routing, code review, document and UI work — with a catalogue of scenarios to copy.
  • Jev DSH Decision Engine - Decision plugin for agent harnesses: Jev picks the tool, skill or owner and scores the output, while the agent keeps planning and execution. Ships for DeepSeek Harness and iPolloWork.
  • Jevify - Agent skill for finding where Jev fits in an existing codebase, designing the typed questions, and measuring whether it helped.
  • lorenzini - Claude Code skills that wait for CodeRabbit, Copilot or Codex to finish reviewing a pull request, then judge whether the verdict actually permits a merge.
  • Jev Studio - One pip install for experimenting: MCP tools for Choice, Noul and Score, prompt libraries and a slash command per cookbook recipe.
  • jevvy - Plugins for coding agents, starting with one that auto-approves shell permission requests it judges harmless and passes everything uncertain to the normal flow.
  • JCR (Jev Capability Resolver) - One tool that searches a nested capability tree and hands the agent only the documented commands and context a task needs.
  • jev-superpowers - Skills framework for coding agents with typed gates on package choices and task completion.
  • jev-use - Claude Code, Codex and pi plugin that hands the agent steps needing no written output to Jev and leaves the prose to the LLM.
  • hermes-jev-approvals - Approvals provider for Hermes Agent: it judges shell commands and refuses every other task, registering no hooks.
  • jev-judge-mcp - MCP server that gives a coding agent eleven judgment tools backed by Jev, for the checks whose answers can be enumerated.
  • jevcore - Typed decisions for DeepSeek Harness and any other MCP host, also usable as a plain Node library.
  • system1-agents - Prebuilt agents whose decisions come from a System One model, Jev or an open one, covering browser use, computer use, robotics and games, with a scaffold for building your own.
  • System One Connector - MCP connector that gives Claude Code, Claude Desktop, Codex, Hermes and pi an evaluate tool, pointed at Jev or at an open System One model you host.
  • quicksilver - Claude Code skill for the bulk judgement calls — which of these files, which of these log lines, which of these tickets — that otherwise get read one by one.
  • dsh-jev-interceptor - Judges every tool call and recalled message inside DeepSeek Harness before it runs.
  • Gatekeeper - Decides which agent or skill should take a request before the agent picks for itself; tool-neutral rulebooks, installed today as a Claude Code hook.
  • jev-harness - Research-stage proposal-review contract: an LLM proposes one action, four narrow questions are answered, and code produces evidence for a host to judge — it applies nothing itself. From the independent TypeSafeAI community organisation, which its README distinguishes from the official team.
  • Decision-Native Agent Runtime - Research runtime for an agent whose every step is a typed decision rather than generated text, with a paged option space and a replaceable decision-model boundary. Chinese.
  • jev-code - MCP server giving Claude Code, Codex, Pi and OpenCode five typed tools - classify, check, score, rank, ask - with one request per tool call and the hosts it talks to written down in SECURITY.md.
  • pi-jev-skill-picker - Takes Pi's generated skill catalogue out of the system prompt and puts a ranking tool in its place, so skills are pulled in on demand instead of carried in every request.
  • Building with TypeSafe Jev - Agent skill with a code sketch per project shape, and an eval harness that runs the same task with and without the skill and keeps every run's output in the repository.
  • omo-jev-plugin - Rates how well the next skill or tool fits the work an OmO or senpi agent is doing and passes back a short suggestion. It runs no tool itself and replaces no permission check. Korean.

Coding Agents & Developer Tools

  • jev-rules - Scores your standing Claude Code instructions against each prompt and delivers only the ones Jev picks, once per session rather than per message. Ships a pane that shows which rules were chosen.
  • Nerve - Supervisory layer for Hermes agents that adds typed decisions, ranking and verification asynchronously, with Jev authoritative and an open model shadowing it.
  • pi-jev - Jev as a decision layer for the Pi coding agent in three places: a gate that judges bash, write and edit calls before they run, an output judge that reads what a bash call printed, and a tool the model can call directly.
  • matchcn - Semantic index across shadcn-format registries: components are tagged once across six dimensions and committed, and your brief is classified at query time to match against them. Ships as an MCP server.
  • fast-jev-compaction - Claude Code plugin that replaces the compaction summary with Jev decisions. Every tool call and result is scored; stale ones are dropped or truncated, and everything kept stays verbatim.
  • Jev Codex Router (archived) - Picks the model, reasoning depth, and speed mode for every Codex turn based on how hard Jev judges it to be. The author reports about 60% lower cost when replaying 237 real turns.
  • Foreman - Puts Jev as a fast supervisor above slower coding agents such as Codex, starting from a ticket, spec, or bug report.
  • Winnow - Context sieve for Claude Code. Jev judges each tool result (Read, Bash, Grep output) for relevance before it enters the context window.
  • Jev Review - Staged code-review workflow for JavaScript and TypeScript with a local dashboard. Jev screens correctness, security, reliability, compatibility, and test risk, then scores severity and suggests a reviewer, with no generative model involved.
  • Jev Review MCP - Local-first MCP server for continuous software-quality review by coding agents.
  • Stanley Code - Bounded Jev workflows for coding agents (formerly jev-code).
  • SkillRanker - Rust CLI that ranks which agent skills fit the next step from live session context, with Claude Code hooks.
  • JevLint - Checks code against conventions written in plain English, in a write-check-fix loop with your coding agent.
  • compact-adviser - Agent plugin that asks Jev whether the session is at a safe point to /compact, and can run it automatically on Pi and Claude Code.
  • jev-pruner - Claude Code plugin that uses Jev to trim long Bash output before it reaches the model, leaving errors, source code, and structured output untouched.
  • perch - Semantic linter that reads each method together with its callers and callees before asking about it. Rules are sentences in a YAML file.
  • jev-lint (mizchi) - Checks whether a function does what its name says, whether a comment is still true, and whether a test verifies what it claims, with a cutoff per rule.
  • patdown - Lints a tree against fuzzy rules kept in one markdown file, behind a provider-neutral interface so the judge can be swapped. Its LICENSE is not a recognised open-source license.
  • agent-dispatcher - Routes a Claude Code or Codex task to one of 27 specialist roles and defines what evidence will count as done.
  • Jot - A general-purpose agent loop where Jev picks the next move and Jot runs it. No license file at the time of writing.
  • oxlint-plugin-jev - Oxlint rules written as plain-English questions about a function, call, JSX element or file, reported when the yes-probability clears your cutoff.
  • Jev Agent Skill Router - Routes a request to the agent skills it needs, with a confidence floor below which it loads nothing.
  • yummy-pi-extensions - Extensions for the Pi coding agent, each released separately, including a Jev-based model router.
  • JevLoop - An agent loop whose seven forks are typed decisions rather than LLM calls, keeping the model for writing. Zero runtime dependencies, and the demo runs offline with no key and no install.
  • jev-test-filter - Reads a Git diff, scores every test for whether the change can alter its outcome, and prints the arguments your runner already understands. Every failure path runs the whole suite instead, including a diff that did not fit the state budget.
  • jev-kit - Claude Code bundle: a tool-call guard, sub-agent sizing, and Jev wired into search, browsing and review.
  • jev-blindspot - Side panel for Claude Code and Codex that asks what a prompt leaves unsaid before the agent acts on it.
  • claude-jev - Claude Code plugin that sends the small judgements — what kind of prompt is this, does it need tools, does this edit break a rule — to a decision model instead of a frontier one.
  • Lintus - A linter whose rules are sentences in a YAML file: each rule is a question asked of every file it applies to.
  • Keel - Local-first macOS workspace around the coding agents you already run: a local Laya selector, or an optional hosted one, proposes the route and the host checks it before Keel applies it.
  • mu - Coding agent built on pi with a judgement kernel deciding the routine calls. Five languages.
  • ESF - Self-hosted software factory: coding agents in microVMs, changes verified, and the patch and execution evidence kept, with Temporal coordinating the workflow.
  • jevmem - Automatic project memory for Claude Code, Cursor and Codex, with typed decisions choosing what is worth remembering.
  • Jev Code Reviewer - Reviews your own agent's pull requests on your machine and posts nothing to GitHub, prioritising where a human should look rather than restating the diff.

Guardrails & Safety

  • agent-chaperone - MCP proxy that screens a tool call before it runs and the tool result before the agent reads it, combining rules in code with typed judgments. Starts in a shadow mode that blocks nothing.
  • tripwire - Runs seven checks on every LLM response in one Jev call, as AI SDK middleware or an OpenAI-compatible proxy.
  • jev-gates - Seven calibrated gates for Claude Code (rules, scope, intent, done, claims, proof, and commit honesty) that escalate but never approve.
  • pi-warden - Guardrails for the Pi coding agent. Jev judges every write and edit against the rules in pi-warden.md.
  • jev-belay - Claude Code Stop hook that checks the transcript for evidence before letting a "done" through, and spends one four-question Jev call only when files changed with no passing check since. Fails open on every error path.
  • Abide - Hooks into Claude Code, Codex, and OpenCode, and asks Jev one question per rule whether each edit breaks your AGENTS.md or CLAUDE.md rules.
  • jev-guard - Risk-scores every tool call against session context into deny, ask, or allow, and flags prompt injection in tool results.
  • Pi Jev Guard - Pi coding-agent plugin with rules configured by timing, plus risk checks, output redaction, and reminders on repeated failures. Chinese documentation.
  • is-malicious - Sends source, configuration, build, and CI files to Jev and points at the files and lines that look deceptive or data-stealing. Its README says a clean report is not proof a project is safe.
  • jevscan-evm - Produces a heat map of likely bugs in EVM code. The author's own warning: a proof of concept whose code they did not read.
  • Jevmind - Nine skills over one brain: a shell-command gate, a diff triage, a router and more, each decision appended to a hash-chained ledger that names any record edited afterwards. Runs offline on local reflexes or against Jev.
  • Canny - Stop hook for Claude Code and Codex CLI that refuses a "done" while no check has passed since the last edit. Jev can only relax that refusal and never cause one, and it still blocks with no API key at all.
  • dsh-jev - Decision layer for DeepSeek Harness whose failure policy rejects the value allow at configuration time, from plain JavaScript as well as TypeScript. Its verify script installs the built tarballs into a fresh consumer before testing them.
  • jev-edge - Admission control at the traffic edge: an OpenResty module, with Lua and JavaScript packages, that screens requests for prompt injection before they reach the app.
  • Super Jev - Puts one judge between an agent and your data: it finds the file, checks the claim, and permits or refuses the action.

Model Routing

  • Astra-Ares - Adjusts a Codex task's reasoning effort mid-run by asking Jev how hard the next step looks. Runs a patched Codex CLI and says it is a reference implementation rather than an app.
  • Agent Orchestration SDK - Orchestration engine for multi-agent work with durable mailboxes and warm sessions, routing each task with a typed decision instead of a manager LLM.
  • jev-router - Per-turn model routing for Claude Code and Codex. Simple work goes to the fast tier and difficult work to the strong tier.
  • tiershift - Sends each LLM request to the cheapest model tier that can handle it and escalates on evidence.
  • safer-with-jev - Neon Function proxy for the Neon AI Gateway. Jev classifies each request and routes it to the right downstream model.
  • jev-gateway - Local gateway for Codex and Claude Code that asks Jev which tool to call next and passes everything else to your usual model.
  • JevRouter - Routes each agent step to a model, subagent, Skill, MCP tool, or CLI with one Jev Choice, requiring confirmation for risky capabilities and keeping decision receipts.
  • Grok Bot Jev Router - Classifies a Grok Bot request before expensive research, browser, retry, or subagent work, so it can reuse a fresh artifact or stop a failing retry.
  • pi-jev-router - Ranks the OpenRouter catalogue per task, takes the Pareto frontier over quality, cost and latency, and routes pi to the knee point.
  • Helm - Picks which of the coding agents on your machine should take a task, from an answer set a probe builds, so an agent you have not installed cannot be recommended. Installs as a Claude Code plugin, a Gemini CLI extension, or an Agent Skill.
  • HiRoute - Local-first routing and coordination engine for long-running agent work, with a jev-decider extension that routes on typed decisions.
  • stuntd - Local proxy that speaks the System One protocol, records the typed decisions an app already makes, and learns to answer them itself.
  • BrighTO Router - Self-hosted Rust gateway that fronts OpenAI-, Anthropic- and /v1/systemone-shaped backends behind one endpoint, with weighted model groups and usage recorded in PostgreSQL.
  • Jevonian - Sits between a coding agent and its providers, picks a model for each turn against quota and cache economics, and records the decision locally.
  • Switchboard - Model and reasoning-effort routing for Claude Code and Codex, model-agnostic and self-hosted.

Command-Line Tools

  • jsort - Sorts lines along a plain-English dimension by judging them in pairs, so the sort key is a description rather than a field.
  • jev (shaharia-lab) - Rust CLI whose exit codes separate a false gate from an answer inside your abstain band, so a script can take a third branch and ask a person. Lints the request before it spends anything.
  • SemDecide - Unix-style CLI for typed semantic decisions: classify, score, filter, and guard inside shell scripts, CI, and data pipelines.
  • jev-repl - Terminal REPL for shaping System One requests before writing code. Simulates answers when no API key is set.
  • triagedy - Security alert triage as a Unix filter: JSONL alerts in, typed decisions out.
  • jev-shell-history - Fish-style zsh autosuggestions, ranked by Jev from your recent history.
  • commit-miner - Classifies Git commits into bug fixes, security fixes with CWEs, and change types.
  • TypeSafe AI Playground - Rust CLI of Jev experiments, including PHI detection, code-comment review, live tone analysis, and occupation and industry classification.
  • jev-commit - Pre-commit hook where one Jev call checks whether the commit message matches the staged diff, flags debug leftovers and unmentioned work, and blocks only when it finds a credential.
  • semgrep (uehaj) - Grep by meaning: Jev scores each line against a description in any language, with AND, OR, and NOT. A single dependency-free Node file.
  • jeff (Alurith) - Read-only Go CLI that checks files against rules such as unclear responsibility or weak error handling with Jev, locally or in CI.
  • jegrep - Semantic grep with no embeddings, index, or daemon: it searches the live tree on every run and matches concepts rather than strings.
  • jgrep - Like grep, but the pattern is a description: it filters piped output as well as files and prints a probability per line.
  • jev-cli - Typed judgments from the command line, published to npm as jevctl.
  • Sniff Test - Prose linter for AI writing tells: countable regex rules run locally, and one judgment question covers the rest.
  • jev-seo - Rust CLI and MCP server for SEO and GEO work, scraping DuckDuckGo instead of paying for a search API.
  • JevGrep - Semantic code search for agents, as a CLI or MCP server: ask what the code does and get source excerpts with paths and line numbers.
  • evoke - Turns a sentence into a call of a small program you installed from Git, run only when the confidence gate allows. A CLI, a package manager for those recipes, and a TypeScript SDK over the same core; your overlay may tighten a reflex's effect but never loosen it.
  • slop-grader - Grades prose against twenty-one named writing tics, asking every rule about every line, and writes its findings as a brief for a coding agent to act on.
  • jgrep (kyu1204) - Semantic grep that packs sixteen chunks and sixteen questions per request, with grep's exit codes and a --diff mode for linting a change against a rule written in English.
  • webctl - Search CLI for agents: results from up to three backends are scored by Jev against your query and an explicit --goal, and only the relevant ones reach the agent's context. Its benchmark excludes an arm it could not observe.
  • jev-cli (tumf) - CLI and stdio MCP server for the three Jev primitives, with --value for shell scripts and structured stderr errors. auth set refuses a key as an argument, keeping it out of shell history.
  • jevyoumean - Semantic "did you mean?" for any command: wraps a CLI and proposes the correction a typo was reaching for. Experimental, by its author's own note.
  • jevgrep - Finds code by what it does rather than what it matches: a CLI for coding agents that asks which files and which regions are relevant to a description.
  • grev - Unix filters that ask a question instead of matching a pattern, so a pipe can select its lines by meaning.
  • JevRev - Puts an LLM and Jev in one workflow, with sift, loop and long modes, a TUI, and a CLI that can be pointed at any /v1/systemone host. English and Chinese.

Browser & Computer Use

  • jev-browser-skill - Agent skill that drives an isolated Playwright Chromium: the agent sets a narrow goal and Jev chooses the in-page actions. Vercel AI Gateway by default, TypeSafe optional.
  • Jev Voice - Floating bar for macOS that takes a voice or text command and picks the next action from the Mac's live accessibility controls, looping until the goal is met.
  • Jev Browser Use - Browser skill that splits the work: Jev handles navigation, clicks, toggles and scrolling while the coding agent thinks and verifies. Uses your existing browser connection, with no extra driver.
  • jev-ultrafast - Fast browser agent from Browser Use. Jev decides each step and which element to act on; a small model is called only when text needs to be typed. The authors report a full Google Flights search in about 7.1 seconds.
  • typesafe-computer-use - macOS computer use without sending screenshots to a large model. The screen is read deterministically and Jev picks the next action.
  • Jev Browser - Headless browser automation through an MCP server, CLI, or library. Jev picks one action per step.
  • Mobile Jev - Android phone automation from DroidRun on its Mobilerun device cloud, with Jev choosing every operation and target. The author reports reaching Uber's payment selection in about 21 seconds.
  • agent-desktop - macOS desktop automation over accessibility trees. Since v0.9.2, its jev-desktop scripts let Jev choose which control to operate and which action to take.
  • Jev-cu - Codex computer-use skill where Jev picks the next element and action from on-screen text, with a local policy gate for sensitive steps. README in Chinese.
  • voice-browser - Voice-controlled Chromium: on each partial transcript, one Jev request judges intent, target element, and whether the command is complete or destructive.
  • JevScout - Coding-agent skill that drives Chrome over CDP to look for jobs on company sites, with Jev scoring pages and links.
  • macbrow - Say a command and it runs as AppleScript, or say a web task and it drives Chrome. Its README opens with a warning about an early version tidying a Desktop rather thoroughly.
  • jev-use - macOS computer use by voice or typing that reads the screen through the Accessibility tree rather than screenshots. Key stored in the Keychain.
  • Jev Voice - Local whisper.cpp for the transcript, then one Jev request picks the action and its typed arguments; code owns execution.
  • Jev macOS Loop - Native macOS GUI automation on Apple silicon: OmniParser CoreML and Apple Vision OCR identify controls locally, Jev selects the action. AGPL-3.0.
  • Jev Desktop - Adds a bounded decision loop to Codex Computer Use for browser tabs and native macOS apps.
  • fastbrowse - Browser agent that indexes the page into candidates for Jev to pick from, leaves planning and reading to an LLM, and cites a quote from the page for every claim.
  • Jev Social - Instagram, TikTok and LinkedIn research where Jev chooses each next operation and a real Chrome session executes it, with the evidence kept.
  • Jev for Chrome - Manifest V3 port of jev-ultrafast that drives the tab you are already looking at, keeping the same observation format and execution rules.
  • CodexQA Jev Browser - Browser automation that indexes the controls inside the page and has Jev choose one, instead of sending a screenshot to a vision model on every step.
  • jev-ultrafast-mcp - MCP server that takes a whole browser task in one call and drives the page itself, so the agent never opens a browser.
  • Jevry - Desktop browser agent where a language model plans, a decision model picks the action, and Chromium carries it out.
  • Jev GUI Delegate - Windows and Chrome GUI delegation for Codex: the model hands over a task contract, a local controller runs deterministic steps, and low confidence stops for a person. Chinese.
  • Flick - Local stdio MCP server that executes a whole browser or macOS goal from the agent's goal, values and completion condition.
  • dejevu - Browser agents that act on one look at the page; the default backend is any open model, and --backend typesafe makes Jev the chooser instead.
  • BrowserPaw - Drives your everyday Chrome from an agent across fifty MCP tools, with each step decided by Jev or by a decider model it downloads and runs on your own machine.

Data & Observability

  • pg-jev - PostgreSQL extension to filter, rank, and classify rows with plain-language conditions.
  • jevql - A psql-shaped CLI and Go/TypeScript/Python SDKs that add jev(), jev_prob, jev_choice, and jev_score to queries against a vanilla Postgres with no extension. The SQL runs on the server and Jev judges the surviving rows in batches.
  • duckdb-jev - DuckDB extension that returns Jev's answers as real SQL types.
  • Jev Logs - Scores OpenTelemetry logs for diagnostic value, priority, and routing before expensive LLM analysis.
  • pg_typesafe - Pre-alpha PostgreSQL extension that calls Jev from SQL for Choice, Noul, and Score, with EXECUTE revoked from PUBLIC by default.
  • tax-doc-classifier - Classifies tax-document pages into IRS forms and page kinds with one Jev request per page, driven by a JSON file of form descriptions.
  • doc-router - Rust tool that asks Jev which PDF pages actually need OCR, extracting text pages locally and sending only the rest to your OCR provider.
  • DocJev - Classifies and splits PDF, DOCX and PPTX with Jev and local OCR, asking one typed question per page and per boundary in a single request. Ships the manifest, per-call records and error analysis behind its benchmark.
  • Jeview - Local gateway and live map of every Jev call your code makes, in one dependency-free file. It holds the key itself: a caller's own bearer token is dropped rather than forwarded, and with no key set it will not proxy at all.
  • jev-ultralightspeed - Packs many items into one Jev request for bulk classification. If any item in a pack comes back unanswered it raises and names the item rather than returning a partial result.
  • jevframe - A .jev accessor for pandas and Polars: the request is built from the columns you name and nothing else in the row, and a failed row raises naming the row instead of becoming a null.
  • jev-curate - Rust pipeline that sifts JSONL and Parquet rows against reasoning rubrics, emitting records verbatim with a rejection log that names the question, the probability and the ceiling crossed.
  • JEV DataOps - Traceable pipeline for training data: upload, screen with Jev, evaluate, fine-tune your own model, then evaluate the result, through a browser workbench or a CLI.
  • Reflex - Rust library for control loops over observability data: metrics and forecasts become typed state, a model recommends an action, and it is committed only if the guards and invariants you declared hold. Not the same project as the open model of the same name.
  • Jevflake - A dbt package and Terraform module that let Snowflake ask a typed question about a row, so the answer comes back as a column you can filter, join and test.
  • jevernetes - Reads Kubernetes logs, decides which lines matter and what to investigate next, and hands off to an agent. Rust, with an offline mode.

Search & Knowledge Graphs

  • Jev Search - Search the web in plain language: Jev answers typed questions about your request, and the app uses those judgments to pick the query, the sources and the time range before ranking what comes back. Installable from the browser as an app.
  • Blink - Semantic codebase search. At each directory level Jev ranks which files and folders are most likely relevant and sends more walkers there.
  • neo4jev - Navigates a Neo4j graph by having Jev score neighbouring relationships, then beam-searching for the most probable path.
  • jev.nvim - Neovim plugin that splits the buffer into functions with Treesitter, has Jev score each one against a plain-language question, and lists the answers in the quickfix window ranked by probability.
  • laya-jev-GraphRAG - Agentic GraphRAG over Neo4j with a swappable decision model, either the Jev API or a local Laya checkpoint.

Apps & Browser Extensions

  • Jev × WebMCP - Chrome extension that discovers the WebMCP tools a page exposes and has Jev choose which one a sentence means, then fills in its arguments.
  • JevIntent - WeChat plugin that reads intent, tone and reply posture from a long-pressed message and shows the verdict locally. Sends nothing and changes no chat history. Chinese.
  • jev-哑巴微信 - macOS helper beside the WeChat window: an LLM drafts several possible replies and Jev scores them, leaving you to press send. Chinese.
  • Jev demos - Seven side-by-side demos that run with no keys and label themselves simulated. Each visitor's key gets its own budget by fingerprint, and any key is redacted out of upstream errors.
  • Passage (Working Memory Jev) - Localhost tool for educators that flags where instructional text may ask a reader to hold too many ideas at once. Its evaluation opens by naming the two tests its own model fails. Custom licence, not open source.
  • RikkaHub Plus - Android chat client with a built-in Jev client: it scores stored memories for relevance in batches before retrieval, and exposes Jev to the model as a callable judgment tool. Endpoint and key are set in its settings. Chinese documentation.
  • unclutter - Browser extension that removes page clutter using Jev and reusable template rules.
  • TypeSafe AdBlock - Chrome extension that asks Jev whether each DOM element is an ad and removes the ones that are.
  • Jev Moderation Bot - Discord bot that filters spam and scam links in real time and escalates repeat offenses.
  • jevmeter - Scores every sentence in a video and renders a live Jev meter as a 16:9 edit.
  • jev-skip - Browser extension that reads the caption track and paints a sponsor-probability overlay on the YouTube seek bar before the intro ends, with no crowd database. The author reports catching 77% of SponsorBlock's sponsor seconds across 23 videos at $0.0008 per video.
  • Jev Chat - Chat-style command bar where Jev picks the tool, arguments, and reply type, and code builds every reply from tool data.
  • Sharp - Browser extension that filters your X timeline by plain-language rules, with Jev as the default classifier.
  • lurk - Self-hostable Reddit buyer-intent finder that uses Jev to judge every post and comment a scan reads.
  • jev-paint - Local app that turns Jev's per-pixel probability distributions into paintings.
  • Live Jev - Control Ableton Live with one sentence, in Japanese or English, from a bar that appears over the session and gets out of the way.
  • x-scanner - Chrome extension that labels every post you scroll past on X with six typed questions per post, and counts what it costs in the corner.
  • RefGarden - A three-dimensional reference gallery over The Met, NASA, Cosmos, and the Prelinger Archives, with Jev choosing the search phrases.
  • Cheshi - macOS workspace for Codex where Jev finds past sessions and the decisions made in them. Apple silicon only.
  • Jev Reviewer - Extracts data for systematic reviews from a trial report and its supplements, quoted from the paper, against your own form or a RoB 2 template.
  • dasheng - Read English aloud and see which words were wrong: streaming speech recognition transcribes, Jev judges word by word, and both models can run on your own GPU.
  • Vibe Check for X - Chrome and Firefox extension that scores a draft X post on a dozen dimensions and gives a send-or-don't verdict before you publish.
  • Crush Monitor - Reads a WeChat conversation and labels each message with emotion and intent, rating how your own replies landed. Local, with your own key.
  • Jevmail - Read-only Gmail triage that sorts an inbox into five trays with an urgency score, running locally through a gateway key.
  • Call Coach - Listens to a live sales call and, after each sentence, tells the rep what to do next with a confidence score.
  • Jev Explained - Interactive playground that walks through a typed request and its probabilities, with your own key.
  • jev-mail-classifier - Config-driven inbox classifier that tags, moves, flags and notifies from typed answers.
  • Jeved - SillyTavern extension that asks your own questions about each reply and, when a rule matches, adds a line to the prompt, rerolls, or runs a script.
  • Shapeshift - One text box that turns what you type into the right small interface, an event card or a checklist or a bill split, with Jev choosing which; falls back to rules when no key is set.
  • jev-suite - Four decision-quality apps on one kernel, each asking Jev a structured question about whether something was delivered as required, with deterministic code keeping the final say.
  • Book of Answers - An LLM lays out the options for an everyday dilemma and Jev picks one, with a page for keeping and re-reading past answers. Chinese.
  • Yanwai - Android accessibility app that reads the visible WeChat conversation and shows emotion probabilities, possible subtext and a suggested reply beside a message. Chinese.
  • QuantStudio - Local research and trading workbench with a Jev module that watches positions and grades trade plans. Chinese. GPL-3.0.
  • 狗头军师 Jev Chat - Reads the chat window on a Mac, analyses the relationship and drafts a reply. Chinese.
  • jevclip - Judges a video's transcript segment by segment and cuts two versions, a short highlight reel and a full one with the filler removed, writing down why each cut was dropped. Chinese.
  • WeChat Jev Assistant - Windows desktop tool that reads the local WeChat transcript, redacts it, and returns the stage of the conversation and what it needs. Chinese.
  • jev-chat jarvis - iOS custom keyboard that shows a message's intent, its risk and candidate replies inside whichever chat app you are already in. Chinese.
  • slop-filter - Chrome and Firefox extension that hides AI-generated posts and comments on X, LinkedIn and Reddit.
  • JevBystander - Android accessibility reader for WeChat that judges the other person's message and shows three short prompts: it writes no replies and modifies nothing. Chinese.
  • Paper Radar - Reads the morning's new arXiv papers against interests you write in plain English and surfaces the few worth opening.
  • sift - Chrome extension that labels every post on X - substance, humor, chit-chat, promo, junk - flags the AI-written and off-topic ones, and hides whichever categories you turn off. The author reports about $0.00003 per post.
  • jev_antispam_bot - Telegram bot that asks whether each group message is spam and deletes only high-confidence matches. Administrators are exempt, and a channel identity only when a fresh lookup proves it is the group's own linked channel.

Evaluation & Benchmarks

  • PZ_Optimization - Performance work on a game, notable here for the harness: the arithmetic and the noise floors are computed in code, and Jev is asked only for the verdict on what the numbers mean. No licence file.
  • jevcal - Picks the confidence threshold that meets your accuracy target on your own data, and fails CI when a model update breaks it.
  • Janus - Measures Jev's calibration and confidence-based routing on Banking77 and Web of Science.
  • jev-benchmarks - Probability-aware evaluation: calibration, and how much work can be automated at a fixed error budget.
  • typesafe-ai-benchmark - Compares LLM structured output with Jev on latency, cost, and judgment quality.
  • Jev Capability Atlas - A bilingual map of where Jev holds up and where it breaks, built from recorded API calls rather than a leaderboard. Its LICENSE is not a recognised open-source license.
  • jev-align - CLI from Sutro that finds the examples a Jev function is least sure about, asks you to label them, and uses GEPA to improve the question.
  • JevBench - Benchmark for typed decision models across several suites, with confidence cascades and committees reported separately.
  • jev-rag-benchmark - Reproducible experiments on whether reranking with Jev improves a small RAG system, on a locked Turkish dataset, with quality, latency and cost reported together.
  • Jev vs. ML - Compares a typed decision model with classical classification pipelines across eight datasets, with a published protocol and an interactive report.
  • jevals - Agent evals and guardrails as typed questions instead of an LLM judge, packing every eval for a trace into one request. From Openlayer, with a mock backend so the whole library runs without a key.
  • jev-calibrate - Checks a Jev question against your own labelled examples and grades it: act on it, only sort by it, or rewrite it. Refuses to grade a question whose classes have too few examples, however good the numbers look.
  • jev-as-a-judge - Uses Jev through langchain-typesafe as the judge in an eval suite, asking typed quality questions instead of asking a larger model to grade. No licence file.
  • Eval Genius - Skill that tells a coding agent when a question needs an eval rather than a vibe, with an opt-in lane that routes the closed-label residue to a decision model and scripts for the cost and confidence arithmetic.
  • jeval - Measures how well a classifier's confidence matches reality and turns the cost of a mistake into the threshold where a human should take over.
  • Typed Evals - Python toolkit that puts evaluation of LLM, RAG and agent output as typed questions, with optional calibration against human labels.

Open Models & Reproductions

  • AgentJev - A 0.6B decision model on a Qwen3 backbone with weights on Hugging Face: state in, a distribution over your options out, nothing decoded.
  • OpenJev-Vision - Encodes an image once and answers several typed questions from the shared distribution. Ships synthetic scenes, trained readouts, a dataset and reproducible evaluations.
  • NotJev - Serves the Jev request shape from any OpenAI-compatible endpoint by presenting options as single letters and reading the letter mass out of logprobs.
  • FastJev - An independently maintained SemIf fork packaged SDK-first, for deploying an open decision model on your own infrastructure.
  • JevForge - End-to-end toolkit for the other direction: synthesise decision data, train a calibrated candidate scorer on it, evaluate it, and serve it behind a Jev-compatible endpoint.
  • jevify - Makes a model you already serve answer typed questions in one pass the way Jev does, and measures how well it manages it.
  • decider - A family of System One-style models that never generate text: one forward pass over a state and typed questions returns a probability distribution per question. Ships ten text games and a Super Mario Bros agent where each move is one typed decision over the legal actions.
  • reflex - A small open decision model for your own GPU: fixed answer options in, per-option percentages out, with no free text so it cannot answer off the list.
  • Jev Visual - Multiple typed questions about one image in a single pass, on Qwen3.5-0.8B with MLX on Apple Silicon. States plainly that it explores the pattern and does not claim to reproduce Jev's architecture or training. Chinese and English.
  • Laya - Non-autoregressive decision engine over 100+ languages: three checkpoints and a router that detects the script and dispatches per request. Its benchmarks end with a limits section naming the datasets it does not generalise to and the headline figure that came from a training split.
  • JEV-CPU - A CPU port of SemIf that swaps only the model loader and reuses the scoring code unchanged, so you can read a decision out of a small model's option logits on a laptop with no GPU.
  • Dev-0.4B - A 399M bidirectional encoder with one universal choice head, answering Choice, Noul and Score in a single forward pass. Every README figure reconciles to an evaluation JSON shipped in the repository.
  • Dohnuts - Small multimodal models for direct decisions on text, documents and images. Its model card publishes the benchmark it loses and states that its confidence field is not a measured probability of correctness. Weights are CC BY-NC-SA.
  • Open Spark Jev - A local decision model for NVIDIA DGX Spark, labelled from policy engines and solvers rather than an LLM judge. Its evaluation protocol records the time its own corpus leaked most of the test set into training.
  • SemIf - Jev-style decisions from a frozen 4B model on a single RTX 3090, with a browser demo. Formerly OpenJev.
  • Jevlike - Train a small model that scores a changing list of text options in one pass.
  • NanoJev - 0.6B parallel decision model with an end-to-end training pipeline.
  • openjev-sglang - Jev-compatible API server running an open model on SGLang.
  • jevmlx - Jev-style typed decisions from local MLX models on Apple Silicon.
  • kev - Jev-style decision models from 0.5B to 8B, built as LoRA adapters on Qwen and served behind a Jev-compatible /v1/systemone API.
  • LocalJev - Local Jev-compatible /v1/systemone server for Bun that asks DiffusionGemma for probabilities, from GitHub Next.
  • Bespoke Nimble - Open data, training recipe, and a 9B model for Jev-style choice and true/false decisions on Apple Silicon or NVIDIA GPUs.
  • Simple Jev - Turns open Hugging Face models into a Jev-style classifier endpoint by reading next-token logits, with a public demo API.
  • OpenJev - Jev-compatible decision server on DiffusionGemma 26B-A4B through vLLM, including questions about images. TypeSafe's SDKs work against it unchanged.
  • jeff - Self-hosted implementation of Jev's System One API on the 400M-parameter GLiFormer model. The official SDK works after changing the base URL.
  • Von - Non-autoregressive System One model with Python and TypeScript clients, published on Hugging Face under Apache 2.0. The author reports sub-25ms inference.
  • AnyJev - Turns any open-weights LLM into a typed decider by averaging the option logits over permutations and subtracting a label-free prior, so the answer barely moves when you reorder the options.
  • JevBERT - A local server that speaks Jev's /v1/systemone shape from a BERT encoder, with a numbered account of every request it refuses that Jev might accept.
  • DeepOpen - A router and presets over Convai's Laya checkpoints, packaged as its own engine.
  • OpenJevPro - Asks an Ollama or OpenAI-compatible model to write a likelihood score per candidate, then softmaxes them with a fixed temperature. PolyForm Noncommercial, not an open-source licence.
  • solar-mini4-jev - Puts Upstage's Solar Mini4 behind Jev's /v1/systemone shape, bring your own Upstage key. Its benchmark grades against a third-party judge rather than a peer model's answers, and every published figure recomputes from the artifacts committed with it.
  • openJev-verdict-2.0 - A 151M non-autoregressive decision model on ModernBERT with calibrated uncertainty and an in-browser WebGPU playground. Its LICENSE is not recognised as the Apache 2.0 its badge claims.
  • OpenDecision - Open-source semantic decision engine: state, a question in natural language, and answer criteria in; a structured decision out.
  • Open Alternative to Jev - Typed, calibrated decisions from any open-weights model in one forward pass, as the Python package open-alternative-jev.
  • choosekit - Scores a finite set of choices against a model you already run and returns a typed decision with a probability distribution, from text or images. Backends for llama.cpp, Ollama and OpenRouter, and a choosekit-mcp package exposing the same choice as one read-only MCP tool.
  • Jev Local - A local /v1/systemone server with two backends: an LFM model zero-shot, and a fine-tuned ModernBERT-Ja cross-encoder. Japanese documentation.
  • LLM2Jev - Adapts a local language model into a Jev-style decision engine, answering runtime-defined Choice, Score and Noul questions through SGLang.
  • Laya for Node - Runs Laya, an open Jev-compatible System One model, from Node.js and TypeScript through ONNX Runtime.
  • OpenJev (SiliconLabAI) - Approximates the System One contract on top of any logprob-capable model: a fixed answer space, each option scored independently, all questions in parallel.
  • Open Jev (intikhab49) - A 150M encoder trained to answer typed questions in one pass, with the training notebook written to run on a free GPU.
  • OpenSourceJev - Research experiment in local System One decisions through llama.cpp logits projection on consumer hardware.
  • OpenThai-SystemOne - Thai and English decision model with a slot-softmax head whose request and response shape mirrors the official API, so existing SDK code can point at it.
  • PlayJev - Multimodal decision model that plays browser games from raw pixels, with weights and a hosted demo.
  • djev-run - Serves DiffusionGemma-Jev behind a compatible API on Cloud Run, with a small game demo on top.
  • Rizzo Flow - Local typed decisions from Spark-X2.5-4B over llama.cpp, serving both its own schema and Jev's /v1/systemone. Its /v1/models alias says in its description that it is not answered by Jev, and every published result names its dataset by hash.
  • Contrastive Language Models - CLM-8B, a contrastively trained System One model served behind a TypeSafe-compatible API, with data, weights and a fine-tuning tutorial.
  • JevK5 - Open-weight decision model that serves the /v1/systemone request shape from your own GPU, with weights on Hugging Face.
  • Valen - Multimodal System One model, text and images and video in and decision probabilities out, with training and evaluation code and weights on Hugging Face.
  • laya-server - Self-hosted API and web interface for Laya's checkpoints, speaking /v1/systemone behind its own API keys.
  • sys1 - System One compatible API in Rust for open decision models such as Laya.
  • Glance - Asks a frozen open vision-language model typed questions about an image and reads the answer out of one forward pass, with a calibration harness around the readout.
  • SNAP - Local, deterministic typed decisions from one forward pass of an open model, serving the Jev request shape.
  • Laya MPS - Runs Laya's typed-decision checkpoints on Apple Silicon through Metal Performance Shaders, with a lower-memory mode.
  • OmniJev - Omni-modal decision model from Beijing Zhongguancun Academy and CASIA: typed questions about images, video, screens and robot scenes, with weights on Hugging Face.
  • JevEmbed - Choice, score and noul decisions read out of an embedding model of your choosing, with a Python API, a CLI and an optional HTTP server.
  • arbiter - Serves typed-decision models, Laya or your own, behind a Jev-compatible API on an NVIDIA GPU or a Mac.
  • ollaya - Pulls and serves open decision models locally the way Ollama serves language models.
  • JevAny - A calibrated decision layer trained on a 27B backbone, published as two LoRA checkpoints, one general and one trained with a calibration reward.
  • Lev - System One decision engine in Clojure on Jolt, answering typed questions over a state with calibrated probabilities.
  • Reflex - GGUF-native Rust and CUDA engine built for cold-start latency, with a system1 command that scores your candidates from a local model.
  • Nemotron Diffusion Decision Lab - Browser lab for asking typed questions of a dense diffusion model and inspecting the distributions, with a disclaimer that it is neither Jev nor a TypeSafe service.
  • jevper - Independent implementation of the documented System One wire format over an OpenAI-compatible chat model.
  • jev-rs - Rust engine that answers the three primitives from any language model in one prefill, reading probabilities rather than generating.
  • vllm-jev - Serves decision models natively on vLLM, answering candidate probabilities over the System One endpoint.
  • this-that-model - A 1.9B typed-decision model with an arXiv paper behind it: one forward pass, no decoding loop, and a /v1/systemone endpoint.
  • tinyjev - A small decision model for a laptop that answers the three primitives and is built around knowing when to ask a person.
  • Kev - Open System One engine for typed choice, score and noul answers with calibration.
  • jevos - Serves /v1/systemone and /v1/models for yes/no questions only — other types are refused — from a GGUF model through llama.cpp on CPU, offline once the file is downloaded.
  • lev - A LoRA adapter on Qwen3.5-4B that answers typed questions from logits it has already computed, served over /v1/systemone so existing clients work against it, with the harness that measures it.
  • Mica-v0.1-4B - A 4B decision model that reads its input once and generates nothing: yes/no, a choice among 2 to 255 options, or a score. Speaks the /v1/systemone format.
  • Open Medical Jev - Two frozen off-the-shelf models answer a yes/no judgment per option, and their agreement becomes a confidence, an auto-release gate and a guaranteed candidate set. Nothing is trained. Its figures are measured against Jev 1.13.0 on national medical exams and are author-reported. Chinese and English.
  • imajev - Small open models at 2B, 4B and 9B that read the photos, records and text a business already has and answer in the options you set, with a probability on each and an explicit "can't tell" that sends the rest to a person.

Games & Real-Time Demos

  • Laya vs Jev Arena - A local open model and the hosted one play a snake race and a fighting game against each other, every move a real decision rather than a script.
  • is-jeven - Answers whether a number is even by asking a decision model. The joke is the point, and it is a three-line look at the request shape.
  • Jev experiments - Latency-focused demos from Nader Dabit, each app in its own directory with its own README. No licence file at the time of writing.
  • Jev Tetris - Two models play Tetris on a shared seeded piece sequence under the same clock; a piece that lands before the answer arrives locks where it fell. No licence file.
  • 1v1 Jev - Three.js quickscope arena where Jev decides movement, aiming, ADS, firing, and jumping at roughly 9 Hz.
  • TypeSafe Mario - Jev picks NES controller inputs for Super Mario Bros. from emulator state, with no screenshots.
  • Jev Plays StarCraft - Jev plays the first StarCraft shareware mission, with its recorded action probabilities.
  • Jev Pong - Pong where the ball moves one step per model decision, pitting Jev against chat LLMs.
  • JevPilot - Three.js driving simulator with a Jev-powered autopilot.
  • jev-drone - Camera-only quadrotor in MuJoCo with Jev making judgment calls at about 2.5 Hz.
  • Jev Chess Lab - Recorded chess experiments with a candid result: Jev on its own still blunders pieces.
  • jev-plays-pokemon-red - Pokemon Red on PyBoy where code owns the route and the arithmetic and Jev only picks at branches, logging a Brier-scored faint prediction against RAM state on every battle turn.
  • Jev Self-Driving Sim - A 2D top-down car in the browser that turns its sensors into a JSON state every 200 ms and executes four typed answers. No license file at the time of writing.
  • jevchat - Turns a decision model into a chat model by asking which symbol comes next, then sampling from the returned distribution.
  • JEV-Star - Real-time StarCraft II macro control in five configurations plus unit micromanagement, with a paper and recorded games.
  • Jev Plays Pokémon Red - A decision model plays the game with no scripts and no cheats, through the AI Gateway. You supply your own legally obtained copy.
  • wc3env - Gym-style environment for real Warcraft III: deterministic stepping, fog-filtered observations and native commands, for driving decision models against a game.

Robotics & Embodied

  • RoboDiag Harness - Command-line diagnostics for ROS 2 robots: an evidence-gathering agent whose tool calls are gated by typed decisions before anything touches the robot.
  • EmbodiedJev - MuJoCo robot decision workbench in the browser: three simulation tasks, a local small model or a hosted API, and every observe-decide-act step shown.
  • jev-libero - Fine-grained robot control on LIBERO tasks with physics previews and configurable task definitions.
  • Jev Reflex Autonomy Lab - Multi-drone simulation where typed reflexes fly the fleet and an optional slower planner may advise but never takes control.
  • RoboJEV - Two-stage control of a Franka Panda in MuJoCo from structured simulator state, with physical success checks the model cannot declare for itself.

Finance

  • BTC 5m Decision Lab - Research tool for Polymarket's BTC 5-minute markets: Jev scores the direction, separate code decides the entry, and any TRADING_MODE other than paper throws at startup. No licence file.
  • Prism - Liquidity-provision agent for Meteora DLMM. Jev judges toxic flow, market stress, and mean-reversion likelihood in shadow/advisory mode only, without driving trades. Not financial advice.
  • jev-trader - Asks Jev buy or sell on every Monad block and places real post-only limit orders on the Kuru MON-USDC book. Not financial advice.
  • Jev Trade - Hyperliquid trading bot based on jev-trader, where Jev decides buy, sell, or hold on every tick for five coins. Dry-runs without a private key.
  • Jev X Sentiment Analysis - Crypto terminal that reads up to 1,000 posts about a ticker alongside market and funding data and turns them into a buy, sell, hold, or take-profit call. No license file at the time of writing. Not financial advice.
  • Jevinik - Stock decision terminal that gathers live market evidence and returns a typed view on the next thirty days, with the sources it used.
  • jev_stock - Experiment in forecasting Hong Kong stock direction: it builds a past-only state from market data, asks for an up, flat or down call, and renders a standalone report.
  • Warren Duffer - Intraday bot for two Indian brokers where Jev ranks Nifty-50 names in two stages; it places real MIS orders and has no paper-trading mode. Not financial advice.
  • beebots - Three trading bots race on OKX perpetual futures with every decision typed and a risk layer in plain code; paper trading is the default. Not financial advice.
  • Jeeva - Mid-frequency trading framework for Hyperliquid perpetuals whose decision makers are typed questions, in a TypeScript API and a Rust engine.

Articles & Analysis

Related Lists

Other community lists of Jev projects, each with its own scope and bar:

Contributing

Contributions are welcome! Read the contribution guidelines first.

About

A curated list of projects, integrations, and resources for Jev, TypeSafe AI's System One model.

mrjev.com

Topics

ai-agentsawesomeawesome-listjevmcptypesafe

Resources

Readme
CC0-1.0 license

Contributing

Contributing
Activity

Stars

14 stars

Watchers

1 watching

Forks

6 forks
Report repository

Releases

Packages

Contributors

Languages