Discover the Best AI Tools

todo-jev classifies requests into rules, specialist skills or model work using Jev and local presence checks. Routing is implemented, but execution handlers return examples and require your own integration. A passed environment check does not establish skill installation, credentials or successful execution, and routing scores are not calibrated success probabilities.

This skill-router CLI ranks installed Claude Code skills against a session goal and suggests discovery when none fit. Real ranking uses TypeSafe; without a key, labeled mock mode matches keywords. Recommendations do not install or execute a skill, and the integration currently targets Claude Code rather than arbitrary agents.

tiershift uses Jev signals and configurable rules to select a model tier, with CLI, libraries and proxy integration. Completion calls can escalate after provider failure. It needs judge and model-provider access; cost and quality results on plain prompts do not establish performance for long, tool-using agent workflows.

Mastra Jev Moderation is a TypeScript input processor that sends the final message text to Jev and blocks above a configured threshold. History, attachments and outputs are not moderated. A key is required; timeouts, HTTP errors and an open circuit breaker let input through, so independent safeguards remain necessary.

jev-shield proxies stdio MCP traffic, combining structural policies, Jev checks on tool calls/results/descriptions and session taint tracking. It requires an external model service and configurable failure behavior, including fail-open. Probabilistic screening may miss attacks and is not a replacement for sandboxing or human authorization.

typesafe-mod adds Claude Code function hooks that annotate question choices with Jev probabilities and optionally suggest skills. Automatic answers are opt-in, and failures leave normal dialogs intact. The question judge reads options rather than conversation history, skips multi-select questions and requires TypeSafe access; confidence is not user authorization.

jcm-router is a local Claude Code proxy that uses Jev to choose model and effort, with cost guards for switching established conversations. It forwards client authentication and sends selected prompt context to TypeSafe. Switching can rebuild expensive caches; estimates and workload-specific results are not guaranteed savings.

LangChain Skill Router replaces deepagents skill middleware with per-turn selection through a pluggable judge, including Jev. Failures restore the full catalog. Hosted judges receive routing context; token reductions in one benchmark do not guarantee lower cost, latency or preserved task quality elsewhere.

Hermes Jev Plugin gives Hermes Agent tools for binary checks, option routing, rubric scores and mixed evaluations using TypeSafe Jev. It requires a TypeSafe API key and returns structured probabilities rather than chat text; agent workflows must interpret the results.

Jev MCP Dispatcher is a prototype that discovers MCP tools, selects actions with Jev and extracts primitive arguments from command text before executing them. It needs a TypeSafe key and explicitly stated argument values; complex schemas, clarification and full argument validation are not supported.

Prompt2Jev combines an agent skill with a CLI to turn requirements, prompts or existing decision code into typed Jev requests and runnable wrappers. The CLI validates and generates artifacts offline; conversion needs a coding agent and live decisions require TypeSafe credentials.

DSH Jev adds a typed-question Jev tool to DeepSeek Harness profiles. It targets a specific DSH release candidate and requires a TypeSafe key; the agent decides when to call it, and it is neither a streaming chat adapter nor automatic enforcement.

Open Jev Approvals reviews Claude Code tool calls with Jev and applies local allow/deny rules with an audit log. It targets macOS and Linux and needs TypeSafe credentials; missing keys, service errors or a broken audit database allow calls rather than block them.

Pi Heed preserves user rules and task state in ledgers for the pi agent and checks tool calls against them. Jev can judge ambiguous rule scope and changes, while code enforces recorded policy. Model omissions, uncertain judgments and unsupported shell patterns can still miss violations.

Fast Jev Compaction for Codex scores tool history with Jev and reinjects retained passages after built-in compaction. This port is an experimental proof of concept whose author advises against real-work use; it needs TypeSafe credentials and cannot replace Codex history directly.

Jevex is an experimental agent loop where Jev selects and approves tool actions while a chat model fills arguments and writes answers. It needs both model credentials; bundled tools are read-only, and arbitrary MCP tools, persistent memory and production injection defenses are outside its scope.

Jev Judgment bundles an agent skill and Python client for closed-question checks before user questions, risky actions and retries. It needs TypeSafe credentials; absent credentials or network failures let the agent continue, and confidence does not grant permission.

TypeSafe CLI is a standard-library Python command-line client that evaluates typed Choice, Score and Noul questions over supplied state. It requires a TypeSafe key and returns structured judgments, not generated chat or code.

Turns evidence-grounded project preferences into configurable semantic checks over code changes and returns findings to a coding agent. Requires a configured decision service; it does not fix code itself or replace deterministic checks, and vague preferences must first become observable criteria.

Narrows external MCP tool discovery for Codex using Jev decisions, with bounded search fallbacks for uncertain results. Requires Vercel AI Gateway access; task context and tool descriptions are sent remotely, and applying setup changes the local Codex integration configuration.

Compares code with Markdown requirements using Jev judgments and configurable thresholds for CI or commit checks. Sends specification and code context remotely; Markdown tables are currently omitted, oversized targets fail, and probabilities do not replace tests or review.

Analyzes public GitHub pull-request context with Jev and presents structured risk and review-depth judgments. Requires a TypeSafe key; large diffs may be trimmed, private repositories are unsupported, and the verdict is advisory rather than a correctness guarantee.

A Pi coding harness that combines Jev probability judgments with deterministic allow, confirm, block and steering policies. Requires Pi and configured decision services; context is transmitted after redaction, and the policy layer is explicitly not a sandbox.

Checks commit messages against staged changes and flags debug leftovers or credential-shaped additions. Sends review context to Jev; most findings warn by default, and API failures allow the commit, so it is not a reliable substitute for dedicated security checks.