Discover the Best AI Tools

A Node.js CLI and MCP server exposes Jev-based classification, choice, routing, ranking, semantic line filtering and action checks. It requires an API key and sends selected text to the service; clipped context can miss relevant lines, and its guard is advisory rather than a security boundary.

An experimental protocol repository includes runnable offline tools for replaying metrics on a fixed historical 40-case evaluation and checking protocol fixtures. It supplies no runtime agent controller or live API evaluation, and the original model responses are unavailable; the replay is not a general-purpose evaluator.

A TypeScript library adds logged, threshold-based decision gates across requirements, planning, execution review and release workflows. The implemented backend uses a compatible LLM provider and needs its credentials; the Jev backend is currently a contract stub rather than a working integration.

An experimental Hermes plugin produces model-routing plans from an operator-defined allowlist and budget constraints, optionally using Jev. It does not dispatch requests or switch models automatically; external calls are off by default and reported fixtures are synthetic, not evidence of live savings or quality.

A prototype GitHub Action turns trusted issues into proposed fixes using an agent, repository checks, a read-only reviewer and Jev decision gates with bounded retries. It opens pull requests without merging; provider credentials are required and its Claude spending cap excludes Jev charges.

A Python loop combines Jev probabilities with operator-supplied priors to propose agent workflow actions from supplied state. It requires an API key and prepared questions; the small included benchmark does not establish an improvement over raw Jev.

This Hermes adapter uses Jev to remove or truncate stale tool history while retaining ordinary conversation text and protecting specified state-changing calls. It reads the session database without writing back and optionally exports JSON. Setup builds an upstream library; a TypeSafe key is required, context is sent externally, and relevance judgments can miss useful evidence.

check-risk combines repository policy rules with optional Jev semantic analysis to score Git changes and recommend checks and reviewers. It runs locally as a CLI or GitHub Action; semantic mode sends code context externally. Live Jev validation remains pending, offline results are incomplete, and risk scores are not failure probabilities.

Frost analyzes a prompt with TypeSafe Jev and locally recommends a configured model, harness and effort level according to cost, quality or speed policy. It does not launch the recommended model. A key and maintained catalog are required; example rankings and optional capacity snapshots do not guarantee account access or outcomes.

pi-typesafe-jev exposes TypeSafe choice, yes/no, score and batched judgments as Pi tools, including reusable question files. Calls send supplied state to the API; users retain responsibility for thresholds and actions. The setup stores the API key in plaintext locally and its input is not masked.

pi-jev-code adds Jev search ranking, pre-edit semantic checks and baseline-to-current diff review to a single Pi coding agent. It needs Pi, Node.js and a TypeSafe key and sends task/code context for judgments. Thresholds remain heuristic; API failures allow continuation and final reviews occur after the agent's edits.

JevKeep preserves selected verbatim conversation excerpts alongside Codex's normal compaction summary using Jev relevance scoring. It requires supported compaction hooks, Node.js and a TypeSafe key; conversation and tool text are sent externally. Excerpt size is capped, selection can miss details, and failures leave native compaction running.

decide-mcp is a local stdio server that delegates bounded choices to configurable models and policy profiles, defaulting to Jev through AI Gateway. Model calls require provider credentials and send context remotely. It distinguishes native distributions from model-estimated percentages; recommendations do not execute actions or guarantee calibrated confidence.

AskJev MCP exposes TypeSafe's choice, yes/no and ordered-score judgments to MCP clients, batching questions over shared context and returning model usage and probabilities. It requires Node.js and a TypeSafe key and sends supplied state to the external API. Scores use ordered-level indices, not a universal zero-to-one scale.

Switchboard is an OpenAI-compatible Python gateway using Jev to screen requests for injection, harm and PII and route to small or large models, with optional output checks. If Jev is unavailable it defaults to allowing the large model with a flag, unless configured fail-closed. Credentials are required; thresholds and security effectiveness need independent validation.

Pi Agent Foreman checks the latest explicit work request and unfinished assistant response, using a classifier and a separate Pi agent to propose a continuation. It respects stop, blocker and permission boundaries rather than reviving older requests. Classification sends request/response text externally and remains probabilistic; it cannot grant new authorization.

OMP Statify optionally compresses large tool text and earlier plain assistant messages while preserving recoverable originals locally. It is off by default and leaves user/instruction messages untouched. OpenRouter receives selected context; failures, low confidence or no reduction retain the original. Compression is not guaranteed to reduce total cost.

XavierJev is a local TypeScript decision library for binary judgments, choices, scoring, gates and routing using token probabilities from Ollama or llama.cpp. It is independent of hosted Jev and includes a Claude permission plugin. Backend failures ask a human; small-model judgments still need task-specific calibration and suitable local resources.

Codex Jev Router now provides deterministic workspace evidence selection through local MCP search, path/line citations and bounded expansion. Its former model-routing design is historical; the current default needs neither Jev nor a local model and does not change Codex’s model or reasoning settings. Selected excerpts are not a complete repository audit.

Jevonian is an experimental local gateway that routes planning, execution and utility requests among configured model providers and records estimated cost and quota usage. It does not host models or act as an agent. Prompts and tool content still reach providers, and its pricing estimates need not match invoices.

DSH Jev Verify adds typed choice, yes/no probability and scoring tools, audit logs and optional action checks to DSH. Autoguard combines deterministic rules with Jev risk thresholds but fails open with a warning on API errors. It requires TypeSafe access; probabilities and small benchmarks are not reliable security guarantees.

Jev Skill Router is a runnable Claude Code hook that logs skill suggestions in default shadow mode or injects a short hint, with log-analysis scripts. Its experiment concluded without demonstrated benefit; it does not change the full skill listing. It needs a paid TypeSafe key and sends prompts and selected skill contents to Jev.

CyberWareX MCP provides agent access to web extraction, screenshots, PDF, blockchain data, speech and other hosted APIs. Calls are paid through x402 with USDC on Base. Servers return payment requirements rather than holding wallet keys or paying themselves; an authorized client handles settlement.

Jev Toolkit is a Bun-based MCP server for typed judgments, ranking supplied candidates and checking claims against supplied evidence. It needs TypeSafe credentials and keeps a local event log; callers must redact ask-state content, and pattern filters are not complete privacy classification.