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.
The layer between your code and the API: SDKs for the languages the vendor does not ship, MCP servers that put the model inside a coding agent, provider packages for the usual frameworks, CLI wrappers and workflow nodes. Most of these are days old and still moving, so check when each one was last touched before you depend on it in something that matters.
119 tools
Showing 119 of 119
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.
Proof-of-concept MCP server for Jev that lets Claude Code, Claude Desktop and Codex call the model and receive probabilities they can branch on. The most-starred Jev MCP server found.
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.
Vercel Labs CLI for generating from the terminal. Its evaluate command takes a state plus typed questions and defaults its evaluation model to typesafe-ai/jev on the AI Gateway, with -m jev as the shorthand and an --input flag for text or JSON state.
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.
Self-hosted, versioned skills library for AI agents. Serves skills over MCP with scoped clients, and adds optional Jev recommendations for which skill to reach for.
Official TypeScript/JavaScript client published to npm as @typesafe-ai/sdk (v0.6.0), requiring Node.js 20+ and shipping ESM, CommonJS and type declarations.
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.
Official drop-in replacement for TypeSafeClient that is backed by ordinary LLM APIs, letting developers write System One code before they have Jev access.
Pre-alpha PostgreSQL extension that calls TypeSafe Jev from SQL for Choice, Noul and Score, including a batched function that classifies many distinct rows in one request.
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.
Official Python client for the TypeSafe System One API, published to PyPI as typesafe-sdk with sync (TypeSafeClient) and async (AsyncTypeSafeClient) clients.
Agent skill and runtime that uses Jev to select page elements through an agent's existing computer-use browser tools. The agent plans once, then Jev picks elements inside a continuous observe-act-verify loop without an agent turn between steps.
Small type-safe client for asking questions about your data, powered by Jev. Returns probabilities, choices and scores in a single request, and ships an agent skill that teaches coding agents how to design the questions.
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.
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.
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.
MCP server for TypeSafe shipped as a single static Go binary with no Node or Python runtime. Sends usage guidance to the client so the agent writes better questions.
Hermes skill that lets an agent call jev-latest as a typed tiebreaker, getting Choice, Score and Noul answers with probabilities so it can act or escalate. Documents when to call Jev, confidence gates and pitfalls, and ships a live reliability suite.
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.
Per-turn model routing for Codex: Jev classifies each turn and picks the model, thinking depth and speed mode, so the cheapest model that can handle a turn serves it. The decision costs about $0.00003 and 0.6 s, and a 7-day replay of 237 real turns measured about 60% savings against a full-frontier baseline.
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.
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.
Experimental Hono router where you describe a request in plain words and Jev decides which description fits the incoming request. The author warns it is not an authorization boundary, and the values of Authorization, Cookie and API key headers are redacted before anything is sent.
Browser-use tool driving a real headless browser through an MCP server, CLI or library, with Jev choosing the actions. Returns text, markdown, HTML or accessibility-tree output plus traces and screenshots.
Fish-style autosuggestions for zsh ranked by Jev. As you type, the plugin sends your last 100 distinct history entries and asks which one you are most likely completing, then shows the best match in grey with its score for you to accept.
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.
ACP and MCP adapter that bridges Jev with any LLM, putting computer use and typed decisions alongside Codex, Claude, Grok and OpenCode.
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.
TypeSafe structured-output provider for RubyLLM 2, wiring Jev into the RubyLLM provider interface.
Jev for OTP, published on Hex as jev. The model is a peer process: you reply to it from a GenServer and its answer arrives as a message you pattern match on, so clause order becomes the routing and thresholds become guards.
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.
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.
Python MCP server exposing Jev as classify, score, check, match and screen tools, with a confidence value on every answer. Ships registration steps for Claude Code, Codex and Cursor that keep the API key out of tool arguments.
Agent-ergonomic CLI for Jev with pick, rate, check, rank, triage and guard subcommands, meant for agents offloading snap judgments from the shell.
Rust client for the System One evaluation API with async and blocking backends, Noul, Choice and Score responses deserialised into typed enums, and several judgments batched over one shared state. Retries can be observed step by step and errors stay inspectable.
Unofficial Home Assistant integration that asks Jev questions about your house and turns each answer into an entity you can automate on. Questions in configuration.yaml become sensors, and four actions answer inside an automation and return a response variable.
Pi extension that lets Jev choose a model and reasoning effort through Vercel AI Gateway, then keeps both pinned for the session. Generation still runs on your existing Pi providers and credentials.
Scores OpenTelemetry log records with Jev for diagnostic value, priority and routing, so expensive LLM analysis can be skipped for low-value traces. Every record stays in your archive.
Community .NET SDK for the System One API with typed noul, choice and score questions returning confidence-scored answers. States it is not affiliated with TypeSafe AI.
A Python CLI that turns Jev calls into Unix-pipeline predicates, routing, scoring and JSONL filtering with stable exit codes, plus an agent-safety guard recipe for authorization and destructiveness checks.
Browser automation where an LLM plans and Jev decides each tactical action, executed through Playwright without feeding page snapshots to the LLM. README reports 40/42 tasks passing and roughly 5x less token context.
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.
TypeScript harness that connects evidence to Jev judgments, permitted actions and verified outcomes, with pluggable data sources, local JSONL traces and no runtime dependencies. Marked experimental at V0.2.0, with offline demos and mocked API tests passing.
Agent runtime in Rust where the context, tools, permissions and requests are explicit state you can read, change and put back, plus an MCP bridge and the kamchatka terminal agent. The linked example uses Jev for content-aware compaction in that agent.
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.
Routes agent skill selection through typed, confidence-aware Jev questions so a weak match is sent for review instead of guessed. On 72 synthetic requests it routed 68 correctly (94.4%) against 51 (70.8%) for a lexical baseline, at a median 1,287 ms; the author labels the results exploratory.
Ruby client for typesafe.ai, MIT licensed, requiring Ruby 3.1+. Defaults to jev-latest.
Unofficial Swift 6.4 SDK for TypeSafe that follows the Python SDK's 0.6.0 API, with macro-based question sets for Choice, Noul and Score. Supports macOS 26+, iOS 26+, tvOS, watchOS, visionOS and Linux, and tracks the upstream version it mirrors.
Public HTTP gate running as a Neon Function: Jev inspects the request body, then optionally forwards the same bytes to a caller-chosen HTTPS URL. Endpoints cover prompt injections, unsafe images and unsafe replies, with a companion demo site at safer-with-jev.com.
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.
An asynchronous Jev integration for Hermes Agent that supervises turn admission, tool-call gating and context curation in the background, using up to sixteen typed choice, score and noul questions per call.
A local-first test selector that asks Jev one semantic relevance judgment per test to decide which e2e tests a code change can safely skip, failing open to the full suite on low confidence. Ships a bundled GitHub Action.
Composable Python toolkit for the Jev decision API bundling question builders, confidence gates, an evaluator, calibration tooling, a CLI, an MCP server over stdio and an agent skill.
CLI and agent skill for TypeSafe System One exposing typed Choice, Score and Noul judgments from the terminal.
Fits a per-question confidence threshold to your accuracy target on your own labeled data, checks it on a held-out split, reports how much traffic still needs an LLM, and fails CI when a model update breaks the locked thresholds. Publishes no Jev numbers on purpose.
TypeScript library that wraps Jev choice, score and noul answers in the parts production needs: a policy, a confidence gate, shadow mode, reusable recipes and an offline eval CLI. On the same row-filter job it measured 1.3 s against 48.9 s for the Claude Code CLI.
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.
Measures on your own labelled data where a small model's confidence stops paying off, then routes each decision to Jev or a larger model at the threshold it found rather than a default. On 500 Banking77 examples Jev was 77.8% accurate but 90.7% confident, and threshold 0.67 reached 80.2% accuracy for $0.1033.
Scala 3 and ZIO client for the Jev System One API, typed end to end with no raw JSON. Several questions go out in one round trip as a NamedTuple and come back keyed the same way, and illegal states are unrepresentable: criteria cannot be built out of range and every probability is provably within 0 to 1.
Dependency-free Python CLI that sends text, JSON, files or stdin to Jev and returns machine-readable noul, choice or score answers. Several questions go in one request, and output can be reduced to the primary value for shell scripts.
Local proxy between Claude Code and the Anthropic API that picks the model and effort level per message with a Jev decision. The author measured that routing subagents saves money while routing an established main chat loses it: 309 logged requests cost $106.73 against an $87.19 baseline, and $17.12 of the $19.53 loss came from the main chat alone.
Unofficial Laravel 12 and 13 integration on top of the community PHP TypeSafe SDK, adding package discovery, scoped lazy dependency injection, config, a facade and a recording fake. Keeps the SDK's typed DTOs, promises and exceptions.
Independent Rust SDK with async and blocking clients, typed Noul/Choice/Score questions, model discovery, configurable retries and cancellation. Published to crates.io as typesafe-ai-rs.
Agent skill that sends closed coding-agent judgments to Jev and acts on the probabilities. Jev answers yes/no, choice and score questions in about 250 ms, so the agent interrupts the user only when a person must decide, and stops before a command that could destroy data or leak secrets.
TypeScript browser agent for ego lite with no Chrome, Playwright or browser harness. Each observation produces a numbered element table, and one TypeSafe request picks the operation and the target element. A coding agent can drive the page itself or ask Jev for ranked directions.
Agent skill that hunts for fuzzy semantic judgment in a system and turns it into small Choice, Score and Noul questions, deciding where the Jev boundary belongs, what state each question sees and which ones can run together. Meant to be installed alongside TypeSafe's official skill.
Command line search that asks a yes/no question of every function in a codebase and ranks the answers by the probability that the answer is yes. It is grep whose pattern is a question, not embedding search, and the author measured 1,302 functions of gin-gonic/gin in 3.7 seconds for $0.018.
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.
Claude Code mod that routes decisions to Jev: it ranks installed skills against each prompt and answers the agent's own this-or-that questions when confidence is high enough, otherwise falling back to asking the user.
.NET SDK for the System One API with dependency-injection support, Microsoft.Extensions.AI integration for chat middleware and guardrails, and native AOT compatibility.
Rust and Python dataset sifter that streams Parquet and JSONL rows past Jev typed decisions at 1,500+ records per second, writing passed and rejected rows to disk. Uses speculative fan-out and calibrated post-training rubrics.
A configurable GitHub Action that reviews directory submissions and classifies pull requests using only Jev: typed yes/no checks plus one category choice, with code applying the policy and posting one PR comment.
A TypeScript toolkit of production patterns around the Jev SDK: decision contracts, confidence-threshold routing with fallback and review paths, an offline evaluation harness, and a RAG diagnosis showcase.
AI SDK middleware and OpenAI-compatible proxy that judges every LLM response before the user sees it, running seven Jev checks in one call of about 100 ms. Policy is YAML, a high-confidence check blocks while a low-confidence one downgrades to a flag, and the author notes there are no accuracy numbers against real Jev yet.
Recursive Choice over a taxonomy. Jev can only list 255 options in one choice question, so jev-tree walks a JSON shape and calls it once per level or partition, letting you select among thousands of leaves.
CLI for the Jev evaluation model: typed questions in, structured JSON answers out.
Elixir SDK for the TypeSafe AI API, bringing Choice, Score and Noul decisions into OTP processes and GenServers. Published on Hex as typesafe_sdk.
MCP server exposing Jev as typed judgment tools (classify, score, check, batched ask) and shipping as a Claude Code plugin. Runs via npx jev-mcp.
Community Go SDK for the TypeSafe AI Jev / System One API.
Spring Boot starter for WebFlux that evaluates each response payload with Jev and turns suspected silent HTTP 200 failures into ordinary exceptions. Evaluation is one non-blocking WebClient call with a 750 ms default timeout, and any API error or timeout is treated as not a failure.
Rust SDK for the TypeSafe AI API. Types the three answer kinds with accessors that fail loudly on the wrong kind, carries usage and request_id, and offers async and blocking clients.
Go client for TypeSafe's System One API, returning typed judgments and calibrated probabilities instead of generated text. Questions are built in Go and answers are read back as Noul or Score values.
Community Rails integration for TypeSafe's System One API, built on the community typesafe-sdk Ruby gem. Adds Rails configuration, persisted usage and cost telemetry, and an opt-in confidence policy for Choice and Score answers.
Unofficial PHP SDK for the System One API supporting yes/no, category and scoring questions, with synchronous calls and asynchronous requests via Guzzle promises.
LLM-agnostic guardrails library using Jev to detect prompt injection, jailbreak attempts, PII exposure and credential leaks in one batched request. Not published to PyPI at time of check.
Unofficial Go SDK for the Jev API with deliberately minimal abstractions over Choice, Noul and Score.
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.
Open-source LLM router that uses Jev to pick a model, built on LiteLLM. Clients send a single model ID and Jev routes each request; it falls through without a TypeSafe API key.
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.
Watches recent agent steps for semantic stagnation, meaning different actions that still chase the same contradicted assumption. Jev reads the trajectory and a small deterministic policy returns CONTINUE, WARN, REPLAN or HALT.
A Home Assistant conversation agent where Jev classifies an utterance and either takes a fast-path light action or hands off to the Grok conversation agent, gated by confidence and yes/no thresholds.
SQLite extension that calls Jev straight from SQL through jev_noul, jev_choice and jev_score, so a whole table can be classified in one query. Written in C, depends only on libcurl, and builds on Linux, macOS and Windows.
PHP and Laravel SDK for TypeSafe AI's Jev model series, distributed on Packagist as binnash/typesafe-sdk.
n8n community node for the System One API exposing typed yes/no, choice and score questions with calibrated probabilities a workflow can branch on. Self-hosted n8n only until n8n verifies the package.
Pi extension that exposes System One judgments as five tools: a yes/no Noul, a Choice over a fixed set, a Score over ordered levels, a batched evaluate for several questions about one state, and an ask for a question pinned in a local YAML or JSON file. The tools call the API directly with fetch and carry no SDK dependency.
Stop hook that keeps a coding agent from finishing early. You write completion rules in plain language, and every time the agent is about to stop, Jev scores the stop against each rule in 0.7 seconds and sends it back to work if a rule is violated. Works with Claude Code and Codex.
Rust derive layer that turns ordinary enums and structs into Choice, Score and Noul questions and returns compile-time-checked answers. Results carry confidence, so a policy can gate on it before acting.
Unofficial Rust client mirroring the official Python SDK's environment variables, defaults, retry semantics and error classification. Published as the typesafe-ai-sdk crate.
Reproducible calibration and selective-risk benchmarks for Jev decisions inside DSPy workflows. Runs offline for confidence gating, latency and cost modelling without live API calls.
Go 1.27 client with generic typed questions (jev.Noul, jev.Choice, jev.Score, plus jev.Raw). Supports batching, retries, and Vercel AI Gateway as an alternative backend.
Idiomatic Elixir client for the TypeSafe AI API with configuration-driven auth, retries, telemetry and test support. Returns judgments as data structures the caller thresholds itself.
Unofficial typed Elixir client for TypeSafe AI and Jev with offline test stubs, concurrent fan-out and atom-keyed answers.
Unofficial dependency-free Go client for the TypeSafe v1 API covering System One and model discovery, with automatic retries.
Model page for Jev 1.13 on OpenRouter, reachable through OpenRouter's OpenAI-compatible endpoint. Listed at $0.042/M input, $0/M output, 32K context.
Async Python client for Jev, version 1.1.0, requiring Python 3.12+ and aiohttp. Supports Noul, Choice and Score and encourages batching multiple questions into one call.
Vercel changelog announcing Jev on AI Gateway under model ID typesafe-ai/jev. Evaluation calls appear in Gateway logs, count toward budgets and accept Gateway provider options.
PyPI listing for the official Python SDK, version 0.6.0, MIT licensed. Requires Python 3.10+.
Official AI SDK provider exposing Jev through the experimental evaluate API in AI SDK 7. Supports Choice (1-255 options), Score (2-10 ordered levels) and Boolean/Noul, batching all questions in one request against the same state.
Auto mode preset for the DeepSeek Harness coding agent, hosted on a self-run GitLab. At every end prompt, Jev decides whether the agent's open questions can be answered without the human, so full-access runs stay guided by a typed decision.
Cloudflare Workers AI model catalog page for TypeSafe Jev, documenting the state plus questions request shape and the Noul, Choice and Score answer types. Examples cover ticket routing, refund review and risk assessment.
OpenRouter lists two TypeSafe models, typesafe/jev-latest and typesafe/jev-1.13, both with a 32K context window, at $0.042/M input and $0/M output.
Community directory site listing systems built on Jev and the primitives each one sends. Users sign in with GitHub to submit projects from a repo or an X post, and can copy examples into a playground.
LangChain integration package (0.0.1a2 pre-release, MIT) providing TypeSafeClassifier as a Runnable plus experimental agent middleware: ModelRouterMiddleware, SkillsMiddleware and AutoModeMiddleware for tool-risk gating.
Official docs for the TypeSafe agent skill, which gives a coding agent context on the three question types, architectural patterns and evaluation practice. Installs via Claude Code plugin, npx skills, or manual copy.
Official browser playground for composing state and typed questions against Jev, with shareable links. Access is gated behind the early-access waitlist.
Official documentation for the @typesafe-ai/sdk npm package, covering installation (Node 20+), client setup and the question DSL.
Official site publishing TypeSafe's four workflow evals (security incidents, agent-trace observability, invoice processing, customer service) with per-model accuracy, cost and latency, including Jev alongside Claude, GPT and Gemini models.
Hex package listing for the Elixir SDK, version 0.4.0, MIT licensed, last updated 2026-09-18.
Nothing matches those filters
Clear a filter to widen the search, or send us the thing you were looking for.