Awesome Jev: source-backed open-source ecosystem radar, plain-language project discovery, and automatic GitHub sync

Awesome Jev — System-1 Agent Architecture Radar

🌐 Search and filter ↗ ｜ 🤖 Install the Agent Skill ｜ 📂 Categories ｜ 🚀 Submit a project (Issue only)

[!IMPORTANT] Submissions via Issues Only · No Pull Requests: Awesome Jev operates as an automated catalog radar where the site frontend and CI pipeline are strictly maintained by the core team. This repository does not accept Pull Requests of any kind (they will be closed automatically). All project submissions and updates are handled exclusively via GitHub Issues.

💡 Why Jev & System-1 Decision Architecture?

When building autonomous agents, routing every small branching decision to a heavy reasoning model (System 2) incurs seconds of latency, runaway token costs, and context drift.

TypeSafe Jev (System 1) is purpose-built for fast, typed discrete decisions:

⚡ Sub-100ms Latency: Delivers decisions in 50–100ms to keep agent loops snappy.
🎯 Native Typed Outputs: Built-in primitives for Choice, Score, and Noul without fragile JSON regex parsing.
🛡️ Zero Vaporware: 854+ projects rigorously anchored to verifiable, commit-pinned public open source across 17 real-world domains.

📊 Architecture Comparison: System 1 (Jev) vs System 2 (Reasoning LLMs)

Dimension	System 2 (Reasoning LLMs)	TypeSafe Jev (System 1 Radar)
Latency	1,500ms – 5,000ms+ (Slow)	50ms – 100ms (Sub-second reflex)
Output Type	Unstructured text / fragile JSON regex	Native typed `Choice`, `Score`, `Noul`
Token Economy	High cost ($1.00 – $15.00 / 1M tokens)	Ultra-lightweight (fraction of a cent)
Context Drift	Prone to hallucinations & attention fade	Deterministic bounded state machine
Primary Domain	High-level planning, open-ended generation	Tool routing, action dispatch, safety gates

🎮 Key Interactive Features

🎰 Tactile Gacha Dispatcher: Discover discrete decision points with real-time streak counting and 10-draw fireworks celebrations (💥 BOOM!).
⚡ Sticky Search & Floating Popover Filter: Filter tags and categories anytime while scrolling via the anchored toolbar popover.
🔍 100% Commit-Pinned Code Evidence: Every listed project links to immutable source files and explicit decision points.

Search and filter ↗ · 854 curated projects

A community-maintained directory and radar for Jev, highlighting open-source projects with verified code and clear decision architectures.

Entries are linked to commit-pinned source code and specific decision points for easy reference. Compatible implementations clearly identify their underlying model.

Projects follow their respective open-source licenses; unstated licenses are noted individually.

Sponsorship · Paid placements

Founding partner slots are open. There are no paid sponsors yet.

Plans and contact · Sponsors

Sponsorship does not change inclusion review, project descriptions, or organic ranking.

Install the Agent Skill

Install the skill to query projects by domain and inspect pinned source evidence directly from your terminal or agent.

npx skills add logicrw/awesome-jev-projects
npx skills add https://logicrw.github.io/awesome-jev-projects/

Agent Skill · llms.txt · llms-full.txt

Browser & OS Action

