Read & learn
Written guides.
Understand Jev, one idea at a time. Walkthroughs, recipes, and writeups — our notes first, the original next.
Learn, build, and play with Jev — from deep technical guides to creative experiments.
Read & learn
Understand Jev, one idea at a time. Walkthroughs, recipes, and writeups — our notes first, the original next.
Watch & learn
See an idea take shape. Tutorials, demos, and deep dives, organized by topic and credited to their creators.
Make & explore
See what builders made with Jev. Games, tools, repositories, articles, and more — traced to their sources.

Every category, from games and tools to repositories and writeups, traced to a primary source.
Same ideas.
Different paths.
This is the full registry, not just the featured picks. Figures like speed, cost, and stars are maker-reported or captured snapshots, not JevMade measurements.
90 experiments · showing 1–60
Simple Jev exposes open Hugging Face models as structured classifiers and includes playgrounds, evaluations, and an autonomous-driving demo.
Rizzo Flow serves local Spark models through a Jev-compatible API and visual playground without generating answer text.
A Jev-compatible server reads answer-label logits from Qwen3.6-35B-A3B while SGLang reuses shared prompt prefixes.
Exposes DiffusionGemma typed readouts through Jev-compatible choice, score, Noul, span, and spans requests.
An unofficial TypeScript client for Jev's choice, score and yes-or-no questions.
An Effect provider that turns Jev's choice, score and yes-or-no answers into typed values for custom agent loops.
A provider-neutral TypeScript runtime keeps bounded decision code stable across Jev, Reflex, compatible endpoints, and test doubles.
Builds probability trees and graphs for multi-step choices, with examples for Game 24, Blocks World, and MiniGrid.
A Rust server runs Laya and other open decision models behind a dynamically batched, Jev-compatible System One API.
Auto-configures a Spring Boot client for Jev’s typed questions and includes a support-triage example.
A TypeScript library runs open typed-decision models entirely in the browser through Transformers.js, WebGPU, or WebAssembly.
OpenJevPro wraps open-model decisions and official Jev calls with calibration, abstention, benchmarking, and fallback gateways.
Turns typed questions about text into probabilities, exit codes, JSON, or MCP results for scripts, CI jobs, and agents.
A local proxy records repeated typed decisions, trains small Laya heads, and falls back upstream when confidence is insufficient.
Implements choice, score, and yes/no decisions from embedding similarities instead of a decision-model API.
Provides a Go client and Unix-friendly CLI for Jev Noul, choice, and score requests.
Brings typed Jev decisions into Rails control flow, with jobs, guardrails, and test helpers.
A local Rust server turns answer-letter logits into typed probabilities through a drop-in Jev-compatible endpoint.
Serve English or Thai typed decisions from local Laya and OpenThai models through one CPU API; neither model is TypeSafe's Jev.
A local Qwen3 decision stack targets NVIDIA DGX Spark with typed schemas, confidence handling, policies, and calibration tools.
Runs open, Jev-like typed choices in an embeddable C runtime or a browser, with Snake, Doom, and autopilot demonstrations.
An Elixir client that lets OTP processes ask Jev questions and pattern-match on the answers.
Adds uncertainty-aware pattern matching, policies, and procedures above Effect DecisionModel providers including Jev.
Use a Jev-shaped typed-decision interface with OpenAI-compatible models, receiving labels, scores and probabilities rather than free-form prose; it does not call Jev.
Brings model judgments into ordinary Elixir branching through adapters for Jev and other ReqLLM providers.
Makes Jev decisions read like Ruby predicates, model validations, pattern matches, and named choices over object fields.
Serves Jev-compatible typed judgements from local or hosted language models through HTTP, CLI, or MCP.
Packages focused Jev decisions—routing, grading, checking, comparison, and labelling—as reusable JavaScript functions.
Offers one Swift interface for typed decisions from hosted Jev or local MLX language models.
Composes typed decisions, thresholds, and workflows behind a provider interface that includes Jev.
Compose typed decision questions in an experimental language whose Rust runtime executes them and exposes their results to programs; it is Jev-inspired, not Jev.
A Rust client for TypeSafe AI with asynchronous and blocking interfaces.
A Go SDK that sends typed questions to TypeSafe AI and returns probability distributions.
Zod checks whether your data has the right shape. Jev checks whether it makes sense.
Offers idiomatic Elixir functions for typed decisions through TypeSafe System One or OpenRouter’s Decisions API.
Trains and serves open models behind a Jev-compatible typed-decision API, without calling hosted Jev.
An extensible Python harness that turns Jev decisions into actions.
An unofficial .NET SDK for asking Jev Noul, Choice, and Score questions.
A Haskell DSL for defining typed Jev question packets and matching answers to their labels.
Translates Jev-compatible questions into constrained calls across Ollama, llama.cpp, vLLM, SGLang, and OpenAI-style backends.
An unofficial Ruby client for the TypeSafe AI API.
An idiomatic Java SDK for TypeSafe AI's Jev decision model.
Use Zod schemas to check your data before asking Jev questions about it.
An independent Rust SDK for the TypeSafe System One API with asynchronous and blocking clients.
An unofficial Java client for the TypeSafe System One API.
Analyzes JSON, NDJSON, and JSONC windows with reusable typed question packs, preserving source-line anchors for every answer.
Ask Jev typed questions from the command line, lint question sets before billing, and send machine-readable answers to scripts or agents.
An Elixir SDK for unified LLM integrations, including Jev support.
An unofficial Go SDK for TypeSafe AI with typed answers, retries, and context support.
A Swift SDK for TypeSafe AI.
A .NET SDK for the TypeSafe AI platform.
A Scala client for TypeSafe AI built with ZIO.
A Rust SDK for the TypeSafe AI API with bounded retry behavior.
jev-resilience catches HTTP 200 responses that hide a failure inside a Spring WebFlux value.
A Go client for Jev that returns typed judgments and calibrated probabilities.
An unofficial Go SDK for TypeSafe AI's Jev API.
An asynchronous Python client for Jev that returns probabilities and choices for typed questions.
A Go client for the TypeSafe System One API with optional Langfuse instrumentation.
An unofficial asynchronous Rust client for the TypeSafe System One API.
A Go SDK for the TypeSafe AI API.
Jev, briefly
A chat model generates text token by token and hopes you parse it. Jev never generates a word. Your code sends the state of the world plus typed questions; Jev returns every answer in one parallel pass — typed values with calibrated probabilities and a confidence score your code can trust. About 70–500 ms end to end, $0.042 per million input tokens, output free. Trained with what TypeSafe calls Reinforcement Learning for Calibrated Decisions.
You define the options. Jev returns the chosen option, a probability for every option, and a confidence. The workhorse of routing, agents, and games — the answer space is always legal, so there is nothing to parse and nothing to hallucinate.
You describe ordered levels — say trivial / normal / critical. Jev returns the level, the probability of each, and a confidence. Scores turn fuzzy judgment (“how severe is this log line?”) into a number-free decision your code can branch on.
You assert a statement; Jev returns the probability that it is true — a noul. Moderation, verification, guardrails, “does this diff actually fix the bug?”: one question, one calibrated probability.
Official material lives at typesafe.ai and docs.typesafe.ai. JevMade is an independent community registry — not affiliated with or endorsed by TypeSafe AI.
Recurring lessons
Games, drones, trading bots, and browser agents all converge on the same loop: serialize the state, ask one decisive question, act, repeat. Jev’s latency makes the loop feel instant — the model lives inside the control loop, not outside it.
The answer says what; the confidence says whether to act. The most reliable entries threshold on confidence to route edge cases to a slower model or a human — automation with an honest escape hatch.
Makers rarely ask Jev to pick from everything. Local tactics prune 225 gomoku moves to ~40; DOM filters turn a page into an element table; code narrows options, Jev judges within them.
A recurring split: Jev makes every decision cheaply and instantly, and a small LLM is only invoked when a human-facing string must actually be written. Decision and generation are separate budgets.
Send the link — repo, live demo, post, or video — plus a line on what it does and which primitives it uses. Every entry is verified against its primary source before it ships.
Submit your experiment → hello@JevMade.com