Awesome Jev

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.

526 entries · every one checked to actually call Jev · last reviewed 2026-10-10

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.

• Trending
• Recent Developments
• What We Found Running These
• Running Without Jev
• Official Resources
• Community SDKs
• Libraries & Integrations
• Agent Integrations (MCP & Skills)
• Coding Agents & Developer Tools
• Guardrails & Safety
• Model Routing
• Command-Line Tools
• Browser & Computer Use
• Data & Observability
• Search & Knowledge Graphs
• Apps & Browser Extensions
• Evaluation & Benchmarks
• Open Models & Reproductions
• Games & Real-Time Demos
• Robotics & Embodied
• Finance
• Articles & Analysis

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

New to this list this week: CopilotKit/openmuse, extend-hq/jevbox, deillusion/Aha-Engine, Zefan-Cai/Open-Jev, anteloc/ldraw-nova and 63 more.

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

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

Dated timeline with sources: mrjev.com/changelog.

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.

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

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.

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.

• TypeSafe AI - Homepage and early-access waitlist.
• Introducing System One Models & Jev - Launch post.
• Documentation - Concepts, the three question primitives, patterns, and API reference.
• Quick start - First API call.
• Python SDK - Official Python client (pip install typesafe-sdk).
• JavaScript SDK - Official JavaScript and TypeScript client (npm install @typesafe-ai/sdk).
• Cookbooks - Official recipes for guardrails, re-ranking, RAG passage classification, citation checks, and more.
• Patterns - Confidence-gated routing, speculative fan-out, composite scoring, and intent routing.
• Jev 1.13 jaggedness - Where the current model is known to be weak.
• Evals - TypeSafe's published evaluations.
• Jev on Vercel AI Gateway - Access Jev through Vercel's AI Gateway.

• 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-decision - 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.
• laya-php - Laravel-ready PHP client for Laya, the open System One model, so a typed decision is a PHP enum rather than a parsed sentence. Self-hosted, no Jev key.
• jev4k - Kotlin Multiplatform DSL and client, published to Maven Central.
• jev (Go client) - Provider-neutral Unix client: a question in, a typed answer out, for shells and scripts. go install.
• ruby_decision_model - Ruby gem with one client for decision models behind several providers: TypeSafe's Jev, OpenRouter (the default), OpenAI, Cloudflare Clef, Perplexity and any /v1/systemone server.

• 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.
• Ten Levels of Jev - Thirty worked uses arranged in ten levels, from one if statement to an agent that reaches for Jev itself, with a video walkthrough.
• TypeSafe Playground - Community playground with 110 use cases, A/B input comparison, editable prompts, and games built on typed answers. From the independent TypeSafeAI community organisation, not the official team.
• JEV_sees - Gives Jev eyes: turns an image, a video stream or an RGB-D camera into the structured state a typed question can be asked about, for risk and triage judgments over what a camera sees.
• Jevstiller - Sits in front of a repeated classification call, trains a local model on Jev's own answers and their distributions, checks the two agree within a budget you set, and then answers most requests itself.
• DuoMind - OpenAI-compatible local server that pairs a small llama.cpp model for generation with a decision model for the closed questions, so generation stays on your machine.
• DSPy System One patterns - Six files, one coding agent, one pattern each, on a single rule: the signature states the question, Jev returns the probability, and plain Python owns the policy.
• system-one-foundation-models - Swift 6 bridge that puts Jev behind Apple's Foundation Models framework, with ticket- and mail-triage example apps.
• agentrun - A workflow DSL for agents with a Jev package for the steps that are decisions rather than generation.
• jevelry - Puts Jev behind ordinary decisions across a codebase and keeps a record of each one it makes.
• pydantic-ai-go - Go port of PydanticAI's agent loop, tools and structured output, with a TypeSafe Jev model provider and a generic System One provider alongside the LLM ones.

