💡 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: 356+ 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)

🎮 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 ↗ · 356 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

Categories

• Browser & OS Action (27)
• CLI & Pipelines (22)
• Classification (2)
• Code Navigation (12)
• Context GC (22)
• Creative Tools (11)
• Data & Search (19)
• Decision Tools (12)
• Domain Tools (22)
• Evaluation & Observability (29)
• High-Frequency / Games (31)
• MCP & Integrations (19)
• Model Routing (27)
• SDK & Decision Frameworks (65)
• SDK Integrations (6)
• Security & Guardrails (26)
• Voice & Conversation (4)

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

• 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

• 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: Not declared

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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

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

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

• 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

• 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

• 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

• 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

• 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

CLI & Pipelines

• 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

• 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

• 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

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

• 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

• 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

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

• 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

• 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

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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

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

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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

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

Data & Search

• 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

• 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

• 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

• 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

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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

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

• 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

• 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

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

• 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

• 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

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

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

• 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

• 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

• 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

• 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

• 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

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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

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

• 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

• 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

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

• 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

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

• 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-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-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-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-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: Not declared

• 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: Not declared

• 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

• 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

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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

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

• 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

• 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

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

• 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

• 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

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

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

• 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

• 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

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

• 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

• 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

• 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

• 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

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

• 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

• 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

• 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

• 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

• 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

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

• 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

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

• 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

• 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

• 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

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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

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

• 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

• 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

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

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

• 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: Not declared

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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: Not declared

• 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

• 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

• 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

• 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

• 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

• 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

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

• 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

• 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

• 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

• 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

• 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

• 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

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

• 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

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

• 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

• 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

• 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

• 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

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

• 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

• 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

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

• 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

• 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

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

• 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: MIT

• 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](https://logicrw.github.io/awesome-jev-projec