cua — Cua’s preview jev-use example pairs Driver observation and execution with bounded Jev browser-action choices.
- Where Jev makes a decision: Reads DOM or supported visual-region descriptions and returns a supplied candidate action ID.
- What this project offers: Provides Python and TypeScript loops with separate offline and live checks.
- Project details and fixed source · License: MIT
jev-ultrafast — A browser Agent that uses Jev to choose actions and page controls, calling a text model only when input is needed.
- Where Jev makes a decision: Chooses an action and its matching DOM element in one request; a text model generates input text.
- What this project offers: Separates UI choices, text generation, and browser execution so each step can be inspected.
- Project details and fixed source · License: MIT
jev-desktop — An optional Jev skill for agent-desktop that chooses controls and actions from native accessibility data.
- Where Jev makes a decision: Jev selects a target and action and estimates presence and risk; local policy decides whether to execute.
- What this project offers: Keeps the full UI tree out of the main Agent context while exposing the selected action.
- Project details and fixed source · License: Apache-2.0
typesafe-computer-use — Builds candidate actions from OCR and UI state for Jev to control macOS, calling a text model only when writing is needed.
- Where Jev makes a decision: Selects the next step from deterministically extracted controls and actions before desktop execution.
- What this project offers: Separates screen reading, action selection, and text generation.
- Project details and fixed source · License: MIT
jev-browser-use — A Skill for Codex browser workflows: Jev chooses navigation, clicks, and scrolling while Codex handles text input and final checks.
- Where Jev makes a decision: Sends page state and permitted candidates to Jev; the existing browser connection executes the actions.
- What this project offers: Separates repetitive page choices into decision steps while reusing the browser connection.
- Project details and fixed source · License: MIT
Jev-cu — A Codex Computer Use loop sending text candidates to Jev while desktop tools observe and act.
- Where Jev makes a decision: Chooses targets and actions and assesses completion and risk; local policy controls execution or confirmation.
- What this project offers: Uses text candidates and starts with a dry run by default.
- Project details and fixed source · License: MIT
omg.dev — An omg.dev mobile testing script can use Jev to read the accessibility tree and choose the next interaction.
- Where Jev makes a decision: Chooses controls and checks completion or blockage before the test runner operates the UI.
- What this project offers: Adds choices grounded in current UI state to mobile testing.
- Project details and fixed source · License: MIT
mobile-jev — Controls an Android phone through Mobilerun, with a web studio and CLI showing Jev decisions.
- Where Jev makes a decision: Chooses apps, controls and next actions from phone state; Mobilerun executes them.
- What this project offers: Records action traces and request latency for inspection.
- Project details and fixed source · License: MIT
jev-voice-browser — Controls a Playwright browser by sending incremental speech transcripts to Jev.
- Where Jev makes a decision: Chooses intent, elements, URLs or verbatim spans and judges command completeness and sensitive actions.
- What this project offers: Shows probabilities, actions and request timing during voice interaction.
- Project details and fixed source · License: MIT
jev-browser — Drives a browser from a task and URL, returning the final page, screenshot and action trace.
- Where Jev makes a decision: Chooses DOM actions and judges goal completion or stalled progress; a separate model can supply typed text.
- What this project offers: Records proposed actions, execution and stop reasons for inspection.
- Project details and fixed source · License: MIT
jev-use — Voice and typed computer use for macOS. You say what you want. Jev picks the next on-screen action. macOS performs it. No screenshots: the app reads the screen through the Accessibility tree.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-voice — Talk to your Mac. Local whisper.cpp + one Jev (TypeSafe) call per command + macOS automation.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-browser — A browser library, CLI and MCP server where the caller supplies goals and text while Jev selects actions.
- Where Jev makes a decision: Chooses elements, actions and values, and assesses completion, errors and irreversible steps.
- What this project offers: Separates browser-action loops from caller planning and returns status and traces.
- Project details and fixed source · License: MIT
typesafe-adblock — An experimental Chrome extension that asks Jev whether candidate DOM elements are ads, then highlights or removes them.
- Where Jev makes a decision: Batches element text, labels, and link information into Noul questions and applies a threshold.
- What this project offers: Shows how semantic judgments can be connected to concrete page elements.
- Project details and fixed source · License: MIT
JevBrowserExt — A Manifest V3 Chrome port of jev-ultrafast: Jev picks the operation and DOM element in one request per step; a small chat model fills TYPE_TEXT.
- Where Jev makes a decision: Chooses CLICK, TYPE_TEXT, SELECT, SCROLL_DOWN, SCROLL_UP, PRESS_ENTER, WAIT, DONE, or BLOCKED and the matching DOM target in one request; PRESS_ENTER is a separate key control. Separate yes/no checks cover goal completion and a stuck loop.
- What this project offers: Runs in the user’s own tabs without screenshots, and keeps the action, target, and typed string inspectable.
- Project details and fixed source · License: MIT
jev-macos-loop — A native macOS automation loop using local OCR and accessibility information with Jev action selection.
- Where Jev makes a decision: Jev selects controls or groups from locally observed candidates; coordinates and input execution stay on the Mac.
- What this project offers: Makes candidate controls and execution checks inspectable, including Finder workflows.
- Project details and fixed source · License: AGPL-3.0
jevfill — Open `test/sample-form.html` in the browser, configure the extension, and click **Autofill page**.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-ego — A browser Agent for ego lite that numbers actionable elements for Jev to choose the next step.
- Where Jev makes a decision: Jev selects an operation and target in one request; a separate helper handles free-form text when needed.
- What this project offers: Offers observation, suggestions and execution, while uploads and dialogs still require other browser tools.
- Project details and fixed source · License: Not declared
jev-agent-browser — Fast, bounded browser agents powered by Jev and agent-browser — typed actions, research, classification, and safe orchestration.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
CUA-JEV — The [experimental open-task paths](docs/OPEN_TASKS.md) separate model planning from Jev's typed action selection. They discover browser DOM elements or Windows UI Automation controls dynamically and offer grounded structured-tool / physical-GUI alternatives without a site- or app-specific click sequence. A twelve-action browser-to-VS-Code research case now runs end to end with a model and Jev, but **arbitrary-task generalization is not claimed**.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-browser — Playwright browser automation with Jev decisions through a shared CLI, MCP server and TypeScript SDK.
- Where Jev makes a decision: Jev chooses actions, matches form fields or extracts structured content from page observations; Playwright executes.
- What this project offers: Supports persistent sessions and UI readback, which does not by itself prove database persistence.
- Project details and fixed source · License: Apache-2.0
aside-jev — An MCP server and skill adding Jev decisions to Aside browser Agents.
- Where Jev makes a decision: The Agent supplies action candidates; Jev picks an ID, then the Agent executes and verifies it through Aside.
- What this project offers: Keeps choices within an application-owned action table while requiring separate outcome verification.
- Project details and fixed source · License: MIT
AskJev — Connects Agents to a browser over MCP, using Jev to choose page actions with confirmation gates for actions such as payment or deletion.
- Where Jev makes a decision: Selects actions from current page controls and assesses risk and irreversibility.
- What this project offers: Combines automated page actions with user confirmation in one workflow.
- Project details and fixed source · License: MIT
jev-mobile — `jev-mobile` accepts a high-level task, persists it in SQLite, and lets one durable worker execute **observe → normalize → decide → mutate → verify** against a USB-connected Android device. Jev receives concise semantics and technically valid actions; it never generates coordinates, MCP calls, or arbitrary code.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-clerk — A macOS desktop clerk that books supplier invoices: Jev picks each click from a closed action list; a deep model only rewrites the playbook.
- Where Jev makes a decision: POSTs https://api.typesafe.ai/v1/systemone as jev-latest with a closed action Choice each step.
- What this project offers: Screen actions follow Jev's closed choices. Author demo numbers were not retested here. GitHub SPDX is empty; the LICENSE file is MIT.
- Project details and fixed source · License: Not declared
jev-yt-time-saver — This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
computer-use-jev — A Go-based macOS controller that asks Jev to choose controls and actions from the accessibility tree.
- Where Jev makes a decision: Uses window state to select an action, target, text-input need, and completion status.
- What this project offers: Grounds candidate controls in UI snapshots so choices can be inspected.
- Project details and fixed source · License: MIT
jev-playwright — Shrinks Playwright suites in CI by letting Jev select tests related to code diffs.
- Where Jev makes a decision: Reporter inspects included changes, asks Jev which tests to run, and skips the rest.
- What this project offers: Speeds up CI runs and saves resources with transparent, typed selection decisions.
- Project details and fixed source · License: MIT
ego-jev — Drive the ego lite browser with Jev (TypeSafe System One): one indexed element table in, one operation + target out, single process. ~2x faster than a per-step LLM loop in our measurements.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-browser — Browser automation CLI for AI agents, powered by the Jev model's millisecond decisions and near-zero inference costs
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Apache-2.0
jev-mobile — One TypeSafe Jev decision per step over the A11Y tree, executed via ADB. No screenshots and ultra fast!
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-ra — Browser use for coding agents, 3-5x faster than browser-use. MCP server + CLI; TypeSafe Jev decides every step in ~300 ms.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-shield — A Chrome ad-filtering extension that uses Jev to assess promotional intent in feed elements.
- Where Jev makes a decision: Batches candidate DOM elements for TypeSafe and uses Noul probabilities with thresholds to decide which to collapse.
- What this project offers: Adds text-based semantic judgments alongside local ad rules.
- Project details and fixed source · License: MIT
browser-use-with-jev — **Keep Browser Use's execution engine. Move bounded decisions to Jev.**
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-2048-selenium — Selenium 2048 player powered by expectimax search and TypeSafe Jev, with portrait FFmpeg recording.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-browser-local — Run jev-browser on a fully local JEV-style decision engine (no cloud API). Warm-browser fork, VRAM guard, measured benchmarks, run traces.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-browser-qa — Browser QA where Playwright drives and films, and TypeSafe Jev judges. JSON-flow CLI for agents, run dashboard, agent skill.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
sedum — Plain-English browser e2e tests cheap enough to run on every PR. Built on Jev and Playwright, open source, bring your own key.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
ego-jev — Complete browser tasks with Ego Lite and actively call Jev for semantic target selection, filtering, ranking, classification and text evidence judgments.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-browser-pilot — A bounded decision layer for browser and desktop automation: a decision-only model picks one next step; the code owns perception, content, actuation and verification.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-browser-skill — Let Jev, TypeSafe's ~100ms decision model, drive your browser. A plug-and-play skill for Claude Code and Codex.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-browser-skill — Browser use & computer use for coding agents, powered by TypeSafe Jev: calibrated judgments from a System One model, control loop in code. ego lite / Chrome / Safari · CLI + MCP
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jevtest — Plain-English end-to-end tests for Android and iOS apps, driven by TypeSafe's Jev. Deterministic, strict, CI-ready.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
playwright-jev — This tool provides a Node CLI for goal-driven web E2E testing where Jev chooses the next step from a code-generated action space, playwright-cli observes and executes browser actions, and code controls inputs, deterministic assertions, and the final verdict.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
WindowsJev — Token-efficient Windows automation and durable research MCP server for Codex and Claude Code, powered by TypeSafe Jev.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
ego-jev — Connects Ego Lite snapshots and browser actions to a bounded Jev decision loop.
- Where Jev makes a decision: Selects only current snapshot candidates and supported actions; another model can supply typed text.
- What this project offers: Executes against current snapshot references and records step state.
- Project details and fixed source · License: MIT
ego-jev — Drive ego-browser pages with TypeSafe Jev: code builds the allowed actions, Jev picks one, code acts and re-checks.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-demo — A zero-dependency local web demo for TypeSafe's **Jev (System One)** decision model: send a state plus typed questions, get choices, scores and calibrated probabilities back.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-tweet-radar — A Chrome extension that scores each X timeline post with one Jev Noul batch for engagement value and optional tags.
- Where Jev makes a decision: One System One request asks Nouls for worth-engaging plus optional tags such as spam, buzz, and AI-ish.
- What this project offers: Turns timeline filtering into inspectable probabilities instead of generated commentary. Post text is sent to TypeSafe.
- Project details and fixed source · License: MIT
jevaluate — Jevaluate: evaluate before you trust. Field notes, runnable scripts and an agent skill for TypeSafe Jev: gated evals, a browser loop, a product walk with DeepSeek vision, a UI text judge and a first-click tree test. Co-authored with Claude Fable 5.1.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jevis — A Flutter integration_test package that registers allowed UI actions and lets Jev pick the next action and whether the goal is done.
- Where Jev makes a decision: POSTs to /v1/systemone as jev-latest: a goal Noul and a Choice over registered Flutter actions.
- What this project offers: Turns natural-language tests into choices over a closed action list instead of free-form tapping.
- Project details and fixed source · License: Apache-2.0
pi-Jev-browser — Browser and macOS desktop agent for pi: Jev (TypeSafe System One) chooses each action from a structured observation in a bounded, surface-agnostic loop. Isolated Playwright tools, an allow-listed accessibility-tree tool, deterministic selectors, four-tier benchmarks.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Apache-2.0
cline-plugin-jev-browser — A Cline plugin using an isolated Playwright browser and Jev decisions through Vercel AI Gateway.
- Where Jev makes a decision: Jev selects operations from a DOM target table; a separate text model supplies typed text when needed.
- What this project offers: Captures before-and-after screenshots and yields on sensitive actions; completion still needs readback verification.
- Project details and fixed source · License: Not declared
JevFilterForX — A browser extension that scores and filters X posts in real time with Jev, folding low-signal content while keeping it expandable. Without an API key, it defaults to local mock scoring.
- Where Jev makes a decision: Jev classifies posts with Choice, rates signal, actionability and originality with Score, and assigns Noul labels; local thresholds and noise rules decide whether to fold each post.
- What this project offers: Adds scores, labels and adjustable filtering thresholds to the X feed, with reversible folding of posts and their attached media.
- Project details and fixed source · License: Not declared

