typesafe-ai/skills (official TypeSafe agent skill)
Official agent skill for Claude Code, Codex and other agent environments; installs via claude plugin marketplace add typesafe-ai/skills or npx skills add typesafe-ai/skills. MIT licensed.
A coding agent reads a repository, edits files and runs tools, and it asks itself small questions all session long. Which file matters here? Is this command safe? Did that test fail for a real reason? A decision model answers those questions with a typed choice or score and a confidence value, so the harness can act on the result in code instead of parsing a paragraph. The examples in this hub run on Jev and other decision models. Some label pull requests, such as 1jehuang/jev-pr-labeler, or pick which tests a change can skip, such as baronunread/leanest. Others sit inside an agent as a gate or a router, like clownware/bouncer, a Claude Code hook that scores each tool call against a policy file. Many ship as plugins or skills for Claude Code, Codex or Pi. Before you copy one, check which agent it targets, what the decision model is shown, what happens when confidence is low, and whether it fails open to the normal path or blocks the agent.
83 entries
Showing 1 to 48 of 83
Official agent skill for Claude Code, Codex and other agent environments; installs via claude plugin marketplace add typesafe-ai/skills or npx skills add typesafe-ai/skills. MIT licensed.
Claude Code plugin that replaces the compaction summary with Jev decisions. Every tool call and result is scored in one request against the whole conversation, stale ones are dropped or truncated, and everything kept stays verbatim. Also usable as an npm library.

Staged code-review workflow with a local dashboard, where Jev judges code changes or a whole codebase.
Places Jev as a fast supervisor above slower Codex coding agents. Codex workers do the engineering while Foreman independently assesses whether the work is complete, requirements are met, tests suffice, or human input is needed.
Automatic per-turn model routing for Claude Code and OpenAI Codex. Jev sends simple work to the fast model tier and difficult work to the strong tier while preserving each CLI's native tools, sessions, permissions and authentication.
Per-call model routing for Codex: Jev answers four choice questions to pick the model tier and thinking depth, so the cheapest sufficient model serves each call. A 7-day replay of 237 real turns measured about 60% savings against always using Astra, under an older policy.
262 starsHistorical replay ~-60% cost
Local-first MCP plugin giving Claude Code, Codex, Cursor and OpenCode structured code-quality scores (correctness, complexity, modularity, security) while they work. Sends focused diffs to Jev and keeps keys and code local.

Open source tool that scores every turn a coding agent takes against project rules that can't be codified into a linter, using Jev, then tells the agent what to fix.
211 starsRule breaks 1 in 13 turnsPer check ~300 ms

A Claude Code and pi plugin that uses Jev to judge whether a session has reached a safe point to run /compact, in a hint mode or a fully automatic mode.
183 starsEval set 40 sessionsHint floor (empty) 0.90
Extension making Jev the decision layer for the Pi coding agent: a measured tool-call gate plus a jev_ask tool. Judges whether an action is destructive, exfiltrates data or exceeds scope, then blocks or warns on calibrated thresholds.
144 starsGate latency ~300ms
A Claude Code plugin that uses Jev to trim noisy Bash output after a command runs but before the result reaches the main model, once the output passes an estimated token threshold.

Guardrails for the Pi agent built on pi-typesafe. Jev judges irreversible and off-task tool calls, detects stuck loops, checks unverified completion claims and flags low-quality output, steering the agent rather than interrupting the user.
138 starsHolds per 1000 calls 3
An Agent Skill that guides a coding agent through writing and improving programs that call Jev.
Rust CLI that hands an agent's live session context to Jev, which compares the available skills and estimates which fit the next step. Ships Claude Code hooks, structured JSON, abstention, a terminal display and local feedback.
Command-line toolkit a coding agent can delegate judgment work to: ranking relevant files, checking a diff against its task and project rules, and triaging test failures or review comments. Each request runs one bounded typed workflow and returns a structured report.

Scores source-file quality by asking Jev a set of yes/no questions, runs the test command you already use, and turns uncovered paths into small queries a coding agent can work through. Scoring costs about a cent per megabyte of source; coverage needs no account, config file or hosted service.
109 starsScoring cost ~1c/MB
A Claude Code hook that splits large tool results into blocks and asks Jev a yes/no relevance question per block, replacing low-relevance blocks with a short recoverable stub before they enter context.
Codebase search that finds files matching a natural-language request through repeated Jev-guided passes over a directory tree.

Semantic code search for coding agents: it scans an authorized repository, asks Jev to score all eligible fragments against a plain-English question, and returns the original source excerpts with their paths and line numbers.

Uses Jev to pick which of your project's rules apply to a given prompt, so Claude only sees the relevant ones.
Adds semantic tool routing, skill discovery and typed Choice, Noul and Score judgments to the Pi coding agent. Opt-in modes pick the model per prompt and use Jev to decide which tool history survives compaction.

Pi extension that gives the agent and other extensions one key-managed TypeSafe client. A batched typesafe_evaluate tool hands classify, triage, compare and score judgments to Jev in a single call, and a terminal playground runs requests without touching the model's context.

Local-first macOS coding workspace built in Rust with a local Laya selector and optional hosted Jev, routing fresh coding tasks and validating each chosen route on the host.
41 starsCost/time cut ~80%
Rust CLI that classifies Git commit diffs and messages with Jev, labelling bug fixes, security fixes with CWEs, and change types. Scans a local repo or remote URL and exports HTML or CSV reports.

Security hook for coding agents that risk-scores every tool call with session context (deny/ask/allow), flags prompt injection in tool results and checks skills and plugins. Supports Claude Code, Codex, Copilot, Gemini, Cursor, pi, OpenCode and ACP.

