💡 Why Jev & System-1 Decision Architecture?
When building autonomous agents, routing every small branching decision to a heavy reasoning model (System 2) incurs seconds of latency, runaway token costs, and context drift.
TypeSafe Jev (System 1) is purpose-built for fast, typed discrete decisions:
- ⚡ Sub-100ms Latency: Delivers decisions in 50–100ms to keep agent loops snappy.
- 🎯 Native Typed Outputs: Built-in primitives for
Choice, Score, and Noul without fragile JSON regex parsing.
- 🛡️ Zero Vaporware: 306+ projects rigorously anchored to verifiable, commit-pinned public open source across 17 real-world domains.
📊 Architecture Comparison: System 1 (Jev) vs System 2 (Reasoning LLMs)
| Dimension | System 2 (Reasoning LLMs) | TypeSafe Jev (System 1 Radar) |
| :--- | :--- | :--- |
| Latency | 1,500ms – 5,000ms+ (Slow) | 50ms – 100ms (Sub-second reflex) |
| Output Type | Unstructured text / fragile JSON regex | Native typed Choice, Score, Noul |
| Token Economy | High cost ($1.00 – $15.00 / 1M tokens) | Ultra-lightweight (fraction of a cent) |
| Context Drift | Prone to hallucinations & attention fade | Deterministic bounded state machine |
| Primary Domain | High-level planning, open-ended generation | Tool routing, action dispatch, safety gates |
🎮 Key Interactive Features
- 🎰 Tactile Gacha Dispatcher: Discover discrete decision points with real-time streak counting and 10-draw fireworks celebrations (💥 BOOM!).
- ⚡ Sticky Search & Floating Popover Filter: Filter tags and categories anytime while scrolling via the anchored toolbar popover.
- 🔍 100% Commit-Pinned Code Evidence: Every listed project links to immutable source files and explicit decision points.
Search and filter ↗ · 306 curated projects
A community-maintained directory and radar for Jev, highlighting open-source projects with verified code and clear decision architectures.
Entries are linked to commit-pinned source code and specific decision points for easy reference. Compatible implementations clearly identify their underlying model.
Projects follow their respective open-source licenses; unstated licenses are noted individually.
Sponsorship · Paid placements
Founding partner slots are open. There are no paid sponsors yet.
Plans and contact · Sponsors
Sponsorship does not change inclusion review, project descriptions, or organic ranking.
Install the Agent Skill
Install the skill to query projects by domain and inspect pinned source evidence directly from your terminal or agent.
npx skills add logicrw/awesome-jev-projects
npx skills add https://logicrw.github.io/awesome-jev-projects/
Agent Skill · llms.txt · llms-full.txt
Categories
Browser & OS Action
- 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
- jev-clerk — A macOS desktop clerk that books supplier invoices: Jev picks each click from a closed action list; a deep model only rewrites the playbook.
- Where Jev makes a decision: POSTs https://api.typesafe.ai/v1/systemone as jev-latest with a closed action Choice each step.
- What this project offers: Screen actions follow Jev's closed choices. Author demo numbers were not retested here. GitHub SPDX is empty; the LICENSE file is MIT.
- Project details and fixed source · License: MIT
- JevFilterForX — A browser extension that scores and filters X posts in real time with Jev, folding low-signal content while keeping it expandable. Without an API key, it defaults to local mock scoring.
- Where Jev makes a decision: Jev classifies posts with Choice, rates signal, actionability and originality with Score, and assigns Noul labels; local thresholds and noise rules decide whether to fold each post.
- What this project offers: Adds scores, labels and adjustable filtering thresholds to the X feed, with reversible folding of posts and their attached media.
- Project details and fixed source · License: Not declared
- jevis — A Flutter integration\_test package that registers allowed UI actions and lets Jev pick the next action and whether the goal is done.
- Where Jev makes a decision: POSTs to /v1/systemone as jev-latest: a goal Noul and a Choice over registered Flutter actions.
- What this project offers: Turns natural-language tests into choices over a closed action list instead of free-form tapping.
- Project details and fixed source · License: Apache-2.0
- cline-plugin-jev-browser — A Cline plugin using an isolated Playwright browser and Jev decisions through Vercel AI Gateway.
- Where Jev makes a decision: Jev selects operations from a DOM target table; a separate text model supplies typed text when needed.
- What this project offers: Captures before-and-after screenshots and yields on sensitive actions; completion still needs readback verification.
- Project details and fixed source · License: Not declared
- ego-jev — Connects Ego Lite snapshots and browser actions to a bounded Jev decision loop.
- Where Jev makes a decision: Selects only current snapshot candidates and supported actions; another model can supply typed text.
- What this project offers: Executes against current snapshot references and records step state.
- Project details and fixed source · License: MIT
- jev-tweet-radar — A Chrome extension that scores each X timeline post with one Jev Noul batch for engagement value and optional tags.
- Where Jev makes a decision: One System One request asks Nouls for worth-engaging plus optional tags such as spam, buzz, and AI-ish.
- What this project offers: Turns timeline filtering into inspectable probabilities instead of generated commentary. Post text is sent to TypeSafe.
- Project details and fixed source · License: MIT
- JevBrowserExt — A Manifest V3 Chrome port of jev-ultrafast: Jev picks the operation and DOM element in one request per step; a small chat model fills TYPE\_TEXT.
- Where Jev makes a decision: Chooses CLICK, TYPE\_TEXT, SELECT, SCROLL\_DOWN, SCROLL\_UP, PRESS\_ENTER, WAIT, DONE, or BLOCKED and the matching DOM target in one request; PRESS\_ENTER is a separate key control. Separate yes/no checks cover goal completion and a stuck loop.
- What this project offers: Runs in the user’s own tabs without screenshots, and keeps the action, target, and typed string inspectable.
- Project details and fixed source · License: MIT
CLI & Pipelines
- foreman — An independent supervisor loop that reads worker diffs, logs and tests, asks Jev Nouls about stuck / off-track / verify, then applies a Python policy.
- Where Jev makes a decision: AsyncTypeSafeClient.system\_one with default jev-latest sends Noul questions for supervision.
- What this project offers: Supervision does not write the worker's code. Distinct from cataloged Shifty-Eye-Games/foreman-jev.
- Project details and fixed source · License: MIT
- orchestkit — OrchestKit can optionally use Jev to classify coding sessions and set their colors when confidence meets a threshold.
- Where Jev makes a decision: Classifies the first task prompt and branch state by work type; local policy accepts the result or falls back.
- What this project offers: Distinguishes sessions by work type and supports a shadow comparison mode.
- Project details and fixed source · License: MIT
- jev-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
- pr-sieve — A GitHub Action that compiles \
.jev.yml\ rules into Jev questions and fails, comments, or passes from the numbers.
- Where Jev makes a decision: Rules become at most twelve questions (\MAX\_JEV\_QUESTIONS\ in src/types.ts). AKIA and private-key armor from src/redact.ts fail locally in src/pipeline.ts with no Jev call.
- What this project offers: Does not write reviews, suggest patches, or approve. Policy is read from the base-ref config.
- Project details and fixed source · License: MIT
- 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
Classification
- typesafe-jev-workflow — An async LangGraph example that classifies mocked emails as invoice-related or general.
- Where Jev makes a decision: Jev returns invoice or general; graph nodes choose the corresponding demo handler.
- What this project offers: Separates model classification from local workflow routing.
- Project details and fixed source · License: Not declared
- jev-tree — A hierarchical selector that asks Jev to traverse branches when a catalog has too many options for one question.
- Where Jev makes a decision: Selects one branch at each level and continues until it reaches a final candidate.
- What this project offers: Returns the selected path without silently truncating the tail of a large catalog.
- Project details and fixed source · License: MIT
Code Navigation
- celesto — A Celesto PR-review example prepares sandbox checks and compares a general model with Jev on candidate findings.
- Where Jev makes a decision: Judges whether a finding was introduced by the change, is supported and merits a fix.
- What this project offers: Shows execution records and reviewer judgments together.
- Project details and fixed source · License: Apache-2.0
- Jev Review — Reviews a Git diff or a codebase in stages and displays review leads in a local dashboard.
- Where Jev makes a decision: Judges risk, files, evidence regions, mechanisms and severity before rule-based reviewer routing.
- What this project offers: Connects review leads to concrete code for human inspection.
- Project details and fixed source · License: MIT
- 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
Context GC
- fast-jev-compaction — Prunes old tool calls and outputs for Claude Code while retaining surviving text verbatim.
- Where Jev makes a decision: Separately judges whether a tool call and its full output are still needed; code keeps, truncates or drops them.
- What this project offers: Avoids rewriting paths, commands and errors into a new summary.
- Project details and fixed source · License: MIT
- 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
Creative Tools
- json-render — A Jev UI-composition experiment inside the json-render website that selects from predefined component and property options.
- Where Jev makes a decision: Evaluates component configurations through Vercel AI Gateway, then composeSpec assembles the UI specification.
- What this project offers: Provides an inspectable composition path alongside token-by-token JSON generation.
- Project details and fixed source · License: Apache-2.0
- youtube-sponsor-detection — YouTube extension detecting sponsored segments from live audio and transcripts using Jev, skipping promotional blocks automatically.
- Where Jev makes a decision: Inspects transcript segments with Jev to identify sponsor reads while browser code handles playback timeline skipping.
- What this project offers: Identifies promotional reads on newly released videos immediately without waiting for crowdsourced segment submissions.
- Project details and fixed source · License: Not declared
- jevmeter — Creates edited videos with score meters by asking Jev to rate transcript sentences against selected rubrics.
- Where Jev makes a decision: Scores transcript sentences with preset questions and scales for meters placed on the video timeline.
- What this project offers: Aligns sentence scores with the corresponding video segments for review.
- Project details and fixed source · License: MIT
- vibecheck — Shows a Jev scorecard before posting on X, assessing draft clarity, tone, and possible offensiveness.
- Where Jev makes a decision: Sends the draft and reply or quote context to Jev for multiple scores and a posting suggestion.
- What this project offers: Collects several perspectives on a draft before it is sent.
- Project details and fixed source · License: Not declared
... (README truncated for length)
