Jev Coding Agent

Rust coding-agent harness (MIT, ~20k stars) whose crates/jcode-base/src/jev.rs is a typed TypeSafe Jev decision transport, used for memory pruning (memory_jev.rs), browser navigation (browser_jev.rs), and voice routing (voice_intent.rs) with separate provider selectors per purpose.

Stencil Labs' coding agent embeds TypeSafe Jev for typed checks, routing, and workflow decisions, with measured Jev tokenizer probes in pi-natives.

A Claude Code configuration CLI shipping Jev modules for model routing, skill suggestion, tool guardrails, auto-mode gates, and sandbox hooks.

A CLI that asks Jev which files and declarations answer a repository question, then prints verbatim excerpts for a coding agent to use.

A single-binary MCP tool named evaluate that sends Noul, Choice, and Score questions to hosted Jev or a local System One server.

Five typed tools — classify, check, score, rank, and ask — plus a skill, wired into Claude Code, Codex, Pi, and OpenCode in one setup command.

Claude Code hooks that narrow a roster in YAML, ask Jev which handler owns a prompt, and log the band before anything is blocked.

Project memory for Claude Code, Cursor, and Codex. Jev decides whether a turn is a decision, rule, bug, or injection, and code writes or supersedes a line in JEVMEM.md.

Guidance on how Jev fits coding agents: it is not a drop-in agent model, so the page routes readers to routing, rubric scoring, and truth checks instead.

A semantic linting CLI that parses a repository into a method-level call graph, then asks Jev to flag likely defects and check rules written in plain English.

A TypeScript layer beside an LLM: JevSift selects approaches, JevLoop audits progress with typed actions, and JevLong watches sessions for stalls without steering them.

A Python framework where an authoring LLM writes a task-specific Jev harness, then optionally evolves it using reward reflection and GEPA over full trajectories.

A pointer to Diogo Almeida's independent working note on building a Jev harness for coding agents, including why harnesses already make these calls badly.

A Claude Code plugin and npm library that replaces transcript summarization with Jev keep-or-drop judgments, deleting stale tool calls and results while kept text stays verbatim.

An MCP server for Antigravity IDE, Cursor, and Claude Code that uses Jev (jev-latest) to locate code semantically and audit git diffs, replacing broad grep sweeps of entire files.

A code reviewer built as AI-powered software rather than an LLM agent: code slices the diff, Jev answers narrow typed questions per hunk, and code composes the verdict and findings.

A research-stage proposal-review contract in TypeScript: an LLM proposes one action, Jev answers four pinned questions, and code produces evidence the host can consider.

A CLI that scores code quality by asking Jev yes/no questions about each file, runs your existing test command, and turns uncovered paths into small actionable queries for agents.

A Claude Code Stop hook that reads the turn transcript locally and spends one four-question Jev call only when files changed with no passing check since, blocking unverified done claims.

A pre-commit hook that answers five Jev questions about the commit message and staged diff together, warning on mismatches and blocking only on a credential-shaped line.

CLI and GitHub Action that turn project-defined semantic preferences from AGENTS.md into Jev Noul or Choice checks over code changes, then map each result to an advisory or blocking outcome. Checks can be tuned on labeled diffs.

Pi extension that supervises a coding agent with Jev judgments: it holds risky tool calls, checks writes against project Markdown rules, and feeds most issues back to the agent as a steer instead of interrupting you. The conscience is beta and off by default.

Agent-ergonomic CLI following the AXI conventions that gives coding agents Jev judgments for blocking risky tool calls, screening fetched content for prompt injection, triaging logs, flagging risky diffs, and ranking many items. Routine commands are decided locally at no cost.

A security hook for coding agents that asks Jev three typed questions before every tool call and scans tool results for prompt injection, with adapters for Claude Code, Codex, Copilot CLI, Gemini CLI, Cursor, pi, OpenCode and ACP.

A local-first MCP server that gives Claude Code, Codex, Cursor, and OpenCode structured quality scores from Jev across correctness, complexity, tests, security, and other dimensions while the agent writes code.

A semantic grep CLI that chunks files or staged diffs into 5-60 line pieces, packs 16 chunks and 16 Jev Noul questions into one request, and prints file:line hits above a probability threshold with grep-style exit codes.

A Claude Code context sieve: large Read, Bash, and Grep results are split into ~25-line blocks and judged by Jev before they enter context, with confident-no blocks replaced by a recallable stub.

An experimental local context-pruning proxy for Claude Code and Codex that asks Jev, through the Vercel AI Gateway, which history spans to omit, then forwards a rewritten request with omission markers.

An agentic software-development skill set built on obra/superpowers, where Jev in the cloud or open-weight Laya locally gates architecture choices, package vetting, shell commands, and completion checks.

A hybrid coding harness for Pi where any LLM writes the code while Jev returns typed probabilities that deterministic policy code turns into allow, confirm, block, warn, or steer.

