Awesome Jev — System-1 Agent Architecture Radar

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: 287+ projects rigorously anchored to verifiable, commit-pinned public open source across 17 real-world domains.

• 🎰 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 ↗ · 287 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.

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 skill to query projects by domain and inspect pinned source evidence directly from your terminal or agent.

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

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

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

• 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

• 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

• 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

• 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

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

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

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

• 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

• 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

• 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

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

• 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-cli — The jevctl command-line tool connects verification, classification and scoring questions to text input and scripts.

  • Where Jev makes a decision: Sends input and bounded answer options to Jev, then reports judgments and probabilities using local thresholds.
  • What this project offers: Provides structured results for pipelines and CI, with request inspection and dry-run support.
  • Project details and fixed source · License: MIT

• jev-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 — A CLI for asking Jev classification, yes/no and scoring questions over text or JSON input.

  • Where Jev makes a decision: Evaluates typed questions over one input and returns choices and probabilities as JSON.
  • What this project offers: Accepts standard input and supports direct TypeSafe calls or a Vercel gateway.
  • Project details and fixed source · License: MIT

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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• bluenoise — An X/Twitter filtering extension using local rules by default, with optional Jev checks for unmatched replies.

  • Where Jev makes a decision: When experimental AI is enabled, Jev evaluates replies missed by rules and local thresholds decide whether to hide them.
  • What this project offers: Applies reversible local rules first and adds model judgment only when requested.
  • Project details and fixed source · License: MIT

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

• 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

• 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

• 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

• 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

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

• 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

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

• 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

• 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

• 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

• 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

• 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

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

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

• 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

• jev-search-rerank-eval — Retrieval evaluation system measuring Jev reranking against lexical, embedding, and fusion baselines across 9,831 query-document pairs.

  • Where Jev makes a decision: Invokes Jev judges to grade multi-level relevance on bilingual queries, evaluating ranking metrics and judge-circularity effects.
  • What this project offers: Provides rigorous empirical evidence comparing discrete judgment rerankers against vector search in multilingual discovery contexts.
  • Project details and fixed source · License: MIT

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

• 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

• 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

• reranker — Python library utilizing Jev System One as a calibrated reranker, scoring up to 30 candidate documents per single API call.

  • Where Jev makes a decision: Packs a search query and documents into state, issuing parallel Noul questions to obtain calibrated relevance probabilities.
  • What this project offers: Evaluates entire batches concurrently without generative overhead, providing scores suitable for absolute thresholding and ranking.
  • Project details and fixed source · License: Apache-2.0

• 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

• 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

• 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

• 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 — Claude Code Stop hook that blocks an unverified done. It reads the turn transcript locally and only spends a Jev call when files changed and no check has passed since; every error path lets the turn end.

  • Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
  • What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
  • Project details and fixed source · License: MIT

• jev-playground — A web playground for entering state and decision questions, then inspecting Jev answers and probability distributions.

  • Where Jev makes a decision: Submits multiple Noul, Choice, and Score questions in one request.
  • What this project offers: Lets users try questions and answer options before writing application code.
  • Project details and fixed source · License: Not declared

• jev-plays-pokemon-red — Pokemon Red on PyBoy where code owns the route and the arithmetic and Jev picks only where the game branches.

  • Where Jev makes a decision: Choice questions at battle actions, blocked-tile sidesteps and dialogue menus; a Noul faints_this_turn on every battle turn is labelled from RAM on the next turn and scored by Brier in uv run measure. Speed and cost numbers are deliberately blank in the README until a full playthrough is measured; implementation in src/.
  • What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
  • Project details and fixed source · License: MIT

• jev-predict-skill — An Agent skill recipe that predicts another skill’s closed-set outcome from its rules and evidence.

  • Where Jev makes a decision: Jev first assesses whether a closed decision is possible, then selects among the target skill’s outcomes.
  • What this project offers: Includes API-call and response-check examples; it predicts the outcome without executing the target skill.
  • Project details and fixed source · License: Not declared

• jev-skip — Browser extension that skips YouTube sponsor reads on videos nobody has labeled, from the caption track alone, and paints a probability per segment on the seek bar.

  • Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
  • What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
  • Project details and fixed source · License: MIT