CLI & Pipelines

JevRev — Your LLM can imagine, write, test, and revise. It should not have to make every cheap routing decision by itself.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
foreman — An independent supervisor loop that reads worker diffs, logs and tests, asks Jev Nouls about stuck / off-track / verify, then applies a Python policy.
- Where Jev makes a decision: AsyncTypeSafeClient.system_one with default jev-latest sends Noul questions for supervision.
- What this project offers: Supervision does not write the worker's code. Distinct from cataloged Shifty-Eye-Games/foreman-jev.
- Project details and fixed source · License: MIT
jev-align — 1. Evaluates the configured dataset and measures uncertainty. 2. Selects ambiguous rows plus a random audit sample for you to label. 3. Uses your accumulated labels and optional rationales to run GEPA. 4. Shows the score, certainty change, and proposed definition diff. 5. Lets you accept, reject, rewind, or resume later.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Apache-2.0
orchestkit — OrchestKit can optionally use Jev to classify coding sessions and set their colors when confidence meets a threshold.
- Where Jev makes a decision: Classifies the first task prompt and branch state by work type; local policy accepts the result or falls back.
- What this project offers: Distinguishes sessions by work type and supports a shadow comparison mode.
- Project details and fixed source · License: MIT
jgrep — Filters text, structured records, functions, and diff hunks against plain-English descriptions using Jev Noul judgments.
- Where Jev makes a decision: Jev judges whether each input unit matches the user description; local code applies the probability threshold and returns matching source material.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-pokemon — Jev, an AI decision model, plays Pokémon Red. It beat the game in 37h 40m.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: GPL-2.0
jev-shell-history — Fish-style Zsh history suggestion tool ranked by Jev, ordering candidate commands from local history based on context.
- Where Jev makes a decision: Packages current command input and historical candidates into a Jev request, ranking the most plausible command for inline suggestion.
- What this project offers: Combines the safety of local shell history with Jev semantic relevance, filtering out stale or risky command candidates.
- Project details and fixed source · License: Not declared
jev-lint — lint text in code by jev scorerer
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
OneJev — 🚀🚀 A multimodal System One decision model that gives calibrated answers to typed questions about screens, photos, video and text in one forward pass.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Apache-2.0
SemDecide — A Python CLI for semantic predicates, routing, scoring and filtering over text or JSONL.
- Where Jev makes a decision: Sends input to Jev and applies local probability thresholds to outputs and exit codes.
- What this project offers: Adds typed decisions to Bash and CI with explicit output and failure states.
- Project details and fixed source · License: MIT
jev-rules — **New in 0.5.0:** [one line under each prompt](#in-the-conversation) names the rules Claude was given and Jev's score for each, and the [rules pane](#the-rules-pane) switches on with one answer: the first time Jev picks a rule, Claude asks whether you want it.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jgrep — grep for what code does, not what it's called. Semantic code search powered by TypeSafe Jev.
- Where Jev makes a decision: Measured (2026-09-19, jev-1.13.0): a 896-chunk TypeScript `src/` tree in 1.8 s for $0.010 (240k input tokens); repeat query 0 s from cache.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
hey-jev — Open, quit, hide, minimise or switch to apps, open a new browser tab or a website ("open youtube.com in Brave"), Mac volume up / down / mute / set, Spotify volume, play / pause / next / previous, dark mode, lock or sleep the Mac. Two things in one sentence work too: "pause Spotify and open Slack".
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-superpowers — Software development framework for coding agents enhanced with Jev for dependency vetting, completion gates, and debugging decisions.
- Where Jev makes a decision: Invokes Jev at workflow checkpoints to evaluate change validity, test sufficiency, and package safety before advancing agent state.
- What this project offers: Constrains coding agent trajectories using fast discrete judgments, preventing hallucinated dependencies and premature task completion.
- Project details and fixed source · License: MIT
jev-test-filter — Score every test against a git diff with Jev, and emit the filter arguments vitest, node:test, Playwright, cargo test and go test already understand
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-skill-suggester — A Python CLI and Codex Skill that recommends a suitable installed skill for the current task using TypeSafe Jev Choice and Noul checks without executing candidate skills.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-calibrate — Jev is the typed-decision model from TypeSafe: it takes a `state` and a set of questions (`noul`, `choice`, `score`) and returns probabilities instead of text. How well a question works depends on its wording, on your data and on the threshold you cut at, and none of the three can be read off a single good-looking answer.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
slop-grader — Rule-based CLI and agent skill that evaluates text and markdown files against custom rulesets for AI slop, grammar, and technical doc quality using Jev scores and line-by-line violation flags, then guides an AI agent to auto-fix violations.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-axi — A CLI for Jev pick, rate, check, rank, triage, and guard tasks, with optional hooks before Agent tool calls.
- Where Jev makes a decision: Converts input state and options into structured questions, returning results or risk scores for local policy.
- What this project offers: Reuses the same decision commands in scripts and Agent workflows.
- Project details and fixed source · License: MIT
jsort — Ranks text along a plain-English criterion using pairwise Jev Noul comparisons and a locally fitted Bradley-Terry scale.
- Where Jev makes a decision: Jev judges whether text A ranks higher than text B on the supplied criterion; local code schedules comparisons and fits a Bradley-Terry scale with standard errors.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-yaba-wechat — This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-cli — The jevctl command-line tool connects verification, classification and scoring questions to text input and scripts.
- Where Jev makes a decision: Sends input and bounded answer options to Jev, then reports judgments and probabilities using local thresholds.
- What this project offers: Provides structured results for pipelines and CI, with request inspection and dry-run support.
- Project details and fixed source · License: MIT
jev-blindspot — A side panel for Claude Code and Codex CLI that shows the blind spots of each prompt you submit: what the request would have needed to consider and shows no sign of. Jev decides, in one call per prompt, whether the prompt is worth a second look; only then does the agent's own headless mode read the project and return the items. Nothing blocks the prompt, nothing is added to the session.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-code — An experimental coding CLI where Jev selects AST productions for Python or Bash, with a separate command-line decision mode.
- Where Jev makes a decision: Chooses from bounded syntax and action options; local code constructs programs or invokes tools.
- What this project offers: Shows coding choices and command-line judgments in inspectable traces.
- Project details and fixed source · License: Not declared
jevyoumean — Unlike an edit-distance `Did you mean?`, `jym` matches on *intent*: it hands Jev the candidate subcommand names plus their help descriptions. `remove → rm`, `list → ps`, `undo → restore` are close in meaning but far in spelling — that is the gap this experiment targets.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-cli — A CLI and stdio MCP server for typed Jev judgments over text or JSON.
- Where Jev makes a decision: Submits noul, choice and score questions and emits JSON or a primary value.
- What this project offers: Accepts files and stdin for use in shell scripts and MCP clients.
- Project details and fixed source · License: MIT
jevcache — MorrowCache — skip the chat call when the question is the same. OpenAI-compatible proxy. npm: @kushalicious/jevcache
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
rift — An optional TypeSafe decision client in the Rust coding terminal Rift for bounded Jev judgments.
- Where Jev makes a decision: Sends state and typed questions to System One and parses answers for terminal workflows.
- What this project offers: Adds a separate decision interface alongside generative coding models.
- Project details and fixed source · License: MIT
ego-jev — Jev (TypeSafe System One) inner loop for ego-browser — one ~0.4s typed decision per DOM step instead of an LLM turn. Agent skill for ego lite.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
pi-jev-model-router — Route pi prompts to task-appropriate model tiers with TypeSafe Jev typed judgments. Budget-aware, with automatic fallback.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
xscout-jev — xscout works for fields that are active on X: tech, AI, developer tools, crypto, finance, media, politics. Some markets barely post there; `validate --online` tells you early when most of the accounts you care about are missing or quiet.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-browse — Fast, cheap browser sub-tasks for Claude and other agents: TypeSafe Jev decisions on top of browser-harness
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jevsearch — Site search that understands the question. Ranked by TypeSafe's Jev model.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
typesafe-jev-incident-router — Confidence-gated incident routing with TypeSafe Jev
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-agent-tools — Jev transport/provider layer: multi-provider transport layer that supports fail-closed validation. Used by jkudish/jev-browser and jkudish/jev-mcp.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
prompt2jev — Agent skill and CLI that turn natural language, an LLM prompt, or the code that runs one into a TypeSafe Jev decision: typed state, Choice/Score/Noul questions, and a runnable script
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
tryjev — A playground for Jev, TypeSafe AI's fast decision model: preset scenarios on the left, an editable state plus typed questions in the middle, typed answers with probabilities on the right. Bring your own key and pick a provider: OpenRouter (`typesafe/jev-1.13`, `alpha.decisions`), Vercel AI Gateway (`typesafe-ai/jev`, AI SDK `experimental_evaluate`) or TypeSafe's own API (`jev-latest`, `POST /v1/systemone`).
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
Jev-Desktop — Jev Desktop lets AI agents use Windows applications through MCP or the command line. Hand off a task and let Jev observe windows, choose controls, type supplied text, and navigate locally. Your agent gets the result or a request for help instead of handling every click.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-linkedin-slop-filter — Judges every LinkedIn post as it scrolls into view and slams a rubber stamp on it — **BAIT**, **CORP**, or **BRAG** — with the confidence score printed on the stamp. The post stays readable underneath.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-oas-sentinel — JEV never writes a review or changes a specification. It returns typed decisions and probabilities; deterministic Python code decides whether to pass, request review, or block.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Apache-2.0
jevmetrics — Use it to assess unfamiliar instrumentation, review candidates for reduced retention, and selectively filter metrics before they reach a primary backend. Inference runs asynchronously, and cached assessments let subsequent batches use the same decision without another API call.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Apache-2.0
Jev_Onco_Statistical_Hierarchy — New prepares use `molecular-origin-v6`. The Choice, the two gated checks, and five boundary checks share the evidence and cannot read each other's answers. Boundary answers are reported with the result. Gates still use the leading score, its margin, sufficiency, and conflict. The parent of the leading class is a local lookup on the taxonomy. A request may use Jev's window: 64k tokens for the call, and 32k for the evidence plus the longest question.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-assist — Don't burn your expensive main model on grep-and-guess grunt work — let jev rank the whole repo, and save the main model for reading the right files and writing the right code.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-demo — This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-mode — I kept watching coding agents burn context on decisions that aren't hard - triage 400 tickets, tag 600 files, route to one of six teams. jev-mode moves those verdicts to a typed-judgment model. I A/B'd it: 78% fewer tokens, 16x less work-attributable input, accuracy 96.1% vs 93.7%. Python, no deps, MIT.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jevcut — Auto-clipper that turns long videos (podcasts, talks, essays, comedy) into short standalone clips for Shorts, Reels and TikTok. Code lists every possible cut; an AI judge picks where each clip starts and ends. Benchmarked on 38 hand-labelled videos.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jevopt — Making intelligent compiler optimisation decisions with Jev
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: GPL-3.0
TypeSafe AI Playground — Rust CLI experiments for health-information screening, comment review, tone analysis and business or occupation classification.
- Where Jev makes a decision: Sends text to Jev for separate Noul probabilities, scores or category choices.
- What this project offers: Offers a terminal interface for inspecting structured judgments.
- Project details and fixed source · License: MIT
hermes-jev — Hermes Agent plugin: route each turn to the one skill that fits, via TypeSafe Jev on the Vercel AI Gateway. Fail-open, opt-in, stdlib only.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-cli — A CLI for asking Jev classification, yes/no and scoring questions over text or JSON input.
- Where Jev makes a decision: Evaluates typed questions over one input and returns choices and probabilities as JSON.
- What this project offers: Accepts standard input and supports direct TypeSafe calls or a Vercel gateway.
- Project details and fixed source · License: MIT
jev-cli — A CLI wrapper written in python for Jev
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-handson — Jev 특강 실습 코드(1~3강): TypeSafe Jev를 Claude Code·Codex·OpenClaw에 붙이는 스킬·훅·라우터·활용 예제
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-kiyafet-bul — Kod yerleri: `lib/filtre.ts` (Adım 1), `lib/regex.ts`, `lib/daralt.ts`, `lib/sirala.ts` (Adım 2 + sıralama), `lib/ara.ts` (hat), `lib/jev.ts` (istemci), `lib/kota.ts`, `app/api/ara/route.ts`, `components/` (arayüz).
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-php — `ScoreAnswer::score` is a probability-weighted numeric score across the provided levels.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: LGPL-2.1
jev-qa-demos — Demos for the video "Jev explained for testers": TypeSafe AI's System One model, called through **Vercel AI Gateway** with the AI SDK's `experimental_evaluate`.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-tmmluplus-eval — Jev is not a chat model. You hand it a `state` plus a map of typed questions, and it returns one typed answer each — with calibrated probabilities and **no generated text**.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-tools — Six evidence-oriented tools for pi and omp coding agents, compatible with the Jev API format.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-triage — Message triage CLI in Go, built on the Jev decision model from TypeSafe AI. Categorizes messages, scores urgency, and flags low-confidence ones for human review.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
openjev — Turn any local LLM into a Jev-style System One decision engine: type-safe answers with raw softmax probabilities. 100% offline, zero API cost.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
paper-radar-jev — An automated research paper radar that fetches the latest papers from arXiv, evaluates their relevance to a configurable research profile using TypeSafe AI, and ranks them by relevance score. Designed for personalized, daily literature discovery across different research domains.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
typesafe-jev-calibrate-for-code-review — About calibrating Jev for code reviews
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
claude-jev-funnel — Claude Code plugin + zero-dependency CLI for TypeSafe's Jev: judge items in bulk with calibrated yes/no, pick-one and rubric answers; handle the confident ends in code, review only the uncertain band.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Apache-2.0
codex-jev-preflight — Fail-open Codex UserPromptSubmit hook that injects TypeSafe Jev pre-task routing metadata.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
Jev_steer_or_queue — Let TypeSafe Jev decide whether a message you send mid-turn should steer, queue, or interrupt your coding agent. Claude Code plugin; Codex CLI in testing.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-browser-skill — This Codex Skill lets Codex drive Chrome through Jev to complete multi-step browser tasks from a goal description with preset inputs.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-model-router — Routes prompts to the right Claude tier (Haiku/Sonnet/Opus) using TypeSafe's Jev model
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-router — Route any task to the right AI agent in under 1 second using Jev (TypeSafe System One). Supports Claude, ChatGPT, Cursor, and Antigravity with auto-launch on macOS, Windows, and Linux.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jevault — Jevault suggests existing destination folders. You can explicitly select a suggestion and confirm a manual move of the classified note. Jevault never moves notes automatically.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jevcheck — Probabilities and model versions move. A raw `0.94` is not a release decision. jevcheck records a **production contract** (baseline model + fixtures + expected answers) and evals a candidate against that fixture.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
pytest-jev — Extra state goes in `context`, such as a policy or the documents a RAG app retrieved. A claim can name it in backticks:
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
VideoAdGuard-Jev — This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: GPL-2.0
ask-jev — Ultra-fast, fail-open advisory decisions and verbatim extractive reading view for AI coding agents and CLI pipelines
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: GPL-3.0
Codex_ChatGPT_JEV_Switch — This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
Codex-Jev — VS Code Codex Plugin for Jev-gated tool output integration
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
cursor-clijev-compaction — TypeSafe Jev-scored context recovery for Cursor CLI (agent). Capture tool I/O, score keep/drop, re-inject after native compact.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
fuzzy-jev — Ask Jev typed questions about text and get calibrated probabilities back, then turn them into decisions with fuzzy rules (AND, OR, NOT, hedges, Mamdani outputs) and draw the rule base as SVG. A CLI and a Rust library (native and wasm32).
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
github-star-classifier-jev — Classify your GitHub stars into GitHub Lists with TypeSafe Jev, and review stars worth dropping
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
here-we-go-jev — The smoke test and the experiments call real APIs and cost a fraction of a cent per run. The experiments need the server running.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-arena — That's the whole bot. No code, no coordinates, no if-statements.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-buzzword-rush — A 25-second IT buzzword game to feel how fast and cheap Jev (TypeSafe System One) is — code + Jev only, no LLM.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-console — Jev does not generate text. You send it a **state** plus a set of **typed questions**, and it answers each one with a typed value and a calibrated probability:
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-for-splunk — Splunk app: the | jev search command asks TypeSafe Jev typed questions about your events and adds calibrated probabilities, choices and scores as fields, cached in the KV store.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-frontier-100 — **Jev scores 77.0%; Qwen3.5 2B with a 2,048-token thinking budget scores 82.0%; Qwen3.5 4B with the same budget scores 96.7%.** This small benchmark makes Jev's observed reasoning limits tangible through nine local-model settings.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-gate — This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-local — JEV-Local: System-1 decision engine for local LLMs. Mimics TypefAI JEV: structured choices only, no chatter, calibrated confidence. Works with Ollama, vLLM, llama.cpp, LM Studio.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-route — Async, typed intent & tool routing for Python agents: Jev decides, a confidence gate stops weak decisions before they reach a privileged tool.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-skill — Jev skill for Claude Code and Codex: TypeSafe System One guide, Python CLI, 5 tested recipes, and findings from 19,367 Jev calls.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-skills — Claude Code & Codex skills powered by Jev, TypeSafe's System One model. 256 calibrated judgements for $0.0005 in 0.72s — 360x cheaper than Claude Opus 5. Includes the first published Jev calibration curve, measured on 4,995 real agent decisions.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-switch — This project integrates Jev to provide structured decisions for its workflow. See the repository for implementation details.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Apache-2.0
jev-toto — Counting and comparison happen in Rust, because Jev is documented as unreliable at arithmetic. Jev receives per-number facts plus plain-English labels and answers two questions per number in one request: a yes/no probability for "drawn in the next draw" and a five-level cold-to-hot score with confidence. Module layout and commands are in `CLAUDE.md`.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-zork — Jev (TypeSafe System One) plays Zork I: one Choice per move over Jericho's valid actions, with its confidence on display. French dashboard.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jevcode — This repository provides an Astro-based multilingual documentation site explaining Jev's Choice, Score, and Noul decision primitives with architecture patterns and usage examples.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jevgrep — On the bundled sample (`examples/sample.log`, 200 lines):
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jevkit — Self-hosted Jev (TypeSafe) tools for coding agents: /ask classification and /review diff triage, with CLIs, agent skills, and a Pi tool
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
Jevometry — an Information-Geometric Analysis Toolkit for any System-one (Jev, Jevlike) agent systems
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jevscript — An early language experiment whose current implementation is a Jev request-batching spike.
- Where Jev makes a decision: The script compares separate and batched answers, usage and latency; the full language engine remains a design goal.
- What this project offers: Useful for studying batching, not a completed compiler or interpreter.
- Project details and fixed source · License: Not declared
pr-sieve — A GitHub Action that compiles `.jev.yml` rules into Jev questions and fails, comments, or passes from the numbers.
- Where Jev makes a decision: Rules become at most twelve questions (`MAX_JEV_QUESTIONS` in src/types.ts). AKIA and private-key armor from src/redact.ts fail locally in src/pipeline.ts with no Jev call.
- What this project offers: Does not write reviews, suggest patches, or approve. Policy is read from the base-ref config.
- Project details and fixed source · License: MIT
r2r-jev — Jev turns unstructured state into typed probabilistic decisions. Evidence Admission decides which observations are eligible to enter governance. R2R turns admitted evidence and events into persistent, replayable relation state.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Apache-2.0
typesafe-jev-plugin — Jev from Typesafe.ai is a "System One" AI model that returns **typed, calibrated judgments** instead of generating text. You define what to classify (a Choice), score (a Score), or verify (a Noul), and Jev returns a structured answer with a probability distribution — fast, cheap, and directly consumable by code.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
typesafe-jev-tools — A Claude Code hook that asks whether the decision you are writing needs a model at all. Includes a measured 149-row comparison of TypeSafe Jev against Claude Haiku 4.5.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
jev-planner — With **N** agents, `--mode ultra` makes **2N + 1** agent calls: drafts, reviews, and final synthesis, plus **N** if Jev requests another review. The default `balanced` makes as few as **N + 1** and never more than `ultra`; `fast` makes **N**, or **N + 1** when it merges. Each Jev evaluation is a separate TypeSafe call.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
slopcheck-jev — A prose linter that catches AI writing tells. Regex settles the 18 a pattern can settle. Jev takes the 15 that need reading, as 15 Nouls in one call, 604 ms median. It ships as a Claude Code `Stop` hook that scores Claude's own output after every turn and warns rather than blocks.
- Where Jev makes a decision: **Deleting a feature made it more accurate.** The first build made a second Jev call to pin each tell to a sentence. Removing it took precision from 0.80 to 0.95 and latency from 1,365 ms to 575 ms. Jev returns typed answers rather than text, so a quote has to come from a second round of typed questions about lines, and that round was where every defect lived. The README documents the two intermediate designs that were worse.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT

Classification

typesafe-jev-workflow — An async LangGraph example that classifies mocked emails as invoice-related or general.
- Where Jev makes a decision: Jev returns invoice or general; graph nodes choose the corresponding demo handler.
- What this project offers: Separates model classification from local workflow routing.
- Project details and fixed source · License: Not declared
jev-tree — A hierarchical selector that asks Jev to traverse branches when a catalog has too many options for one question.
- Where Jev makes a decision: Selects one branch at each level and continues until it reaches a final candidate.
- What this project offers: Returns the selected path without silently truncating the tail of a large catalog.
- Project details and fixed source · License: MIT

Code Navigation

jevgrep — Find code by asking what it does. A CLI for coding agents that uses Jev to discover relevant files and source context with exact excerpts and line numbers.
- Where Jev makes a decision: Jev evaluates source declarations across directories and files to decide relevance, implementation scope, and referenced symbols for natural-language behavior queries.
- What this project offers: Zero embeddings or index required; returns relevant files, reading leads, and verbatim source excerpts in one stdout response, saving ~30% cost on agent benchmarks.
- Project details and fixed source · License: MIT
celesto — A Celesto PR-review example prepares sandbox checks and compares a general model with Jev on candidate findings.
- Where Jev makes a decision: Judges whether a finding was introduced by the change, is supported and merits a fix.
- What this project offers: Shows execution records and reviewer judgments together.
- Project details and fixed source · License: Apache-2.0
Jev Review — Reviews a Git diff or a codebase in stages and displays review leads in a local dashboard.
- Where Jev makes a decision: Judges risk, files, evidence regions, mechanisms and severity before rule-based reviewer routing.
- What this project offers: Connects review leads to concrete code for human inspection.
- Project details and fixed source · License: MIT
neo4jev — Navigates a Neo4j graph one hop at a time, asking Jev which relationship to follow next.
- Where Jev makes a decision: Choice scores neighboring relationships and Noul checks goal completion; local beam search retains candidate paths.
- What this project offers: Connects a natural-language goal to inspectable graph paths.
- Project details and fixed source · License: MIT
jev-code — Helps coding Agents locate code, check change intent, triage test failures, and organize review findings.
- Where Jev makes a decision: Selects a fixed workflow and makes structured judgments over bounded diffs, code, or log excerpts.
- What this project offers: Returns inspectable leads and states which parts were not checked.
- Project details and fixed source · License: MIT
jevgrep — Jev-powered semantic code search for coding agents — find behavior across repositories via CLI or MCP, with exact source excerpts and line numbers.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT
Blink — Finds files from a natural-language query using multiple walkers through the directory tree.
- Where Jev makes a decision: Jev scores file and directory names; code distributes walkers using those probabilities.
- What this project offers: Searches without a vector index and reports the share of walkers reaching each path.
- Project details and fixed source · License: Not declared
commit-miner — Classifies Git commit messages and diffs with Jev for bug fixes, security fixes, CWEs, and change types.
- Where Jev makes a decision: Asks fixed-category questions about commits and saves results for filtering and HTML/CSV reports.
- What this project offers: Organizes large commit histories into records for further review.
- Project details and fixed source · License: Not declared
jev — A Go Claude Code plugin using Jev to find files, answer bounded questions across code and handle large reads.
- Where Jev makes a decision: Screens and verifies code relevance before whole files enter the agent context.
- What this project offers: Returns file locations and judgments for focused inspection.
- Project details and fixed source · License: MIT
claude-jev — Adds Jev checks to Claude Code review findings, debugging hypotheses, design options and search results.
- Where Jev makes a decision: Scores candidate defects, explanations or options against preset questions and local policies.
- What this project offers: Keeps a second judgment and its probabilities available for comparison.
- Project details and fixed source · License: MIT
leanest — Adds Jev-based selection before an existing test runner using diffs and test source.
- Where Jev makes a decision: Jev judges relevance; local policy runs tests on uncertainty, API failure or changes to the test file itself.
- What this project offers: Supports shadow-mode comparison, but selected subsets cannot guarantee complete regression coverage.
- Project details and fixed source · License: MIT
PiJ — A Pi-based terminal coding Agent whose main model handles reasoning, edits and tools while Jev provides advice.
- Where Jev makes a decision: Jev suggests skills, reranks actual source candidates and triages failures without automatic retries or permission approval.
- What this project offers: Preserves paths, line numbers, source and errors; the author’s bounded experiments do not establish universal gains.
- Project details and fixed source · License: MIT
jev-review-action — A configurable GitHub Action that reviews catalog submissions or classifies PRs and updates a templated comment.
- Where Jev makes a decision: Answers policy questions over pinned repository evidence or PR patches, then applies classification rules.
- What this project offers: Keeps question definitions, thresholds and comment templates inspectable.
- Project details and fixed source · License: MIT
jev-graphrag — Small demos + use-case backlog: TypeSafe AI's Jev as a calibrated decision layer for GraphRAG pipelines on Neo4j.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jev-prompt-enhancer — Enhance your prompts using Jev by giving your coding agent a clearer task before it writes the first line.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: Not declared
jevex — One MCP tool that returns the files a coding agent should read.
- Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
- What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
- Project details and fixed source · License: MIT

Context GC

fast-jev-compaction — Prunes old tool calls and outputs for Claude Code while retaining surviving text verbatim.
- Where Jev makes a decision: Separately judges whether a tool call and its full output are still needed; code keeps, truncates or drops them.
- What this project offers: Avoids rewriting paths, commands and errors into a new summary.
- Project details and fixed source · License: MIT
jev-pruner — A Claude Code output-pruning plugin filtering selected Bash output before it reaches the main model