Building a harness with Jev
Architecture notes on putting bounded Jev judgments inside an agent harness.
ROUTING, GATING, VERIFYING
Where a typed decision sits inside a larger loop: model routing, tool-risk gates, context compaction, rollout rules.
The same pattern across sources: a generative model writes, Jev decides, code executes.
Architecture notes on putting bounded Jev judgments inside an agent harness.
A long-form explanation of integrating typed judgments into agent workflows.
Jev is framed as a constrained structured-output primitive inside a larger agent harness.
A model or agent route is chosen from a fixed catalog based on the current task.
Per-turn routing chooses a model, reasoning depth and speed mode for Codex.
Jev scores which tool calls and results remain relevant before context is compacted.
A conceptual map of where a low-latency decision model can sit in software.
Keep a bypass, decompose questions, tie confidence to actions and shadow-run before replacement.
A community guide covers typed calls, batching, middleware, confidence gates and migration.
A prompt asks coding agents to inventory every bounded semantic decision where Jev might replace a heavier model call.
An agent skill for finding and designing bounded Jev decisions in software.
Vercel's changelog entry: Jev is callable through AI Gateway from AI SDK 7 (7.0.105+) via the experimental `evaluate` API as model `typesafe-ai/jev`, with Choice, Score and Noul questions.
OpenRouter's beta listing for `typesafe/jev-1.13` with a `jev-latest` alias: $0.042/M input, free output, 32K context, plus the platform's own latency and token-volume telemetry.
Workers AI exposes the model as `typesafe/jev` (jev-1.13.0) with `state` plus noul / choice / score questions and a 32,000-token context window.
Netlify's changelog: the gateway injects credentials so `@typesafe-ai/sdk` runs inside Netlify Functions without managing keys; alias `jev-latest`, Node 20+.
Vercel benchmarked the auto-mode safety reviewer of its fx coding agent with Jev in place of GPT Luna and says it is likely to become the default.
Screens agent tool calls for destructive, exfiltration, privilege-escalation and off-task actions using Jev probabilities, ships as an npm package and a Claude Code PreToolUse hook, and logs an audit trail.
A proof-of-concept MCP server exposing three tools: verify a claim against evidence, screen text for injection or relevance, and rank candidates semantically.
A Claude Code plugin that asks Jev which standing rules and codebase maps are relevant to the current prompt or file edit, injects only those, and falls back to all rules if the API is down.
A Claude Code hook where Jev decides whether a task goes to Haiku, an Opus sub-agent, or an external harness such as Codex or OpenCode.
Wires Jev into five decision points of a coding-agent harness; the main test is failure triage on 102 real provider-API failures from session logs.
A tutorial that replaces an LLM-as-judge with Jev to score Langfuse traces, with a full Python example detecting user disagreement per conversation turn.
Benchmarks Jev as a router across 13 flagship models on LLMRouterBench and a RouterArena pilot.
Uses Jev as a four-tier difficulty classifier in place of NVIDIA NeMo Switchyard's router classifiers, with code.
An experimental semantic router for Hono by its creator: routes are described in plain language and Jev matches incoming requests to them from method, URL, headers and body.
An n8n node with Ask Yes/No, Ask Choice, Ask Score, batch Evaluate and model lookup operations, defaulting to `jev-latest`.
Sits between MCP clients and servers with three layers: structural allowlists, semantic hazard detection via Jev, and session taint tracking; targets poisoned tool descriptions, injection, exfiltration and secrets.
Jev scores each request on eleven dimensions (difficulty, stakes, safety and more) and YAML thresholds map the scores to model tiers; TypeScript and Python SDKs plus an HTTP proxy.
An OpenAI-compatible router that uses Jev to pick a model on top of LiteLLM, filtering candidates by capability and falling back to the cheapest model without a TypeSafe key.
Routes Claude Code tasks to a cheaper or more suitable model based on a Jev decision; listed in the Studio Yebisu roundup.
The agentgateway proxy project ran Jev as a prompt guardrail with distributed tracing and cost tracking, with an example linked.
Tested Jev as a pre-action safety check for agents; the follow-up setup filters everything with Jev and escalates only suspicious cases to Gemini.
Foreman watches coding agents and uses Jev to continuously assess progress, completeness, tests, drift and verification, intervening when needed.
skillbox reads the query and returns the relevant agent skills immediately with Jev, instead of agents spending many turns searching for them.
Adds a `:typesafe` provider to RubyLLM 2 with Noul, Choice and Score primitives, schema building and validation, and an offline models catalog.
A Rust crate with enum responses and confidence, async or blocking backends, batched questions and observable retries; examples cover PR questions and semantic search.
A TypeScript client for batching several typed questions about your data into one Jev request; the example triages GitHub issues.
Validates state locally with Zod-style schemas, bundles all questions into one parallel Jev request and projects typed answers; built on the official SDK.
An async LangGraph workflow that classifies mock emails (invoice versus general) with the Choice primitive and routes them to handlers, with unit tests; pins jev-1.12.
Pydantic AI merged a TypeSafe model provider: `TypeSafeModel('jev-latest')` with confidence thresholds, a FileUnderstanding capability and fallback to an LLM for tool calls; docs cover jev-latest, jev-preview and pinned releases.
The LiteLLM proxy scores older tool results with Jev and replaces low-relevance ones with short removal notices before the request reaches the LLM; a TypeSafe pass-through endpoint is documented too.
Braintrust added Jev as a scorer with a confidence-threshold pattern (accept above 0.95, route 0.70–0.95 to an LLM judge, flag below 0.70 for humans) and auto-instrumentation of TypeSafe client calls in its Python SDK.
A Python package that traces TypeSafe System One calls as OpenInference LLM spans (request, response, model, token counts) for Phoenix and compatible backends; a JS package is documented in Phoenix.
A Claude Code and Codex CLI plugin that intercepts Bash output above roughly 10K estimated tokens, chunks it and asks Jev which lines are still needed, dropping progress logs and boilerplate.
A layer that decides when an agent's stored memory should be invalidated, using Jev checks; a playground is hosted.
An experimental protocol where a worker agent sends requirements, code and test results to Jev, which returns an evidence verdict for the team-lead agent before results are accepted.
A local MCP server that runs Jev "packs" (code audit, PR review, GUI automation) for Cursor, Claude Code and Codex.
A Cloudflare Worker demo where a Flue agent uses Jev through Cloudflare AI Gateway for intent and urgency routing.
A zero-dependency Ruby client for decision models supporting TypeSafe's native API and OpenRouter, with retries, timeouts and usage/cost fields.
A seven-step setup that puts Jev between Grok Bot and its actions: a jev-usage-router skill is consulted before browser, research, retry or extra-bot steps; it starts in shadow mode with logs, then goes active, with a kill switch. Repository included.
Notes from integrating Jev into a custom agent harness: beyond cheap classification, the interesting uses are continuous evals and monitoring, custom verifiers for long-horizon agents, and recursive self-improving harness loops; a guide is in progress.
A small plugin exposing Jev to Nous Research's Hermes Agent as tools: jev_check, jev_route, jev_score and jev_evaluate.
An MCP server for Jev built in about four hours and paired with a local GLM 5.3 Flash model — the author's 'absolute deadly combo'.
A multi-robot harness CLI (Microduck, Open Duck Mini, LeRobot, XLeRobot, AlohaMini and more) where each robot has an LLM brain and Jev handles the cheaper decision steps; a LeRobot SO-101 setup takes about five minutes.
Go HTTP middleware that lets Jev judge and route requests, plus a CTF-style example site inviting people to try injection attacks against it.
New Zammad ticket comes in, Jev decides which team owns it with a confidence score attached, and routes it.
Jev routes each ticket to a specialist agent (general / account / billing / technical) and decides whether a human should take it instead — all typed — while Cerebras writes the reply.
Open-source log triage for OpenTelemetry: Jev scores each log line's signal so only what matters reaches the expensive LLM analysis; a write-up covers Jev vs a fine-tuned alternative.
LangChain's webinar on using Jev to build a better agent harness, with Sydney Runkle, Hunt Lovell and Allie.
No demo: notes from three days running Jev inside production systems, misses included, organised as map → shadow → measure → promote.
Jev-powered model routing, memory, context compaction, skill selection and computer/browser use for Hermes agents (also Claude Code and Codex), with a routing dashboard and shadow mode that shows what Jev routing would have saved before you switch it on.
A portable agent plugin and MCP tool for batch text classification: the agent asks Jev whether a file is worth reading, a tool worth calling, a website worth browsing — before spending tokens on it.
An MCP connector that gives any MCP-capable agent direct Choice / Score / Noul calls to Jev; the Chinese roundups call it the first thing to install after getting an API key.
Jev as a command-line filter: classify, score and filter lines in a shell pipeline, for crawlers, CI gates and data pipelines.
Agents can write code but struggle to understand what they built at runtime; Reticle gives web and desktop apps a Jev-style runtime perception layer so agents know which interface they are looking at.
Many RL tasks need a judge to verify pieces of outputs or trajectories, and at scale that is the bottleneck; a fast, cheap, calibrated judge could remove it. Draws on earlier work with Harvey's LAB benchmark, where harness engineering plus open models cut judging costs by orders of magnitude.