• jevchat — A chat-style Jev demo whose answers are selected from predefined or custom options rather than generated prose.

  • Where Jev makes a decision: Maps answer styles to Choice options and selects chat titles from fragments of the question.
  • What this project offers: Shows answer options and probabilities in a chat UI with customizable answer sets.
  • Project details and fixed source · License: Not declared

• jev-commit — Pre-commit hook for the commit-msg stage: one Jev call judges the message against the staged diff, then warns and gets out of the way, except on a credential on an added line, which it blocks.

  • Where Jev makes a decision: Jev returns a structured decision for the local program; consult the source for the exact decision policy.
  • What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
  • Project details and fixed source · License: MIT

• jev.nvim — Neovim plugin: type a plain-language question, every function in the buffer gets judged, answers land in quickfix ranked by probability.

  • Where Jev makes a decision: Treesitter splits the buffer into functions; one request scores each function against the question; implementation in lua/. The README compares against a regex grep on a twelve-file fixture corpus, no accuracy claim beyond that.
  • What this project offers: Adds structured choices or scores to the workflow; performance and cost benefits have not been independently verified.
  • Project details and fixed source · License: MIT

• 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

• 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

• 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

• 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

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

• jev-for-engineers — Eight mechanical and electrical engineering experiments using Jev for task routing, log checks and component selection.

  • Where Jev makes a decision: Jev classifies engineering text and candidates; calculations and final actions stay in Python rules.
  • What this project offers: Shows how to connect judgments to engineering workflows using synthetic examples.
  • Project details and fixed source · License: MIT

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

• 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

• 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

• 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

• 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

• 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

• 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

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

• 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

• 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

• 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-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-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-rerank-bench — Compares Jev, dedicated rerankers and chat models on the same retrieved passages.

  • Where Jev makes a decision: Ranks candidate passages with Choice, Noul and rubric scores, then computes retrieval metrics.
  • What this project offers: Publishes raw responses, scoring code and per-dataset results for inspection.
  • Project details and fixed source · License: MIT

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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

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

• jev-experiments — Uses Jev to play Chrome Dino and a local shooter arena while Python executes structured decisions.

  • Where Jev makes a decision: Chooses jumping, ducking, movement, aim, or firing from game state, with local execution rules.
  • What this project offers: An inspector lets users compare state, model answers, and executed actions.
  • Project details and fixed source · License: Not declared

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

• 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

• 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

• typesafe-mcp — An MCP server that lets Claude Code, Claude Desktop, Codex and Pi ask Jev typed questions.

  • Where Jev makes a decision: Submits state and Choice, Score or Noul questions and returns structured answers with probabilities.
  • What this project offers: Provides decisions that calling code can inspect and branch on.
  • Project details and fixed source · License: MIT

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

• synkora-ai — Synkora includes optional TypeSafe client tools for classification, scoring and yes/no judgments.

  • Where Jev makes a decision: Sends workflow state and named questions to Jev and returns structured answers to agents.
  • What this project offers: Makes these judgments available within existing platform workflows.
  • Project details and fixed source · License: MIT

• plasmallm — A Jev Decisions adapter in a KDE Plasma assistant widget for displaying structured judgments.

  • Where Jev makes a decision: Converts the current message into decision questions and receives answers from TypeSafe or a compatible Decisions endpoint.
  • What this project offers: Makes decision models available in an existing desktop assistant UI.
  • Project details and fixed source · License: GPL-2.0

• 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

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

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

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

• 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 — High-throughput semantic router for Claude Code and CLI tools, directing requests to the most cost-effective model via Jev.

  • Where Jev makes a decision: Classifies task complexity with Jev discrete choice queries, dispatching trivial edits to lightweight models and reserving large models for complex logic.
  • What this project offers: Reduces aggregate API costs for developer tools while preserving quality on challenging architectural questions.
  • 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• jev-demo — A customer-service routing demo that batches Jev questions before following the resulting route.

  • Where Jev makes a decision: Assesses classification levels, human-handoff intent and frustration, with low-confidence escalation.
  • What this project offers: Combines routing and human handoff while leaving response generation to the application.
  • Project details and fixed source · License: Not declared

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

