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.
- Where Jev makes a decision: After length and content checks, Jev judges which chunks to retain while original output is archived.
- What this project offers: Short output, errors and recognized structured or source content pass through unchanged.
- Project details and fixed source · License: MIT
Jev-Mem — **Better memory for long-running AI agents—with fast decisions and focused reasoning.**
- 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
Winnow — A context filter for Claude Code that hides irrelevant tool-output blocks and keeps the original text available for recall.
- Where Jev makes a decision: Jev scores whether Read, Bash and Grep output blocks are needed; local thresholds keep relevant or uncertain blocks.
- What this project offers: Reduces visible output while retaining a way to retrieve hidden text.
- Project details and fixed source · License: MIT
bluenoise — An X/Twitter filtering extension using local rules by default, with optional Jev checks for unmatched replies.
- Where Jev makes a decision: When experimental AI is enabled, Jev evaluates replies missed by rules and local thresholds decide whether to hide them.
- What this project offers: Applies reversible local rules first and adds model judgment only when requested.
- Project details and fixed source · License: MIT
jev-use — Claude Code / Codex / pi plugin that hands agent steps needing no text output to Jev (TypeSafe's judgment model) — measured p50 ~230 ms and ~$0.02 per 1,000 judgments, with typed escalation back to the 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-recall — Retrieve by relevance, not resemblance: filter an AI assistant's memories with TypeSafe's 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
yoshi — Context-pruning proxy for Claude Code and Codex, employing Jev to prune redundant history while keeping tool protocols intact.
- Where Jev makes a decision: Intercepts request payloads and uses Jev to score historical messages, discarding outdated tool noise before forwarding to upstream LLMs.
- What this project offers: Decreases input token counts and time-to-first-token while preserving protocol compliance with client tool calling standards.
- Project details and fixed source · License: MIT
elons-job — Local-first Chrome extension that uses Jev to filter sexual and solicitation content in X replies with reversible hidden placeholders.
- Where Jev makes a decision: Scores X reply text with Jev Noul questions for sexual content, solicitation, and spam, then combines probabilities with local thresholds and structural signals.
- What this project offers: Combines local rules, caching, concurrency and cost controls, and fail-open handling; it requires no X API and keeps hidden comments recoverable.
- Project details and fixed source · License: MIT
jevlogs — Adds Jev diagnostic-value, priority and routing signals to OpenTelemetry logs before deeper analysis.
- Where Jev makes a decision: Scores log records and judges whether they merit further model analysis.
- What this project offers: Can annotate records while preserving the existing archive path.
- Project details and fixed source · License: MIT
azdaja — Bare, open-source RLM layer for existing coding agents
- Where Jev makes a decision: Jev receives selected source material and explicit questions. It can rank passages, classify records, assess whether evidence supports a claim and judge whether records match for semantic joins. Its returned probabilities let the RLM compare results and decide what to inspect, combine or explore next.
- 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-chat-for-twitch — Filter any live Twitch chat with Jev: a bring-your-own-key Chrome extension
- 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-fast-jev-compaction — A Pi extension that prunes stale tool history verbatim and falls back to Pi summary compaction when needed.
- Where Jev makes a decision: Judges whether calls and outputs should survive in the context sent to the model.
- What this project offers: Retains the original session file and records pruning decisions.
- Project details and fixed source · License: MIT
omp-jev-compaction — An Oh My Pi extension that prunes tool history verbatim and reuses decisions to limit prefix rewrites.
- Where Jev makes a decision: Jev judges tool-call and output utility; the extension truncates selected content with recovery notes.
- What this project offers: Remembers pruning decisions and reapplies them across requests.
- Project details and fixed source · License: MIT
fast-dev-compaction — Codex plugin for context compaction, using Jev within session lifecycle hooks to preserve essential history while pruning noise.
- Where Jev makes a decision: Assesses past conversation turns with Jev when context limits approach, selecting critical tool outputs and user requirements for retention.
- What this project offers: Avoids blanket truncation or lossy re-summarization by selectively preserving exact code locations and decision traces.
- Project details and fixed source · License: MIT
jev-skill-gate — Ranks Claude Code skills for the current project to reduce the descriptions loaded by default.
- Where Jev makes a decision: Assesses skills against the project stack, directory, and README before adjusting description visibility.
- What this project offers: Keeps relevant descriptions while preserving manual access to other skills.
- Project details and fixed source · License: MIT
pi-jev-context — Model performance first. Token savings second. A Pi extension with freshness-aware read dedupe, Jev log filtering, and searchable verbatim recall. Keeps existing message history intact.
- 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 — Skills without the context tax. Claude Code and Codex plugin: TypeSafe's Jev decides on every turn which skills the model sees. Always-on context cost: 0 tokens.
- 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
deepseek-harness-jev-pre-compaction — A pre-compaction advisor for DeepSeek Harness. Runs before the standard `compaction-basic` backend, using TypeSafe JEV to safely prune low-value tool results from model context. Original session events stay in the append-only log; only the model-visible view is replaced with compact markers or archive pointers to reduce context bloat.
- 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
jevbrief — [Adapters](#adapters) · [Quick start](#quick-start) · [Game demo](#watch-jev-play-a-game) · [Python](#use-it-in-python) · [Viewer](#see-every-decision) · [How it works](#how-it-works) · [Benchmarks](#benchmarks) · [Build an adapter](#build-your-own-adapter) · [Contributing](#contributing)
- 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
your-signal — A BYOK Chrome extension using Jev to score X posts against personal preferences and adjust their display.
- Where Jev makes a decision: Scores relevance, substance, usefulness, and promotion; local weights and thresholds control highlighting, collapsing, or hiding.
- What this project offers: Makes personal feed rules adjustable and display changes reversible.
- Project details and fixed source · License: MIT
alphaoptimizer — AlphaOptimizer is an open-source tool from AlphaTales that helps Codex work with large command and tool outputs. Instead of sending a huge log or search result straight into the context window, AlphaOptimizer keeps the useful parts visible, keeps the original output available for a limited time, and uses Jev to help rank what matters when an API key is configured.
- 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-compaction — Curates Codex handoff context by using Jev to select old tool records while retaining selected text verbatim.
- Where Jev makes a decision: Judges relevance of eligible read-only tool records; local rules protect required content and assemble a handoff packet.
- What this project offers: Preserves source references, selection reasons, and original text order in the handoff.
- Project details and fixed source · License: MIT
jev-compaction — A context compactor that can only score, never write — so an agent's memory can't hold a fact the transcript never contained. Working demo, runs offline.
- 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-compaction — Automatic Jev context clearing for Pi. Keep the conversation, prune stale tool output, retrieve originals without rerunning commands.
- 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
fast-compaction-dsh — Verdict-based context compaction for DeepSeek Harness — replaces lossy LLM summaries with fast keep/truncate/drop decisions from jev-latest; everything kept stays verbatim. Port of tamaratran/fast-jev-compaction.
- 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
jevskill — Teach your coding agent to stop burning context. Jev (System One) via OpenRouter or TypeSafe: 325ms, 0.000013 USD per decision. A/B tested 99.3% fewer input tokens with accuracy up. Ships a reversible reduce and a ledger that learns when Jev pays off.
- 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-carryforward — What your last session knew, scored against what this one is doing. MCP server: a per-project ledger written as things happen, recalled per task with TypeSafe's Jev evaluation model via Vercel AI Gateway.
- 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-selection — Pre-message hook: use TypeSafe Jev to keep/drop skills and shrink agent context
- 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
jeverifier — JeVerifier: cheap Jev (TypeSafe) checks that keep code maintainable and docs consistent, plus context retrieval — modest token savings
- 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-fast-jev-compaction — Fast JEV compaction extension for pi
- 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-context — A reversible Pi context filter using Jev to judge whether older messages remain useful.
- Where Jev makes a decision: Scores historical fragments and hides low-scoring content from future requests while preserving session history.
- What this project offers: Disabling restores full context; enabling sends selected history to TypeSafe.
- Project details and fixed source · License: MIT
dsh-jev — This DeepSeek Harness plugin sends each round's latest user message to the systemone (Jev) API for emotion and intent classification and injects the result as plugin-sourced runtime context, with API Key and all parameters configured in the GUI settings 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-context — A Codex search plugin that filters ripgrep passages through Jev before returning relevant code.
- Where Jev makes a decision: Judges passage relevance and withholds No and Unknown results.
- What this project offers: Records paired payloads for measuring returned text under a named tokenizer.
- Project details and fixed source · License: MIT
jev-inbox-queue — Turn an inbox into a short action queue with Jev (TypeSafe System One)
- 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-toolspace — Jev answers yes/no (`noul`) questions about a shared state and returns an independent probability for each one. One API call scores every tool in a menu with one question per tool, and a tool's score does not compete with the others.
- 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
openclaw-jev-compaction — Verbatim context compaction for OpenClaw: a context engine powered by TypeSafe's Jev. Drops stale tool calls and results, never summarizes.
- 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-compaction — Extractive context compaction for Pi that keeps selected original tool records instead of generating a summary.
- Where Jev makes a decision: Jev judges complete read-only tool pairs; local code removes those rated unnecessary.
- What this project offers: Preserves original evidence and Pi’s recent-message boundary.
- Project details and fixed source · License: MIT
pi-observational-memory-jev — Jev decides what to keep. Compaction never rewrites the transcript.
- 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
fast-jev-compaction-pi — This Pi extension asks Jev whether each completed tool call and its full result should be kept, then locally retains, truncates, or drops verbatim tool evidence in the compaction summary.
- 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.tg — Local Telegram filter stores channel messages locally and sends them in batches to Jev or a local model to keep only messages matching natural-language conditions.
- 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
pi-jev-compact — A Pi context-pruning extension targeting tool history by default, with optional assistant-prose pruning.
- Where Jev makes a decision: Jev judges which candidates remain useful; surviving text is returned verbatim.
- What this project offers: Provides configurable pruning scope and decision records.
- Project details and fixed source · License: Not declared

Creative Tools

json-render — A Jev UI-composition experiment inside the json-render website that selects from predefined component and property options.
- Where Jev makes a decision: Evaluates component configurations through Vercel AI Gateway, then composeSpec assembles the UI specification.
- What this project offers: Provides an inspectable composition path alongside token-by-token JSON generation.
- Project details and fixed source · License: Apache-2.0
youtube-sponsor-detection — YouTube extension detecting sponsored segments from live audio and transcripts using Jev, skipping promotional blocks automatically.
- Where Jev makes a decision: Inspects transcript segments with Jev to identify sponsor reads while browser code handles playback timeline skipping.
- What this project offers: Identifies promotional reads on newly released videos immediately without waiting for crowdsourced segment submissions.
- Project details and fixed source · License: Not declared
jevmeter — Creates edited videos with score meters by asking Jev to rate transcript sentences against selected rubrics.
- Where Jev makes a decision: Scores transcript sentences with preset questions and scales for meters placed on the video timeline.
- What this project offers: Aligns sentence scores with the corresponding video segments for review.
- Project details and fixed source · License: MIT
jev-cookbook — 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-paint — Requires Python 3.9+ and a modern browser with module workers and OffscreenCanvas (current Chrome, Edge, Firefox, or Safari). No packages, build step, or Node installation needed.
- 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
vibecheck — Shows a Jev scorecard before posting on X, assessing draft clarity, tone, and possible offensiveness.
- Where Jev makes a decision: Sends the draft and reply or quote context to Jev for multiple scores and a posting suggestion.
- What this project offers: Collects several perspectives on a draft before it is sent.
- Project details and fixed source · License: Not declared
refgarden — A visual-reference gallery drawing from The Met, NASA and Cosmos, with Jev in local Explore mode.
- Where Jev makes a decision: Jev selects search phrases and highlights references using titles and descriptions, not image pixels.
- What this project offers: Keeps source links; the public search demo does not call Jev and is not evidence of visual clustering.
- Project details and fixed source · License: MIT
snifftest — A Markdown and plain-text prose linter using local rules and optional Jev judgments.
- Where Jev makes a decision: Assesses paragraphs against style rules such as redundant closings, clichés and excessive hedging.
- What this project offers: Reports files, lines and rules while leaving revision to the author.
- Project details and fixed source · License: MIT
jevthoven — Turns a music prompt into editable multitrack MIDI by asking Jev to choose instruments, harmony, and bar patterns.
- Where Jev makes a decision: Selects form, instruments, chords, and rhythm candidates; local code renders the choices as notes.
- What this project offers: Preserves editable tracks and decision receipts with playback and MIDI export.
- Project details and fixed source · License: MIT
slidepilot — Voice-driven semantic auto-advance controller for Slidev presentations powered by Cloudflare Agents and TypeSafe Jev.
- Where Jev makes a decision: Analyzes live speech transcripts with Jev to judge whether the current slide's topics are covered, triggering slide transitions.
- What this project offers: Enables hands-free slide navigation by combining semantic completion checks with manual safety overrides.
- Project details and fixed source · License: MIT
jev-cookbook — The complete cookbook for Jev by TypeSafe AI — 120+ use cases, 10 runnable examples, 4 composition patterns, and first-principles theory for the world's first System One AI 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
ui-generator-instinct-jev — Turns UI descriptions into selections from existing shadcn/ui components, fields and styles.
- Where Jev makes a decision: Breaks requests into choice and score questions and maps answers to a bounded component catalog.
- What this project offers: Demonstrates UI composition through decisions; Jev itself does not generate page code or copy.
- Project details and fixed source · License: Not declared
ComfyUI-Jev — Custom nodes for using Jev's text interpretation and judgments in ComfyUI. Use natural-language instructions to select candidates, evaluate conditions, score text, or extract numbers, then pass the results to other nodes. Jev judgments use the TypeSafe API by default.
- 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-in-blender-experiment — Blender exposes ~2,500 operators; a TypeSafe `Choice` question holds at most 255 options, so the search is hierarchical (two requests per search):
- 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-windows-agent — Windows UI Automation extension of arc-cua: a fast, JEV-powered decision loop for desktop computer-use agents
- 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
emoji-jev — The app sends typed text to Jev to get parallel emoji Choice, emotion Choice, Score, and Boolean results displayed as an emoji keyboard.
- 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-riffs — Music pattern ripper: MIDI → interval tokens → code mines candidate motifs → Jev (TypeSafe System One) grades their significance. Web UI with piano roll, click-to-play, WAV export.
- 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
bes-kelime-jev — Jev bir sohbet modeli değil, **evaluation** modeli. Serbest metin üretmez; tipli sorulara `choice` / `score` / `boolean` cevapları döner. Bu, "sadece şu 5 kelimeden birini söyle" kısıtını *prompt'la rica etmek* yerine **tip sistemiyle garanti altına almayı** mümkün kılıyor: model 5 kelimenin dışına çıkamaz, çünkü API'nin döndürebileceği değerler bunlar.
- 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 — Constructors build reusable questions locally. `Ask` calls Jev; `Resolve` applies your confidence threshold locally. Choose thresholds using your own evaluation data.
- 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-got — A Game of Thrones text-adventure demo where a language model writes the story and Jev labels the scene.
- Where Jev makes a decision: Classifies location, narrative beat, mood, danger and whether text remains in fiction.
- What this project offers: Uses explicit scene state to drive backgrounds, music and the next turn.
- Project details and fixed source · License: Not declared
jev-music-theory-1 — Explores Jev on harmony exercises and music-theory questions, alongside a piano demo driven by chord choices.
- Where Jev makes a decision: Chooses voices, pitches, durations, or chords; code grades exercises or synthesizes playback.
- What this project offers: Puts music-theory tests and an audible composition experiment in one project.
- Project details and fixed source · License: Not declared
jev-paste — Contextual, inline clipboard decomposition for macOS — Tab-to-paste with full history and time-decay ranking. Powered by TypeSafe JEF.
- 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-playground — Can a System One model steer music? Jev picks the plan (enums only); code renders sheet, audio and MIDI.
- 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
jevspeak — Jev can't generate text. So I made it talk anyway. A conversational interface built from probabilistic decisions and a deterministic language compiler — no generative 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
let-jev-speak — TypeSafe's `/v1/systemone` endpoint classifies text — it returns a `choice`, a `score`, or a probability. It does not generate prose. This library makes it generate prose anyway: every word of the answer is a separate `choice` question over a vocabulary, and the loop feeds its own output back in as the prefix.
- 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
voicevox-jev-proxy — 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-esketcher — Generative painting canvas where Jev, TypeSafe's calibrated decision model, picks paint materials and colour palettes for 105 procedural sketches. FastAPI + React + TypeScript.
- 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
1-million-emojis — A shared 1000 × 1000 emoji canvas where humans paint and Jev paints alongside them: after each stroke, one Jev request chooses which emoji goes next to it and where, from typed options named against the stroke, and says whether the stroke is an unfinished shape.
- 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

Data & Search

deep-searcher — Open Source Deep Research alternative with Jev search-stopping evaluation.
- 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
GPTCache — Semantic cache with a Jev evaluator that uses Noul judgments to check whether a cached response can serve an incoming request.
- 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
memsearch — A persistent, unified memory layer for all your AI agents (e.g. Claude Code, Codex, DSH), backed by Markdown and Milvus.
- 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
bootcamp — Runnable search tutorials using Gemini embeddings, Milvus retrieval, and Jev judgments for reranking, filtering, and routing.
- 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
kody — Optional second-stage search: widen the hybrid pool, then Score-rerank candidates with Workers AI typesafe/jev.
- Where Jev makes a decision: Sends a Score question per candidate, reorders and drops low scores; the model id is typesafe/jev.
- What this project offers: Attaches Jev rerank to existing MCP search instead of replacing retrieval. License is Fair Source FSL-1.1-ALv2, not OSI open source.
- Project details and fixed source · License: Not declared
jev-search — Searches the web with Jev choosing sources and time ranges, then ranking returned links.
- Where Jev makes a decision: Judges search intent, source and time settings, and relevance of individual results.
- What this project offers: Keeps links, snippets, editable filters and source-failure warnings visible.
- Project details and fixed source · License: MIT
pg-jev — Adds natural-language filtering, classification, and ranking of rows to PostgreSQL queries.
- Where Jev makes a decision: Sends row content to Jev for a match decision, category, or score used by SQL conditions and ordering.
- What this project offers: Combines semantic conditions with existing SQL and reuses cached results.
- Project details and fixed source · License: Not declared
vector-graph-rag — Graph RAG with pure vector search, achieving SOTA performance in multi-hop reasoning scenarios.
- 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-semgrep — A semantic grep that scores each line with Jev against a meaning, including AND/OR/NOT and cross-language queries.
- Where Jev makes a decision: Batches about thirty lines and asks jev-latest a Score or Noul per line for the stated meaning.
- What this project offers: A zero-runtime-dependency semantic grep; query text is sent to TypeSafe.
- Project details and fixed source · License: Not declared
jev-curate — A Rust dataset-filtering experiment using Jev scores to keep or reject text records.
- Where Jev makes a decision: Runs local prefilters, calls TypeSafe and applies probability and score thresholds to each record.
- What this project offers: Provides local prefilters and score thresholds for experimenting with per-record data pipelines.
- Project details and fixed source · License: MIT
pg_typesafe — A pre-alpha PostgreSQL C extension for calling Jev from SQL for classification, yes/no judgments, and scoring.
- Where Jev makes a decision: Converts SQL input into System One requests and returns answers through database functions.
- What this project offers: Adds typed semantic judgments to existing database queries.
- Project details and fixed source · License: MIT
jev-dataops — An open-source JEV-powered workbench for streaming data selection, quality evaluation, automatic LoRA training and held-out model evaluation.
- 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
milvus-model — A library integrating embedding and reranker models from OpenAI, SentenceTransformers etc for semantic search in vector database.
- 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
laya-jev-GraphRAG — Agentic GraphRAG engine using swappable System One decision models (local Laya / cloud Jev). Features a complete 4-phase pipeline (Ingestion, Pre-Retrieval, Traversal, Post-Retrieval) and evaluation across Neo4j, Memgraph, Apache AGE, and Kùzu driven by a custom A* traversal algorithm.
- 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
polar_llama — A Polars library for parallel provider inference that also calls Jev per row as Noul, Choice, and Score questions, or as one typed contract over a document.
- Where Jev makes a decision: One System One request per row: Noul, Choice, or Score answers land as ordinary typed columns with confidences.
- What this project offers: Puts closed-set Jev answers on existing Polars columns instead of another chat-completion pass.
- Project details and fixed source · License: MIT
duckdb-jev — A DuckDB extension that calls Jev from SQL and returns answers as ENUM, numeric, or STRUCT types.
- Where Jev makes a decision: Asks Choice, Score, and Noul questions about row text and maps answers to SQL types defined by the questions.
- What this project offers: Uses structured judgments while querying tables or Parquet data.
- Project details and fixed source · License: MIT
jevframe — Semantic AI for pandas and Polars: classify text, analyze sentiment, and score DataFrame rows with natural-language questions and full probabilities using 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
jevql — Adds Jev semantic filtering, grouping, and ranking around ordinary PostgreSQL without installing a database extension.
- Where Jev makes a decision: The CLI or service layer evaluates jev_* calls over row text before completing the query.
- What this project offers: Shares semantic SQL interfaces across a CLI, HTTP, MCP, and SDKs.
- Project details and fixed source · License: MIT
reranker — A Python reranker that packs a query and up to 30 candidates into one Jev state, with one Noul relevance question per document.
- Where Jev makes a decision: One Noul relevance question per document; long lists are chunked and scored, then filtered by threshold or sorted.
- What this project offers: Uses a probability as a threshold or sort key instead of a generative reranker.
- Project details and fixed source · License: Apache-2.0
jev-search-rerank-eval — Retrieval evaluation system measuring Jev reranking against lexical, embedding, and fusion baselines across 9,831 query-document pairs.
- Where Jev makes a decision: Invokes Jev judges to grade multi-level relevance on bilingual queries, evaluating ranking metrics and judge-circularity effects.
- What this project offers: Provides rigorous empirical evidence comparing discrete judgment rerankers against vector search in multilingual discovery contexts.
- Project details and fixed source · License: MIT
jev-bigquery-cloudrun — Classify support tickets in BigQuery with Jev and Cloud Run
- 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
duckdb-jev — High-throughput, robust native DuckDB extension for batched and streaming TypeSafe/Jev classification, scoring, and semantic predicates from SQL.
- 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-rag — Local knowledge search with three modes: BM25 + Jev by default, agentic multi-query lexical search + Jev without vectors, and optional BM25 + embeddings/RRF + Jev, with grounded streaming answers.
- 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
llama-index-jev — Provides Jev rerankers and routers for LlamaIndex to score retrieved passages or select query tools.
- Where Jev makes a decision: Uses Score for passage relevance and Choice for selecting query engines or tools.
- What this project offers: Adds Jev judgments to existing retrieval and query workflows.
- Project details and fixed source · License: MIT
every — Ask a yes/no question of every function in a codebase. Ranked answers in seconds, for cents. Grep whose pattern is a question, powered by TypeSafe Jev.
- Where Jev makes a decision: Converts natural language questions into boolean/probability queries across functions, ranking matches locally by confidence.
- What this project offers: Enables natural language function discovery across codebases at low cost, similar to an intelligent grep.
- Project details and fixed source · License: MIT
jev-harness — A Pi agent harness built around TypeSafe's Jev (System One model): router, context picker, gate, verifier. Tested on Neon Postgres branches.
- 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-papers — 1,000 arXiv AI papers classified with one Jev decision each, checked against an LLM judge. Open rebuild, 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
jev-in-codex — Jev-powered tool and skill selection, context search, and output triage for Codex via 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
jev-search — Experimental semantic line search with TypeSafe Jev via OpenRouter. Python CLI with no runtime dependencies.
- 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
jlink — The string baselines are best-match Jaro-Winkler and best-match TF-IDF cosine; the table shows the better of the two. Exact matching after normalization scores 0.26, 0.41, 0.00, 0.00 and 0.22.
- Where Jev makes a decision: Jev judges whether two candidate records refer to the same entity under a user-supplied match definition; local code generates candidates and resolves accepted matches.
- 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-scout — A repository and Rust crate search tool that asks Jev to score and select retrieved candidates for a request.
- Where Jev makes a decision: Compares candidate information with the request, scores fit and maintenance signals, and chooses a candidate.
- What this project offers: Keeps recommendations tied to retrieved candidates and source links.
- Project details and fixed source · License: MIT
jeveryword — Jev answers multiple-choice questions and does not generate text, so on its own it cannot return a name, an email address or a quote. jeveryword numbers the words of your text, offers those numbers as the answer options, and converts the numbers Jev picks back into the original substring with its character offsets.
- 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
JevFind — Fast semantic code search powered by Jev. Find the relevant files, line ranges, and snippets
- 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
jevpdf — `server/index.ts` is a small Bun server that serves `dist/` and the `/api/jev` proxy, which uses the same forwarding code as dev (`server/jev-upstream.ts`). Because the live proxy spends real credits, it only accepts same-origin POSTs from the app, pins the model, caps request size, and rate-limits each IP.
- 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
jevsql — Adds Jev semantic judgments to SQLite for filtering, ranking, matching and tracking decision evidence.
- Where Jev makes a decision: Sends row data and typed questions to Jev and maps answers into queryable SQL results.
- What this project offers: Provides batching, caching, budgets and decision history.
- Project details and fixed source · License: MIT
jev-reranker — Rerank, filter, and compress JSON search results with TypeSafe AI's 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
jevsql — Text-to-SQL where the model never writes SQL — typed, calibrated decisions (TypeSafe Jev) + code-assembled queries
- 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
hfjev — Classify Hugging Face datasets across typed semantic dimensions with TypeSafe Jev System One. Auto-adapts evaluation rubrics to dataset domains (reviews, news, LLM tuning, support) and classifies rows in a single parallel System One call with calibrated probabilities.
- Where Jev makes a decision: hfjev classifies dataset rows in parallel across typed Choice, Score, and Noul dimensions against TypeSafe System One.
- 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-311-heatmap — The live run excluded 205 reports with missing or invalid coordinates, completed **634 API calls without retries**, and reported **539,979 input tokens**. Repeated descriptions share one evaluation.
- 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-research-pipeline — **Code owns the loop, Jev judges, Qwen writes: a daily research monitor for standing questions.**
- Where Jev makes a decision: For each (fetched source, open research question) pair, Jev answers Noul gates (on topic, method transferable, evidence compatible) and then Score dimensions through Pydantic AI's native `typesafe:` model; deterministic code applies the thresholds and routes each pair to keep / review / drop.
- 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-retrieval — Grep-shaped Rust CLI for coding agents that finds files matching a plain-language concept: a local BM25 pass recalls candidates, Jev verifies each file window-by-window with Noul gates, and one listwise Choice per lane reranks the kept files into `path:line score` output with calibrated probabilities. (Author-submitted: I am the maintainer.)
- 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
jselect — Selects source-linked evidence within a token budget using Jev Noul relevance judgments and local diversity-aware selection.
- Where Jev makes a decision: Jev judges whether each passage is useful evidence for the supplied task; local code selects verbatim passages and citations within the token budget.
- 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-information-extraction — Ask questions about a PDF. Use Jev to rank the source text that answers them. Inspect each match, its probability, and its location on the original 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: Not declared
jev-reviews — The flagship experiment in this workspace is **`jev-reviews`**: an automated pipeline that ingests Google Maps restaurant reviews from **Apify Storage**, stores and deduplicates them in **Supabase PostgreSQL**, and classifies them using **Jev (TypeSafe System One)** or traditional generative LLMs across 5 operational pillars, extracting dishes, customer highlights, and owner recommendations.
- 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
jevtok-ts — **No Python, network calls, API keys, native extensions, or runtime dependencies.** Vocabulary and lookup tables ship inside the package. Ordinary `o200k_base` tokenization is not interchangeable with Jev: `evidence` is three tokens and `2024` is four.
- 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
DataJev — ⚡ DataJev LLM → Analyze Jev → Continue / Switch / Verify / Stop System-1 control for System-2 data agents
- 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
el-jev — High-speed System One decision sidecar & Copilot CLI pre-turn hook powered by Azure AI Foundry Cohere with keyless Entra ID auth.
- 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-bfs — Wikipedia link race pathfinder guided by Jev: assesses outbound links to navigate between two articles in real time.
- Where Jev makes a decision: Applies Jev semantic heuristic scoring and pruning to outbound links at each BFS exploration step.
- What this project offers: Combines classic graph traversal with probabilistic judgments to prune the Wikipedia multi-hop search space.
- Project details and fixed source · License: MIT
JevDeepResearch — GPT directs the research; Jev uses Choice and Noul to locate evidence across document regions concurrently, and code returns original passages for GPT to verify and continue. The released integration pairs Pi-Serini BM25 search with Jev batches of 20, 40, or 60 documents.
- Where Jev makes a decision: Within each supplied source region, Choice selects source-line locations and Noul estimates whether the region addresses each evidence question. Code validates the answers, merges selected ranges, and returns verbatim evidence. Source loading and dependent research steps remain sequential; Jev region requests run concurrently.
- 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
jevsome-projects — A Jev project directory and discovery pipeline that stores integration evidence and can use Jev for classification.
- Where Jev makes a decision: When configured with a key, sends project state and candidate categories to Jev; otherwise uses local classification rules.
- What this project offers: Keeps a project index alongside concrete source evidence.
- Project details and fixed source · License: MIT
sieve — Sieve checks a folder of Markdown notes against itself. Crosscheck compares every note with every other, from both sides, and lists the pairs that contradict each other, the pairs that make the same point twice, and the notes that have gone stale. It also ranks the whole folder by any plain-English question, and lints notes against plain-English rules in CI. No index, no embeddings, no generated text. Node, no dependencies.
- Where Jev makes a decision: Asks one five-way Choice (same, supports, contradicts, topic, unrelated) for every ordered pair of notes, so each pair is judged from both sides; code averages the two probabilities and lists a pair as a contradiction when the average is 50% or more (the default). Ask and lint put one Noul or Score question to each note, and code ranks or gates on the probability.
- What this project offers: Finds the notes in a Markdown folder that contradict each other or make the same point twice, with no index and no embeddings; the cost of a run is estimated before anything is spent, and a run stops when it reaches its budget.
- Project details and fixed source · License: MIT

Decision Tools

killmyidea — A startup-idea evaluation demo assigning KILL, FIX or SHIP labels from Jev scores.
- Where Jev makes a decision: Jev answers scoring, category and clarity questions; local weights and gates calculate the final label.
- What this project offers: Shows a structured assessment process, not market validation, a success forecast or investment advice.
- Project details and fixed source · License: Not declared
jevify — An Agent Skill for finding suitable Jev decision points and designing questions and comparison experiments.
- Where Jev makes a decision: Designs Noul, Choice, and Score question packs for an application, with a script for API-backed case runs.
- What this project offers: Connects integration ideas, question design, and evaluation methods.
- Project details and fixed source · License: MIT
hermes-jev — An asynchronous Jev companion for Hermes Agent covering relevance, completion, recovery and optional admission decisions.
- Where Jev makes a decision: Jev evaluates bounded questions in the background while Hermes retains reasoning and execution responsibilities.
- What this project offers: Records decision provenance and supports configuration that avoids blocking ordinary execution.
- Project details and fixed source · License: MIT
claude-jev — Claude Code plugin: Jev for rule checks, verbatim compaction, and prompt routing
- 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-belay — A Claude Code Stop hook that reads the turn transcript locally and calls Jev only when files changed and no check has passed, blocking an unverified “done”.
- Where Jev makes a decision: Four questions: whether the closing message claims done, claims checks passed, whether verification applies, and a complete / partial / blocked / other choice.
- What this project offers: Skips the model when a check already passed; every error path lets the turn end.
- Project details and fixed source · License: MIT
wechat-jev-assistant — 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-commit — A commit-msg hook that scores the message against the staged diff with one Jev request of five Nouls and warns by default. Default blocking is a local regex belt on high-precision added-line hits; the secret_shaped Noul blocks only with --strict.
- Where Jev makes a decision: Five Noul questions in one request: checkable message, hunk match, debug leftovers, unmentioned work, and credential-shaped added lines. Default blocking is the regex belt; secret_shaped participates only under --strict.
- What this project offers: Turns commit-message review into thresholded probabilities instead of prose; API failures still allow the commit.
- Project details and fixed source · License: MIT
jev-chat-windows-deepseek-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: Not declared
jev-apply — In Codex, Claude Code, or another CLI agent:
- 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-plays-pokemon-red — Pokemon Red on PyBoy where Python owns the route and the arithmetic, and Jev chooses only among legal actions at actual branches.
- Where Jev makes a decision: A Choice over legal actions at each branch; battle turns also ask Noul faints_this_turn and should_flee; failures take the code default.
- What this project offers: The model only picks among code-proven legal moves; a failed call never loosens the script.
- Project details and fixed source · License: MIT
Jev-chat-assistant — 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.nvim — A Neovim plugin that asks a plain-language question of every function in the buffer and lists every Jev hit in quickfix, ranked by probability.
- Where Jev makes a decision: Scores each Treesitter function against the user question, splitting across requests if the buffer does not fit. Every hit is listed in quickfix; only hits at or above the threshold get buffer marks.
- What this project offers: Finds cross-language shapes that grep misses, and lands the ranked hits in the existing quickfix loop.
- Project details and fixed source · License: MIT
jev-skill-router — Claude Code plugin: asks TypeSafe Jev which installed skill fits each prompt and logs the answer (shadow-first). A working reference for the skill-suggestion cookbook on Claude Code — the README records why it is unlikely to help a strong model as a router.
- 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-skip — A browser extension that classifies YouTube caption segments with Jev, splitting requests when the segment or token budget is exceeded, paints five categories on the seek bar, and auto-skips those painted slices over the threshold.
- Where Jev makes a decision: One Choice per caption segment among content, sponsor, intro, outro, self_promo, recap, and other. Painted categories sponsor, self_promo, intro, outro, and recap skip when probability is at or above the threshold; content and other never skip.
- What this project offers: Works on videos nobody has labeled yet; with no captions it does nothing.
- Project details and fixed source · License: MIT
jev-bot — Self-hosted Jev decision workbench and Feishu bot: automatic choices, probabilities, and experimental word/character writing.
- 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
spending-effort-with-jev — Jev-powered /effort advisor for Claude Code: tells you when to switch effort, per prompt
- 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-demos — Every demo lives in its own folder with its own README, dependencies and instructions. Most run without an API key in a clearly labelled `SIMULATED` mode; put `TYPESAFE_API_KEY=...` in the demo folder's `.env` for live results.
- 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-in-the-Loop — Researching how Jev can accelerate tasks that rely on LLM decision-making.
- 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-laya-benchmark — Speed and accuracy benchmark: TypeSafe's Jev API vs the local Laya MLX typed-decision model on synthetic tasks
- 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-predict-skill — An Agent skill recipe that predicts another skill’s closed-set outcome from its rules and evidence.
- Where Jev makes a decision: Jev first assesses whether a closed decision is possible, then selects among the target skill’s outcomes.
- What this project offers: Includes API-call and response-check examples; it predicts the outcome without executing the target skill.
- Project details and fixed source · License: Not declared
astra-jev-harness — The default `batch` policy retains an entire batch when any judgment is uncertain. The experimental `select --policy per-file` retains uncertain/unjudged files while omitting confidently irrelevant siblings. Dependencies and the global no-match fallback still apply. Compare before changing policy; fewer bytes alone do not establish correctness.
- 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
dsh-jev — DSH bundle that registers jev_ask for TypeSafe Jev noul, choice, and score answers.
- 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-chat-gate — A framework-independent participation gate for AI agents in group chats, powered by typed Jev 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: MIT
jev-chat-windows-laya — 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-codex-router-skill — Portable Codex Skill for Jev model and reasoning-effort routing, with safe installation and Chinese usage guides
- 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-nethack — TypeSafe's Jev model plays NetHack 5.0: code lists the legal moves, Jev picks one, no LLM in the loop
- 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-slop-guard — Jev Slop Guard — a Chrome extension that scores and stamps AI slop on your X and LinkedIn feeds as you scroll
- 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 — JevCode - Jev can code. We want to dogfood JevCode
- 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
fake-real-jev — See link entry, the live scan timer, JEV's evidence-checking role, a saved REAL example, a saved FAKE example, and the linked sources. The live documentation scan shown ended without a verdict; its credit was returned. The coffee reports are clearly labeled saved examples, with their original analysis times.
- 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_projects — 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-crawlers — Jev learns your repo's decision norms, then adversarially judges past decisions against them. Unix-style primitives (seed, expand, judge, verify, report, norms) with per-node typed judgments from typesafe-ai/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-demo — Showcase of TypeSafe JEV classifying emails: spam (noul), category (choice) and urgency (score) - Next.js + MUI app and Python 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: Not declared
jev-linter-action — `glob` accepts one pattern or a newline-separated list. All matched files are reviewed together by default; `per-file: true` reviews each file independently. Missing inputs, malformed questions and ambiguous combinations fail before 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-playground — A web playground for entering state and decision questions, then inspecting Jev answers and probability distributions.
- Where Jev makes a decision: Submits multiple Noul, Choice, and Score questions in one request.
- What this project offers: Lets users try questions and answer options before writing application code.
- Project details and fixed source · License: Not declared
jev-triage — Millisecond-class test-failure triage for coding agents: RETRY / FIX_CODE / FIX_ENV, 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
Jevatar — 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
jevchat — A chat-style Jev demo whose answers are selected from predefined or custom options rather than generated prose.
- Where Jev makes a decision: Maps answer styles to Choice options and selects chat titles from fragments of the question.
- What this project offers: Shows answer options and probabilities in a chat UI with customizable answer sets.
- Project details and fixed source · License: Not declared
typesafe-jev-ruby — Ruby client for Jev, TypeSafe's System One model: typed questions, probabilistic answers. Zero runtime dependencies.
- 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
xjevboost — Add as much tabular data as you want to Jev models using adaptive ensembles that learn to query only the rows and columns needed.
- 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-book-tags — A free calibre plugin that suggests genre and subject tags for individual books, selected books or an entire library, with configurable thresholds and review controls.
- Where Jev makes a decision: I maintain JEV Book Tags, an independent, free GPL-3.0-or-later calibre plugin. It was developed with substantial AI assistance and reviewed and tested during implementation. It is not affiliated with TypeSafe AI or calibre; users bring their own API key and external API charges may apply.
- 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-no-enem — Reproducible benchmark evaluating TypeSafe AI's Jev (System One paradigm) on Brazil's ENEM 2025 standardized exam. Evaluates typed decision-making, domain-specific accuracy, and RLCD uncertainty calibration against open LLM baselines with an interactive GitHub Pages 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: Not declared
turing-jail — Interactive three-level AI interrogation game powered by TypeSafe Jev; write responses and pass plea, logic, and paradox verdicts to earn release.
- Where Jev makes a decision: For each level, Jev evaluates release probability plus plea, logic, and paradox signals, then selects a persuasion tactic and scores persuasiveness.
- What this project offers: Turns structured Jev judgments into playable feedback, pass thresholds, and leaderboard results that show how arguments affect release probability.
- Project details and fixed source · License: Not declared

Domain Tools

ai-hedge-fund — An educational AI hedge-fund prototype with an optional Jev adapter for structured judgments in fund decision workflows.
- Where Jev makes a decision: Converts strategy questions to System One requests and normalizes native answers to the project’s result format.
- What this project offers: Allows Jev or other model backends to be used in the same research workflow.
- Project details and fixed source · License: MIT
jev-trader — A market-making experiment on Kuru’s MON-USDC book on Monad, with optional per-block Jev buy/sell decisions.
- Where Jev makes a decision: In Jev mode, order-book judgments feed code that simulates fills or submits configured post-only limit orders.
- What this project offers: Defaults to a mock model and dry-runs without a private key; simulated results do not establish profitability.
- Project details and fixed source · License: MIT
jev-chat-windows — A Windows companion reply assistant that captures WeChat Windows 4.x windows with local offline OCR, uses Jev to judge intent and generate three candidate replies, and fills the chosen text into the WeChat input box without auto-sending.
- 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
tax-doc-classifier — A tax-document page classifier that uses Jev to choose from predefined IRS form and page categories.
- Where Jev makes a decision: Extracts PDF page text and sends it to Jev for form type, page type, and confidence.
- What this project offers: Connects a fixed form catalog to per-page classifications for downstream document workflows.
- Project details and fixed source · License: Apache-2.0
jev-seo — **PDF: how the audit was made, the scorecard and the priorities**
- 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-trade — An experimental Hyperliquid trading bot using Jev to choose long or short and whether to open, close, or hold.
- Where Jev makes a decision: Each asset account sends market state to Jev; execution code places or cancels orders based on the decisions.
- What this project offers: Separately records model decisions, order execution, and dashboard state.
- Project details and fixed source · License: Not declared
332_lab-jev-chat — The Windows app reads visible WeChat chat text via UI Automation or local OCR, uses Jev for structured intent judgment, and optionally uses DeepSeek to generate three copyable reply suggestions.
- 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-social — Jev-powered Instagram, TikTok, and LinkedIn research: typed routing, real browser evidence, streamed post cards, video capture, and cited socai reports.
- 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
Prism — A Solana liquidity Agent with Jev shadow judgments compared against rule-based decisions.
- Where Jev makes a decision: Evaluates entry distribution, toxic flow, holding and stress signals for calibration logs.
- What this project offers: Adds comparable advisory signals to deterministic trading rules without claiming returns.
- Project details and fixed source · License: MIT
jev-eval-agent — Agent tool evaluation harness comparing standard LLM tool selection against Jev routing across 100 mocked tools.
- Where Jev makes a decision: Employs Jev for two-stage discrete pruning over tool catalogs, narrowing extensive tool lists down to relevant candidates in milliseconds.
- What this project offers: Mitigates context bloat and hallucinated tool calls in complex agents by isolating candidate selection into fast discrete steps.
- Project details and fixed source · License: Not declared
jev-seo — An experimental Rust SEO/GEO CLI and MCP tool combining page checks, DuckDuckGo queries and optional Jev scoring.
- Where Jev makes a decision: Classifies search intent, direct answers and content gaps, with a custom citation-likelihood rubric.
- What this project offers: Collects local checks, search results and model judgments into reports.
- Project details and fixed source · License: MIT
jevlint — A linter to codify code taste using 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
Working-Memory-Jev — Edit `.env` locally and replace the placeholder with your own key. Keep this file private; Git ignores it. Do not paste the key into frontend code, a browser field, an issue, or a command that will be saved in shell history.
- 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
HA-Jev — Turns Jev judgments into Home Assistant sensors, such as checking whether finished laundry has been left unattended.
- Where Jev makes a decision: Reads selected entity states and returns probabilities, choices, or scores that configured thresholds can use in automations.
- What this project offers: Connects natural-language conditions to existing sensors, notifications, and scenes.
- Project details and fixed source · License: MIT
JevIntent — It is a FkWeChat plugin that analyzes a long-pressed WeChat text message with the Jev model for intent, emotion, urgency and reply posture and shows the result in local Toasts.
- 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
Jevstiller — Distill a repeated Jev classification task into a local model, on the fly — same answers, your hardware.
- 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-Trades — A dashboard combining live crypto market data with Jev-guided paper trading; no broker or live-order API is connected.
- Where Jev makes a decision: Jev reviews completed minute candles and indicators; Python applies confidence and position limits to a simulated portfolio.
- What this project offers: Shows market inputs, model judgments and paper positions together.
- Project details and fixed source · License: Apache-2.0
JevScout — A demo job-search Skill for coding Agents that browses company careers pages in Chrome, uses Jev to screen AI and software-engineering roles, and saves the results.
- Where Jev makes a decision: Jev uses Choice to classify pages and Noul to assess careers links, role relevance, filter controls and candidate fit; local thresholds select navigation, job details and saved results.
- What this project offers: Connects careers navigation, role screening and detail matching in one CLI workflow, with local JSON and Markdown reports.
- Project details and fixed source · License: Not declared
jev-reviewer — A systematic-review tool that selects verbatim evidence from papers and supplements for human checking and export.
- Where Jev makes a decision: Jev selects candidate line IDs; code copies the original text with file and location references.
- What this project offers: Connects quotes, source locations and human verification status.
- Project details and fixed source · License: MIT
clash-jev — A Clash Royale bot with no trained policy: Jev (TypeSafe System One) makes every decision from the live game 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: MIT
JEV-Paper-Radar — In GitHub Actions the links point at your own repo automatically (`GITHUB_REPOSITORY`), so a fork needs no configuration. Locally, set `output.feedback_repo = "owner/name"` or run `paper-radar harvest --repo owner/name`.
- 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-trip — Jev Trip is an explainable day-trip planner. The LLM plans ahead; Jev chooses and checks. Deterministic code handles route facts, time calculations, validation, and versioning.
- 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-linkmap — Site: www.bles-software.com, 566 pages, 8,460 link decisions (15 candidate targets per page). Run on 19 Sep 2026. Every number below is from the run files in `out/` and `runs/`.
- 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-ai-playground — Community playground for TypeSafe AI and Jev featuring 110 real-world scenarios, dilemmas, and interactive experiments.
- Where Jev makes a decision: Submits custom states and questions to Jev via Next.js API routes, displaying discrete probabilities, latency, and confidence scores.
- What this project offers: Offers an intuitive web interface for exploring prompt criteria, testing edge cases, and evaluating discrete decision outputs.
- Project details and fixed source · License: MIT
jev-anything — Agent skill for designing, building, testing, and tuning bounded JEV decision layers
- 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-usecases — Production TypeSafe Jev (System One) use-case harnesses with confidence-gated decision logic
- 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
JevBystander — This Android accessibility app reads visible WeChat one-to-one chat text and uses Jev to judge intent, emotion, urgency and reply posture, showing the result as 3 Toasts without generating or sending replies.
- 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
jevlint — Semantic lint rules for the code-review questions a deterministic linter can't express
- 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
jevernetes — Live Kubernetes log analysis, contextual investigation, and agent handoff powered by 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_Ontology — We built a working MVP that pairs an LLM-authored ontology with Jev's calibrated classification, tested it against the live Jev API on 78 unique tickets across 5 sessions (86 classifications -- Session 4 re-runs Session 2's eight tickets), closed the feedback loop, and ran a 3-iteration convergence experiment. Total cost: $0.0085.
- 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-bot — JEV-powered market decision bot for stocks, crypto and memes. State in, BUY/SELL/HOLD/AVOID out, paper by default
- 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
jevmory — Coding-agent memory where every fact is a verbatim quote graded by TypeSafe Jev's calibrated confidence. Local-first, SQLite receipts, zero dependencies.
- 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
ask-jev — Ask Jev is a Neo-Brutalism style web app where users enter everyday dilemmas and receive direct decisions from 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_project_context — Evidence-first long-term experiment memory skill for AI coding agents, with optional Jev decision-model layers
- 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
kojev — Kotlin Multiplatform client for Jev that returns your own enum/sealed types instead of string keys.
- 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 — OpenJev: An Opencode plugin that replaces text-generation decisions with Jev (TypeSafe System One).
- 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
JevFlow — A Claude Code plugin that keeps your AI agents honest. Claude plans tasks as phases with checks, and when it tries to stop, Jevflow runs them and asks Jev if the work is really done. Many agents, one plan, with a live viewer to watch it all.
- 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 — It provides a web and CLI demo that sends user text to Jev through OpenRouter for Choice, Score, and Noul probability judgments and compares the results side-by-side with a general 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: Not declared
jevchess — Jev, TypeSafe's System One model, plays chess against any OpenRouter LLM, Stockfish and you. One-page web app with live moves, Jev's move probabilities, saved games and win rates.
- 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 — 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-for-engineers — Eight mechanical and electrical engineering experiments using Jev for task routing, log checks and component selection.
- Where Jev makes a decision: Jev classifies engineering text and candidates; calculations and final actions stay in Python rules.
- What this project offers: Shows how to connect judgments to engineering workflows using synthetic examples.
- Project details and fixed source · License: MIT
jev-music-tag — A minimal FastAPI and React workbench that sends local audio tags to Jev for decisions and writes the returned metadata updates back to the audio files.
- 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-span — Jev answers typed multiple-choice questions with calibrated probabilities, but it never returns entity spans on its own. **JevSpan turns it into an entity recognizer.** It cuts text at punctuation, offers every candidate window to Jev as an option, verifies what Jev nominates, and then lets Jev settle the exact boundaries and type. Every entity comes back with a probability and a trace of the questions that produced 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
JevLight — Jev-powered traffic signal control on CityFlow with structured phase and green-time 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: MIT
cairn-jev-lab — Use it to test a memory policy before letting it decide what an agent keeps. The lab includes editable cases, a reusable JavaScript entry point, and reports that retain both successful judgments and mistakes. Node.js 22+, no runtime dependencies.
- 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
dsh-jev-prune — Jev-judged context compaction for DeepSeek Harness: semantic tool-result pruning + deterministic receipt compaction
- 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
heyreach-jev-bot — Signal-based LinkedIn outbound scoring for HeyReach, running on Jev (TypeSafe System One).
- 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-lens — No scripted rules, no keyword lists, no cloud account of ours. Your API key, your profile, your browser.
- 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
JevEmon — Verified milestones so far: Jev can leave the Player's House, cross Pallet Town, deliver itself through Route 1 (fighting and winning any wild encounters along the way), and reach Viridian City. Further legs of the journey (Oak's Parcel, the first Gym) aren't built yet — the walk currently ends the run once it reaches Viridian City.
- 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
JevTools — A toolkit, knowledge base, web cockpit, and reference implementation for building AI applications with **Jev (TypeSafe System One)** via **OpenRouter Alpha Decisions** and **TypeSafe Direct API**.
- 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
robo-harness — SO-101 robot-arm workbench combining Bun/Effect and Python drivers, using Jev for joint action constraints.
- Where Jev makes a decision: Assesses spatial coordinates and sensor states, using Jev to select safe step actions within bounded budgets.
- What this project offers: Extends TypeSafe Jev low-latency discrete judgments to physical-world robotic arm motion control.
- Project details and fixed source · License: Not declared
work-with-jev — Work with Jev is a local-first message classifier that uses Jev to sort work messages into urgent, to-do, worth-reading, and skippable groups with cross-chat to-do management and Feishu and WeCom adapters.
- 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
dbt_jev — Score a candidate pair after ordinary SQL has generated 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
jev-A-share-trader — A Jev-powered technical analysis workspace for China A-shares, supporting AKShare/Tushare, market scans, and Buy/Hold/Sell assessments with time horizons and traceable evidence.
- 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-connector — WordPress connector for the TypeSafe System One API (Jev): typed questions, confidence-scored answers, core Connectors API key management
- 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-oncall — Incident triage on TypeSafe Jev — the model judges, plain code decides. Routing on probability distributions with a human-review middle band and fail-open defaults.
- 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-storyboard-lab — (`agent_framework.foundry.FoundryChatClient` is a different client this repo doesn't use — its `credential` parameter only accepts Azure AD token credentials, not an API key. If you only have a key-based Azure OpenAI resource, `OpenAIChatClient` is the path that actually works.)
- 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-tab-grouper — One-click AI tab grouping for Chrome — Jev typed decisions (~1s, whole window) or any OpenAI-compatible LLM that invents its own group names. Featured in awesome-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-trading — **Jev Trading is a stock decision service that runs on your computer.** Use the web workbench or call it from your own software over HTTP. It sends market data, indicators, fundamentals, and news collected by AIStock to a model, then returns a structured decision with a record of the evidence.
- 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-wrapped — The browser asks for up to four pages at a time (the plan says how many), which makes up to 24 Jev requests in flight, and shows every answer as it arrives. If a page comes back throttled, it goes to the end of the line and the run drops to three pages at a time, then two. There is no shared queue: every visitor's run is paced by their own browser, and the only shared ceilings are the daily ones below.
- 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
jevscan — An EVM Token screening tool with library, CLI and MCP interfaces for market-feature-based risk judgments.
- Where Jev makes a decision: Uses a deterministic local engine by default; a TypeSafe key enables real Jev judgments over features.
- What this project offers: Shows features, decision provenance and scores together for inspection.
- Project details and fixed source · License: MIT
JevSeek — Local coding workspace and agent decoupling tool routing via Jev from detailed argument generation via DeepSeek.
- Where Jev makes a decision: Employs Jev to classify and select the next tool action based on execution state, delegating parameter generation to DeepSeek.
- What this project offers: Combines low-latency discrete routing with capable generative modeling, reducing overall prompt overhead and turn latency.
- Project details and fixed source · License: MIT
jevsume — A resume-review app that checks general writing and structure or compares a resume with a specific job description.
- Where Jev makes a decision: Jev evaluates extracted resume text against typed questions; a Worker combines the results into review output.
- What this project offers: Records inputs and judgments so individual reviews can be inspected later.
- Project details and fixed source · License: Not declared
sqlite3-jev — SQLite C extension enabling TypeSafe Jev judgments as native SQL functions for semantic scoring and choices.
- Where Jev makes a decision: Registers custom functions like jev_choice and jev_score directly inside the SQLite query pipeline.
- What this project offers: Enables row-level semantic classification directly inside relational SQL queries without glue code.
- Project details and fixed source · License: MIT
claude-jev — Jev System One for Claude Code — typed Choice/Noul/Score via live TypeSafe API (mirror of opencode-openjev, live-only 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
Hinge-Jev — 🎯 A Jev-powered decision engine and visual studio that prices uncertainty and asks the question that matters.
- 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-clean — decision-first data cleaning system powered by 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-deep-dive — Start with a mismatch everyone has felt: chat models surpassed average humans at conversation years ago. So where is the automation? The launch post opens with exactly this question (M1).
- 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: CC-BY-4.0
jev-fuse — A governed execution layer between typed-decision models (TypeSafe Jev) and agent/AI tooling like Claude Code, MCP, and AI SDKs, turning probabilistic decisions into deterministic, policy-controlled, and auditable actions.
- 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-geo-audit — 300 public pages audited for AI citability with Jev decisions, checked against an LLM judge: agreement, cost and latency, measured
- 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-humanizer — 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-py-integration — Jev System one AI model, very fast decision making engine. Jev AI will use input tokens but no output tokens
- 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-writer — Unlike generative writing assistants that flatter drafts, jev-writer enforces strict statistical safeguards: an observational power gate, date-confound controls, and Benjamini-Hochberg false-discovery corrections. It reports what it finds in plain English and refuses to state findings when sample sizes cannot support them.
- 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
jevlint — A linting tool combining static analysis and Jev queries to help improve... Jev queries
- 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
tempo-jev-demo — I created Tempo with OpenAI's Codex, using Astra and GPT-5.6 Sol, with my direction and guidance. Codex also came up with the name Tempo. I haven't personally reviewed all of the code. This is an experimental demo so don't use it for anything serious. It may contain bugs, unexpected behaviour, and issues I'm not aware of. More details on how to get started below. Have fun!
- 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
BizzJev — The system detects all of them at once. Several signals may be present simultaneously; there is no winner-takes-all classification.
- 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-drive — Jev + autonomous driving: structured decisions, multimodal baselines, recovery research, and measured API diagnostics.
- 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-intent-classification — JEV intent classification using Python
- 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-issue-radar — Jev Issue Radar is a read-only dashboard for GitHub duplicate-issue triage. It retrieves likely candidates, asks Jev whether each pair is duplicate, related, distinct, or insufficiently documented, and shows selected passages from both original reports for a maintainer to review.
- Where Jev makes a decision: The app never closes issues, posts comments, or changes labels. Retrieval is currently lexical and bounded to a recent-item scan; this limitation is explicit in the UI and README.
- 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-prompt-optimization — automatically optimizing the instructions and decision criteria of TypeSafe Jev Choice from labeled data
- 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-resume-screening — 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-stock-decision-maker — JEV Decision is a live demo that turns market data into structured decisions. It pulls real-time prices, valuation ratios and sector context, then runs a 20-question against TypeSafe Jev model to score buy/sell conviction, financial health and risk
- 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-test — Pre-registered benchmark: can a 2B local model (Gemma 4 E2B) answer web questions without making things up when a decision model (TypeSafe Jev) makes every call? SearXNG for search, MemPalace for verbatim memory, seven arms including open local judges. Spec and thresholds fixed before any run.
- 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-testbench — `jev-testbench` is a lightweight Jev testbench built through **Agentic Engineering**.
- 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-trade — A simulated crypto trading loop that sends BTC and ETH market features to Jev and models execution costs and latency.
- Where Jev makes a decision: Jev answers bounded direction and risk questions; local policy decides simulated positions.
- What this project offers: Records judgments, delay and trading costs in the same experiment.
- Project details and fixed source · License: Not declared
jev-triage — Near-free GitHub issue triage powered by TypeSafe AI's Jev - typed, confidence-gated labels that escalate only the uncertain cases.
- 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-xiangqi — Play Chinese Chess (Xiangqi) against Jev - TypeSafe System One decision model as the AI. Score fan-out over legal moves.
- 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: BSD-2-Clause
jeves-desk — This repository implements a configurable customer-service platform combining ChatKit UI, Jev decision-making, generative chat, RAG knowledge lookup, plugin Tools, MCP data access, and YAML-driven Agent dispatch.
- 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
jevextract — Grounded information extraction that cannot hallucinate: code proposes spans, Jev decides. An open-source alternative to LangExtract, with a bilingual benchmark and paper.
- 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
JevLang — A policy engine for LLM decisions: declare routes, gates and actions once in TypeScript or Python, and every decision comes validated, explainable, replayable and audited.
- 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
leadgenrationaivoiceagent — An experimental TypeSafe module in a marketing and voice platform chooses specialization labels for agent roles.
- Where Jev makes a decision: Sends role data and bounded specialization candidates to Choice, then maps labels to capabilities.
- What this project offers: Provides an example of role classification in a business application.
- Project details and fixed source · License: MIT
tc39-atlas — Interactive semantic explorer and taxonomy for TC39 proposals. Applies TypeSafe AI System One (Jev) to classify ECMAScript proposals across adoption pathways, cognitive overhead, web-compatibility risk, and foundational intent archetypes.
- Where Jev makes a decision: tc39-atlas enriches ECMAScript proposals using TypeSafe System One (Jev) across multi-dimensional rubrics (domain, complexity score, adoption choice, cognitive overhead score, web-compat risk score, and intent archetypes).
- 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
tictacjev — A tic-tac-toe app where one player is Jev, TypeSafe AI's System One Model with live confidence scores and probabilities.
- 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-playground — A BYOK playground for practicing TypeSafe's Jev — the first System One model — with your own LLM or native Jev API access. Experiment with Noul, Score, Choice, custom state, and structured 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
cube-lab — Cube Lab is an interactive 3D Rubik's Cube app that generates candidate solutions with local planners and uses Jev to select moves across seven solving stages with animations and recorded turning sounds.
- 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-calculator — Vars live in `wrangler.jsonc`: `JEV_BASE_URL` / `JEV_MODEL` (gateway), `TYPESAFE_BASE_URL` / `TYPESAFE_MODEL` (direct fallback), `TURNSTILE_SITEKEY`, `TURNSTILE_HOSTNAMES`, `JEV_DISABLED` (kill switch). Rate limits are Workers Rate Limiting bindings: `API_LIMIT` per IP and `FALLBACK_LIMIT` for the direct route as a whole.
- Where Jev makes a decision: Do the calculation in a probalistic way. Select digit one at a time.
- 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
JevPulse — Analyze the YouTube comments to gain insights into what the audience is saying from any video link.
- Where Jev makes a decision: Jev analyzes each comment on the dynamic question criteria generated by the LLM : is_opinion (noul): separating substantive discourse from greetings, spam, and timestamps. comment_type (choice): Categorical intent (praise, criticism, question, suggestion, agreement, disagreement, correction, experience, other). specificity (score): 3-point ordinal score measuring argument depth and empirical detail. has_claim (noul): Measuring whether the utterance asserts a verifiable factual claim.
- 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

Evaluation & Observability

latitude-llm — Latitude includes an optional Jev preclassifier for conversation checks and their selection records.
- Where Jev makes a decision: Judges which checks apply and can add checks when thresholds and rate limits permit.
- What this project offers: Records models, thresholds, latency and selection reasons alongside the baseline.
- Project details and fixed source · License: MIT
jev-review — A local MCP code-quality reviewer returning structured scores to coding Agents.
- Where Jev makes a decision: Jev scores correctness, complexity, tests and security; code ranks areas to improve.
- What this project offers: Compares scores across checkpoints while leaving code changes to the primary Agent.
- Project details and fixed source · License: MIT
supercov — A quality and coverage CLI for coding agents: Jev assesses source properties while local coverage highlights testing targets.
- Where Jev makes a decision: Asks Jev about file-quality properties; code composes scores and ordering.
- What this project offers: Breaks scores into named properties and caches results by content.
- Project details and fixed source · License: MIT
taskuary — An optional Jev judgment module in Taskuary for checking user-defined conditions on task state.
- Where Jev makes a decision: Turns conditions into yes/no probability questions and returns local-threshold verdicts plus probabilities.
- What this project offers: Adds structured checks to task outcomes without making Jev the controller of the whole messaging system.
- Project details and fixed source · License: MIT
Canny — Keeps an execution ledger for Claude Code and Codex CLI to check for passing validation after edits.
- Where Jev makes a decision: Jev can identify completion claims and semantic-rule issues; stop gates depend on ledger facts and local rules.
- What this project offers: Separates execution evidence from model opinion rather than letting Jev alone certify completion.
- Project details and fixed source · License: MIT
jev-playground — A MoonBit and TypeScript Jev playground covering games, browsers, command risk and small languages.
- Where Jev makes a decision: Experiments send action candidates or typed questions to Jev, then execute or record the answers.
- What this project offers: Includes source, experiment notes and some offline replays for comparing decision designs.
- Project details and fixed source · License: Not declared
goodwatch-monorepo — A film-and-TV attribute-scoring experiment inside GoodWatch comparing Jev question designs and batch sizes.
- Where Jev makes a decision: Asks whether predefined traits are present or how strongly they appear, recording scores, latency and Token usage.
- What this project offers: Compares rating scales, input variants and batching over a frozen sample.
- Project details and fixed source · License: MIT
typesafe-ai-benchmark — Compares Jev with other structured-output models on shared application tasks, recording errors, latency, Tokens, and estimated cost.
- Where Jev makes a decision: Maps the same tasks to Jev Choice/Noul questions and normalizes answers to a shared result format.
- What this project offers: Preserves comparison methods and results for inspecting model differences.
- Project details and fixed source · License: MIT
jev-benchmarks — A benchmark comparing Jev and GLiNER on text classification, probability calibration and selective automation.
- Where Jev makes a decision: Runs the same labeled text tasks through both backends and records probabilities, latency and failures.
- What this project offers: Helps examine task-specific accuracy and whether confidence scores support chosen thresholds.
- Project details and fixed source · License: Apache-2.0
typesafe-playground — Interactive Jev experiments for support-routing previews and 3D driving simulations.
- Where Jev makes a decision: Judges support messages or chooses lanes and target speed from structured simulated sensors.
- What this project offers: Shows inputs, probabilities and resulting behavior together.
- Project details and fixed source · License: Not declared
jev-pref — Turns AGENTS.md preferences into rules checked by Jev against hunks, staged files or PRs.
- Where Jev makes a decision: Jev classifies change evidence against configured rules; code maps answers to review outcomes.
- What this project offers: Feeds semantic-rule findings to coding Agents without replacing type checks, tests or security audits.
- Project details and fixed source · License: MIT
jevcal — A toolkit for evaluating Jev probabilities on labeled data, selecting confidence thresholds and checking model drift.
- Where Jev makes a decision: Runs fixed questions and measures accuracy, calibration, coverage and escalation rates.
- What this project offers: Connects threshold selection and model-change checks to reports and CI.
- Project details and fixed source · License: MIT
jev-rerank-bench — Compares Jev, dedicated rerankers and chat models on the same retrieved passages.
- Where Jev makes a decision: Ranks candidate passages with Choice, Noul and rubric scores, then computes retrieval metrics.
- What this project offers: Publishes raw responses, scoring code and per-dataset results for inspection.
- Project details and fixed source · License: MIT
jev-benchmark — Benchmarks Jev on chess moves and identifying which game NPC a player addresses.
- Where Jev makes a decision: Selects legal chess moves or judges whether an utterance addresses each NPC.
- What this project offers: Publishes labeled data, raw requests and responses, and evaluation code.
- Project details and fixed source · License: MIT
jev-lm — A word-level generation experiment that asks Jev to select words or verify locally drafted continuations.
- Where Jev makes a decision: Choice selects the next word; Noul evaluates candidate chunks and stopping conditions.
- What this project offers: Exposes the limitations of using a decision model as a text generator.
- Project details and fixed source · License: MIT
jev-frontend-qa — Frontend QA that uses Jev to choose browser actions and checks contracts through DOM, HTTP and database evidence.
- Where Jev makes a decision: Jev selects observed controls and operations; test code owns expected values and pass criteria.
- What this project offers: Records exploratory behavior separately from contract acceptance.
- Project details and fixed source · License: MIT
jev-chat — A research chat decoder that repeatedly asks Jev to choose words or phrases and assembles them in code.
- Where Jev makes a decision: Compares stepwise Choice decoding with selection from complete candidate replies.
- What this project offers: Provides decoder methods, experiment traces and documented failure cases.
- Project details and fixed source · License: MIT
jev-agent-failure-benchmark — A benchmark using Jev to attribute multi-Agent failures to an Agent, step and error type.
- Where Jev makes a decision: Builds candidate sets from traces and submits three choice questions.
- What this project offers: Provides evaluation scripts and author results; some baselines generate answers while Jev selects candidates.
- Project details and fixed source · License: Apache-2.0
jev-behavior-study — An independent Jev 1.13.0 behavior study recording successes and failures across question framing, input conditions and games.
- Where Jev makes a decision: Sends controlled variants of fixed tasks and records choices, probabilities and raw request-response evidence.
- What this project offers: Lets readers inspect individual cases rather than infer broad capability from simple-task success.
- Project details and fixed source · License: MIT
jev-exploration — A research repository tracking Jev claims and limitations, with calibration experiments and runnable examples.
- Where Jev makes a decision: Calls Jev on defined questions and labeled cases, then analyzes errors, calibration, and difficulty effects.
- What this project offers: Links research claims to experiment code, data, and an evidence ledger.
- Project details and fixed source · License: MIT
jev-gomoku — A nine-board, 15×15 Gomoku workbench comparing how two Jev players respond to different input representations.
- Where Jev makes a decision: Jev chooses from locally generated move candidates while the experiment varies board and tactical information.
- What this project offers: Supports labeled replays and bring-your-own-key live games with per-move records.
- Project details and fixed source · License: Not declared
hermes-jev-north-star — A Hermes goal-checking skill that saves requirements, creates a run prompt and checks completion evidence.
- Where Jev makes a decision: Local checks handle machine-verifiable requirements; Jev assesses the remaining semantic conditions.
- What this project offers: Connects goals with checkable criteria without replacing actual acceptance evidence with model opinions.
- Project details and fixed source · License: MIT
jev-synergy-screening — A Jev title-and-abstract screening experiment compared with Cohen Abstract Triage labels for an ADHD review.
- Where Jev makes a decision: Asks Choice and Noul questions about eligibility, then combines them into include or exclude decisions.
- What this project offers: Records metrics for specific dataset slices and question designs to examine screening errors.
- Project details and fixed source · License: Not declared
ask-jev — A Windows PowerShell tool for auditing recorded Codex execution evidence with :jev.
- Where Jev makes a decision: Sends selected records to Jev for judgments about execution claims and evidence sufficiency.
- What this project offers: Only reads and sends records on explicit invocation; judgments do not replace real tests.
- Project details and fixed source · License: MIT
jev-eval — Compares Jev and OpenRouter models on labeled tasks for accuracy, calibration, latency and cost.
- Where Jev makes a decision: Collects judgments on matched tasks and computes confidence intervals and repeat-input stability.
- What this project offers: Publishes data processing, runner and statistics code with model-specific results.
- Project details and fixed source · License: Not declared
jev-flash-review — An MCP review engine that evaluates Agent-supplied diffs against explicit rules.
- Where Jev makes a decision: Jev checks the diff, selects evidence from actual hunks and adjudicates candidate findings.
- What this project offers: The caller supplies diffs and task boundaries; the engine does not scan the repository itself.
- Project details and fixed source · License: Not declared
foreman-jev — An experimental Jev supervisor for Codex workers with programmer-selected acceptance commands.
- Where Jev makes a decision: Jev assesses progress and completion signals; deterministic acceptance checks still decide whether the work passes.
- What this project offers: Separates a model’s assessment from executable completion checks.
- Project details and fixed source · License: MIT
jev-calibration-audit — Audits Jev calibration, option-wording effects and Korean judgments through public APIs and datasets.
- Where Jev makes a decision: Collects Noul and Choice outputs and compares them with labels for error, accuracy and stability.
- What this project offers: Keeps per-call records and experiment notes to qualify conclusions.
- Project details and fixed source · License: MIT
jev-demos — Maze experiments comparing Jev single-step choices with multi-step lookahead.
- Where Jev makes a decision: Chooses moves from direction candidates, then checks collisions, paths and completion.
- What this project offers: Keeps experiment settings and failures visible for studying limitations.
- Project details and fixed source · License: Not declared

High-Frequency / Games

kev — Tiny Jev-like decision head built atop Qwen2.5-0.5B that can be trained and run locally on Apple Silicon MacBooks.
- Where Jev makes a decision: Attaches a parallel decision head to an open 0.5B model to answer discrete questions directly from token activations.
- What this project offers: Runs entirely offline on edge hardware with minimal memory footprint, offering an accessible base for custom judgment modeling.
- Project details and fixed source · License: Apache-2.0
NanoJev — Nano replica of Jev featuring parallel decisions, dynamic candidate sets, and an end-to-end training and evaluation pipeline.
- Where Jev makes a decision: Evaluates multiple questions and dynamic candidate spaces concurrently in a single forward pass, logging navigation choices.
- What this project offers: Provides open-source training infrastructure and game environment benchmarks for investigating non-generative discrete decisions.
- Project details and fixed source · License: MIT
typesafe-mario — An experimental NES Mario controller that gives Jev structured emulator RAM and telemetry instead of screenshots.
- Where Jev makes a decision: Reads motion, enemies, terrain and recent controls, then selects a predefined legal action.
- What this project offers: Records model state and actions without screenshot input.
- Project details and fixed source · License: Not declared
jev-drone — A MuJoCo drone experiment deriving scene features from camera buffers for Jev tactical advice.
- Where Jev makes a decision: Uses range sectors, obstacle heights and target state to choose maneuvers and assess risk or target loss.
- What this project offers: Separates tactical judgments from local guidance, reflexes and flight control.
- Project details and fixed source · License: MIT
jevpilot — A browser driving simulator where Jev chooses among locally generated paths and speeds.
- Where Jev makes a decision: Jev reads road and traffic state and selects motion; geometry, collision prediction and braking remain local.
- What this project offers: Makes candidate trajectories and decision probabilities visible during a simulation.
- Project details and fixed source · License: Not declared
jevk5 — An open model that answers the same typed questions Jev answers — yes/no, choice, score — in one forward pass with zero generated tokens (~13 ms on an H100), plus a head-to-head harness that puts Jev and the open model on the identical board and question so the two can be compared directly. It serves TypeSafe's `/v1/systemone` wire format, so a Jev client can point at it unchanged.
- Where Jev makes a decision: Disclosure, so the listing is accurate: this project is primarily an **open alternative** to Jev (it is ranked second of 76 on JevBench v1.4, behind Jev itself), not an application built on top of Jev. Its Jev integration is the comparison harness above and the shared wire format. If the directory is only for projects that consume Jev, please close this — no hard feelings.
- 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
laya-vs-jev — Laya vs Jev: local MLX and hosted AI decisions playing T-Rex side by side, with live metrics and replay 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: Apache-2.0
jev-libero — Two LIBERO tasks, one control engine. Each demo loads its own JSON task definition. Videos follow simulation time, with decision and physics-preview waiting omitted.
- 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
RoboJEV — RoboJEV is a small, inspectable robotics laboratory. JEV receives **structured simulator state, not images**, selects an immediate intent, then selects X/Y/Z directions and a gripper command. A Cartesian controller executes the action using real MuJoCo contacts. Each task has independent physical success checks; model answers cannot declare success.
- 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
litjev — Open reproduction of Jev decision layer on open-weights models, serving the System One schema by inspecting option logits directly.
- Where Jev makes a decision: Implements the /v1/systemone endpoint (Choice, Score, Noul) by calculating candidate token log-probabilities without text generation.
- What this project offers: Enables private and local hosting of Jev-compatible decision services on GPUs without relying on proprietary cloud APIs.
- Project details and fixed source · License: Apache-2.0
OneVOneJev — A browser-based 1v1 shooter where Jev reads structured match state and chooses movement, aim, and firing.
- Where Jev makes a decision: Each decision tick asks about movement, view, aiming, firing, and jumping, with a heuristic fallback on API failure.
- What this project offers: Makes structured decisions visible in an interactive game loop.
- Project details and fixed source · License: Not declared
jev-doom-agent — A browser Doom experiment comparing Jev-controlled players from the same initial state.
- Where Jev makes a decision: Jev reads structured health, ammunition and targets and selects tactical controls executed by a local controller.
- What this project offers: Exposes model decisions alongside explicitly labeled offline and fallback policies.
- Project details and fixed source · License: Not declared
laya-vs-jev-arena — Laya (open source, local) vs TypeSafe Jev (API): two AI models race in Snake and fight in a Mortal-Kombat-style arena. Every move is a real model decision.
- 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
tsai-sc — A Jev harness for StarCraft shareware’s Strongarm mission, pausing the game during state reads and inference.
- Where Jev makes a decision: Selects commands from structured game state and executes them with mouse and keyboard input.
- What this project offers: The author provides a victory recording and verification report; this is a bounded mission experiment, not a real-time competitive benchmark.
- Project details and fixed source · License: MIT
typesafe-snake — Snake autoplayer driven by TypeSafe Jev, executing one discrete System One decision per tick with code-enforced legal moves.
- Where Jev makes a decision: Supplies board state, fruit location, and legal direction choices to Jev, selecting the optimal move direction each tick.
- What this project offers: Demonstrates fast discrete choice in constrained environments while deterministic logic prevents illegal collisions.
- Project details and fixed source · License: Not declared
live-jev — A browser-based top-down driving simulator using Jev for lane and speed choices, with an optional chat-model comparison.
- Where Jev makes a decision: Jev answers lane, speed, hazard and pedestrian-yield questions; local rules apply the actions.
- What this project offers: Runs controllers on the same seeded course, with separate local emergency-braking logic.
- Project details and fixed source · License: Not declared
jev-reflex-autonomy-lab — Multi-drone autonomy lab demonstrating TypeSafe Jev reflex decisions with optional System 2 strategy guidance.
- 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
jevtown — A check costs from half a cent (a text that dies in the first wave) to ten cents (one that reaches all 10,000), and takes from 3 seconds to a minute. The interface comes in Ukrainian and English, and so do the personas: a text is read by the crowd that speaks its language, 10,000 Ukrainians or 10,000 English speakers, so there is nothing to choose.
- 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
jevscape — A RuneBench extension using Jev and a bounded rs-sdk action catalog for RuneScape tasks.
- Where Jev makes a decision: Chooses goal actions, tick interventions and the next polling interval from game state.
- What this project offers: Provides action-distribution views, run logs and burst or tick control modes.
- Project details and fixed source · License: Not declared
jev-askable-arm — Uses Jev to chain predefined skills for English-language goals in a ManiSkill robot-arm simulation.
- Where Jev makes a decision: Chooses a skill and target from privileged object and gripper state and about thirty primitives.
- What this project offers: Separates skill selection from Python motor control.
- Project details and fixed source · License: MIT
heist-one — Observable browser stealth game where Jev makes typed guard judgments while deterministic code owns the physics world.
- Where Jev makes a decision: Queries Jev during gameplay ticks or events to determine guard alert states, feeding discrete decisions back into the game loop.
- What this project offers: Demonstrates using Jev for game AI behavior trees, achieving dynamic situational awareness within deterministic constraints.
- Project details and fixed source · License: MIT
jev_deep_rl — This project evaluates a fixed model. It records rewards and decisions without training or updating model weights. A seeded random policy provides a local baseline.
- 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
JevBird — A Python Flappy Bird game where code simulates candidate routes and Jev picks one.
- Where Jev makes a decision: For each new pipe, Jev selects a route and the game executes its scheduled flaps.
- What this project offers: Visualizes candidate trajectories, probabilities and the selected path.
- Project details and fixed source · License: MIT
soupbase — Soupbase is a bilingual Chinese-English Turtle Soup game where Jev judges player questions and reconstructions, and the app checks structured Choice results and confidence to decide clearance.
- 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
doom-jev — A ViZDoom Agent that uses Jev to choose movement, targets and firing from structured game state.
- Where Jev makes a decision: Jev selects tactical goals and actions while local geometry handles fine aiming.
- What this project offers: Separates game ticks from network inference so the engine need not wait on every frame.
- Project details and fixed source · License: Not declared
jev-gamepilot — **Jev-GamePilot** is a universal autonomous AI gaming agent powered by **Laya (local sub-30ms System One inference)** and **TypeSafe's Jev System One** (`Choice`, `Score`, `Noul`). It captures real-time gameplay at 60+ FPS, fuses instant local reflexes with high-level strategic reasoning, and executes physical hardware inputs across Windows PC games and connected Android phones.
- 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-little-airways — An island-airport simulator using Jev for routes, yielding, emergency broadcasts and landing order.
- Where Jev makes a decision: Turns aircraft and nearby traffic state into questions whose answers drive simulated actions.
- What this project offers: Shows requests, answers and simulation state, with a separate mock path available.
- Project details and fixed source · License: MIT
jev_vampire_survivors — TypeSafe's Jev model plays Vampire Survivors on Steam: BepInEx plugin + Python brain + live decision dashboard. Native Linux 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: MIT
jev-robotics-demo — A MuJoCo arm demo where local code proposes candidate moves and Jev chooses the target, grasp or release, and completion.
- Where Jev makes a decision: Chooses among candidate targets, grasp or release, and a done Noul.
- What this project offers: Candidate motions are generated in a local physics copy; Jev only chooses. Author-reported timings were not retested here.
- Project details and fixed source · License: MIT
jev_fsd — **An AI model drives a car through a real city, and you can watch every decision it makes.**
- 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-nanojev — Jev Arena is a fully local grid tactical game arena where NanoJev, rule agents and search algorithms make per-step move, attack, shoot, heal, dash and environment-interaction decisions across multiple levels with a Chinese Pygame interface.
- 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-flappy-bird — A live demo of TypeSafe's Jev model playing Flappy Bird, one flap-or-wait decision at a time.
- 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-gpt — Cascaded Choice questions that make Jev pick the next word from a word tree instead of generating text.
- Where Jev makes a decision: POSTs /v1/systemone as jev-latest with one type:choice question per tree level.
- What this project offers: Shows how Jev can assemble short text without generating prose. No LICENSE file is present.
- Project details and fixed source · License: Not declared
jev-market-reflex — Fast typed AI decisions on live crypto markets using TypeSafe AI 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-rl — JEV Reinforcement Learning: four classic games trained with JEV-powered rewards, reproducible experiments and checkpoint replays.
- 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-broadcast-lab — A Jev experiment workbench centered on chess, with additional classification and matching exercises.
- Where Jev makes a decision: Chooses from locally generated legal chess moves; Stockfish scores are shown to the operator rather than Jev.
- What this project offers: Lets users compare model move choices with a separate local chess evaluation.
- Project details and fixed source · License: Not declared
jev-chess — Chess moves, evaluations, persona opponents, and game classification using TypeSafe AI System One models. Resolves natural language move intents into legal moves, evaluates positional sharpness and king risk in parallel, and powers historical persona opponents (Tal, Capablanca, Petrosian).
- Where Jev makes a decision: jev-chess invokes Jev primitives via `@typesafe-ai/sdk` for natural-language move resolution, multi-dimensional position evaluations, and persona style scoring.
- 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-factorio-agent — Jev picks what, code owns how - a System One Factorio agent driven by TypeSafe's Jev on FLE
- 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-flappy-bird — Jev learns to play flappy-bird game with physics based context and without 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: Not declared
jev-play-ping-pong — Uses Jev to choose serve direction, return angle and pace in a browser table-tennis game.
- Where Jev makes a decision: Reads structured telemetry and selects contact and pace through Choice before code executes inputs.
- What this project offers: Keeps action, latency and match records for reviewing a run.
- Project details and fixed source · License: MIT
jev-synthetic-survey — New to synthetic survey respondents? [Start here](#new-to-this-start-here). For the raw runs, the scored reports and the code, see [where to go](#where-to-go).
- 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
jevarena — Two Jev Agents play Snake in side-by-side browser panes with visible per-step choices.
- Where Jev makes a decision: Selects a direction-button target from allowed controls using structured board state.
- What this project offers: Displays candidate controls, action probabilities and game progress together.
- Project details and fixed source · License: MIT
jevTrader — A High Frecuncy Trader made in Rust using Jev as a decision maker.
- 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
mk-jev-fly-brain — Compares a fly-connectome spiking simulation, Jev and rule policies in the mk.js fighting game.
- Where Jev makes a decision: Jev reads game state and chooses among the same seven moves offered to other controllers.
- What this project offers: Uses control variants, match records and experiment notes to compare contributions.
- Project details and fixed source · License: MIT
snake-jev — Real-time Snake game driven by parallel Jev assessments, deciding optimal turns in a single API call per tick.
- Where Jev makes a decision: Scans obstacles and food locations per tick, querying Jev in parallel for survival and approach probabilities.
- What this project offers: Demonstrates Jev high-frequency, deterministic low-latency performance in real-time game ticks.
- Project details and fixed source · License: MIT
tsai-civ2 — An experimental harness where TypeSafe Jev plays classic Civilization II in a browser, computing live action probability distributions.
- Where Jev makes a decision: Evaluates city builds, tech research, diplomatic postures, and unit moves per turn from game state.
- What this project offers: Demonstrates Jev real-time probability distributions applied to complex strategic planning and game loops.
- Project details and fixed source · License: Not declared
can-jev-bayes — How well can Jev make sequential decisions under uncertainty, and how can Bayesian methods help it learn and act more effectively?
- 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-charactor — Jev-Character: a TypeScript core for role-playing agents, autonomous game NPCs and AI towns. Agent memory, natural-language behavior authoring and programmatic dialogue, with a playable 2D multi-agent simulation.
- 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-claim-vs-measured — A post with ~400k views says TypeSafe's **Jev** is the fastest AI model ever built for trading, makes calibrated buy/sell decisions in under 100 ms, and shows how to build an HFT system on it. The article behind it contains no backtest, no P&L and no hit rate. So I ran the tests: on the raw tape at one decision per second, and at 15–60 minute horizons. It cost **$0.97** of API credit. Everything needed to check me is in this repository.
- 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-clash-royale-test — A Clash Royale-style sandbox whose Jev bot decides play-or-hold, card, lane, and depth in one System One call.
- Where Jev makes a decision: One systemOne call with a should_play Noul plus card, lane, and depth Choices.
- What this project offers: Makes play choices inspectable probabilities. package.json says ISC; there is no LICENSE file.
- Project details and fixed source · License: Not declared
jev-experiments — Uses Jev to play Chrome Dino and a local shooter arena while Python executes structured decisions.
- Where Jev makes a decision: Chooses jumping, ducking, movement, aim, or firing from game state, with local execution rules.
- What this project offers: An inspector lets users compare state, model answers, and executed actions.
- Project details and fixed source · License: Not declared
jev-practice-speed — A WebGL demo where you play the card game Speed against a CPU whose brain is TypeSafe AI's Jev. The whole point of the app is to measure and show Jev's decision speed and decision accuracy in real time.
- 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-table-tennis — Table tennis vs. TypeSafe's Jev (System One). Every paddle move on the right is a live model decision — no local prediction, just a lookup table and a servo.
- 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-tetris — Tetris that plays itself: TypeSafe's Jev model picks every placement with one typed Choice call, with live probabilities, latency, and 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
typesafe-jev-decision-studio — Fast, calibrated System One decision platform powered by TypeSafe Jev via OpenRouter. Sub-second logprob scoring, transfer curves, zero hallucinations.
- 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-traffic-demo — This is a **simulation**. It is not connected to, and cannot control, any real traffic signal — Hong Kong's Transport Department publishes no write API for that, only a read-only feed of sensor data. Everything downstream of that feed (the phase timing, the amber/all-red clearance, the safety limits) runs entirely in this process's own memory.
- 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

MCP & Integrations

vellum-assistant — An optional Jev provider in Vellum Assistant sends conversation state and explicit questions to TypeSafe.
- Where Jev makes a decision: Submits state and question bundles to System One and returns structured answers to the Assistant.
- What this project offers: Adds choices, probabilities, and scoring to an existing assistant.
- Project details and fixed source · License: MIT
jev-mcp — Eight MCP tools for evidence checks, content screening, search, reranking, classification, comparison and extraction.
- Where Jev makes a decision: Uses typed questions to assess evidence support, content risk and candidate relevance.
- What this project offers: Returns judgments and probabilities; the caller owns thresholds and enforcement.
- Project details and fixed source · License: MIT
typesafe-mcp — An MCP server that lets Claude Code, Claude Desktop, Codex and Pi ask Jev typed questions.
- Where Jev makes a decision: Submits state and Choice, Score or Noul questions and returns structured answers with probabilities.
- What this project offers: Provides decisions that calling code can inspect and branch on.
- Project details and fixed source · License: MIT
jev-judge-mcp — Typed judgment tools for MCP agents. TypeSafe's Jev model as verify, screen, find, classify, rerank, decide, compare, extract, review, gate, and score: the model judges, policy decides auto, review, or escalate.
- 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 — Helps Pi Agents find tools and skills for a task, with structured evaluation and optional history filtering.
- Where Jev makes a decision: Judges how candidate tools, skills, and history relate to the task so local rules can load or retain them.
- What this project offers: Lets capabilities enter an Agent workflow on demand.
- Project details and fixed source · License: MIT
pi-typesafe — A Pi Jev extension providing a decision tool, terminal playground commands and an API for other extensions.
- Where Jev makes a decision: A shared client batches typed questions, validates responses and records usage and availability.
- What this project offers: Centralizes key and client handling so other extensions can reuse the decision interface.
- Project details and fixed source · License: MIT
Jevbridge — Exposes a shared structured-decision interface for Jev and other models through ACP, MCP and a CLI.
- Where Jev makes a decision: Sends state and bounded questions to the chosen backend, with an offline rule backend also available.
- What this project offers: Lets agents compare or replace decision backends through one interface.
- Project details and fixed source · License: MIT
synkora-ai — Synkora includes optional TypeSafe client tools for classification, scoring and yes/no judgments.
- Where Jev makes a decision: Sends workflow state and named questions to Jev and returns structured answers to agents.
- What this project offers: Makes these judgments available within existing platform workflows.
- Project details and fixed source · License: MIT
plasmallm — A Jev Decisions adapter in a KDE Plasma assistant widget for displaying structured judgments.
- Where Jev makes a decision: Converts the current message into decision questions and receives answers from TypeSafe or a compatible Decisions endpoint.
- What this project offers: Makes decision models available in an existing desktop assistant UI.
- Project details and fixed source · License: GPL-2.0
jev-mcp — Wraps Jev classification, scoring, yes/no judgments and candidate matching as MCP tools.
- Where Jev makes a decision: The MCP server calls the TypeSafe SDK and returns choices, probabilities and scores.
- What this project offers: Provides a shared decision interface for MCP-compatible clients.
- Project details and fixed source · License: MIT
jevwire — Provides Jev MCP tools, an embeddable library and Claude Code hooks for Agents.
- Where Jev makes a decision: Uses Jev for ranking, verification, action checks and next-step selection, with code applying policy.
- What this project offers: Reuses the decision layer through MCP or host code; hook behavior depends on configuration.
- Project details and fixed source · License: MIT
harness-router — Fast decision routing for agent harnesses — native MCP with Jev for tool selection and MCTS for multi-step decisions.
- Where Jev makes a decision: Jev evaluates the assembled tool descriptors against agent state using OpenRouter decisions API, returning high-confidence tool selection or fallback.
- What this project offers: Separates tool routing from problem solving, eliminating wasted LLM tokens and latency across large, overlapping MCP tool registries.
- Project details and fixed source · License: MIT
jev-codex-plugin — Open-source Codex plugin for TypeSafe Jev decision consultation, failure diagnosis, and evidence-based completion 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
jev-mcp — An MCP server and Claude Code plugin for Jev classification, scoring, checks and batched questions.
- Where Jev makes a decision: Calls TypeSafe with Choice, Score and Noul questions and returns structured answers.
- What this project offers: Makes the typed decision primitives available to MCP clients.
- Project details and fixed source · License: MIT
jev-as-quant — Typed System-1 decisions (Laya/Jev) as the judgment layer of a quant research stack, with Claude as System 2. Requirements → design → code → experiments.
- 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-classifier — A local Jev tool-routing gateway for coding Agents, with an MCP suggestion interface.
- Where Jev makes a decision: Jev selects among available tools; adapters may record suggestions or influence actual tool selection.
- What this project offers: Keeps decision logs while some clients remain observation-only or choose whether to follow suggestions.
- Project details and fixed source · License: MIT
tenbin — Documentation, an MCP server and a Skill for designing Jev judgments with question linting, batch evaluation and calibration.
- Where Jev makes a decision: Runs Choice, Score and Noul over samples and uses measured results to design local thresholds.
- What this project offers: Connects question design, sample evaluation and runtime rules.
- Project details and fixed source · License: MIT
Jev-AI-Skill — One AI skill + MCP server for Claude Code, Codex and Hermes: Jev (TypeSafe) gates large-model turns (event triage, review verdicts, owner questions, tool choice), runs build-and-repair loops with independent review, routes models and skills, and guards Git steps. Script-only watch mode and a shared HTTP server.
- 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-mcp — An evaluation-focused Jev MCP server for individual questions, batch processing and question or threshold comparisons.
- Where Jev makes a decision: Runs typed questions and uses labeled samples to measure accuracy and calibration.
- What this project offers: Makes question design and threshold choices inspectable through sample results.
- Project details and fixed source · License: MIT
jev-mcp-server — MCP server for Jev (TypeSafe System One): the three official question types — choice, score, noul — plus batch classify. Calibrated probabilities, ~0.5s, <$0.001/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
jev-skill-router — Keep skill catalogs outside the main LLM context. Jev selects relevant skills through one read-only MCP 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
JevTrace — An MCP server that cuts coding-agent token usage by retrieving only the relevant JS/TS code using the TypeScript compiler and 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
toolJev — Code Mode for MCP, where the sub-model is a calibrated decision model (Jev), not an LLM. Benchmarked on MCPToolBench++, LiveMCPBench, When2Call and live Claude agents.
- 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-mcp — This repository is an MCP server for TypeSafe Jev that provides a single evaluate tool taking state plus typed questions and returning noul, choice, or score answers with probabilities.
- 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-agent-kit — jevkit: fast typed decisions for agents. CLI and MCP tools (route, triage, guard, grep, rank, compact, judge) on TypeSafe Jev. Zero dependencies.
- 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-agent-toolkit — Jev-first portable Agent Skill and optional MCP bridge for Claude Code, Codex, Cursor and compatible agents.
- 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-mcp — MCP server wrapping TypeSafe's Jev System One models — typed noul/choice/score judgments for AI agents
- 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: AGPL-3.0
jev-mcp — Local MCP server exposing TypeSafe Jev (System One decision model) as native Claude Code / Codex tools
- 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-mcp — MCP server for Jev (TypeSafe AI's System One model) — give any agent typed, calibrated decisions: classify, score, check, gate risky tool calls. Try free: jevtypesafeai.com
- 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-mcp — MCP server that lets Claude Code, Codex & AI agents drive a real Chrome browser with JEV (TypeSafe System One): ~100 ms typed decisions, calibrated confidence, human-in-the-loop questions, safety gates and a debug trace.
- 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-mcp-spring — On success each tool returns its typed result directly. On failure the tool call fails at the MCP protocol level (`isError: true`) with a short, safe message — no response body or stack trace is ever echoed 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: Apache-2.0
jev-rust-review — Rust-aware code review for Claude Code and coding agents, 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
jev-workbench — Defines, tests, and publishes Jev decision functions in a local UI so backends and Agents can call fixed versions.
- Where Jev makes a decision: Encodes classification or evidence checks as Noul, Choice, or Score questions sent to TypeSafe.
- What this project offers: Lets multiple callers reuse the same versioned decision function.
- Project details and fixed source · License: MIT
JevScout — Jev decides what reaches your coding agent: verbatim, recoverable context for Claude Code and reviewed operations for Codex. npm i -g jevscout
- 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
n8n-nodes-jev — Jev by TypeSafe AI for n8n: typed decisions, probabilities, and confidence-aware workflows
- 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
n8n-nodes-typesafe-jev — An n8n community node for submitting typed questions to TypeSafe Jev.
- Where Jev makes a decision: Builds state and questions from input items, calls Jev and appends or separately outputs answers.
- What this project offers: Supports form or JSON question configuration and use as an Agent tool.
- Project details and fixed source · License: MIT
openrouter-jev-mcp — A Python decision gateway and Model Context Protocol (MCP) server exposing TypeSafe's Jev model through OpenRouter's decisions endpoint to Claude Code, Codex, and Cursor agents.
- Where Jev makes a decision: The server exposes Jev Choice (`jev_classify`), Score (`jev_score`), and Noul (`jev_check`) decisions over standard stdio MCP to AI coding agents, executing requests against OpenRouter's decisions endpoint:
- 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-opencode — Jev is not a conversational replacement for Gemini, Claude, or GPT. It evaluates application state against typed questions and returns structured answers and probabilities that an agent can use to route or gate work.
- 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
android-jev — Whichever way it reaches the server, the key never appears in a state, a log, a run folder or a transcript.
- 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_ampcode — An Amp plugin for comparing supplied alternatives against supplied evidence and priorities.
- Where Jev makes a decision: Uses Jev Choice to compare bounded options and return probabilities for further review.
- What this project offers: Keeps alternatives and decision inputs explicit.
- Project details and fixed source · License: Not declared
jev-eyes — Also in the state: `image` (size, source), `blocks` (`[x, y, w, h]` boxes with OCR confidence) and, if installed, `labels`. `see(img, compact=True)` keeps only `image`, `text` and top label names when tokens matter more than positions.
- 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-in-mcp — MCP relay that adds use_jev to every server: Jev picks the tool calls, the calling model writes the values Jev cannot choose, the relay executes. Built on jev-dev-kit.
- 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-mcp — MCP local que expone Jev (TypeSafe) como herramienta para Claude Code, Codex, Hermes y cualquier agente: ask_jev y list_jev_models, sin dependencias
- 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-mcp — A Rust MCP server for TypeSafe AI Jev structured 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: MIT
jev-mcp — `jev-mcp` exposes TypeSafe AI's Jev decision model as four conservative, read-only MCP tools for **bounded probabilistic 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: MIT
jev-mcp-open-source — Self-hosted Jev MCP on Cloudflare Workers with intent routing, retrieval reranking and batch 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-netlify-mcp — Free, key-locked TypeSafe Jev via Netlify AI Gateway, plus an MCP server for Claude Code, Codex and Claude Desktop
- 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-playwright-mcp — Jev-augmented Playwright MCP proxy — page-state triage, prompt-injection shielding, goal-based snapshot pruning, risky-action gating. Drop-in wrapper around @playwright/mcp for any coding agent.
- 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-review-mcp — Single-purpose MCP server (one tool, one job): a code-review gate powered by TypeSafe Jev (System One decision 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-routing — Go Jev harness for Claude Code, Codex, and Grok Build. No npx. Not an MCP server.
- 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-screen-mcp — Single-purpose MCP server (one tool, one job): a content-moderation gate powered by TypeSafe Jev (System One decision 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-tool-search — Tool search for LLM agents: BM25 vs embeddings vs rerankers vs Jev on 525 real MCP tools, plus an experimental Jev search engine
- 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-toolkit — MCP-first toolkit for TypeSafe/Jev — the System One decision model. One stdio server (jev mcp) serves any MCP-capable harness, backed by one local event log and Prometheus impact metrics you can scrape into your own Grafana.
- 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
jevmod — Moderation for communities and apps: every message gets a probability for **spam, scam, harassment, nsfw, off-topic, self-harm, doxxing, sexual content involving minors**, and for **rules you write in plain English**. You set the thresholds and the actions. Every decision is logged with its 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
mcp-server-jev — Typed AI decisions for Codex, Claude and any MCP client, powered by TypeSafe Jev. Classify, score and evaluate with one generic 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
openclaw-typesafe-ai — An independent OpenClaw plugin registering one explicitly invoked typesafe_decide tool.
- Where Jev makes a decision: Sends caller-provided state and questions to TypeSafe and returns typed Jev decisions.
- What this project offers: Adds no chat provider, automatic hooks or background service; it is not a scraping or CAPTCHA plugin.
- Project details and fixed source · License: MIT

Model Routing

litellm — LiteLLM can use Jev to classify requests for its complexity-based model router.
- Where Jev makes a decision: Maps requests to configured complexity classes that drive backend routing.
- What this project offers: Makes the complexity judgment behind routing inspectable.
- Project details and fixed source · License: Not declared
oh-my-pi — Oh My Pi includes an optional TypeSafe judgment provider for bounded decisions in coding-agent workflows.
- Where Jev makes a decision: Sends agent state and typed questions to Jev and parses structured answers.
- What this project offers: Adds a replaceable judgment provider to existing agent workflows.
- Project details and fixed source · License: MIT
jev-model-router — A community Claude Code Templates mod that uses Jev to suggest subagent models and reasoning levels.
- Where Jev makes a decision: Evaluates task tier, reasoning needs and production risk; local policy maps results to invocation settings.
- What this project offers: Makes routing rules and per-request choices explicit and configurable.
- Project details and fixed source · License: MIT
openchamber — OpenChamber’s optional automatic model router uses Jev to classify a message before selecting a configured model and reasoning level.
- Where Jev makes a decision: Jev selects a task category; local category mappings determine the model configuration.
- What this project offers: Keeps routing categories and their model assignments explicit.
- Project details and fixed source · License: MIT
firstmate — Firstmate can optionally use Jev to match task briefs to dispatch rules before local policy chooses an Agent configuration.
- Where Jev makes a decision: Sends the task brief and candidate rules to Jev, then resolves execution profiles with confidence and local conditions.
- What this project offers: Separates semantic matching from the final dispatch policy.
- Project details and fixed source · License: MIT
hermes-jev-skills — Jev-powered model routing, memory, compaction, skill selection, computer and browser use for Hermes agents (also 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
atomic — An optional Jev decision backend in the Atomic coding Agent for bounded structured choices such as routing.
- Where Jev makes a decision: Sends predefined questions to Jev and decodes answers for callers; regular models still generate code.
- What this project offers: Separates structured decisions from text-generation interfaces.
- Project details and fixed source · License: Not declared
jev-router — A Claude Code and CLI proxy that asks Jev to score task complexity and pick a model from the account’s available set.
- Where Jev makes a decision: Scores task, reasoning, and tool complexity, then chooses among the exact models the account can run; failures keep the current model.
- What this project offers: Makes model choice an inspectable closed-set decision, and never blocks a prompt when Jev is down.
- Project details and fixed source · License: MIT
vexjoy-agent — An optional Jev routing path that matches VexJoy requests to specialist Agents, skills and workflows.
- Where Jev makes a decision: After deterministic routing guards, Jev judges the remaining candidates and required workflow components.
- What this project offers: Keeps repeatable routing rules and model-selected candidates in separate stages.
- Project details and fixed source · License: MIT
WrongStack — An optional Jev dispatch classifier for choosing among WrongStack specialist Agents.
- Where Jev makes a decision: Jev evaluates the task against eligible specialists; local dispatch rules use the result.
- What this project offers: Makes specialist selection a configurable step in an existing coding Agent.
- Project details and fixed source · License: MIT
JevRouter — Routes among models, subagents, skills, MCP tools and CLIs using a shared candidate set.
- Where Jev makes a decision: Jev makes a Choice; the router separately checks availability, permissions, risk and confirmation policy.
- What this project offers: Records model choices separately from execution policy.
- Project details and fixed source · License: MIT
jev-codex-router — Uses Jev to classify each Codex turn, then applies local rules to choose the model, reasoning effort, and speed mode.
- Where Jev makes a decision: Classifies task difficulty and reasoning needs before local policy selects a model configuration.
- What this project offers: Keeps routing policy and decision logs local for inspection and tuning.
- Project details and fixed source · License: MIT
skillbox — A self-hosted, versioned Agent skills library with optional Jev recommendations.
- Where Jev makes a decision: Jev scores task relevance among skills the client is allowed to access.
- What this project offers: Suggests relevant skills while retaining the library’s client access scope.
- Project details and fixed source · License: MIT
grok-bot-jev — Connect TypeSafe Jev to Grok Bot as a cheap decision layer - usage gates, skill template, 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: MIT
stuntd — Local proxy that learns your app's typed LLM decisions and answers them with a Laya head. Jev and OpenAI compatible.
- 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
hono-jev-router — An experimental semantic HTTP router for Hono using natural-language route descriptions.
- Where Jev makes a decision: Jev scores request-to-description matches; code selects the first route above its threshold.
- What this project offers: Explores semantic routing; the author explicitly warns against using it for authentication or authorization.
- Project details and fixed source · License: MIT
loki — Loki optionally adds Jev typed-judgment tools and routes a new session to a model within the selected gateway.
- Where Jev makes a decision: Assesses the first task’s capability needs; local policy chooses a same-gateway model and keeps the route sticky.
- What this project offers: Makes model routing explicit while retaining the selected route for the session.
- Project details and fixed source · License: MIT
muse-jev-playbook — Jev decision layer for Muse: a fast, cheap TypeSafe AI gate before expensive agent work — confidence policy, recipes, reference router, honest measurement.
- 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
JevLoop — The agent loop where decisions don't cost a large language model call. Zero deps, runs offline, no API key needed.
- 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
pi-jev-router — Automatic model router for Pi coding assistant: integrates Jev via Vercel AI Gateway to dispatch tasks efficiently.
- Where Jev makes a decision: Quickly estimates task complexity from code context and user query, routing between SLMs and frontier models.
- What this project offers: Brings out-of-the-box intelligent cost-saving routing directly into the Pi terminal workflow.
- Project details and fixed source · License: MIT
switchboard — Switchboard is a local Claude Code and Codex router. It assesses a new conversation's task with Jev, applies deterministic confidence rules to select the model and reasoning effort, and pins that route through follow-ups, tool calls, and resume to avoid unnecessary prompt-cache disruption.
- Where Jev makes a decision: Jev classifies the task's capability tier, whether context is sufficient, and the lowest adequate reasoning effort for the candidate model. Application code applies confidence floors, maps the result to a model and effort, and persists that pair for later turns and tool continuations.
- 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
sabi — Adaptive inference scheduling for AI agents — per-round model, effort and provider routing for coding harnesses: a Command Code mod or a local OpenAI-compatible proxy.
- 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 — An open-source LLM router built on LiteLLM and Jev: dynamically routes requests based on task complexity and context.
- Where Jev makes a decision: Evaluates reasoning requirements of input prompts via single forward pass, delegating dispatch to LiteLLM.
- What this project offers: Achieves high-throughput prompt triage and cost optimization without brittle heuristic regexes.
- Project details and fixed source · License: MIT
typesafe-skill-router — An opt-in Hermes Agent plugin that asks Jev to suggest one relevant skill before a model call.
- Where Jev makes a decision: Compares the request with the skill roster; inserts a suggestion only when suitable and abstains on failure.
- What this project offers: Adds a targeted skill hint that the Agent can still ignore.
- Project details and fixed source · License: MIT
dejevu — Jev? Déjà vu. Browser agents that run on instinct, no Jev needed. One look at the page, one call to any open model, one action. Faster than the Jev demo on Google Flights.
- 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-all — Jev for every agentic development workflow — the System One decision model wired into whatever harness an agent codes in: OpenCode today, Claude Code and Hermes adapters next.
- 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
laya-jev-lab — Independent measurements of typed-decision models: Jev (TypeSafe API) vs Laya (open weights), and a local-first cascade that matches Jev's accuracy at 1.8x the speed
- 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 — Cost-aware LLM router that picks the cheapest model capable of handling a query, using TypeSafe's Jev for fast classification instead of an LLM 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
jevia — outcome-aware & adaptive model routing for coding agents with deterministic cache powered by 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
opencode-jev-router — Adaptive reasoning effort for OpenCode via Jev, with an in-process plugin and Responses API proxy
- 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-Auto-Router — Jev Auto Router (Jev Router): experimental per-call GPT model routing for Codex via TypeSafe Jev and a local Responses proxy, with independent task 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: Apache-2.0
Jev-Model-Router-Claude-Code — Begleitmaterial zum Video „Jev + Claude Code: 3 Use Cases".
- 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-router — Pass-through model router for Claude Code and Codex CLI that picks a model tier per human turn with Jev, TypeSafe AI's decision 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: Apache-2.0
tool-prune — Calibrated tool selection and schema pruning for AI agents. Dual-engine: zero-dependency offline TurboQuant or TypeSafe System One (Jev). Prunes candidate MCP tools and schemas down to the relevant set before calling LLMs to eliminate hallucinations and save tokens.
- Where Jev makes a decision: Jev makes atomic decisions on tool selection (`choice`) and whether user intent requires open-ended creative generation (`noul`), with calibrated probability distributions.
- 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-pilot — Let Jev steer Claude Code: the right reasoning effort, subagent model and skill for every prompt. A Claude Code plugin powered by TypeSafe's Jev (OpenRouter / TypeSafe).
- 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-opus — Claude Opus 5.5 with the effort level re-decided every step by the TypeSafe Jev reflex — without breaking the prompt cache. CLI + Claude Code plugin.
- Where Jev makes a decision: Jev chooses the reasoning effort level (low/medium/high) when a prompt arrives and after every tool batch, raising effort on failures and dropping back on pass.
- What this project offers: Re-decides effort level at every step via per-message effort statements to keep prompt cache intact while controlling cost.
- Project details and fixed source · License: MIT
codex-jev-router — Portable JevRouter setup for cost-aware Codex subagent model selection, with English and Russian instructions
- Where Jev makes a decision: Uses Choice to select a subagent tier and Noul to flag exceptionally difficult tasks; routes at subagent creation while keeping thresholds and fallback behavior in local code.
- 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-claw — Typed model routing for OpenClaw agents, 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
jev-codex-pilot — A Codex overlay incorporating JEV to make the best decisions regarding model selection and depth of reasoning. All while automating the process via an automated Kanban system.
- 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 — Model router for Claude Code using 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-smart-router — JEV Smart Router — a Databricks App that uses TypeSafe JEV to pick which model answers each message, then runs inference on the chosen Databricks Foundation Model API endpoint.
- 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
opencode-jev-orchestrator — An OpenCode orchestrator that keeps a cheap sticky parent model and, when Jev flags a hard turn, escalates through a child subagent.
- Where Jev makes a decision: Scores task, reasoning, and tool complexity, then chooses fast / balanced / strong / long; local policy stays, escalates, or fans out.
- What this project offers: Keeps a cheap sticky parent model and opens a stronger child only when Jev flags a hard turn.
- Project details and fixed source · License: MIT
jev-codex-model-and-effort-router — Copy and paste this into your coding agent:
- 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 — **Run it. Log it. Distill it. Own 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: Apache-2.0
tiershift — Policy-driven model routing framework routing every LLM call to the cheapest capable tier in ~180 ms via TypeSafe Jev.
- Where Jev makes a decision: Uses declarative YAML policies evaluated by Jev discrete classification without requiring pre-collected training data.
- What this project offers: Provides unified TypeScript and Python interfaces to minimize inference spend with minimal routing overhead.
- Project details and fixed source · License: MIT
todo-jev — A task-routing experiment combining skill conditions and environment checks to suggest rules, skills or a large model.
- Where Jev makes a decision: Jev classifies requests and matches skills, with heuristic fallback when unavailable.
- What this project offers: Classification and recommendations are implemented; execution handlers still return examples and need real integrations.
- Project details and fixed source · License: MIT
chat2jev — Convert OpenAI-compatible Chat Completions requests into TypeSafe System One (Jev) **State / Questions**, compare generated text with structured judgments, and publish reusable question sets as proxy routes.
- 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-native-router — Experimental native Codex Desktop and CLI model routing with Jev and a configurable allowlist
- 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
hermes-jev — Jev decision sidekick for Hermes Agent — TypeSafe and Cloudflare, explicit tools and official 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
Janus — Framework for measuring when to employ Jev versus generative LLMs on proprietary datasets, routing queries based on measured benchmarks.
- Where Jev makes a decision: Benchmarks Jev response accuracy and latency via a TypeSafe provider integration, deriving empirical routing policies.
- What this project offers: Replaces intuition with empirical data when adopting discrete decision models, optimizing overall cost while preserving task success.
- Project details and fixed source · License: MIT
jev-agent-hooks — TypeSafe Jev hooks for Claude Code, Codex and pi: per-turn skill suggestion and subagent model routing
- 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-cc-codex-router — Per-turn model routing proxy for Codex: asks Jev which tier each task needs, rewrites the model, retries flaky upstream errors.
- 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-claude-router — Model router for Claude Code using 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-model-router — Cost-optimized OpenRouter model router using TypeSafe's Jev, with a live full-catalog scorer instead of a hardcoded model list
- 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-research — A Jev and Herdr integration guide with a prototype for routing tasks to different Agents.
- Where Jev makes a decision: Uses task and repository state to choose an executor and assess risk and dispatch readiness.
- What this project offers: Provides a readable, editable example of multi-Agent task routing.
- Project details and fixed source · License: MIT
jev-router-playground — A model-routing playground where Jev picks a candidate and users compare the resulting answers.
- Where Jev makes a decision: Selects a model from the task and candidate profiles and records probabilities and runs.
- What this project offers: Exports observations for checking routing choices against user preferences.
- Project details and fixed source · License: MIT
jev-routing-experiment — Benchmarking TypeSafe's Jev decision model as a cost-efficient LLM router on RouterArena
- 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
jevbus — A streaming event bus whose routing, subscription and consumption are decided by a probabilistic judge. The reference judge is TypeSafe AI's Jev (System One) model: send it a payload and a set of typed questions, get back calibrated probabilities instead of prose.
- 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
openclaw-jev-plugin — A silenced message never reaches the language model, so it costs one Jev call and no model tokens. Direct messages always get an answer unless you choose to gate them too.
- 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
cribrix — Self-hosted RAG service that uses Jev to decide which retrieved context reaches the generator and whether the generated answer is released.
- Where Jev makes a decision: All calls go through the official typesafe-sdk (AsyncTypeSafeClient.system_one):
- 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
hermes-jev-router — Hermes Agent plugin: TypeSafe Jev model routing + trim-then-compress
- 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-codex-factory — Route smarter. Code in parallel. Resume what breaks. A Jev-powered multi-agent factory for 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: Apache-2.0
jev-lab — Open lab: Jev (TypeSafe System One) routing in front of Claude Code - measured bugs, patch, and a hard fallback with alerts
- 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
JudgeJev — The public site replays **17 real, recorded Jev evaluations** of fictional support cases. It starts with a false shipping guarantee that scored **15.1%**, alongside a correct control that scored **95.5%**. You can inspect raw requests and responses, adjust decision rules, and see why a five-pair candidate fails a release gate.
- 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
omp-plugin-jev-router — Route Oh My Pi prompts between simple and advanced models with TypeSafe AI's Jev classifier.
- 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
stuntdouble — Drop-in /v1/systemone proxy that shadows Jev with local decision models (Kev, Laya) and reports whether you can swap
- 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-decision-gateway — A gateway that asks Jev continue / tool / verify questions and invokes a generative LLM only when policy says generation is needed.
- Where Jev makes a decision: TypeSafeClient.systemOne answers policy questions; the adapter then decides whether a generative model runs.
- What this project offers: Places expensive generation behind a Jev gate. Author-reported call savings were not retested here.
- Project details and fixed source · License: MIT
jev-demo — A customer-service routing demo that batches Jev questions before following the resulting route.
- Where Jev makes a decision: Assesses classification levels, human-handoff intent and frustration, with low-confidence escalation.
- What this project offers: Combines routing and human handoff while leaving response generation to the application.
- Project details and fixed source · License: Not declared
jev-gateway — Session-aware OpenAI-compatible model-routing gateway powered by 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: AGPL-3.0

SDK & Decision Frameworks

composio — An optional TypeSafe provider for Composio that uses Jev to choose among tools and bounded argument options.
- Where Jev makes a decision: Turns tool or action conditions into structured questions and passes Jev answers to local invocation logic.
- What this project offers: Adds structured judgments to existing tool interfaces.
- Project details and fixed source · License: MIT
ai — The TypeSafe provider in AI SDK lets TypeScript applications call Jev through the shared evaluate interface.
- Where Jev makes a decision: Maps choice, score, and yes/no questions to TypeSafe System One requests and parses typed results.
- What this project offers: Reuses a common evaluation interface within AI SDK applications.
- Project details and fixed source · License: Not declared
eliza — An optional TypeSafe HTTP adapter in Eliza’s source, not registered with the Agent runtime by default.
- Where Jev makes a decision: Only an explicit systemOne call sends state and questions, returning validated typed answers.
- What this project offers: Provides a reusable server-side module; its presence is not evidence of deployed Jev adoption.
- Project details and fixed source · License: MIT
langchainjs — An optional LangChain.js TypeSafeClassifier integration for sending state and predefined questions to Jev.
- Where Jev makes a decision: Uses invoke to call TypeSafe and parse choice, noul, score and probability fields.
- What this project offers: Adds typed decisions to LangChain workflows without treating Jev as a chat generator.
- Project details and fixed source · License: MIT
rig-typesafeai — An experimental TypeSafe crate in Rig for expressing Jev questions and answers with Rust types.
- Where Jev makes a decision: Sends application state and questions to Jev and parses Choice, Score or Noul answers.
- What this project offers: Reuses field layouts between questions and answers and validates answers against questions.
- Project details and fixed source · License: MIT
jev — jevos is an open-source, Jev-compatible alternative to TypeSafe's Jev for yes/no decisions that runs entirely on a laptop CPU. Send text plus a yes/no question over HTTP and get back P(yes) from a single forward pass of a 1B model — no text generation, no GPU required.
- 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 — An independent System One decision server compatible with Jev’s API, running an open DiffusionGemma model.
- Where Jev makes a decision: Accepts Jev-style state and Noul, Choice, and Score questions, producing probabilities with a local model.
- What this project offers: Lets existing TypeSafe SDKs connect to a self-hosted compatible service.
- Project details and fixed source · License: Apache-2.0
req_llm — A TypeSafe provider for calling Jev through ReqLLM’s evaluate interface in Elixir.
- Where Jev makes a decision: Sends state and questions, normalizes answers and retains the raw provider response.
- What this project offers: Keeps decision evaluation separate from chat generation in Elixir applications.
- Project details and fixed source · License: Apache-2.0
simple-jev — Adapter turning open LLM endpoints into Jev-compatible classification services without training a separate classifier head.
- Where Jev makes a decision: Extracts log-probabilities of candidate tokens from model vocabulary logits, formatting them into standard Jev responses.
- What this project offers: Enables rapid prototyping of Jev-like decision workflows against standard inference servers such as vLLM or Hugging Face.
- Project details and fixed source · License: Apache-2.0
jev-skill — This project is a collection of Jev use cases, workflows, and agent skills with a stdlib-only Python decision wrapper.
- 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
instructor-php — A TypeSafe Decision driver within Instructor PHP’s Polyglot module.
- Where Jev makes a decision: Converts application state and typed questions into Jev requests and maps responses to PHP decision objects.
- What this project offers: Lets PHP applications use Jev through a shared Decision interface.
- Project details and fixed source · License: MIT
jev-visual — Local Jev-like visual inference experiment on Apple Silicon Mac. Scores and classifies single images across multiple questions with 3 playable game demos.
- Where Jev makes a decision: Reuses multimodal visual context to score candidate answers directly from logits without autoregressive generation.
- What this project offers: Brings Jev-style single-pass multi-question scoring to local edge vision on Apple Silicon.
- Project details and fixed source · License: MIT
pi-fabric — Pi’s programmable runtime includes an optional Jev loop for observing state, making decisions and running bounded actions.
- Where Jev makes a decision: Programmed questions feed Jev judgments into local action logic under runtime budgets.
- What this project offers: Keeps observation, judgment and execution steps in a reusable program.
- Project details and fixed source · License: MIT
typesafe-sdk-js — The JavaScript and TypeScript SDK published by TypeSafe, with typed Jev requests and answers.
- Where Jev makes a decision: systemOne submits state and named questions and infers answer types from the questions.
- What this project offers: Includes ESM, CommonJS and TypeScript declarations for application integration.
- Project details and fixed source · License: MIT
typesafe-sdk-python — Official TypeSafe Python SDK with synchronous and asynchronous clients for Jev System One, plus question and answer types.
- Where Jev makes a decision: system_one sends context and choice, score or yes/no questions to the API, then parses answers by question name.
- What this project offers: Reuses request handling, typed answers and connection management in Python, with support for with and async with.
- Project details and fixed source · License: MIT
openai-scala-client — A dedicated TypeSafe module in a Scala client that supports multiple AI providers.
- Where Jev makes a decision: Sends shared state and typed questions to Jev and parses structured answers.
- What this project offers: Lets Scala applications reuse provider transport and error-handling conventions.
- Project details and fixed source · License: MIT
jev-dsh-decision — Provides Jev structured decision support for Agent Harness to recommend tools, Skills and Agents and return judgments with probabilities, with a native DeepSeek Harness plugin and an iPolloWork entry serving OpenCode, DeepSeek Harness and Codex 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: Not declared
jevbench — JevBench v1 - a benchmark for Jev-class typed decision models: smart, cheap, fast, reliable, open.
- 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
runline — A TypeSafe plugin exposing Jev decisions as callable actions in Runline Agent JavaScript.
- Where Jev makes a decision: evaluate, choice, score and noul actions submit questions and retain answers and usage.
- What this project offers: Composes decisions with Runline plugins; it does not automatically inspect every shell command for safety.
- Project details and fixed source · License: Not declared
ai — A Jev forwarding endpoint in the Hack Club AI proxy, using its authentication, limits and usage logging.
- Where Jev makes a decision: Forwards authorized structured requests to TypeSafe and returns answers with usage accounting.
- What this project offers: Adds a decision API to the existing proxy rather than an MCP tool server.
- Project details and fixed source · License: Not declared
effect-agent — An Effect Agent TypeSafe decision provider for typed question sets and optional model selection.
- Where Jev makes a decision: Jev answers probability, choice and score questions for application transitions or model selection.
- What this project offers: Integrates decisions into Effect dependencies and errors; applications configure retries and deadlines.
- Project details and fixed source · License: MIT
Jev — Unofficial TypeSafe Jev showcase — System One decisions, not chat.
- 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
advocaat — A small TypeScript client for asking Jev multiple typed questions about the same data.
- Where Jev makes a decision: Combines yes/no, Choice and Score questions and maps responses to typed values.
- What this project offers: Reuses one interface for probabilities, choices and scores.
- Project details and fixed source · License: MIT
jeview — An unofficial local visualizer for Jev (TypeSafe): a live view of every call your code makes. Not affiliated with TypeSafe AI.
- 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
ruby_decision_model — A Ruby decision-model client for Jev through TypeSafe’s native API or OpenRouter.
- Where Jev makes a decision: A shared Client sends state and typed questions and parses choices, probabilities, scores and usage.
- What this project offers: Uses only the Ruby standard library and supports provider selection behind one interface.
- Project details and fixed source · License: MIT
solar-mini4-jev — A drop-in wrapper that exposes Upstage **Solar Mini4** through the TypeSafe Jev System One API shape.
- 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
ask-jev-skill — A skill for Hermes and other agents to query TypeSafe Jev for bounded option judgments and confidence escalations.
- Where Jev makes a decision: Evaluates candidate intents for agent workflows; escalates uncertain choices to human review or higher-tier models.
- What this project offers: Equips autonomous agents with deterministic narrow judgments, mitigating infinite-loop hallucinations.
- Project details and fixed source · License: MIT
go-jev — Go SDK and CLI for TypeSafe Jev: typed decisions (yes/no, choice, score) from a 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 — Integrates Jev as an asynchronous Elixir/OTP process whose replies are handled with GenServer pattern matching.
- Where Jev makes a decision: Sends state and typed questions to TypeSafe, then delivers answers as messages.
- What this project offers: Fits decision calls into existing message-handling and supervision patterns.
- Project details and fixed source · License: MIT
pijev — pijev turns Jev's option-order variations into a single averaged prediction, with Brier score and log loss guaranteed no worse than the average across the included orderings. All permutations run in one `system_one` request. Keep the same calls and official response types; pijev handles the rest.
- 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-capability-atlas — This repository collects real Jev API-call receipts, test suites, and bilingual guides to map which narrow-decision tasks suit Jev and how Agents should evaluate and report fit.
- 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
minojev — Decisions, not tokens: minojev reads calibrated, typed probability distributions straight from hidden states in one forward pass — zero output tokens, fully reproducible on a laptop CPU.
- 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-agent-design-with-topk-logits-choices — Research design for a Jev-native agent system: tool integration, speculative parameter proposals, external helper logits Top-k proposals with Jev-controlled fallback ,decision-aware hierarchical memory, and dependency-aware replanning.Feature:Jev naturallanguage conversation prototype using external helper logits and dynamic Top-k token selection.
- 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-to-answer — 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
jevalyn — The decision layer for your Rails app. A Rails-native wrapper around TypeSafe's Jev System One API: typed, calibrated decisions in your control flow.
- 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-rs — System One judgments (noul/choice/score) from any LLM in one prefill — a Rust, Jev-compatible /v1/systemone engine
- 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
swift-jev — A Swift client for TypeSafe AI's Jev — typed judgements, not 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
swift-typesafe — A community Swift TypeSafe client with typed questions, dynamic questions and response parsing.
- Where Jev makes a decision: Sends Jev questions through systemOne and exposes answers as Swift types or dynamic maps.
- What this project offers: Supports integration on its documented platforms; Swift and OS requirements are version-specific.
- Project details and fixed source · License: MIT
discern — A semantic control-flow library for Effect: Jev's `Choice` / `Noul` / `Score` answers become typed branches. Thresholds are caller-supplied, and an answer below them takes an explicit `Uncertain` branch the compiler forces you to handle rather than being rounded up to the top label. Procedure routing filters candidates with deterministic predicates first and skips the model call entirely when one candidate survives.
- 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
learn-jev-end-to-end — **Learn Jev end to end** is a free, hands-on course. In 12 short notebooks you go from *"what is Jev?"* to building **13 real AI tools** with it: an email triage job, a scam-text detector, a code vulnerability hunter, an agent safety guard and more. You need **one API key**, and running the whole course costs **less than $0.20**.
- 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
super-jev — A TypeScript decision-to-action harness connecting evidence, Jev judgments, permitted actions, and outcome records.
- Where Jev makes a decision: Submits typed questions, validates answers, and lets domain rules choose registered tools with permission and argument checks.
- What this project offers: Keeps local traces of judgments, tool calls, and outcomes.
- Project details and fixed source · License: MIT
typesafe-ai — A Rust TypeSafe client with asynchronous reqwest or blocking ureq backends and observable retries.
- Where Jev makes a decision: Sends multiple Jev questions over shared state and parses typed answers, probabilities and usage.
- What this project offers: Offers synchronous or asynchronous integration with inspectable errors.
- Project details and fixed source · License: Apache-2.0
typesafeai-dotnet-sdk — Community .NET SDK for TypeSafe AI and Jev, providing asynchronous typed evaluation for Choice, Score, and Noul primitives.
- Where Jev makes a decision: Wraps System One API endpoints in TypeSafeClient to issue parallel question evaluations and parse responses into immutable C# records.
- What this project offers: Brings native Jev decision primitives to the .NET ecosystem with dependency injection integration and configurable retry policies.
- Project details and fixed source · License: MIT
usejev — Run Laya locally with Bun: native ONNX inference, a TypeSafe-compatible API, and a bilingual decision playground.
- 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
SpecPi — A Pi configuration and extension bundle with an optional Jev advisor for capabilities and workflow checks.
- Where Jev makes a decision: Jev evaluates candidate capabilities, outputs and task state; per-feature switches control applying or recording advice.
- What this project offers: Advisor failures return to the original path rather than guaranteeing better parameters or lower costs.
- Project details and fixed source · License: MIT
typesafe-sdk-java — A community Java TypeSafe client with a Spring Boot Starter for configuring Jev calls.
- Where Jev makes a decision: Sends Java state and Noul, Choice, and Score questions to System One and parses typed results.
- What this project offers: Reuses request, configuration, and error-handling code in Java and Spring Boot projects.
- Project details and fixed source · License: MIT
jev-ai-sdk-form-router — Route form submissions to the right people with Jev and AI SDK.
- 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-dspy-lab — Reproducible calibration and selective-risk benchmarks for Jev/TypeSafe decisions in DSPy workflows
- 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-sdk-go — A Go TypeSafe SDK for defining typed questions and reading Jev choices, scores, and probabilities.
- Where Jev makes a decision: Validates requests, calls System One, and decodes typed answers.
- What this project offers: Packages authentication, requests, and error handling in a reusable Go client.
- Project details and fixed source · License: MIT
hermes-jev-plugin — TypeSafe Jev (System One) decision tools for Hermes Agent: jev_check / jev_route / jev_score / jev_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: MIT
jevgo — Unofficial Go client for the TypeSafe AI System One API (Jev) — typed questions in, calibrated answers out.
- 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
JevOps — Jev is a **gate**, not a generator. This package does **not** write Lean. Lake (or another oracle) lives in the implementation that *uses* the kernel.
- 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: AGPL-3.0
zod-jev — Adds semantic rules to Zod validation, such as checking whether text matches a description or contains personal information.
- Where Jev makes a decision: Combines semantic conditions from one parse into Jev Noul questions and maps probabilities to validation results.
- What this project offers: Uses Zod’s error structure to attach semantic validation issues to fields.
- Project details and fixed source · License: MIT
jev_jsonschema — `probabilities` is keyed by your schema's values, not Jev's internal labels, so a score of `1`–`5` reads as `"1"`–`"5"` and not `"0"`–`"4"`. Noul questions carry no confidence of their own, so `confidence` is `None` for booleans and 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
jev-android — A Kotlin Android SDK for UI automation powered by TypeSafe Jev, with an accessibility runtime and sample app.
- 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-dsl — An early Haskell DSL that describes labeled Jev questions, renders requests and decodes matching answers.
- Where Jev makes a decision: Uses inferred types and labeled handlers to connect Choice answers to predefined program branches.
- What this project offers: Keeps questions, result types and branch handling in one inspectable definition.
- Project details and fixed source · License: MIT
open-bonsai-jev — openjev's mechanism, Bonsai's weights: typed decisions read straight from one forward pass of a 1.75-bit 27B model. Credit to TheoLeeCJ (SemIf/OpenJev) and PrismML.
- 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-ai-rs — An independently maintained Rust SDK with async and blocking clients, retries and response metadata.
- Where Jev makes a decision: Sends application state and questions to Jev and parses Choice, Score or Noul answers.
- What this project offers: Packages requests and response parsing for typed decisions in applications.
- Project details and fixed source · License: MIT
typesafe-sdk — A community Ruby client for TypeSafe System One, defaulting to jev-latest.
- Where Jev makes a decision: Builds Choice, Score and Noul questions and exposes parsed answers by type.
- What this project offers: Lets Ruby programs read choices, scores and probabilities directly.
- Project details and fixed source · License: MIT
daf-jev — A Python toolkit for Jev requests, batch evaluation, calibration and MCP access.
- Where Jev makes a decision: Builds Noul, Choice and Score questions, then combines returned probabilities through local functions.
- What this project offers: Reuses request, failure-recording and evaluation interfaces across experiments.
- Project details and fixed source · License: MIT
jev-go — A community Go SDK and CLI supporting TypeSafe directly and Vercel AI Gateway.
- Where Jev makes a decision: Sends application state and questions to Jev and parses Choice, Score or Noul answers.
- What this project offers: Packages requests and response parsing for typed decisions in applications.
- Project details and fixed source · License: MIT
jev-ood-calibration — Independent calibration test of TypeSafe's Jev on a task it cannot have seen: 900 rule-generated support tickets (choice / score / boolean) plus 3 public benchmarks via Vercel AI Gateway. Raw responses, ECE with noise floor, temperature refit, per-type sign of miscalibration. Reproducible for ~$0.06.
- 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-pilot — Fast System-1 Decision, Arbitration & Safety Engine for Autonomous AI Agents (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
jevriel — **Codex · Claude Code · Portable skill** | [Apache-2.0 code and docs](LICENSE) | Early release
- 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
goodall — An optional TypeSafe package in a Go Agent library, using Jev as a tool or routing judge alongside chat models.
- Where Jev makes a decision: Submits typed questions through a separate client for tools, turn routing and a mail-triage example.
- What this project offers: Keeps typed judgments separate from the generative Agent loop.
- Project details and fixed source · License: MIT
jev — Ruby client for the typesafe AI 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 — A Go client for the TypeSafe AI's System One API and its model, 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-go — A Go TypeSafe System One client with typed questions, answers and batching helpers.
- Where Jev makes a decision: Sends application state and questions to Jev and parses Choice, Score or Noul answers.
- What this project offers: Packages requests and response parsing for typed decisions in applications.
- Project details and fixed source · License: MIT
jev-java — Unofficial Java SDK for TypeSafe Jev and Vercel AI Gateway, with Spring Boot and WebClient support
- 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-numeric — **Both are multiway decision trees; decimal-digit decoding is a ten-way instance.** On an aligned decimal grid, they can have identical branches and leaves, expressed through different prompts. The digit is a **Choice option**, not a vocabulary token; Jev returns the option probabilities directly.
- 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-sdk-java — Type-safe Java 21 client for the TypeSafe AI Jev (System One) decision API
- 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-web-analyzer — See what Jev thinks about your SaaS website — powered by ReplyNodes web context and Vercel AI Gateway.
- 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
jevlang — The simplest way to write decision workflows in Python. Python with a smart if.
- 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
limpet — A Stop hook guardrail for coding agents: prevents premature completion by judging plain-language rules via Jev.
- Where Jev makes a decision: Intercepts agent termination signals, using Jev to verify if context meets natural language acceptance criteria.
- What this project offers: Prevents coding agents from cutting corners or faking completion, boosting autonomous task completion rates.
- Project details and fixed source · License: MIT
questions — A TypeScript decision library that asks typed questions via Zod or native batches, defaulting to TypeSafe Jev, with optional Vercel or generative adapters.
- Where Jev makes a decision: Posts state plus Choice, Score, or Noul questions to `/v1/systemone`, defaulting to jev-latest.
- What this project offers: The same question definitions can target TypeSafe, Vercel, or a generative backend without rewriting callers.
- Project details and fixed source · License: MIT
typesafe_sdk — An Elixir TypeSafe SDK that brings Jev’s typed questions and probabilistic answers into Elixir applications.
- Where Jev makes a decision: Builds state and Noul, Choice, and Score requests and parses System One responses.
- What this project offers: Reuses Elixir data structures and client wrappers for decision APIs.
- Project details and fixed source · License: MIT
zio-typesafe-ai — A Scala 3 / ZIO client that asks typed Noul, Choice, and Score questions in one round-trip and returns a NamedTuple of answers.
- Where Jev makes a decision: Encodes state and typed questions as a System One request and decodes Probability, Choice distributions, and Score values.
- What this project offers: Keeps Jev questions and answers as compile-time field names in ZIO, without raw JSON key lookups.
- Project details and fixed source · License: Apache-2.0
ask-jev-ai — Most AI demos generate text. Jev does not. It reads a sentence and returns typed answers with probabilities: a choice, a yes or no, a score. That makes it usable as a primitive inside ordinary code rather than a chatbot bolted onto a 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: Not declared
jev-layer — Portable System-1 decision layer for agent harnesses with host-owned routing, receipts, replay, and fail-open integrations.
- 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-phone — Drive a phone with a model that never writes a word. TypeSafe's Jev picks each action, phone-use runs it on iOS and Android.
- 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-PhoneControl — Visual Android automation powered by three agents: vision, a text-only supervisor, and TypeSafe JEV. Executes actions through ADB with a local web console.
- 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
jevrag — Replaces hardcoded RAG thresholds with explicit calibrated decision points. Five primitives (retrieval stopping, chunk splitting, context selection, answer abstention, cache trust) behind one swappable state → Decision → confidence → action interface, each evaluated on real datasets with a calibration harness that reports honestly.
- Where Jev makes a decision: jevrag/decision.py — the `ask(state, questions) -> DecisionResult` method calls `api.typesafe.ai/v1/systemone` via the Jev backend. All five primitives in `jevrag/primitives/` route through this method.
- 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
dsh-jev-decide — This DSH plugin registers TypeSafe Jev as an Agent tool that returns calibrated probabilities for noul, choice, and score judgments without generating 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
everything-about-jev — tell you everything about jev,TypeSafe AI's System One model for typed 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: MIT
jebadiah — Jebadiah, an open System One decision model: trainer, data builders, evals and every run record
- 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-benchmark — Rubric-Based Zero-Shot Classification Benchmark: Jev vs Claude Haiku 4.5 vs Claude Sonnet 5 vs OpenJev on rubric-conditioned classification, chained decision execution, and exam grading -- with full price tracking.
- 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-builder — A browser form for building requests to TypeSafe's Jev: pick a template, fill in the blanks, copy the request. No JSON, no install, runs locally.
- 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-does-not-play-dice — Code, recorded outputs, and analysis scripts for probability-output experiments with Jev: fair random draws, Noul (Yes/No) questions, and forecast documents.
- Where Jev makes a decision: The live evaluator calls hosted Jev through the Vercel AI SDK `experimental_evaluate` path:
- 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-Persian-Benchmark — Benchmarks for **Jev** on **480 authored general Persian questions** and a **24-excerpt classical Persian poetry pilot** (48 main questions plus 48 controls). Related general questions are batched; poetry questions run individually. Raw responses are saved and answers are scored locally, without a runtime model judge. The general benchmark's historical Laya comparison is retained below.
- 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-skills — Practical agent skills and examples for building with Jev. API setup, routing, ranking, and evidence 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
Jev4Mellea — This is an unofficial, synchronous adapter. Jev evaluates text; it does not generate or repair 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: Apache-2.0
jevex — An Agent experiment where Jev directs a tool loop, a chat model fills arguments and prose, and MCP tools execute.
- Where Jev makes a decision: Jev selects the next action and approves the concrete call; tool results feed the next state.
- What this project offers: Separates decisions, content generation and execution, with author-run comparisons.
- Project details and fixed source · License: MIT
pi-typesafe-jev — A Pi extension exposing TypeSafe judgments as five narrow tools, keeping threshold and action control in host code.
- Where Jev makes a decision: Packages choice, score, and boolean judgments into five Pi tools for structured agent decisions.
- What this project offers: Strictly decouples semantic evaluation from execution, keeping automated scripts safely constrained.
- Project details and fixed source · License: Not declared
RSI-Jev-Slay-the-Spire-2 — 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
typesafe-ai-rails — Ruby on Rails integration gem for TypeSafe AI and Jev, providing model-level classification and decision policy patterns.
- Where Jev makes a decision: Dispatches state and criteria from ActiveRecord models or services to Jev System One endpoints, logging structured outcomes.
- What this project offers: Simplifies adding Jev discrete judgments to Rails web apps with standard Railtie configuration and policy wrappers.
- Project details and fixed source · License: MIT
typesafe-go — An unofficial Go client without third-party dependencies for System One calls and model discovery.
- Where Jev makes a decision: Sends application state and questions to Jev and parses Choice, Score or Noul answers.
- What this project offers: Packages requests and response parsing for typed decisions in applications.
- Project details and fixed source · License: MIT
typesafe-sdk-rust — A Rust client for TypeSafe with asynchronous and optional blocking calls plus typed question and answer wrappers.
- Where Jev makes a decision: Builds Jev requests and handles authentication, transport and structured response parsing.
- What this project offers: Reuses API models and transport logic in Rust applications.
- Project details and fixed source · License: MIT
jev_dart — Jev Dart SDK to build cli, server and Flutter apps.
- 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-architecture-research — Black-box reverse engineering research archive for the Jev decision 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-by-example — Ten runnable Jev examples for agent decisions: memory conflicts, tool-result checks, recovery, context selection, and handoffs. JavaScript, zero dependencies.
- 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-doom — Watch Jev play Freedoom in a local dashboard. TypeSafe direct and Vercel AI Gateway, inspectable decisions, and bounded spending.
- 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-starter — TypeScript patterns for thresholds, fallbacks, human review and evaluation on top of the TypeSafe SDK.
- Where Jev makes a decision: Jev returns judgments; application policies choose automatic handling, fallback or human review.
- What this project offers: Separates model calls, execution policy and evaluation.
- Project details and fixed source · License: MIT
jevclient — An asynchronous Python Jev client that batches typed questions in one request.
- Where Jev makes a decision: Calls TypeSafe through aiohttp and parses choices, scores and probabilities into objects.
- What this project offers: Fits existing async applications without parsing generated prose.
- Project details and fixed source · License: MIT
jevgo — A community Go client with a standard-library core and optional Langfuse tracing.
- Where Jev makes a decision: Sends application state and questions to Jev and parses Choice, Score or Noul answers.
- What this project offers: Packages requests and response parsing for typed decisions in applications.
- Project details and fixed source · License: MIT
qualm — A TypeScript wrapper for Jev decisions with an explicit unsure branch.
- Where Jev makes a decision: Preserves probabilities and option types and routes uncertainty to a caller-supplied fallback.
- What this project offers: Uses types to require uncertainty handling without guaranteeing model correctness.
- Project details and fixed source · License: MIT
typesafe-ai-jev-example — This repository provides six runnable Python demos and four notes covering TypeSafe Jev primitives and composition patterns, with offline mock mode and committed live samples from jev-1.13.0.
- 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-go — A TypeSafe System One client that uses only the Go standard library to send Jev questions and read structured answers.
- Where Jev makes a decision: Builds requests from state and Noul, Choice or Score questions, then validates and parses responses.
- What this project offers: Reuses transport, typed mappings and error handling in Go applications.
- Project details and fixed source · License: MIT
typesafe-jev-examples — Worked examples for TypeSafe's Jev System One decision model, runnable today through OpenRouter
- 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-sdk-php — A community TypeSafe SDK for PHP 8.2+, with synchronous calls and Guzzle-based async requests.
- Where Jev makes a decision: Sends application state and questions to Jev and parses Choice, Score or Noul answers.
- What this project offers: Packages requests and response parsing for typed decisions in applications.
- Project details and fixed source · License: MIT
WaterSheep — Open-weight Jev alternative that serves /v1/systemone locally, with calibrated Noul, Choice, Score and multi-label answers.
- Where Jev makes a decision: Serves /v1/systemone locally to evaluate Noul, Choice, Score and multi-label structured questions with calibrated probabilities.
- What this project offers: Runs a high-performance decision server locally compatible with Jev APIs, without relying on proprietary cloud APIs.
- Project details and fixed source · License: Apache-2.0
claude-jev-mod — Typed decisions in Claude Code: adds $.jev over TypeSafe's Jev, through OpenRouter, Vercel AI Gateway, Cloudflare Workers AI, LiteLLM or the TypeSafe API.
- 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 — Unofficial Go client for TypeSafe's System One API and its model, 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_playground — Jev answers typed questions about a state with calibrated numbers. This repo is where we find out which of those numbers deserve to drive code, and where a regex or a constant does the job better.
- 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-go — A small unofficial Go SDK for Jev calls and model listing.
- Where Jev makes a decision: Sends application state and questions to Jev and parses Choice, Score or Noul answers.
- What this project offers: Packages requests and response parsing for typed decisions in applications.
- Project details and fixed source · License: Not declared
jev-go-sdk — Dependency-free Go client for TypeSafe AI's System One API and the 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: Apache-2.0
jev-is-not-odd — A probabilistic, AI-powered utility to determine if a number is not odd (or not even) using TypeSafe's Jev model and the Vercel AI SDK.
- 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-lab — This repository provides a single-page classifier demo that sends text with choice questions to Jev and displays the request JSON, probability distribution, confidence, latency, and token usage.
- 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-lab — Hands-on research lab for TypeSafe's Jev (System One model): reproducible benchmarks of Noul/Choice/Score primitives, confidence gating, fan-out latency, agent control — plus a living audit of the Jev ecosystem.
- 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-labs — Never confidently wrong: a TLA+-verified consensus kernel around TypeSafe's Jev, run through 1,680 chaos-tested pharmacy decisions with zero wrong verdicts. Film, code, and every captured 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
jev-msw — Mock Jev API decisions with MSW for deterministic tests without real API calls or credits.
- 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-swap — Find the LLM calls in your codebase that are really decisions, see what they'd save on TypeSafe Jev, and prove it on live traffic before you swap. TypeScript, JavaScript, Python.
- 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-tab-order — **Organize the entire window with a single Jev API request.** Grouping and ordering decisions are evaluated together, regardless of the number of tabs.
- 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 — Automated issue & PR triage for open-source maintainers, powered by Jev (TypeSafe AI).
- 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
jevcore — A judgement primitive for TypeSafe **System One / Jev** — ask N things × K typed questions in bounded, cheap, fail-open requests — plus the **JEV harness**, the closed boundary in code that makes a Jev answer safe to consume. Standard library 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
jevinf — An inference engine for decision models of the Jev kind: each candidate path runs as segmented forwards with prefix reuse, and the Jev wire contract is served on top. NanoJev is the backend wired up today.
- 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
jevish — Every mode auto-curries when called with only the patterns:
- 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
jevpolicy — JevPolicy is an open-source TypeScript decision runtime that turns probabilistic judgments from Jev, accessed through Vercel AI Gateway, into versioned, deterministic, replayable, observable application 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: Apache-2.0
Jevs-Garage — System One turns unstructured or structured state into fast probabilistic judgments. Instead of asking for free-form prose, these demos ask `Choice`, `Score`, and `Noul` questions and receive typed values with uncertainty that application code can reason about.
- 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-ai-ruby — A stdlib-only Ruby client that sends Choice, Score, or Noul questions to TypeSafe System One.
- Where Jev makes a decision: system_one POSTs to /v1/systemone, defaulting to https://api.typesafe.ai and jev-latest.
- What this project offers: Gives Ruby programs a stdlib path to ask Jev without wrapping a generative SDK.
- Project details and fixed source · License: MIT
typesafe-go — An unofficial Go SDK with typed answers, retries and context cancellation.
- Where Jev makes a decision: Sends application state and questions to Jev and parses Choice, Score or Noul answers.
- What this project offers: Packages requests and response parsing for typed decisions in applications.
- Project details and fixed source · License: MIT
typesafe-rs — A community Rust Jev client with async requests, an optional blocking interface and local mock testing.
- Where Jev makes a decision: Sends state and named questions to TypeSafe and parses choice, score and noul answers.
- What this project offers: Provides client configuration, retries and error types for async or blocking Rust applications.
- Project details and fixed source · License: MIT
typesafe-sdk-swift — An experimental Swift SDK for TypeSafe using Swift Package Manager, Swift concurrency, and URLSession.
- Where Jev makes a decision: Sends state and typed questions to System One and receives structured answers through async/await.
- What this project offers: Lets Swift applications reuse Jev request and response handling.
- Project details and fixed source · License: MIT
TypeSafeSDK — An unofficial .NET client that POSTs state and typed questions to TypeSafe /v1/systemone. The parent repo also contains unrelated SDK dumps.
- Where Jev makes a decision: TypeSafeClient.SystemOneAsync POSTs {Endpoint}/v1/systemone, defaulting to https://api.typesafe.ai and jev-latest.
- What this project offers: Gives .NET an HTTP path to ask Jev. Other SDKs in the parent dump are not Jev integrations. Distinct from cataloged saibimajdi/typesafeai-dotnet-sdk.
- Project details and fixed source · License: MIT

SDK Integrations

langchain — An optional Jev classifier integration for Python LangChain workflows.
- Where Jev makes a decision: Submits binary, categorical and ordered-score questions and returns typed answers with probabilities.
- What this project offers: Adds a classification step that can participate in existing LangChain pipelines.
- Project details and fixed source · License: MIT
pydantic-ai — An optional TypeSafe provider and Jev model integration for Pydantic AI.
- Where Jev makes a decision: Converts supported structured output fields into typed Jev questions and maps answers back to the output model.
- What this project offers: Lets supported classification outputs use the existing Pydantic AI interface.
- Project details and fixed source · License: MIT
ax — Ax provides a TypeSafe integration for boolean or finite-class signatures and native Jev answers.
- Where Jev makes a decision: Maps supported signatures to Jev questions or sends native System One requests.
- What this project offers: Reuses structured signatures and Jev probabilities within Ax workflows.
- Project details and fixed source · License: Apache-2.0
ruby_llm-typesafe — A TypeSafe provider for RubyLLM 2 that exposes Jev’s three judgment types through structured output.
- Where Jev makes a decision: Builds Noul, Choice and Score questions with Schema and returns answers to the RubyLLM application.
- What this project offers: Reuses the structured-output interface in existing RubyLLM programs.
- Project details and fixed source · License: MIT
laravel-typesafe-jev — A Laravel adapter for Jev with configuration, dependency injection, a Facade and a request-recording test fake.
- Where Jev makes a decision: Wraps a community PHP SDK for typed judgments and preserves promises and exceptions.
- What this project offers: Fits Jev calls into Laravel services, queues and existing tests.
- Project details and fixed source · License: MIT
jev-resilience — A Spring WebFlux integration that detects error messages hidden in HTTP 200 response bodies.
- Where Jev makes a decision: Jev checks for hidden errors or maintenance notices; a local threshold raises a business exception.
- What this project offers: Lets existing error-handling code see failures concealed by the HTTP status.
- Project details and fixed source · License: Not declared

Security & Guardrails

agentgateway — A Jev guardrail example in Agentgateway using a webhook to inspect model requests and responses.
- Where Jev makes a decision: Jev scores jailbreaks, harmful content and secret disclosure; thresholds or evaluation errors reject requests.
- What this project offers: Demonstrates gateway integration, not guaranteed prevention of all attacks.
- Project details and fixed source · License: Apache-2.0
Agent — An optional Jev command-risk advisor inside a native macOS Agent, with a TypeSafeKit client.
- Where Jev makes a decision: Adds a destructive-risk judgment after local shell checks and refuses commands above the configured threshold.
- What this project offers: API failures generally allow the command with a warning, so it is not complete system protection.
- Project details and fixed source · License: Not declared
jev-experiments — A collection of Jev developer-tool experiments, including Commit Sentry for semantic checks on staged diff hunks.
- Where Jev makes a decision: Judges risks such as exposed credentials or destructive changes; local rules warn or block a commit.
- What this project offers: Presents risk labels with the corresponding diff before commit.
- Project details and fixed source · License: Not declared
unclutter — A browser extension using Jev to identify ads, promotions, and subscription popups and save reusable hiding rules.
- Where Jev makes a decision: Evaluates candidate page elements before the extension applies local hiding rules.
- What this project offers: Turns page judgments into reusable rules.
- Project details and fixed source · License: MIT
interlinked-cli — Interlinked adds option

logicrw/awesome-jev-projects

Star growth

Repository activity

Embed badge

README