Community projects / 83 listings
Agent and developer tooling
These tools use typed judgments to search, route, review, or gate developer work. Inspect each tool's action policy, fallback behavior, and request costs.
Download topic card
Augustus
Independent augustus and augustus-train agent skills for placing and building application-specific decision models: primitive, base-model, and method selection, data assembly, fitting, export/reload, bounded improvement, and offline evaluation. TypeSafe Jev is the default hosted exemplar, not a model this project reproduces, and rules-only or no-training outcomes are valid results.
Beacon
Cross-harness agent memory tool with an explicit beacon memory evaluations run command: Jev judges bounded, redacted trace projections for reusable lessons, which a person reviews before adding to project memory or installing as a skill. Hooks and dry runs do not call Jev; normal capture can retain sensitive session text locally, so inspect retention before enabling it.
Bicameral
Pi coding harness where an LLM writes while Jev supplies typed reflexes for policy, loop detection, and review; explicitly not a sandbox.
Building with TypeSafe Jev
Unofficial agent skill for Claude Code, Codex, and Antigravity CLI that holds the Choice, Score, and Noul API shapes, cookbook thresholds, community failure modes, and 150+ community projects sorted by implementation shape, each with a code sketch; it is Markdown only and sends nothing itself, but it is a 2026-09-25 snapshot of the docs and tells the agent the live docs win on any conflict.
Canny
Claude Code and Codex hooks that record edits and checks in an append-only ledger, flag a "done" claim without a passing check after the last code edit, and use optional Jev Noul judgments for advisory rule checks or to recognize a non-completion message; its default gate allows a repeated stop after warning, the author has not measured project-wide quality gains, and enabling Jev sends clipped diffs, project rules, and final messages to TypeSafe.
Codex Jev Router
Instruction-driven Codex subagent router that asks Jev Choice and Noul questions about a short task summary, applies confidence thresholds in code, and falls back to Sol when the decision fails; hosted Jev receives the summary, while local compatible backends are optional. Its installer changes local Codex configuration with a backup, but routing is not enforced at the tool boundary.
DGP
Experimental decision-based agent protocol with a Jev adapter, immutable evidence frames, typed assessments, and application-guarded commits; the local reference app simulates domain effects, and opt-in live mode sends decision evidence to TypeSafe.
Distill
Coding agent harness that can use Jev to select a model and effort, route bounded utility tasks, and judge what context to retain. Code constrains the choices and validates utility results; failed or low-confidence decisions leave the normal path in place. Jev does not decide tool permissions, and routing can send the user's request and recent steps to the configured endpoint.
Every
Semantic code search CLI that asks a yes/no question of every function and ranks the resulting probabilities.
evoke
Rust CLI and TypeScript SDK that ask Jev to select an installed reflex and bounded arguments, then gate the outcome in code as run, confirm, ask, or abstain. Reflexes fetched from Git run as your user without a sandbox, so inspect them before installing.
fast-jev-compaction
Claude Code function-hook plugin and npm library that asks Jev which older tool calls and results to keep, truncate, or remove without rewriting user and assistant messages; it sends a bounded version of the conversation and tool inputs to TypeSafe, and its relevance probabilities do not guarantee safe deletion.
Foreman
Experimental Codex/OpenCode supervisor that sends bounded job, output, and diff context to Jev for progress checks; workers run locally without isolation, and judgment accuracy is unproven.
fx
Experimental Zig coding agent with an optional Jev permission reviewer: setting review_model to typesafeai/jev sends the composed policy, context, and pending action to TypeSafe directly or through Vercel AI Gateway, then maps Jev's Choice to a permission decision; recorded probabilities and confidence are not threshold gates.
Hermes Jev Skills
Python toolkit and nine agent skills for Hermes, Claude Code, and Codex: Jev can route models, filter retrieved passages, select skills, and choose bounded computer or browser actions. The installer has a dry run and routing offers shadow mode; enabled features send redacted prompts or excerpts to TypeSafe, so read the per-feature data disclosure before use.
Hermes JIT Context OS
Coding-agent context runtime with an optional Jev Noul ranker for candidate facts: it sends a bounded query and fact excerpts to OpenRouter, caches scores, and labels deterministic token-overlap fallback when the remote path is unavailable. Its published ten-task live-call record uses small SWE-bench-style fixtures built from inline files, not full repository checkouts or a SWE-bench score.
Hippo Memory
Local agent memory system with an opt-in Jev reranker that batches Noul judgments over the top 40 recalled memories and falls back to a local cross-encoder on errors. The author's published study found better ranking on two corpora but no demonstrated answer-quality gain over the cross-encoder; enabling Jev sends the query and candidate memories to TypeSafe.
hush
GitHub Action for issue triage that abstains: label, spam, needs-more-info, and possible-duplicate in one call, each applied only above a threshold the maintainer sets, and nothing at all below it.
is-malicious
CLI that scans source, configuration, build, and CI files with Jev, reports suspicious behavior with file and line pointers, and sends scanned file contents to TypeSafe's API.
jeff
Go CLI with noul, choice, score and eval commands that map a threshold to an exit code, plus a rank command that sends one Score per item per weighted dimension of a YAML spec in a single request and computes the composite order in code; the state goes to TypeSafe, and the weighted sum is the tool's own arithmetic rather than a Jev feature.
Jev Clean
Experimental CSV cleaning tool that computes repair candidates locally and uses Jev Choice, Noul, and Score judgments to gate changes, with audit and rollback records; it sends bounded candidate details and data samples to TypeSafe, and currently limits inputs to 10,000 rows and 30 columns.
Jev Codex Router
Local Codex Router extension that asks Jev for a model tier and thinking depth on each model call, including tool continuations, then relays the native Responses request; it needs a local routing stack, and its published savings backtest simulates an older policy rather than measuring current quota saved.
Jev Cookbook
Fifteen runnable OpenRouter recipes for support triage, data cleanup, search, browser actions, and Gmail labeling, with small labelled samples and saved live results; the examples keep action thresholds in code, and their sample results do not establish production accuracy.
Jev MCP
Python MCP server exposing classify, score, check, match, and screen tools to MCP-compatible agents.
Jev MCP by jkudish
Node MCP server with ten bounded Jev tools for checking claims against supplied evidence, screening content, choosing candidates, reranking, extraction, and patch review; it can use TypeSafe or configured gateways, but its judgments do not run tests or independently establish factual truth.
Jev Review
Staged code-review workflow and local dashboard that follows structured signals through focused Jev calls.
jev-align (Sutro)
Experimental active-learning CLI that evaluates CSV, Parquet, and JSONL data with Jev, asks people to label uncertain and randomly audited examples, and uses GEPA to propose improved definitions while keeping labels and proposal acceptance under human control.
Jev-assisted shell
When built with --assisted-shell and ran with --advise, the kamchatka agent classifies shell commands, providing the user with a quick, color-coded safety rating for each command that a model wants to run.
jev-axi
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 build logs, flagging risky diffs, and filtering or ranking many items; its own benchmark found agents using it read fewer files but cost the same, so it is meant for judgments rather than as a substitute for reading code.
jev-belay
Claude Code Stop hook that checks the transcript for evidence before trusting a "done" claim, spending one four-question Jev call only when files changed with no passing check since, and failing open on every error path.
jev-cli
TypeScript CLI (npm install -g jevctl) that turns Jev judgments into pipeable, exit-code-gated shell commands: verify claims against evidence, screen text for prompt injection before an agent reads it, classify, extract, match, route, find and rerank up to 250 candidates, compact agent transcripts by dropping stale tool calls verbatim, and batch any of them over JSONL with a concurrency pool; thresholds and --fail-on policy live in code, not prompts, it works over TypeSafe, OpenRouter, or Cloudflare Workers AI, and it ships as a Claude Code plugin with a compaction hook.
jev-commit
Pre-commit hook where one Jev call judges whether the commit message matches the staged diff, flags debug leftovers and unmentioned work, and blocks only when it detects a credential.
jev-engineering
Decision layer for coding agents: deterministic rules run before any model call, then one Jev request, shipped as a Claude Code PreToolUse hook, an MCP server, a loopback service and a team policy where personal overrides may tighten thresholds but never loosen them. Includes an adversarial kit and its published results: over 300 calls, blunt injections moved 0 of 30 dangerous commands but caused 10% false denials on safe ones, while authority framing moved 3 of 30.
jev-graphify
Python CLI that names and classifies graphify code-graph communities by having Jev pick from candidate names built from the graph, then routes a developer question to the community and symbol to read first; sends symbol names, file paths and short code comments (not source bodies) to TypeSafe, and has only been tested on one codebase.
jev-lint
MIT-licensed fuzzy linter that uses Jev to flag team-rule violations as Claude Code and Codex edit, with configurable rules and local thresholds; added code goes to TypeSafe and API errors fail open.
jev-logtriage
CLI that asks Jev Noul, Score, and Choice questions of collapsed Loki log batches and maps answers in code to suppress, watch, review, notify, or page; remediations stay candidates and nothing is executed.
jev-mobile
Experimental Android agent that uses Jev for bounded, per-step choices over prevalidated UI actions, with confidence gates, pagination, escalation, and optional LLM planning; currently a proof of concept tested mainly against Android Settings.
jev-pref
CLI and GitHub Action that turn project-defined semantic preferences into Jev Noul or Choice checks over code changes, then map results to advisory or blocking outcomes in code; supports tuning on labelled diffs, and sends reviewed change text to TypeSafe.
jev-pruner
Claude Code plugin and opt-in Codex wrapper that use Jev to trim long Bash output before the main model sees it, while preserving diagnostics and archiving the full output locally for recovery; scoring sends command output and session history to TypeSafe, and its retention rules are heuristics rather than guarantees.
jev-router
Claude Code and Codex wrappers that ask Jev to choose a model tier for each fresh user turn while retaining the native CLI sessions and authentication; prompt text goes to TypeSafe, and the documented compatibility testing is on Windows with specific CLI versions.
jev-semgrep
Node CLI (@uehaj/semgrep) that batches Jev Noul questions per line for multilingual grep by meaning and combines queries with AND, OR, and NOT in code. Every searched line goes to TypeSafe, repeated searches pay for the corpus again, and its semgrep command name collides with the static-analysis tool.
jev-skill-router
Claude Code plugin that ports the skill-suggestion cookbook to a UserPromptSubmit hook over user, plugin, and project skills; it sends the prompt text and skill descriptions to TypeSafe, starts in a log-only shadow mode, and ships thresholds that are not yet calibrated on its own data.
jev-unpack-hook
MIT Codex and Claude Code Stop hook that sends sufficiently long assistant messages to TypeSafe's Jev to count asks and list points, then prompts the agent to handle a multi-ask, multi-point handover one issue at a time above confidence thresholds; short messages are skipped, and API/key failures block the stop with a warning.
jev-use
Claude Code, Codex, and pi plugin that hands the steps needing no text output to Jev: jev_judge batches typed noul, choice, and score questions about one state into a single call, jev_gate is an opt-in PreToolUse gate that can only deny or ask, and a typed escalation contract (writing, open_ended, oversized, unsure, unreachable) returns every other step to the LLM rather than guessing — an unreachable backend escalates instead of allowing, so a gate that cannot be judged never waves a command through. Interchangeable TypeSafe, OpenRouter, and Vercel AI Gateway backends, a routing skill, and a native pi extension; its own live benchmarks, including the runs where Jev did worse, are published in the repo.
jev.nvim
Neovim plugin that splits the buffer into functions with Treesitter, scores each against a plain-language question with Jev, and ranks answers by probability in the quickfix window.
jevcal
CLI that fits a per-question confidence threshold to a target accuracy on your own labeled data, verifies it on a held-out split, estimates how much traffic still needs a fallback model, and re-checks the locked thresholds in CI; publishes no Jev results of its own, and thresholds fitted on fewer than about 100 labeled rows should not be trusted.
JevDroid
Experimental Python framework that uses Jev to choose Android actions from accessibility trees and executes them through ADB or UIAutomator2, with explicit action permissions and per-run budgets; goals and visible UI text are sent to the selected TypeSafe or Vercel provider.
jevgrep (allebee)
Streaming grep-by-meaning CLI (jevgrep-cli on PyPI) for logs and other text, including tail -f: it batches one Jev Noul per line and prints lines above a code-set threshold. Its hand-labelled, 195-line synthetic-log benchmark compares Jev with Claude; every judged line goes to TypeSafe or OpenRouter, and optional --explain sends selected lines to Anthropic through OpenRouter.
Jeview
Experimental unofficial loopback proxy and live map of Jev calls, grouping decisions by project and linking later calls to earlier answers; it forwards requests to TypeSafe and stores requests, responses, and the API key in local SQLite (the key in plaintext), so keep it off public addresses.
JevLoop (Python)
Experimental Python agent runtime where Jev selects typed actions and targets, low-confidence decisions can trigger LLM arbitration, and a shared guarded kernel executes file and shell operations in Docker sandboxes; task and tool context are sent to the configured model providers.
Jevonian
Experimental local proxy for coding agents using OpenAI, Anthropic, or Responses-compatible APIs. The jevonian/auto route asks Jev to choose a model and thinking level after deterministic compatibility and quota filters; explicit routes skip Jev. The ledger records the serving model, route reason, token usage, and estimated cost. Jev receives recent messages and tool results, and the optional fullPrompt setting can send the whole conversation. Low confidence is flagged rather than automatically rerouted; costs and cache savings are estimates.
jevr
Rust CLI for semantic code and document search: a local BM25 pass recalls candidate files, Jev Noul questions judge bounded windows, and a Choice reranks the survivors into grep-style path:line results; the query and selected source excerpts go to TypeSafe in requests containing up to 24 KB of source text.
JevRouter
Routes models, skills, MCP tools, CLIs, and plugins through Jev's typed choices while code enforces availability, permissions, risk, and confirmation; it includes an offline demo mode and append-only decision receipts.
jgrep
Semantic grep CLI (npm install -g jevgrep) that splits files or git diff hunks into 5–60 line chunks, packs several chunks into one request with a Noul question per chunk, and prints file:line hits above a probability threshold with grep-style exit codes, so a diff can be linted in CI against rules written in English; ships an interactive jgrep init and an opt-in Claude Code and Codex skill; chunks are judged in isolation so cross-file questions do not match, and every chunk's text is sent to TypeSafe's API.
langchain-skill-router
Per-turn skill routing for LangChain deepagents: a Jev adapter or another configured judge ranks and verifies candidates before middleware loads one skill or offers a shortlist; the request, recent conversation, and skill text go to that judge, and the published evaluation uses one generated testbed and one agent model.
mintocode
Context compiler for Claude Code, Codex, OpenCode, and ZCode that compiles a repository once and sends the agent only the code paragraphs a question needs, with optional Jev Noul judgments ("is this paragraph needed?") over candidate paragraphs; enabling Jev sends the question and up to 4,000 characters of each candidate's text to TypeSafe, and the Jev path is implemented but not yet benchmarked, so the project's published results use other selectors.
Mobile Jev
Local Android agent and studio using Mobilerun: Jev selects operations and observed targets, code rejects stale actions, and the included dark-theme demo checks the resulting switch; it needs a device plus Mobilerun and TypeSafe keys, while CI tests do not control a live phone.
mu
Pre-release coding agent and desktop app built on Pi that sends the routine calls of its loop to Jev as typed questions at 38 decision points (what enters the context, whether a flagged command was asked for, prompt-injection screening of fetched pages and MCP output, whether "done" was verified, what passes between sub-agents), each switchable between active, shadow and off and logged to a local ledger; the judge receives only the fields a question needs, which go to OpenCode Zen when no key is set, and a local judge or any LLM can take a decision point instead.
Oko
Local MCP code search for Codex, Claude Code and OpenCode that reranks a keyword shortlist with Jev Noul judgments and returns whole-function excerpts; sends the question and up to 90 code chunks per search to TypeSafe, and a keyword-only mode works without a key.
oxlint-plugin-jev
Experimental Oxlint plugin that asks Jev Noul questions about functions, calls, JSX elements, or files and reports matches above a chosen cutoff. It sends matched snippets to TypeSafe; API failures skip checks by default, so set ci: "fail" in CI. Keep it out of editor linting because edits can trigger paid calls.
patdown
CLI, GitHub Action, and agent hooks that judge files or changes against Markdown rules with a provider-swappable Jev backend and configurable probability threshold; it sends matched file content to TypeSafe, has no request budget or result cache yet, and its semantic verdicts need human review for consequential gates.
perch
Code scanner that parses methods and their call graph, asks Jev typed questions about each method in scope, and ranks potential defects and security findings; --since scopes CI runs. It sends method source to TypeSafe and reads every method in scope, so review request cost and findings before using it as a gate.
pi-heed
Pi extension that turns constraints stated in conversation (English and Chinese) into a scoped, replayable policy (deny, allow, exceptions, once/run permissions, ask-first, tests-before-push) and checks side-effecting tool calls against it before they run; rules handle side effects and paths while Jev only classifies how each message changes the policy, re-checks exceptions and skips tools a free-text rule cannot concern; ships a replayable benchmark and an experiment log on Jev calibration and question design; experimental, shadow mode by default, fails open, and the benchmark is scripted rather than drawn from real sessions.
pi-jev
Pi extension with a shadow-mode tool-call gate, output judge, and a general typed jev_ask tool.
pi-jev-compaction
Pi extension that asks Jev which older tool results to hide after context pressure rises, retains the original session messages, and exposes a jev_read tool to recover an output without rerunning its command; it protects recent results and leaves context unchanged on API failure, but Jev sees bounded conversation and tool-output excerpts that may contain private data, and tests do not establish live relevance quality or cost savings.
pi-jev-context
Pi extension that shortens long tool output before it enters the context, so no cached prompt prefix is invalidated: Jev gives every block of the output a probability that the current request needs it, only blocks it is confident are unneeded are hidden, code guarantees that failure lines, request terms and the top-ranked blocks survive, kept lines stay verbatim, and a context_recall tool returns the original; ships experiment reports and a findings log with pre-registered synthetic sets and weakly labelled replays of real sessions, including a negative result (Jev-judged pruning of old context dropped information needed later, so that part stays shadow-only); experimental, shadow mode by default, and the real-session replays come from one user's sessions.
pi-verdict
Pi permission gate that first applies deterministic rules (danger floor, user allow/deny, protected-path prompts) for clear decisions, then routes gray-zone cases to a fail-closed enforcing classifier (configurable via classifierModel to point at Jev: allow/ask/deny); the Jev backend is experimental — served through OpenRouter or TypeSafe's direct API, it ignores protected-path hints and can be swayed by adversarial transcript content; transcripts are sent to whichever classifier backend is configured.
pi-warden
Pi guardrails built on pi-typesafe that return Jev's verdict to the agent as a held tool result or a short steer instead of a dialog, check writes against a project rules file, and grade their own holds against the user's next message on recorded sessions; the action guard is calibrated on one user's 17k calls, the other guards on synthetic cases only.
pytest-jev
pytest plugin for semantic assertions about LLM output: jev.expect batches Noul claims about one text, reports each probability, and by default fails uncertain claims (holds needs at least 0.8, lacks at most 0.2); Choice checks the selected option and Score checks probability mass across ordered levels. It caches answers in .pytest_cache, skips Jev tests without a key by default, and sends tested text and context to TypeSafe or OpenRouter.
reasoning-router
MIT OpenCode plugin, Pi extension, and local Responses/Messages proxy for Codex CLI and other clients that asks a classifier (Jev by default; Clef, Laya, Kev, OpenAI Decisions, and CLM also work) to pick the reasoning effort for each model request, then adds it as an OpenAI configuration_update item or an Anthropic effort-only system message so the cached prompt prefix still matches; the classifier receives bounded excerpts of recent conversation and up to eight recent tool results, the published eval covers one GPT-6 Astra task mix (Jev routing and fixed high effort each solved 44 of 44, routed used about 14% fewer output tokens), and the project is alpha.
Second Thought
Python SDK, CLI, and optional local dashboard that captures typed decisions from Laya, Jev, or a custom classifier, measures calibration, and routes uncertain cases to human review; its dataset export excludes Jev decisions in code, and its reported Laya result comes from a 24-ticket example run.
Skillbox
Self-hosted agent skill library with opt-in Jev recommendations over task text and authorized active skill descriptions, using an owner-provided TypeSafe, OpenRouter, or Vercel AI Gateway key. Failed, oversized, or rate-limited evaluations fall back to deterministic search rather than returning a partial model ranking.
SkillRanker
Rust CLI that uses Jev Choice and Noul judgments to shortlist and rerank agent skills against the current task, with a real none option, local replay, and opt-in network disclosure; fresh ranking sends redacted session context and skill excerpts to TypeSafe, and its license includes an OpenAI/Anthropic rider rather than plain MIT.
slop-grader
CLI tool that grades markdown and text files against custom rulesets for AI slop, grammar, and documentation quality using Jev scores and flags, then guides an AI agent to auto-fix violations.
Sniff Test
Prose linter with local countable rules and opt-in Jev Noul judgments over individual paragraphs, available as a CLI, pre-commit hook, and GitHub Action; its author-published comparison uses a small seeded corpus, with some judgment rules tuned on those same seeds.
strayguard
Pre-commit hook that uses Jev Choice to flag scratch files, output dumps, build output, and local-only files; sends new-file paths, sizes, nearby tracked names, and up to 40 lines of eligible text to TypeSafe. Local rules suppress contents for matched secret-file paths, but unmatched text may contain secrets; on API failure or without a key, it falls back to local rules, and non-interactive warnings do not block unless strict mode is enabled.
Supercov
Code quality for coding agents: Jev scores each source file so the agent knows what to fix first.
Switchboard
Local Claude Code and Codex wrapper that assesses a new conversation's task with Jev, applies local confidence policy to choose the model and reasoning effort, and pins that route through follow-ups, tool calls, and resume to avoid unnecessary prompt-cache disruption. It preserves native authentication and sends task text to the configured TypeSafe, Vercel, or OpenRouter Jev endpoint; raw prompt history is stored only when explicitly enabled.
System One-assisted compaction
Archived Rust example that asks a configured OpenRouter decision model to score which tool outputs are worth keeping during context compaction; it compares the ordering with an age-based policy on a synthetic session, not a live-agent outcome.
toolgate
MIT TypeScript tool-call firewall for Claude Code (PreToolUse hook) and MCP servers (stdio proxy): static rules first, then seven Jev Noul risk questions per action mapped to allow, ask, or deny by policy thresholds, with an action ledger, key-aware redaction, and a local JSONL audit log. Sends redacted tool input, cwd, and recent prompts to TypeSafe, OpenRouter, or Vercel AI Gateway (owner's key); in one author's 1,369-decision window on 0.9.1, blind second labeling of 150 sampled allows found no permissive misses, while 21% of decisions required an ask, mostly from one axis. Version 0.11.0 addresses that axis but has not been re-measured. Heuristic redaction and model judgments are defense in depth, not a sandbox.
TypeSafe MCP
Go CLI and single-binary MCP server with setup for Claude Desktop, Claude Code, and Codex.
Vercel Eve
Agent framework whose auto model router defaults to Jev through Vercel AI Gateway and whose evaluate helper asks typed Choice, Score, and Boolean questions inside tools; the underlying AI SDK evaluation model specification is experimental, and the caller owns routing and effects.
VexJoy Agent
Cross-harness coding-agent toolkit whose /d path uses up to two Jev evaluations to select agents, skills, and a pipeline, then checks the proposed intent before dispatch; deterministic force-route rules bypass Jev. Request text goes to TypeSafe or Vercel AI Gateway, and the installer changes local agent configuration and hooks.
wakegate
Experimental TypeScript gate for long-running agents on Workers, Durable Objects, and Node: before a sleeping agent's LLM is resumed on a timer or incoming event, Jev answers one Choice (wake, not yet, unrelated) against the agent's own sleep note, and code skips the wakeup only below 0.2 on wake while always waking on user messages, bare timers, a skip limit, errors, and timeouts; its eval is 21 hand-written scenarios, not a benchmark.
No listings match that search. Try another term or clear the filter.
Community entries are independent unless their source says otherwise. Inclusion is not an endorsement or security review. Report an outdated detail →