• 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-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.
• dsh-jev-plugin - Eleven DeepSeek Harness judgments - skill and file selection, supervision, tool-output filtering, approval help - each configurable and all off by default. The main model still plans and answers.
• jev-anything - Agent skill for designing, building, testing and tuning a bounded decision layer, with a client scaffold it writes for you.
• ReelQL - Claude skill and API that turns a video link into one typed JSON document: chapters, scenes, key moments, on-screen text and transcript.
• Harness Router - Routes an agent's tool calls, as a hook on every call or a skill you invoke, with MCTS for multi-step decisions.
• pi-heed - Checks every side-effecting tool call the pi agent is about to make against what you actually asked for, before it runs.
• dsh-jev-tools - DeepSeek Harness plugin that judges tool output before it enters the context, screens fetched pages for injected instructions, and gates completion claims. Chinese.
• ego-jev - Agent skill that decides each DOM step from the page's candidate elements rather than spending an LLM turn on it.
• jev-harness (Soilet) - Five semantic gates in front of a frontier agent, for trivial errors and doom loops, with a dependency-free local deterministic mode. English and Portuguese. One of three projects on this list called jev-harness.
• jev-permission-gate - Claude Code mod that answers auto mode's tool-call question with eight yes/no questions in one request, behind a shell-aware blocklist whose flags Jev can deny but never wave through.
• dsh-engram - DeepSeek Harness memory plugin built on the memory-palace layout - fixed locations as the index, routes that only grow - with cue-only spaced recall. Chinese.
• jev-for-all - Connects Jev to the harnesses agents already code in, from OpenCode to Hermes, so they can ask which skill to load, which tools a step needs, and where to go next in a browser.
• jev-skill-router - Claude Code hook that asks Jev which skill fits each prompt, in shadow or inject mode, published with the log of the week its author ran it and why they removed it. English and Japanese.
• paseo-slp-plugin - Supervisor, Lead and Peer roles for a team of Paseo coding agents, with opt-in Jev routing that records a verifiable receipt in shadow mode and binds it when armed. English and Vietnamese.
• dsh-plugin-jev - Gives the agent in DeepSeek Harness's web GUI a jev_ask tool, so the model calls Jev itself when a decision needs a calibrated answer, with a per-chat usage chip. No licence file.

• 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.
• KISS - Rust terminal coding agent with 44 providers that asks Jev for its own decisions; kiss-coding holds the client.
• jev-spec - Checks each commit's code against the Markdown specs beside it and fails when they have drifted apart.
• Software Factory - Local pipeline that puts a typed judge between stages, including a secret gate, published on PyPI.
• Supercov - Coverage, security and code quality for coding agents. Jev answers twelve quality and twelve security questions about each source file, and the CLI ranks the files so the agent knows what to fix first.
• jevlint (Go) - Extracts code units with Tree-sitter and asks whether each passes a rule written in plain language; prebuilt binaries. Unrelated to the JevLint above.
• agent-stack - Turns one Linux machine into a team of coding agents that plans, writes tests first, builds, uses the result and has a second model family review it, with Jev making the routing decisions.
• dotpals - A desktop pal that watches Claude Code, Codex or any agent and says in plain words which files changed, which commands ran and what failed. Runs locally.
• jev-compaction-plus - Claude Code compaction that keeps what is still needed word for word and moves the rest to a draft, derived from fast-jev-compaction.
• fast-jev-compaction for OpenCode - The fast-jev-compaction approach ported to OpenCode: stale tool history is pruned rather than rewritten by an LLM.
• code-quality - Deterministic quality gate for Claude Code, Codex and pi: Git hooks that block test tampering and secrets, with an optional Jev review that adds findings to the report.
• Gobstopper - A local proxy that compacts long Claude Code and Codex sessions as they run, with Jev as one of the scorers that decide what stays; nothing is sent until you choose one.
• Clean Code Review - Reviews every code file in a pull request against a question set drawn from Clean Code: Jev answers, Luna writes the review. Runs on eve with Jev through Vercel's AI Gateway; a hosted version is live.
• Deeds - CLI and Claude Code plugin that reads each commit's diff and counts capabilities gained, fixes and upkeep, ignoring commit messages. Needs only a Jev key; only diffs and file paths are sent.
• jev-lint - Fuzzy linter for coding agents: a hook checks each file the agent writes against your team's rules in .jev-lint/ with Jev and reports violations while the agent is still working.
• jevmory - Memory for coding agents where every fact is a verbatim quote, graded by Jev into keep, stale, wrong or unsupported, with local SQLite receipts and jevmory audit for existing memory files.
• first-pass - Claude Code plugin with rules and checks that make the agent look around a change before calling it done; an optional Jev judge decides whether a review finding is real harm and what proof a small fix needs.
• BGTS Context Engine - Deterministic code-graph context for coding agents on PostgreSQL, Apache AGE and pgvector, over MCP and REST; Jev or a local decider model can optionally re-select the ranked symbols, failing open to the plain ranking.
• sieve - DeepSeek Harness plugin that filters tool output, prunes old context and discloses skills progressively, with Jev or Laya as the judge of what can go; it never uses the session's own model for that. English and Chinese.
• Sedum - Plain-English browser end-to-end tests on Playwright, cheap enough to run on every pull request: Jev resolves what each sentence refers to and whether a claim holds on the page. TypeSafe, a compatible endpoint, or Cloudflare Clef.
• Taste Lint - Design review on every commit: 28 blocking checks and more advisory ones, with the fuzzy ones — vague errors, bare confirm labels, empty states — sent to Jev through Vercel's AI Gateway as review notes.