• opencode-jev-orchestrator — OpenCode orchestrator that keeps a sticky affordable parent model and delegates difficult turns to subagents using Jev difficulty decisions.

  • Where Jev makes a decision: Evaluates turn complexity before execution, triggering specialized subagents powered by premium models only when escalation criteria are met.
  • What this project offers: Maximizes context cache hits on low-cost models while preserving high-tier reasoning capabilities for challenging code changes.
  • Project details and fixed source · License: MIT

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

• 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

• 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

• 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

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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• SpecPi — A Pi configuration and extension bundle with an optional Jev advisor for capabilities and workflow checks.

  • Where Jev makes a decision: Jev evaluates candidate capabilities, outputs and task state; per-feature switches control applying or recording advice.
  • What this project offers: Advisor failures return to the original path rather than guaranteeing better parameters or lower costs.
  • Project details and fixed source · License: MIT

• typesafe-sdk — A community Ruby client for TypeSafe System One, defaulting to jev-latest.

  • Where Jev makes a decision: Builds Choice, Score and Noul questions and exposes parsed answers by type.
  • What this project offers: Lets Ruby programs read choices, scores and probabilities directly.
  • Project details and fixed source · License: MIT

• daf-jev — A Python toolkit for Jev requests, batch evaluation, calibration and MCP access.

  • Where Jev makes a decision: Builds Noul, Choice and Score questions, then combines returned probabilities through local functions.
  • What this project offers: Reuses request, failure-recording and evaluation interfaces across experiments.
  • Project details and fixed source · License: MIT

• 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 and ZIO library for TypeSafe AI and Jev, integrating discrete decision endpoints into a purely functional effect system.

  • Where Jev makes a decision: Models Jev System One queries as ZIO effects, submitting state and typed questions concurrently with robust schema decoding.
  • What this project offers: Enables functional Scala applications to leverage Jev fast decision-making with fiber-based concurrency and structured error management.
  • Project details and fixed source · License: Apache-2.0

• 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

• 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-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-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-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-go — A small unofficial Go SDK for Jev calls and model listing.

  • Where Jev makes a decision: Sends application state and questions to Jev and parses Choice, Score or Noul answers.
  • What this project offers: Packages requests and response parsing for typed decisions in applications.
  • Project details and fixed source · License: Not declared

• jev-starter — TypeScript patterns for thresholds, fallbacks, human review and evaluation on top of the TypeSafe SDK.

  • Where Jev makes a decision: Jev returns judgments; application policies choose automatic handling, fallback or human review.
  • What this project offers: Separates model calls, execution policy and evaluation.
  • Project details and fixed source · License: MIT

• jevclient — An asynchronous Python Jev client that batches typed questions in one request.

  • Where Jev makes a decision: Calls TypeSafe through aiohttp and parses choices, scores and probabilities into objects.
  • What this project offers: Fits existing async applications without parsing generated prose.
  • Project details and fixed source · License: MIT

• jevgo — A community Go client with a standard-library core and optional Langfuse tracing.

  • Where Jev makes a decision: Sends application state and questions to Jev and parses Choice, Score or Noul answers.
  • What this project offers: Packages requests and response parsing for typed decisions in applications.
  • Project details and fixed source · License: MIT

• qualm — A TypeScript wrapper for Jev decisions with an explicit unsure branch.

  • Where Jev makes a decision: Preserves probabilities and option types and routes uncertainty to a caller-supplied fallback.
  • What this project offers: Uses types to require uncertainty handling without guaranteeing model correctness.
  • Project details and fixed source · License: MIT

• typesafe-ai-rails — Ruby on Rails integration gem for TypeSafe AI and Jev, providing model-level classification and decision policy patterns.

  • Where Jev makes a decision: Dispatches state and criteria from ActiveRecord models or services to Jev System One endpoints, logging structured outcomes.
  • What this project offers: Simplifies adding Jev discrete judgments to Rails web apps with standard Railtie configuration and policy wrappers.
  • Project details and fixed source · License: MIT

• typesafe-go — An unofficial Go client without third-party dependencies for System One calls and model discovery.

  • Where Jev makes a decision: Sends application state and questions to Jev and parses Choice, Score or Noul answers.
  • What this project offers: Packages requests and response parsing for typed decisions in applications.
  • Project details and fixed source · License: MIT

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