An experimental local proxy for coding agents that sends jevonian/auto turns to Jev to pick a model and thinking level after deterministic compatibility and quota filters, while explicit routes skip Jev.

A router that turns models, subagents, skills, MCP tools, CLIs, and plugins into one candidate set Jev answers with a single typed Choice, while the router code owns availability, permissions, and confirmation.

A Pi extension that keeps conversation text verbatim while pruning stale tool history with Jev keep-or-drop decisions, falling back to Pi's built-in summary compaction when pruning cannot free enough context.

A Pi extension that turns constraints stated in conversation into a scoped, replayable policy and checks every side-effecting tool call against it before it runs, with Jev only classifying how each message changes the policy.

A Codex plugin and npm library that wraps native session compaction: Jev scores every tool call and result, and the verbatim history it keeps is re-injected after Codex summarizes. The README does not recommend using it.

An Agent Skill that sends closed coding-agent judgments to TypeSafe Jev and acts on the probabilities, asking for yes/no, choice, and score answers in about 250 ms while the main coding model keeps writing code.

A tool-call gate for Claude Code, Codex, Cursor, and other harnesses backed by Jev: deterministic rules and a read-only allowlist run first, then one request answers allow, ask, or deny in about 400 ms.

An ACP and MCP adapter that bridges TypeSafe Jev with any LLM: native Jev when TYPESAFE_API_KEY is set, or Codex, Claude, Grok, OpenCode, and OpenAI-compatible endpoints standing in as System One when it is not.

A Stop hook that keeps coding agents from quitting early: rules written in plain language are scored by Jev in about 0.7 seconds, and a violated rule sends the agent back to work instead of letting it stop.

A Rust coding-agent harness and TUI that uses Jev to pick a model and effort, route bounded utility work, and decide what context to keep, with code constraining every choice and validating results.

A collection of Jev demos, workflows, and agent skills for coding agents: five installable skills and 108 scenarios, installed by pointing Codex, Claude Code, or OpenCode at an agent prompt.

A multiplayer triage dashboard for public GitHub repos: issues and PRs sync into Postgres, Rocicorp Zero replicates them live, and Jev answers typed questions about each one, including what a maintainer should do next, with human corrections kept.

An ast-grep semantic linter where each rule is one natural-language question judged by Jev: 98 rules flag name/body drift, stale comments, weak tests, quiet failures, and commits whose diffs contradict their messages.

A local-first Herdr CLI that filters your agent subscriptions with fixed eligibility rules, then asks TypeSafe Jev to rank the remaining Cursor, Claude Code, Codex, or OpenCode options and pick a reasoning effort.

A local gateway for coding agents that asks Jev which tool to call each turn and steers the LLM when Jev is confident, while every other request goes to your usual provider untouched.

A collection of 26 production-ready agent skills for Claude Code, Cursor, Kiro, Windsurf, and OpenCode; four skills call TypeSafe Jev for calibrated Score and Noul judgments and fall back to heuristics when it is unavailable.

A Jev-guided context compaction library for coding agents: instead of summarizing old context, Jev decides which tool calls and results still matter while user and assistant text is kept verbatim.

An MCP server and agent skill that verifies coding-agent work by driving the real running app and returning pass, fail, or couldn't-tell verdicts with the file:line to fix; its listing frames the approach as Jev-style machine-native runtime perception.

An open coding-agent workflow where every project has a Project Book that people and agents can read; it wires in Jev as an optional helper for small decisions like whether a build looks healthy, through OpenCode Zen's free Jev endpoint with no separate key.

A Jev-first command-line coding agent: natural-language requests are routed by Jev to one of ten bounded review and triage workflows, and unsupported requests fall back to the Pi coding agent or a workflow Stanley stages for promotion.

A Pi coding-agent extension that routes tools and skills with Jev: one pass activates only what a prompt needs, with opt-in model selection, tool-call guards, and compaction.

An omp plugin that does verbatim Jev-scored context reduction: stale tool calls and results are truncated to a short head plus a recoverable note, while sticky rewrites keep the provider's prompt cache intact.

A Python asyncio runtime that puts Jev in a supervision loop above Codex or OpenCode workers: it judges completion, test sufficiency, and stuck loops, then steers, retries, or stops the job.

An MCP server exposing ten Jev judgment tools, including verify, screen, find, rerank, classify, review, and gate, each returning typed probabilities in roughly 150 to 500 ms.

A Pi coding-agent extension with Jev as a decision layer: a gate judges bash, write, and edit calls before they run, and an output judge flags leaked secrets and classifies failures.

A Rust CLI that ranks agent skills for the next step with a two-stage Jev pass plus lexical prefiltering, with Claude Code hooks, a TUI, abstention, and --why-not explanations.

An MCP server that puts Jev in the coding loop for Cursor, Codex, and other MCP clients: coding-loop checks, ranking, verification, and review tools.

Jev-backed auto mode for the Pi coding agent: semantically approves bash, write, and edit tool calls, and fails closed whenever a decision cannot be made.