• 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 (archived) - 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.
• jev-safety-gateway - Go reverse proxy that sits between nginx and a model backend, judges each request's user input, blocks the harmful ones and passes the rest through untouched. Chinese.
• sensored - Streaming PII redaction for TypeScript with regex and NER detectors, and an opt-in step where Jev confirms a detection before it is redacted.
• jes - Open-source guardrails for AI agents that check prompts, skills, retrieved content, tool calls and responses for prompt injection with a decision model such as Jev or Laya, with thresholds you set; LangChain integration and lessons. Apache-2.0.

• 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.
• auto-model-router - Picks a model per turn across any number of OpenAI-compatible providers against cost, cache and quota, with a Claude Code shim.
• Jevia - Local-first, outcome-based router for coding harnesses: it picks a capability tier per task, applies your safety policy, and learns from recorded execution history.
• TriRouter - Routes each request across Claude, Codex and other agents, and queues a prompt sent while an earlier one is still running instead of overwriting it.
• pi-jev-model-router - Reads each pi prompt with four typed questions before the turn starts and picks a model tier, with a budget and an automatic fallback.
• jev-router - Local pass-through proxy for Claude Code and the Codex CLI that asks Jev which model tier each human turn needs and only moves up within a session, so prompt caches survive. No runtime dependencies.
• Claude Model Router - Claude Code mod that sets the model and effort for each main-conversation turn from a prompt classifier: Jev by default, or Cloudflare Clef, OpenAI or a local Ollama model. It does not proxy Anthropic traffic.
• opencode-jev-router - OpenCode plugin that asks Jev how much reasoning each step needs, so one model handles quick edits and hard debugging; runs in-process or as a Responses API proxy.
• jev-pilot - Claude Code plugin that asks Jev before each turn for the reasoning effort, subagent model and skill to use, with a decision log, tuning suggestions and an animated pet that says what Jev decided.

• 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.
• 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.
• JevGrep (Arifette) - 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 (dzhng) - 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. Unrelated to the JevGrep above, which has the same name.
• 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.
• sys1grep - Greps by meaning rather than pattern, scoring every line against a description and combining meanings with AND, OR and NOT; a single dependency-free Node file. Japanese and English. Formerly jev-semgrep.
• jeq - Typed questions in a shell pipeline, for scripts and agents that want an answer without the boilerplate.