• 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-rs — A community Rust Jev client with async requests, an optional blocking interface and local mock testing.

  • Where Jev makes a decision: Sends state and named questions to TypeSafe and parses choice, score and noul answers.
  • What this project offers: Provides client configuration, retries and error types for async or blocking Rust applications.
  • Project details and fixed source · License: MIT

• typesafe-sdk-swift — An experimental Swift SDK for TypeSafe using Swift Package Manager, Swift concurrency, and URLSession.

  • Where Jev makes a decision: Sends state and typed questions to System One and receives structured answers through async/await.
  • What this project offers: Lets Swift applications reuse Jev request and response handling.
  • Project details and fixed source · License: MIT

• 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

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

• interlinked-cli — Interlinked adds optional Jev judgments and evidence checks to local coding-agent checks.

  • Where Jev makes a decision: Assesses inputs such as test names, documentation claims and supporting evidence.
  • What this project offers: Keeps model advice distinct from deterministic rules and records checks.
  • Project details and fixed source · License: MIT

• unclutter — A browser extension using Jev to identify ads, promotions, and subscription popups and save reusable hiding rules.

  • Where Jev makes a decision: Evaluates candidate page elements before the extension applies local hiding rules.
  • What this project offers: Turns page judgments into reusable rules.
  • Project details and fixed source · License: MIT

• captaincore — Jev commands in the WordPress toolkit CaptainCore answer structured questions and prioritize malware scanner findings for review.

  • Where Jev makes a decision: Sends scan rules, matched snippets, and file context to Jev to assess likely true positives and suggested handling.
  • What this project offers: Organizes rule-based scan findings into a queue for human review.
  • Project details and fixed source · License: MIT

• pi-jev — A Pi extension that flags tool risks before execution and checks output for secrets and failure types.

  • Where Jev makes a decision: Jev scores destructive actions, scope and output risks; configuration chooses warnings or confirmation.
  • What this project offers: Defaults to shadow mode and fails open on API errors; it is not a standalone security boundary.
  • Project details and fixed source · License: MIT

• pi-warden — Adds checks for project rules, out-of-scope actions, repeated failures, and completion claims to Pi Agents.

  • Where Jev makes a decision: Uses Jev to judge rule violations, irreversible actions, and task drift, feeding results back to the Agent.
  • What this project offers: Brings rule findings and actions needing confirmation into the active workflow.
  • Project details and fixed source · License: MIT

• Jev-Moderation-Bot — A Discord moderation bot using Jev to check spam and scam links, with local warning and timeout rules.

  • Where Jev makes a decision: Assesses messages or recent member history; the bot applies deletion, warnings or timeouts.
  • What this project offers: Connects judgments, moderation logs and manual correction controls.
  • Project details and fixed source · License: Not declared

• pi-jev-auto-mode — Adds rule checks to Pi commands and file operations, then uses Jev to assess cases that need further judgment.

  • Where Jev makes a decision: Local rules handle explicit denies and allows before Jev assesses authorization and risk for bash, write, and edit.
  • What this project offers: Keeps policy and decision records available for adjusting operation gates.
  • Project details and fixed source · License: MIT

• is-malicious — CLI security scanner using Jev to inspect source files, build scripts, and CI configs for suspicious patterns before execution.

  • Where Jev makes a decision: Feeds file contents and security criteria into Jev to assess risks such as data exfiltration, obfuscated loaders, and credential leakage.
  • What this project offers: Provides rapid pre-execution safety screening across multiple file formats without needing a heavy static analysis toolchain.
  • Project details and fixed source · License: MIT

• jev-guard — Tool-call checks for coding Agents that assess operation risk, user intent and prompt-injection signals.

  • Where Jev makes a decision: Jev evaluates tool inputs or outputs in session context; local rules allow, warn or block.
  • What this project offers: Adds review points around Agent tools, with behavior depending on the host client.
  • Project details and fixed source · License: MIT

• hermes-jev-approvals — An experimental Hermes command-approval provider for the auxiliary.approval task only.

  • Where Jev makes a decision: Jev returns APPROVE, DENY or ESCALATE, with local thresholds and policy determining handling.
  • What this project offers: Demonstrates an approval integration; the author labels it a proof of concept, not production assurance.
  • Project details and fixed source · License: MIT

