THE JEV ECOSYSTEM, INDEXED
Jev is TypeSafe's model for fast, structured decisions. Explore what people built with it, with sources and evidence labels attached.
A native Mac switcher asks Jev which running app the user is likely to open next. A Rust core supplies recent activation and dwell-time history, while a Swift menu-bar app executes the selected app activation and exposes the request and response.
A browser-native experiment compares Jev control with a labelled local policy using isolated Chocolate Doom WebAssembly engines. Jev chooses movement, view, firing and interaction controls from structured spatial state, and local code executes those controls.
A 3D rover sandbox compares a local baseline with a Jev controller under energy, storm and sample-delivery constraints. A decision timeline exposes observations, available actions, model choices, execution and recorded usage.
A classic-novel reader adds Jev's whole-sentence emotion associations alongside a deterministic character map. Readers can adjust which emotion scores are highlighted and explore nearby text without changing the original novel.
A ManiSkill Franka simulator turns a spoken or typed English goal into a chain of hardcoded robot primitives. Jev chooses the next primitive and target, while local PD control executes the motion.
A Chinese and English caption interface combines streaming speech recognition with Jev judgments for important statements, emotion and communicative intent. Partial captions receive provisional annotations, followed by another judgment when the sentence closes.
A command-line tool fetches an artist's discography and lyrics, asks Jev for theme, mood and lyrical-complexity judgments, and displays the results in a terminal dashboard. Saved classification files can be rendered again without new model calls.
An independent rebuild of a TypeSafe community teleprompter scores unfinished talking points against the speech transcript. Code checks off a point when its score crosses the selected threshold, so the speaker can cover topics in any order.
A local laboratory routes Doom observations and control commands through F prime flight software, CCSDS, Yamcs and Open MCT. Jev selects bounded game actions on the ground, with alternative rule and compatible-model providers for comparison.
A local racing game asks Jev to choose the racing line, pedal input and whether the car is in trouble. Browser physics follows the chosen line, while recorded corner performance informs bounded speed adjustments for the next lap.
A browser simulation lets Jev choose bounded flight actions while local code maintains the world, sensors and movement projections. Optional slower planning advice can be requested asynchronously without replacing the reflex loop.
A Franka Panda simulator separates Jev's choice of manipulation intent from its choice of movement and gripper commands. A local executor applies those commands, and independent physical checks determine whether a task succeeded.
A spatial reference explorer retrieves images and archive clips from source-linked collections. In the local app, Jev selects bounded search phrases and highlights image references from their metadata; collected references can be pinned and exported.
A Mac voice interface combines local whisper.cpp transcription with Jev decisions over an enumerated action catalog. Code executes the selected shortcuts, app controls and multi-step actions, with an inspector for the decisions.
A MuJoCo robot workbench compares bounded skills, incremental movement and hierarchical control on manipulation tasks. It exposes decision traces, physical checks and alternative providers, including Jev, compatible chat models and a local MiniCPM model.
A text box switches among predefined cards for events, timers, lists, calculations and other intents. Jev classifies the intent and supporting signals while deterministic parsers extract values and a confidence-based state machine controls when the interface changes.
A Qwen3-0.6B backbone with its language-model head removed scores caller-supplied candidates through a permutation-equivariant head. The project releases training, serving and prefix-sharing code for Boolean, Choice and Score decisions, including a coding-completion checkpoint.
An independent experiment compares Jev's reported probabilities with known uncertainty on fair dice, coins and option sets. It also tests whether typed decisions preserve probabilities stated in forecast documents, publishing recorded outputs and offline analysis scripts.
A local workbench runs open decision engines side by side and can compare them with hosted Jev. It includes a visual request builder, dataset benchmarks, truncation diagnostics and resource or concurrency measurements with separate engine processes.
A measurement harness compares many typed questions in one Jev request with the same questions asked separately. It varies state size and question count, repeats requests to estimate noise and publishes response-level usage, billing and latency evidence.
A retrieval study compares typed Jev scoring strategies with dedicated rerankers and open-model controls on the same passage candidates. Saved provider responses, query-level evidence, bootstrap intervals and an interactive viewer support inspecting each result.
A reproducible zero-shot evaluation freezes the LexGLUE test splits and maps legal classification tasks to Choice or per-label Noul questions. Its runner saves completed requests, checks model-version changes and writes micro/macro-F1, calibration, usage and cost reports.
A frozen-protocol study checks Jev's option probabilities and output schema on Banking77 and CLINC150. It publishes corpus pins, raw responses, scoring rules, amendments, controls and a separate blind rescore.
An independent CUDA runtime scores verified single-token option labels with existing language-model weights. It batches independent fields through vLLM, reuses shared prefixes when supported and assembles typed output in code; browser experiments also use local WebGPU models.
A Rust inference server exposes open decision models through the TypeSafe-compatible API. Candle inference, dynamic token-based batching and CPU, Metal or CUDA builds support serving Laya through the same typed request contract.
A Swift package offers typed probabilities, enum choices and ordinal scores through a model-and-session interface. It can call TypeSafe Jev or a compatible local server, and an optional MLX backend reads local model token probabilities without generating text.
An offline linter checks Jev request design before inference, including missing escape options, broken state references and malformed criteria. An optional semantic layer asks Jev whether a structurally valid question has missing or ambiguous answer boundaries.
An evaluation library expresses agent, quality and security checks as typed questions and packs compatible checks into shared decision requests. The same definitions can measure recorded traces or gate an agent step, using hosted Jev or supported local decision engines.
A deployment toolkit exports compatible open decision scorers to ONNX, quantizes them and serves the TypeSafe request format locally. It preserves upstream readouts and calibration settings while exposing accuracy and precision trade-offs for CPU deployment.
A family of open 4B and 27B models applies stated rules and policies through typed option probabilities. The repository includes data generation, distillation, quantization, evaluation and a TypeSafe-compatible server, with GPU and Apple Silicon builds.
A training and deployment library adapts language-model backbones to typed decisions with learned pointer heads or direct option-token readouts. It publishes LoRA checkpoints, data preparation, calibration and evaluation tools alongside an archived application replay gallery.
Distilled Qwen models answer Choice, Noul and Score questions by reading option-token logits. The project releases 4B and 9B weights, fitted temperatures, a TypeSafe-compatible server and runtimes for CUDA or GGUF.
A Linux and WSL2 tmux controller provides a local web interface for Claude and Codex sessions. Jev maps typed or spoken requests to bounded operations such as sending, switching, reading or interrupting.
A shared TypeScript decision tool integrates natively with Pi and through local MCP with Codex. It collects bounded conversation context from a known session and returns compact structured results through OpenRouter Decisions.
A Python CLI and library reduce a skill catalog into bounded candidates before asking Jev which skill fits. Choice and fit signals produce a route, no-skill result or review outcome.
Claude Code function hooks ask Jev for a model tier and effort at turn start and apply the selection as the turn runs. A sticky cache guard and usage footer expose the selected route and actual model.
A Rust Anthropic-compatible proxy uses Jev judgments to select Claude model and effort settings. Deterministic routing rules also account for continuations, side requests and prompt-cache considerations.
A Python CLI parses source files into functions and asks Jev the same yes/no question about each unit. It ranks the returned probabilities and uses chunks when a language cannot be parsed at function level.
A local proxy forwards Jev requests and records calls and responses in SQLite for a browser inspector. Projects, decision dependencies and a live event stream help examine how decisions connect.
A Databricks app discovers model endpoints, MCP servers and skills from Unity Catalog metadata. Jev selects an agent specification before the OpenAI Agents SDK constructs and invokes the selected configuration.
A bounded executor lets a parent agent hand browser work to Jev over agent-browser snapshots. The parent receives structured handoffs when the task is blocked, repeats or reaches its step budget.
A TypeScript browser decision core chooses operations and observed targets from snapshots without importing a particular coding harness. CLI and harness adapters share the same Jev questions and step validation.
A Python browser agent uses Jev decisions over observed page candidates and returns structured results or cited answers. Browser execution, spending controls and result verification are handled by separate code paths.
An experimental Pi extension maintains quoted rule and task ledgers and checks side-effecting tool calls against them. The main agent records user receipts; Jev handles bounded semantic checks while code enforces resource, scope and precedence rules.
A CLI checks files against fuzzy rules written in Markdown, using a swappable judge with TypeSafe as the default backend. Companion packages apply the same rules to Pi writes and Claude Code Write/Edit hooks.
An experimental Oxlint plugin evaluates natural-language yes/no rules over functions, calls, JSX elements or files using Jev. Violations are reported when the configured probability cutoff is met.
Middleware for LangChain deepagents selects the skills a user turn needs instead of listing the entire catalog in every prompt. A provider-neutral routing core includes a Jev adapter that ranks descriptions and verifies shortlisted instructions.
A Rust CLI and TypeScript SDK turn a sentence into an inspectable plan over installed programs called reflexes. Jev selects offered programs and bounded inputs; deterministic code applies execution and confirmation rules.
Try a broader search or .