• 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.
• playjev - Natural-language browser automation for Playwright, in the shape of Stagehand. Not the same project as the PlayJev decision model below.
• jev-browser - One core behind a typed SDK, a persistent CLI and an MCP server: native Playwright operations and assertions need no key, and only the natural-language paths call Jev. Japanese.
• laya-browser-agent - Browser agent whose next action is decided by Laya on your own machine, with no cloud and no API key. Japanese.
• jev-ui-test - UI test framework where cases are written as sentences and each step is scored against the page's candidate elements rather than generated, run by pytest with Allure reports. Chinese.
• jev-sim-use - Drives an iOS Simulator or Android device without spending a frontier reasoning turn on every tap.
• arc-cua - Lets a planner hand bounded desktop subtasks to a decision model that runs the UI loop, with a lean macOS driver usable on its own.
• jevwright - Browser tests for business flows written as the steps a user takes: the model finds each control once, and the recording replays without it.
• jev-agent-browser - Bounded browser tasks for a parent agent: Jev picks the next typed action, agent-browser runs it, and ambiguity or a stuck state comes back as a structured handoff.
• zero-use-computer - Computer use over MCP that reads what a screen reader reads and acts on real controls, with an optional decision model - Jev or any compatible server - for the small choices.
• IronBee Express - Browser agent for checking that a web app really did what the page says: each step is one Jev choice over the page's controls, a text model is optional, and a recorded run replays with no step decisions. Elastic-2.0.
• Mobile Agent - On-device Android agent that reads and taps any app through accessibility and vision; its allow / confirm / block safety gate can be handed to Jev or a self-hosted Laya over /v1/systemone, off by default. In Chinese.
• OpenComputerUse - Background computer use for agents as an MCP server, written in Rust: sessions drive an app behind your other windows, and plain-English recipe steps are placed by one Jev (or Clef) choice over the window's interactive elements, stopping when it is not confident.

• 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 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.
• jev4pg - A self-developing SQL database with semantic operators and natural-language queries backed by Jev.
• Jevaro - Python batching proxy that asks the same Jev questions about many states and streams the answers back as Apache Arrow, one row per state and one column per question, with Python and JavaScript readers.
• Jevline - Starts from one confirmed-malicious process, account or host in a telemetry export and asks Jev, round by round, which linked activity belongs to the same incident; returns a timeline and evidence table for analyst review. Experimental.
• SOLO - Reorders rows and fields so a prefix-caching backend reuses more work when a decision model judges every record in a large table; ships a vLLM backend for the open AutoTrust JEV-9B model and works with your own.

• 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.
• jev-doc-search - Long-document search that walks a PageIndex tree and asks Jev which branches to open.
• jev-graph-search - Jev-assisted retrieval over local Markdown, Obsidian vaults and Logseq, keeping the evidence it used inspectable.
• Jev RAG - Local knowledge search with seven selectable pipelines, BM25 plus Jev reranking by default, streaming cited answers over your own document folder.
• dsh-paper-reader - DeepSeek Harness plugin that turns the workspace into a paper-reading bench: PDF transcription and search, with keyword candidates reranked by Jev and a fallback to keyword order without a key. Chinese and English; no licence file.