Local context-pruning proxy for Claude Code and Codex. Jev judges which conversation history is still needed above a configurable size gate, and Yoshi applies the validated omissions before forwarding to Anthropic or OpenAI; the author calls it a proof of concept headed into CompozyOS.
Auto mode for the Pi coding agent, which has no permission system of its own. A deterministic layer handles hard denies and your allow and deny patterns, then Jev judges the bash, write and edit calls it escalates and fails closed when it cannot decide. Thresholds come from recorded real-API calibration.
A skills framework for AI coding agents that adds Jev-based gates and vetting to the workflow.
A Jev decision layer for agents, shipped as an MCP server, an embeddable DecisionModel library, and an escalate-only Claude Code plugin.

An OpenCode plugin that embeds the running session state with Laya and scores how far it has drifted from the calibrated plan using weighted Jensen-Shannon divergence, shown live as a sidebar score.
Pi coding-agent extension that splits large tool results into blocks, has Jev score whether the agent will need each one, and hides low-scoring blocks behind a stub recallable with pi_jev_recall.
14 starsContext freed 9.7%Judge spend $0.65
A minimal Pareto-optimal router for OpenRouter models in the Pi coding agent, using Jev to pick a model on the cost-quality frontier for each turn.

A fuzzy linter that uses Jev to check code against rules and conventions written in plain language, shipped as a CLI, a GitHub Action and a pi package.
Agent skill that runs a /jev-me planning interview. Jev scores which questions would change the plan and whether the user's answers actually settle them, and logs the interview for later inspection.

Decision layer for the Pi coding agent, where Jev answers the closed questions a harness asks dozens of times per session: is this command destructive, did that output leak a key, did the agent verify its claim. Rules live in JSON packs, every answer is recorded, and everything fails open.
A speed-focused Pi extension that pairs a local coding model with hosted Jev judgments, using file retrieval and exact-result caching to reduce context and repeated network calls.
A task-boundary model router for the Pi coding agent: Jev judges task tier, context sufficiency and consequences, and deterministic code decides whether to switch models based on your configured capabilities and costs.
Judges every code file in a pull request against Robert C. Martin's Clean Code with Jev, one calibrated probability per question, then has a writing model turn those findings into two sentences per file and a decision for the change. Runs on Vercel's eve framework as one Next.js project.

Agent skill for designing judgment-assisted systems with Jev, where code stays in control and the model supplies narrow typed judgments. It maps Choice, Score and Noul onto classical methods such as decision theory, reranking and routing, and requires a falsifying experiment before a design is treated as settled.
A GitHub App that routes pull-request review work: it sends the PR context to Jev, gets back a structured risk decision such as low, normal or specialist, and a policy layer maps that to auto-approval, a review request, or a check-run update.
A GitHub Action that asks Jev a set of yes/no questions about a pull request, answered in parallel in one call, and approves it only when every answer clears a confidence threshold you set.

A CLI that turns AGENTS.md preferences into Jev-checked semantic rules, reviewing code hunks or pull requests with typed choice and noul questions and feeding findings back to a coding agent.
Paste a public GitHub pull request URL and one Jev call returns risk bars and a verdict. The single request covers merge risk, review depth, whether design or security review is needed, missing tests, docs debt and how wide a bug could spread.

Runtime constraints for the Pi coding agent that check every side-effecting tool call against what you actually said before it runs, using your own words as the reason when it blocks a call.
Hybrid coding harness for the Pi agent: any LLM writes the code while Jev returns typed probabilities, and deterministic policy code turns those into allow, confirm, block, warn or steer. Isolation stays with containers, so it is not a sandbox.

An Agent Skill that helps you decide what to build with Jev, where it could improve existing software, and what to test before committing to it.

Checks your code against Markdown specs on every commit by asking Jev one focused question per requirement and comparing the returned probability with a threshold you set, failing the build on drift.

Filters every tool result through Jev before the coding model reads it, with an A/B harness that measures pass@1 and cost against an unfiltered control.
Nothing matches those filters
Clear a filter to widen the search, or send us the thing you were looking for.
In practice the decision model handles the narrow, repeated questions and the coding LLM keeps the writing. devagrawal09/stanley-code is a command-line toolkit an agent can delegate to for ranking relevant files, checking a diff against its task and project rules, and triaging test failures. cephalization/jev-triage asks a fixed set of typed questions per GitHub issue, such as what kind it is and how severe.
Score fits ranking jobs like picking relevant files or tests. Choice fits labelling and routing. Noul, a yes or no with a probability, fits gates such as whether a tool call is destructive. A hook like clownware/bouncer turns the answer into allow or deny with plain code, so a person owns the policy file. The answer is a number or a label, so the hook or plugin can compare it with a threshold in code.
The trade-off is where the check sits. A gate on every tool call adds a decision to every step. Entries such as baronunread/leanest fail open to the full test suite when the model is unsure, so a wrong call costs time instead of a missed bug. Pick the failure mode before you pick the tool. Read each entry's docs for which way it fails.
Entries here use Jev to label pull requests by the size of the change, classify commits, triage issues and check a diff against project rules. It returns typed answers with confidence, so a CI step or agent can act on them. It does not write the review text.
Most entries ship as a hook, plugin or skill. A hook runs before or after a tool call and asks Jev a question about it. Read each project's install notes, since they target different agents and versions.
No. The coding LLM still writes and edits code. The decision model answers small questions around it, such as which file is relevant or whether a command is safe.