# Infra / SDKs / Integrations

Use this category for ecosystem tooling built around Jev — SDKs, wrappers, gateways, framework adapters, evaluation scaffolds, local ports.

## Submission format

```md
- [Name](URL) - Industry: one-sentence description of the Jev use case.
```

## Entries

- [eve](https://github.com/vercel/eve) - Agent frameworks: Vercel's eve engine ships Jev as the default evaluation model (`typesafe-ai/jev`) in its experimental evaluate path.
- [AI CLI](https://github.com/vercel-labs/ai-cli) - Developer tooling: Vercel Labs CLI that can run Jev as the evaluation model for its `evaluate` command.
- [jev-mcp (jkudish)](https://github.com/jkudish/jev-mcp) - MCP ecosystem: proof-of-concept MCP server that puts Jev claim verification, content screening, and candidate ranking behind standard MCP tools.
- [jev-mcp (blakestone-x)](https://github.com/blakestone-x/jev-mcp) - MCP ecosystem: MCP server exposing Jev classify, score, check, match, and screen as tools for any agent, with confidence on every answer.
- [zio-typesafe-ai](https://github.com/jamesward/zio-typesafe-ai) - Scala ecosystem: ZIO client for TypeSafe AI with a typed DSL over Jev decisions.
- [laya-mlx](https://github.com/mizorewww/laya-mlx) - Local runtime: independent MLX port of the Laya checkpoints that runs typed decisions natively on Apple Silicon — 13.4 ms median end-to-end per short English decision, 7.4 ms with the multilingual checkpoint, and zero output tokens, with no PyTorch, Transformers runtime, or cloud API.
- [TypeSafe AI Swift SDK](https://github.com/alterhq/typesafe-sdk-swift) - Swift ecosystem: dependency-free Swift 6 client for Jev Choice, Score, and Noul questions with strict concurrency, configurable authentication and retries, and offline transport tests.
- [laravel-typesafe-jev](https://github.com/Butochnikov/laravel-typesafe-jev) - PHP ecosystem: unofficial Laravel integration for Jev with typed responses, async requests, scoped dependency injection, and testing fakes.
- [advocaat](https://github.com/pithings/advocaat) - Data tooling: small type-safe client for asking Jev questions about a dataset.
- [jevclient](https://pypi.org/project/jevclient/) - Python ecosystem: async client for Jev published on PyPI.
- [jev-trust](https://pypi.org/project/jev-trust/) - Python ecosystem: trust middleware for the Jev API that logs every typed decision, measures calibration in your own domain from outcomes you record (accuracy, Brier, top-label ECE, C = 1 − ECE), annotates each answer with its measured effective confidence, fires overconfidence alerts, and signs the evidence (ed25519) for independent recomputation.
- [LlamaIndex Jev](https://github.com/WiktorB2004/llama-index-jev) - Retrieval / RAG: unofficial LlamaIndex adapter where Jev `Score`s each retrieved passage and `Choice`/`Noul` selects the query engine, with nfcorpus nDCG@5 0.340→0.396 at about $0.0003/query.
- [safer-with-jev](https://github.com/andrelandgraf/safer-with-jev) - Cloud infrastructure: Neon Function proxy for the Neon AI Gateway that routes decisions with Jev.
- [typesafe-ai/skills](https://github.com/typesafe-ai/skills) - Official tooling: installable agent skills package (`npx skills add typesafe-ai/skills`) that teaches agents the Jev workflow.
- [Smithers](https://github.com/smithersai/smithers) - Agent frameworks: TypeScript workflow framework with a Jev session checker wired into its workflows.
- [skillbox](https://github.com/kitze/skillbox) - Skills infrastructure: self-hosted versioned skills library that adds optional Jev recommendations using your own TypeSafe or Gateway key.
- [Jevbridge](https://github.com/tacticocc/Jevbridge) `{agent: multi}` - Agent bridges: ACP and MCP adapter that exposes Jev typed decisions to Codex, Claude, Grok, and other LLMs.
- [jev (Elixir)](https://github.com/dannote/jev) - Elixir ecosystem: GenServer client that replies with Jev's answer so callers can pattern match on it directly.
- [jev-go](https://github.com/Stumble/jev-go) - Go ecosystem: community Go SDK for Jev.
- [jev-cli](https://github.com/tumf/jev-cli) - Developer tooling: small dependency-free CLI for Jev.
- [decide-mcp](https://github.com/dakdevs/decide-mcp) - MCP ecosystem: configurable decision server with percentage scores and bias-profile routing on top of Jev.
- [typesafe-jev-examples](https://github.com/rajivkuriakose/typesafe-jev-examples) - Starter examples: worked ticket-triage and reranking examples runnable through OpenRouter without an early-access key, shipped with their own sample data and Makefile.
- [ai-python](https://github.com/vercel-labs/ai-python) - Python ecosystem: the official Vercel AI SDK for Python carries Jev through its evaluation operation and Gateway examples.
- [Cline plugins](https://github.com/cline/plugins) `{agent: cline, type: plugin}` - Coding agents: Cline's official plugin collection includes a Jev-driven browser plugin (`jev-browser`), so Jev arrives as a first-class Cline capability.
- [hono-jev-router](https://github.com/yusukebe/hono-jev-router) - Web frameworks: Hono middleware that routes HTTP requests by meaning rather than by method and path, deciding with Jev.
- [rotom](https://github.com/RyanKung/rotom) - Local gateways: OpenAI- and Anthropic-compatible API gateway that carries Jev through its model catalog and evaluation path.
- [Jev AI](https://jev-ai.pro) - Developer tooling: public Jev playground and API that puts typed `Choice`, `Score` and Yes/No questions to the model about pasted text - ticket triage, moderation, review scoring - and returns a parsed answer with a confidence value in about 0.5 s per decision.
- [jevql](https://github.com/kylemclaren/jevql) - Data tooling: psql-shaped CLI and Go/TypeScript/Python SDKs that run plain SQL on a vanilla Postgres (no extension) and then ask Jev Noul, Choice, or Score questions about each surviving row so the client can apply `jev()` filters, `jev_prob` sorts, and `jev_choice` groups.
- [sqlite-jev](https://github.com/mgaitan/sqlite-jev) - SQLite ecosystem: loadable C extension and Python package that expose Jev Noul, Choice, and Score judgments as SQL functions and batched virtual-table queries with confidence results.
- [duckdb-jev](https://github.com/prasanthj/duckdb-jev) - DuckDB ecosystem: native extension that applies Jev Noul, Choice, Score, and multi-question decisions directly to structured SQL rows, measuring 1,943 rows/s for 1,000 Choice classifications with confidence and bounded concurrency.
- [jevkit](https://github.com/ariel-frischer/jevkit) - Developer tooling: Rust CLI that validates `Choice`/`Score`/`Noul` question sets with 13 offline lint rules before any Jev call, then sends the canonical wire payload and prints parsed, confidence-bearing JSON answers to stdout using exit code 2 to reject a billed-but-useless request.
- [jev-use](https://github.com/shitianfang/jev-use) `{agent: multi, type: plugin}` - MCP ecosystem: Claude Code / Codex / pi plugin (MCP server + library, native pi extension) that hands agent steps needing no text output to Jev as typed judgments — untypeable and generation-needing questions are rejected before the call, low-confidence answers come back flagged as priors, and a fail-open PreToolUse gate can only deny or ask.
- [huncho](https://github.com/edgardcham/huncho) - TypeScript ecosystem: dependency-free SDK that turns Jev `Noul`, `Choice` and `Score` answers into named decisions with `enter`/`exit` thresholds (hysteresis), nested decision trees settled in one call, a JSONL journal, replay of a threshold change over recorded answers with no inference, and Brier/reliability calibration, over TypeSafe direct, OpenRouter or Vercel AI Gateway.
- [jev-experiments](https://github.com/dabit3/jev-experiments) - Demo collection: 22 latency-focused Jev applications built by Devin, each with its own README and testing notes, spanning shell guards, log sentinels, instant search, reranking, and voice turn-taking.
- [ruby_decision_model](https://github.com/obie/ruby_decision_model) - Ruby ecosystem: client for decision models such as Jev, so Ruby applications can put typed questions directly to the model.
- [s1_ruby](https://github.com/innocentdiaz/s1_ruby) - Ruby ecosystem: makes System One measurement, and the collapse that follows it, a Ruby primitive, with a TypeSafe provider behind its own spec suite.
- [JarvisCore](https://github.com/Prescott-Data/jarviscore-framework) - Agent frameworks: Python multi-agent runtime that ships Jev natively from 1.12, where agents ask typed `Choice`, `Score` and `Noul` questions through a decision client separate from the text model, the Kernel picks a specialist subagent by `Choice`, and each retrieved RAG passage is withheld from the generating model when its prompt-injection `Noul` exceeds 0.70.
- [hunch (carldaws)](https://github.com/carldaws/hunch) - Ruby ecosystem: turns judgment calls into control flow — `if Hunch.likely?("fraudulent", given: order)` reads like plain Ruby but branches on a typed Jev answer, with `pick` for Choice, `rate` for Score, and graded predicates from `possibly?` to `definitely?`.
- [Early experimentation using Jev to rethink harness UX](https://www.elvex.com/blog/early-experimentation-using-jev-to-rethink-harness-ux) - Harness integration: an agent platform wires Jev into its LLM harness as a callable tool for search, approvals and context, reporting 2,000 expense reports categorized in 20 seconds for five cents.
- [jev-mcp (burnigtm)](https://github.com/burnigtm/jev-mcp) `{agent: multi}` - MCP ecosystem: server that puts Jev into the coding loop for Cursor, Codex, and any MCP client, with 20 test files behind it.
- [jev-skill-suggester](https://github.com/win4r/jev-skill-suggester) - Coding agents: recommends which installed skills apply to a request, keeping the recommendation bounded and letting Jev decide.
- [grok-bot-jev](https://github.com/Bodila51/grok-bot-jev) - Agent bridges: connects Jev to Grok Bot as a cheap decision layer, with usage gates, a skill template, and worked examples.
- [jev-architect](https://github.com/karanb192/jev-architect) - Design skill: finds, designs, and evaluates Jev decision loops, packaged as a skill with references on decision design and delivery.
- [Building a Harness with Jev](https://www.langchain.com/blog/building-a-harness-with-jev) - Framework guide: LangChain's walkthrough of wiring Jev into an agent harness as the decision layer, from a team that then published its own evaluation of Jev as a judge.
- [openrouter-jev-mcp](https://github.com/ctmx/openrouter-jev-mcp) - MCP ecosystem: Python decision gateway and stdio MCP server exposing TypeSafe's Jev model through OpenRouter's alpha decisions endpoint.
- [system-one-adapter-python](https://github.com/typesafe-ai/system-one-adapter-python) - Python ecosystem: TypeSafe AI's official open-source drop-in adapter for running and benchmarking Jev System One decision evaluations across OpenAI- and Anthropic-compatible LLM APIs.
- [neurolink](https://github.com/juspay/neurolink) - Provider abstraction: the pipe layer of an AI nervous system — Juspay's TypeScript interface connecting provider neurons to an application, with `decide` as a first-class inference type alongside generate and stream.
- [jev-spring-boot-starter](https://github.com/danvega/jev-spring-boot-starter) - Java ecosystem: Spring Boot 4 starter that puts Jev behind Spring MVC and RestClient.
- [jevify](https://github.com/altryne/jevify) - Agent skill: finds where a codebase could hand a decision to Jev, designs the typed questions for it, and learns from recent community usage.
- [mysql-ailike](https://github.com/maayanlevy/mysql-ailike) - Database filtering: MySQL plugin that filters rows by a natural-language predicate instead of a literal one, powered by Jev.
- [jev-usecases](https://github.com/kenhuangus/jev-usecases) - Reference harnesses: a set of production-shaped use-case harnesses built around confidence-gated decision logic.
- [FastJev](https://github.com/chengyongru/fastjev) - Local runtime: self-hosted Python SDK and System One-compatible API for runtime-defined `Choice`, `Boolean`, and `Score` decisions on pinned open models across Torch, vLLM, MLX, llama.cpp, and WebGPU, with committed row-level benchmarks and checksums.
- [kojev](https://github.com/ItisNoMatter/kojev) - Kotlin ecosystem: Kotlin Multiplatform (JVM, Android, iOS) client for Jev that answers Choice and Score questions as the caller's own enums, with one typed way to read answers, no default thresholds, and offline MockEngine tests.
- [ask-jev](https://github.com/logicrw/ask-jev) - Python ecosystem: zero-dependency CLI that routes small semantic judgments — Choice, Noul, Score, batch questions, and verbatim passage extraction — to Jev for AI agents and CLI pipelines.
- [Search with Jev and Milvus](https://github.com/milvus-io/bootcamp/tree/master/bootcamp/RAG/search_with_jev) - Search engineering: nine runnable notebooks combine Gemini embeddings and Milvus retrieval with Jev Noul and Choice judgments, while Python applies ranking, filtering, routing, and stopping policies to synthetic examples.
- [discern](https://github.com/doeixd/discern) - TypeScript ecosystem: Effect library where a Jev `Choice`, `Noul` or `Score` answer becomes a typed branch under caller-supplied thresholds, anything below them takes an `Uncertain` case the compiler forces you to handle, and procedure routing skips the model call entirely when deterministic predicates leave one candidate.
- [jeff (logan-markewich)](https://github.com/logan-markewich/jeff) - Self-hosted runtimes: self-hosted drop-in replacement for TypeSafe Jev powered by GliFormer, exposing native Choice, Score, and Noul decision endpoints without cloud API dependencies.
- [CloJev](https://github.com/antlobach/clojev) - Clojure ecosystem: unofficial portable Clojure SDK for System One, so Clojure applications can put typed questions to Jev without a Java interop layer.
- [hunch (steven-shoemaker)](https://github.com/steven-shoemaker/hunch) - Python and TypeScript ecosystem: libraries that turn Jev Choice, Score, and Noul questions into functions over lists and DataFrames (classify, score, check, where, extract, pick, rank, verify), with request deduplication, caching, and optional escalation of unsure rows to an LLM that must pick from the same labels; TypeScript port at [hunch-js](https://github.com/steven-shoemaker/hunch-js).
- [typesafe-mcp](https://github.com/itsmostafa/typesafe-mcp) `{agent: multi, type: cli}` - MCP ecosystem: Go-based CLI and MCP server exposing an evaluate tool that routes typed decisions to Jev with automatic configuration for Claude Code, Claude Desktop, Codex, and pi.
- [spring-ai-typesafe](https://github.com/spring-ai-community/spring-ai-typesafe) `{type: library}` - Java ecosystem: Java SDK for TypeSafe AI's Jev API and Spring AI integration, providing typed decisions for evaluation as a judge, guardrails, and RAG post-processing.
- [JevFlow](https://github.com/Mawfyy/jevflow) `{type: library}` - TypeScript ecosystem: composes Jev `Noul`, `Score`, and `Choice` decisions into deterministic threshold workflows that batch into a single `systemOne` call and return an ordered, explainable action set instead of side effects, with matched rules recording the actual value behind each action and a mock provider so policy tests run without an API key.
- [stuntd](https://github.com/bladedevoff/stuntd) `{type: proxy}` - Local runtime / learning proxy: Jev-compatible local server on Laya that also proxies a Jev upstream, records every `Choice`, `Score` and `Noul` decision, trains a head per decision site, and answers live with calibrated confidence, falling back to the upstream below its threshold and demoting itself on drift; measured 22 ms per decision and 90% of support-triage questions answered locally at a 0.99 agreement target.
- [Jev AI Tools](https://jevai.tools/) `{type: hosted}` - Developer education: hosts six bounded recipes plus a custom builder for AI SDK `Choice`, `Score`, and `Boolean` evaluations; recipes display answer probabilities separately from provider confidence and use deterministic local thresholds to pause uncertain routes for review, while every configuration exports as TypeScript.
- [Jeview](https://github.com/andududu/jeview) `{type: proxy}` - Developer tooling: zero-dependency local proxy and live visualizer that intercepts Jev API calls, logs decisions to SQLite, and renders real-time decision flows in a browser dashboard.
- [SemDecide](https://github.com/sharziki/semdecide) `{type: cli}` - Developer tooling: Unix CLI for semantic decisions in shell pipelines and CI, evaluating Jev predicates, routes, and scores with predictable exit codes.
- [jev-foundation-models](https://github.com/peterfriese/jev-foundation-models) - Apple platforms: a Swift 6 bridge that runs Jev decisions through Apple's Foundation Models on device, with a protocol-based model interface and six tests.
- [simple-jev](https://github.com/featherless-ai/simple-jev) - Serving: turns any open model into a Jev-compatible classifier endpoint, so a self-hosted model answers the same typed questions as the hosted API, with 27 tests.
- [cu-Jev](https://github.com/dtunai/cu-Jev) - Inference engine: a CUDA-native implementation of the Jev System One API that keeps decisions GPU-resident, shipping a Starfighter demo and a benchmark script.
- [jevcache](https://github.com/hyperspaceai/jevcache) - Cost control: memoizes Jev-class decisions so a repeated question is served from cache instead of a new call, keeping repeats deterministic and free.
- [jev-switch](https://github.com/ARCJ137442/jev-switch) `{type: proxy}` - Local gateways / cloud relay: dual-mode Rust router for typed Jev decisions — tokenless local multi-upstream routing (Vercel, TypeSafe, local Laya) with noul/boolean translation and DAG failover, or token-gated cloud relay aggregating Jev endpoints behind one API, proven by 155 workspace tests plus end-to-end smoke over Choice/Score/Noul round-trips.
- [Qwev](https://github.com/HopLee6/Qwev) `{type: self-hosted}` - Local inference: turns dense Qwen3 and Qwen3.5 checkpoints into a training-free Jev-style `Noul`, `Choice`, and `Score` service that shares one state prefill across isolated questions and, on its included 27-question Qwen3.5-9B/A100 fixture, reports 0.500 s versus 13.554 s for generated JSON.
- [jev-sdk-go](https://github.com/HomayoonAlimohammadi/jev-sdk-go) `{type: library}` - Go ecosystem: dependency-free Go 1.24+ client for Jev `Noul`, `Choice` and `Score` questions that reads `Choice` and `Score` answers back as the caller's own types, rejecting any label or level the question never offered, with retries, OpenRouter support, and eleven examples tested against an in-process fake of the API.
- [typesafeai-dotnet-sdk](https://github.com/saibimajdi/typesafeai-dotnet-sdk) `{type: library}` - .NET ecosystem: community .NET SDK for the TypeSafe AI System One API with strongly-typed Noul, Choice, and Score questions and structured answers.
- [jevcompat](https://github.com/mandu5/jevcompat) `{type: cli}` - Interoperability: a 48-requirement spec of the `POST /v1/systemone` wire contract, each rule citing TypeSafe's docs, OpenAPI file or SDKs, and a suite that checks any Jev-compatible server against it (`Choice` probabilities keyed by option and summing to 1, `Score` equal to Σ i·p, 2–255 options, error shapes, answers that stay put when question ids or order change), finding 2 of the 8 most-starred open ports conformant, with a reference mock that breaks each rule on purpose and a proxy that fixes what can be fixed.
- [typesafe-ai (Rust)](https://github.com/Twister915/typesafe-ai) `{type: library}` - Rust ecosystem: typed TypeSafe AI client with async (reqwest) and blocking (ureq) backends, deserializing Noul, Choice, and Score responses into Rust enums with observable retry streams.
- [Pydantic AI](https://github.com/pydantic/pydantic-ai) `{type: library}` - Python ecosystem: official Pydantic AI agent framework shipping first-class `TypeSafeModel` integration to map Pydantic schema fields into typed Jev System One questions with confidence scoring.
- [Milvus Model](https://github.com/milvus-io/milvus-model) - Search infrastructure: batches candidate-document Noul questions through Jev and returns score-sorted results with original indices through a Python reranker adapter.
- [djev-run](https://github.com/taeold/djev-run) - Serving: deploys DiffusionGemma-Jev behind a TypeSafe-compatible API on a Cloud Run GPU with snake, dino and tetris demos wired to the decision endpoint.