• 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.
• hey-jev - Mac voice assistant that maps what you said onto an action - apps, windows, volume, Spotify, dark mode - and handles two instructions in one sentence.
• txt - Text-only pseudonymous forum whose moderation is a typed judgment per post. Spanish.
• BridgeClip - Desktop app that cuts long videos into short clips, asking which moments are strongest and whether a cut still makes sense on its own.
• Jadense in Zotero - Zotero reading assistant that classifies your library with typed questions. Chinese.
• OmniStudio - Local-first desktop workbench for llama.cpp, vLLM and SGLang that also serves /v1/systemone through its own gateway, with the contract written down field by field. Chinese.
• emotion-system - Reads an AI companion's emotion out of what it wrote itself rather than assigning one, through OpenRouter. Chinese.
• osso - Chrome extension that strikes the filler out of a page and leaves the substance.
• Touxian - Desktop and Android attention workbench: reads your notifications, checks what they rest on, and tracks the deadline rather than the fact that you saw them. Chinese.
• Kibu - A desktop pet for the Mac that takes an instruction, does the work across files, apps and websites, and shows its evidence.
• spinlens - Scans a Bilibili video's comments for rhetorical moves rather than arguments - false balance, labelling, muddying - and quotes the evidence for each of eight labels. Chinese.
• ldraw-nova - Agent tooling for building LEGO models, where Jev judges part and model descriptions during search.
• jevbox - Permission-aware document library: browse document trees and parsed output, search the hierarchy with Jev, and ask source-grounded questions.
• Jevboard - Proof of concept for ranking Bopomofo input-method candidates with Jev.
• quietly - Chrome extension that drafts replies on WhatsApp Web and Gmail and quiets the YouTube feed; the YouTube sorting is a yes/no question per video, on Jev by default.
• xscout-jev - Watches X for news that matters to you, judged by Jev, and alerts you in Slack.
• OpenMuse - CopilotKit's self-hosted personal agent with its own browser, terminal and files; Jev decides whether a reply becomes a clarification panel, a comparison of options or plain prose, and overrides the agent only when confident. Alpha.
• Varina (Aha-Engine) - Multi-seat exploration engine for game mechanics and rule systems that diverges, fact-checks and repeats; Jev decides whether an answer deserves deeper exploration and whether a new idea is already on the board. Business Source License, in Chinese.
• JevGuide - Android accessibility app from the JevIntent author that reads a WeChat chat, has Jev judge it and score how the relationship is going, and has a chat model draft three replies. Sends no messages and modifies nothing. In Chinese.
• MultiTool Office Next - Windows file manager and office workbench with local search, OCR, translation and to-dos; Jev helps pick extracted contract fields, with amounts and long numbers filtered out first. Optional, in Chinese.
• Bops - A team of AI bots that run business operations on their own computers, each with email and a phone number; Jev handles the small yes/no calls, such as whether a request is risky and which bot should take it. Functional Source License.
• Tomarigi - macOS app that shows each Claude Code or Codex session as a bird in an always-on-top window; with a TypeSafe key, Jev flags messages you send that are abusive toward the agent. In Japanese.

• 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.
• inference-benchmarks - 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.
• judge-audit - Pre-registered calibration audits of AI judges, comparing Jev's native probabilities with LLMs' verbalised confidence and vote shares, caveats stated beside every result.
• JevBench (metamorphic) - Tests whether a decision model's probabilities fit together, using 50 laws of probability and choice and no gold labels. Unrelated to the JevBench above.
• Decision Index - Reproduction kit for a public leaderboard of typed decision engines: runs the public text suite against any /v1/systemone endpoint, locally or as one Hugging Face Job. Not affiliated with TypeSafe.
• jev playground - Weekly go-to-market workflows built on Jev, such as lead triage and deal risk, each tested against Claude with its harness published. No licence file.