• safer-with-jev — An HTTP inspection gateway that checks request content with Jev before optionally forwarding it to an HTTPS destination.

  • Where Jev makes a decision: Jev judges prompt injection or unsafe content; local rules forward, flag or block the request.
  • What this project offers: Adds an inspectable content check ahead of an existing HTTP service.
  • Project details and fixed source · License: Not declared

• jev-block-android-ad — An Android notification and SMS filter that applies local OTP rules before asking Jev whether a message is advertising noise.

  • Where Jev makes a decision: Classifies text that passes local gates; local mapping decides whether to allow or suppress it.
  • What this project offers: Makes OTP handling and fail-open behavior explicit in code.
  • Project details and fixed source · License: MIT

• jev-cvss — Scripts that use Jev to select CVSS metrics from vulnerability descriptions, then compute v3.0, v3.1 or v4.0 scores in Python.

  • Where Jev makes a decision: Maps attack conditions and impacts to discrete metrics; local CVSS formulas calculate the numeric score.
  • What this project offers: Exposes the selected metrics and vector alongside the final score.
  • Project details and fixed source · License: MIT

• jev-judgment — Adds judgment checks for authorization, operation risk, and failure causes to coding Agents.

  • Where Jev makes a decision: Uses conversation and command results to assess whether to ask the user, whether an action exceeds scope, and whether to retry.
  • What this project offers: Makes checkpoints that may require user confirmation explicit.
  • Project details and fixed source · License: MIT

• oc-plugins — The oc-auto-perms plugin in an OpenCode plugin collection uses Jev to check tool intent against natural-language rules.

  • Where Jev makes a decision: Sends proposed actions and permission rules to Jev, then uses local logic to allow, deny, or ask the user.
  • What this project offers: Connects permission policies to judgments about individual tool actions.
  • Project details and fixed source · License: Not declared

• jev-tool-permissions — Adds tool-call approval and tool-list pruning to the Vercel AI SDK.

  • Where Jev makes a decision: Deterministic rules run first; Jev assesses remaining call risks and tool relevance for threshold-based handling.
  • What this project offers: Approval-call failures request human review; model judgments cannot guarantee detection of every risk.
  • Project details and fixed source · License: Not declared

• aiavatarkit — An optional AIAvatarKit component uses Jev to judge turn endings from speech transcripts.

  • Where Jev makes a decision: Assesses utterance completeness and whether the user is likely to continue speaking.
  • What this project offers: Adds a semantic signal to silence-based turn detection.
  • Project details and fixed source · License: Apache-2.0

• OpenWhisper — A dictation and meeting-notes app with optional Jev checks for topic changes, note-taker instructions and sensitive text.

  • Where Jev makes a decision: Makes bounded transcript judgments for checkpoints, note-taking actions or screening before remote text cleanup.
  • What this project offers: Keeps model probabilities separate from local thresholds, switches and failure fallbacks.
  • Project details and fixed source · License: MIT

• jev-system-one — A terminal Q&A app where OpenAI writes answers and Jev sets response policy and reviews drafts.

  • Where Jev makes a decision: Judges response mode, depth, uncertainty and draft quality inside a LangGraph workflow.
  • What this project offers: Displays the answer alongside a structured decision report.
  • Project details and fixed source · License: MIT

• ha-conversation-jev — A Home Assistant conversation integration routing simple lighting commands to services and other requests to Grok.

  • Where Jev makes a decision: Jev classifies the utterance and exposed devices; code chooses a lighting service or conversation path.
  • What this project offers: Provides a bounded lighting fast path rather than support for every smart-home command.
  • Project details and fixed source · License: Not declared

Node.js 22+

npm ci --ignore-scripts
npm run dev
npm test
npm run build
npm run build:readme

The website serves static data and handles no credentials. Actions use short-lived repository tokens with least privilege, and submitted code is never executed directly.

We use lightweight, cookie-free Cloudflare Web Analytics for aggregate performance and visit metrics, respecting DNT/GPC.

Submissions are welcome! Please provide the repository URL, core use case, and code location of the Jev decision logic.

Submit a project

• Catalog audit record
• Security

Never paste tokens, private keys or other credentials into public security reports.

MIT © logicrw · X @0xLogicrw — directory code only; project licenses are separate.