• WaterSheep - An open-weight model that answers Choice, Score and Noul questions, plus multi-label ones, with a probability for every option. Serves a local POST /v1/systemone endpoint; its README says TypeSafe's Python SDK works against it by changing the base URL. Also runs in the browser through ONNX.
• 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 (archived) - 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.
• 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.
• jeff (Firelex) - Qwen3.5 and Gemma 4 fine-tunes for zero-shot classification that take Jev's request shape. The author reports about 22 ms per decision on an RTX PRO 6000 and 28 ms on an M4 Max under MLX.
• OneJev - Multimodal decision model answering typed questions about screenshots, photos, video and text in one forward pass. English, Chinese and Japanese.
• open-jev-fast - Faster inference backend for Open-Jev-27B: fused CUDA kernels, a prefix tree and CUDA graphs. Needs an Open-Jev install and its weights.
• RSI-Jev - Typed-decision checkpoints produced by a self-improving loop of agents that register predictions before spending GPU time, published with the code that produced them.
• privatemode-decisions - Gets a choice and a probability per option out of any OpenAI-compatible model in one forward pass, for Edgeless Systems' confidential-computing API or any endpoint you set.
• Jeeves - A Jev-style classifier that reasons before it decides: Qwen3.5-9B with a LoRA and a pointer head, trained with SFT and CISPO, plus a diffusion drafter. From PostHog.
• Lichen - Drop-in replacement serving /v1/systemone from open weights on your own hardware, returning the same choice, noul and score shapes.
• JevAny - Infrastructure for training, evaluating and deploying decision models across language and multimodal backbones, with calibrated LoRA checkpoints on a 27B backbone. English and Chinese.
• opendecider - Calibrated decision models from 400M to 80B on CPU or NVIDIA, with weights on Hugging Face and a Colab notebook.
• StartLux-Decision - Typed decision models from 0.8B to 27B, each answer carrying a probability per option, with a chess duel demo.
• laya-rust - Pure-Rust inference for Laya on candle: ModernBERT-large with its RL decision head, no Python at serving time.
• dohnuts.cpp - Native C++ inference for Dohnuts on the released Qwen3.5-0.8B base, so the same decisions run on a CPU.
• usejev - Runs Laya under Bun with native ONNX inference behind a TypeSafe-compatible API, so the official SDK reaches it with a baseURL. Ships an English and Persian playground.
• Open-Jev - Open typed-decision models that return probabilities over candidates directly, without generating or parsing an answer, with a project site and reports.
• Bekko System One - Small decision models from 17M to 400M for yes/no, choice, score and reranking, with a training toolkit, Python inference and a browser app.
• cygnet-recipe - Typed decisions from a frozen Gemma-4-12B-it by reading one option-letter token over stock vLLM, packaged for JevBench.
• gutsy - Local decision model behind the Jev request shape: no generation, no network calls, no per-call cost.
• Qev - Qwen fine-tuned into decision models at 2B, 4B and 9B, with the training data and evaluation code. English and Chinese.
• Jev-Style - Small Qwen3.5 decision models at 0.5 and 1.3 GB in 4-bit, with a systemone-compatible local server, agent skills and a Claude Code guard.
• Vev - Jev-style decision models that also take images, with open weights on Qwen3.5 for your own GPU.
• jiwo - Small open decision models fine-tuned from Qwen3.5 (0.8B and 4B, Apache-2.0) with a server that speaks Jev's POST /v1/systemone format: one forward pass, a probability per option.
• Bud Decision Studio - Desktop app and local server for open Jev-style decision models on macOS, Windows and Linux: pick a model, ask typed questions, read every answer as a chart, or call it over a /v1/systemone-compatible API. No licence file yet.
• OpenJev - Open decision models (1.7B to 8B) trained by distillation for general decisions and browser-agent steps, served behind the POST /v1/systemone shape, with training code and results. Apache-2.0.
• Drex decision models - Nace.AI's open decision models, Drex v1.5 on a 9B Qwen-based backbone and Drex DLM on NVIDIA's Efficient-DLM-8B diffusion backbone, each answering POST /v1/systemone from a Python server or forks of llama.cpp and Ollama. Formerly drex-dlm; Drex DLM weights under CC-BY-NC-4.0.
• Ollajev - Pulls System One decision models from Hugging Face and serves them, Ollama style, behind TypeSafe's routes and shapes, so the stock SDK works by changing TYPESAFE_BASE_URL.
• ruling - Turns any open chat model into a local decision engine: a state and typed questions in, a probability for every option out, no text generated. Not affiliated with TypeSafe.

• 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.
• Jevspresso - A simulated espresso bar where Jev makes every barista decision inside an XState machine; break the equipment and watch it cope.

• 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.
• DriveJev - An open System One decision model for autonomous driving.

• 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.
• jev-bot - Market decision bot for stocks, crypto and memes: state in, buy, sell, hold or avoid out, paper trading by default.
• trade-jev - Backtests Jev as a buy, sell or hold trader on NQ level-10 order-book data.
• x402check - Pre-payment risk-check provider for x402 agents and wallets: sanctions lists, phishing feeds and transaction simulation, plus Jev questions over what the agent acted on to catch injected instructions. Signed verdicts.

• Jev: The Language Model That Won't Talk - Critical look at the "no hallucination" and benchmark claims.
• A deep dive into Jev - Hands-on developer walkthrough.
• Jev: TypeSafe's System One Model That Never Hallucinates - Overview from DataCamp.
• TypeSafe AI debuts model for machines that plays Doom - Launch coverage from The Register.
• Jev Cookbook (Chinese) - Datawhale's Chinese course built on the official documentation: the three primitives, the official recipes, evaluation and local fine-tuning.
• fastcampus-jev - Thirteen notebooks and a sample app on attaching Jev to DeepAgents for tool choice, guardrails and gates on risky operations. Korean.
• workshop-jev - Workshop building a LangGraph sales agent where each decision can be made by Jev or by a frontier LLM, given the same inputs. Portuguese.

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

• kydlikebtc/awesome-jev - Examples indexed by the decision each one makes, with runnable code beside them.
• Amal-David/awesome-jev - Demos, projects, SDKs and skills, with a curated gallery alongside.
• awesome-jev-by-typesafe - Broad list with decision tables and a use-case map.
• yibie/awesome-jev - Category files with written inclusion criteria.
• cobanov/awesome-jev - Large list with sourced research notes.
• fatwang2/awesome-jev - Uses Jev itself to review incoming pull requests.
• awesome-jev-projects - Structured metadata per entry, in four languages.
• hellogumbo/awesome-jev - The largest list, with a searchable site.
• v-modal/awesome-jev-tools - Tools only, no articles or models.
• AppitStudio/awesome-jev - Resources paired with runnable examples.
• yzfly/awesome-jev-zh - Chinese-language list, refreshed daily.
• OmniJev/awesome-jev-gallery - Papers, open reproductions and independent evaluations.
• awesome-typesafe-jev - Source-backed field guide, pairing SDKs and demos with independent evaluations.
• BeatAPI/awesome-jev - Catalogue with a stated star threshold, reviewed through pull requests, plus a live gallery.
• awesome-jev-live - Index rebuilt automatically every few hours with no curation threshold, so it is far larger and unfiltered.
• heyjunpenn/awesome-jev - Large table of projects with stars, language and last-commit date, plus a searchable site.
• Promethe-us/awesome-jev - Official material, community projects and research, with its sources tracked in a separate file. Bilingual.
• awesome-jev-use-cases - Demos grouped by use case, with notes on writing criteria and setting thresholds.
• anandi1989/awesome-jev-usecases - Use cases with every headline figure tagged self-reported or independent.
• aliaihub/awesome-jev-usecases - Use cases paired with patterns and written guidance for building on them.
• Jev Directory - Runnable evals and community builds, also served to agents as an MCP server and an llms.txt index.
• JEV HUB - Long posts and demo videos from X, each kept as a link to the original rather than rehosted. Chinese.
• Jev Radar - A tracked casebook of the ecosystem, kept as a live monitor. Bilingual.
• kraayenjon/awesome-jev - Use cases, projects, SDKs and learning resources in one curated list.
• awesome-jev-typesafe - Organised by the coding agent you use, with a short primer before the entries.
• tanxarx/awesome-jev - Resources, clones and engineering playbooks, with each link resolved back to the post it came from.
• Ai-trainee/awesome-jev - Case library of posts and projects, packaged as a skill an agent loads to suggest how Jev might fit the work in front of it. Chinese.
• ckaraca/awesome-jev - Directory of tools, integrations and experiments, sorted by stars within each section.
• Li-Evan/awesome-jev - Searchable gallery of 3,400+ projects, demos and write-ups gathered from GitHub, X, Reddit and elsewhere, organised by scenario. English and Chinese.
• daftAI2026/awesome-jev - Ecosystem directory with a nightly radar workflow that watches for new projects, and a companion site.
• AnotiaWang/awesome-decision-models - Directory of decision models across vendors - hosted APIs, open weights, runtimes, SDKs and research - rather than of Jev projects alone.
• 2456868764/jevguide - Showcases from X organised by category, with media previews and links to the source.
• Awesome Jev Papers - Curated research literature on Jev and typed probabilistic decisions: preprints, technical reports and evaluations, excluding code repositories. CC0.

Contributions are welcome! Read the contribution guidelines first.