251 open source Jev projects in this category, part of AionEdge's independent index of the Jev ecosystem.
A macOS floating-window companion (documented in Chinese) for WeChat that reads the screen and uses a local small model to judge an incoming message's real intent and risk level, then drafts reply candidates — strictly read-only, with no injection into or hooking of WeChat itself.
AgentJev-0.6B, a fast open 'System One' decision model for AI agents that takes unstructured state (diffs, traces, logs) plus structured questions and returns calibrated probability distributions from a single roughly 50ms forward pass, with no output tokens decoded.
A framework where an LLM authors a task-specific harness for Jev — turning raw observations into features, constructing Jev questions, and combining the answers into actions — which can then be run, inspected, and optionally improved using reward signals and full execution traces.
A joke npm package that left-pads a string by calling TypeSafe's Jev model to do it, deliberately using a model call for a task that a single `padStart()` line could already handle.
A complete Chinese translation of a set of engineering notes on building with Jev, attributed as a synthesis of design notes by TypeSafe's founder, preserving the original structure and all seven illustrations, alongside the original unformatted source notes in a separate folder — an independent, unaffiliated compilation.
A Jev-powered LinkedIn recruiting agent that, given a role description, autonomously browses relevant candidate profiles, saves the ones it considers matches, and shows the underlying evidence for each judgment against your hiring brief.
An open-source, Jev-powered workbench covering the full data-to-model pipeline — streaming data selection, quality evaluation, automatic LoRA training, and held-out evaluation of the resulting model — with a public no-install browser demo.
A research project (with an accompanying arXiv paper and HuggingFace demo) exploring agentic memory that is controlled by a System-One decision model rather than left to the main generator to summarize and manage.
A memory-retrieval library that reranks a pile of candidate memories against a user query using one calibrated yes/no Jev judgment per memory in a single request, aiming for LLM-reranker quality at semantic-search speed and price.
A Java SDK for the TypeSafe AI Jev API together with integrations for the Spring AI framework, published to Maven Central.
A Rust-based random-baseline server (documented in Chinese and English) that speaks the same protocol as Jev — noul/choice/score — but never reads the prompt at all, answering instead from fast pseudo-random numbers, intended as a dummy/mock lower bound for evaluating agent routing setups.
A Clash Royale bot that plays on a real Android device using no trained policy at all — every in-match decision comes from Jev reading the live game state and choosing among a fixed set of options in real time.
A pure-HTTP (no browser) automation tool that walks through TypeSafe's account signup flow end to end — registration, confirming the magic-link email, onboarding, and creating an API key — supporting two different temp-email backends for bulk signups.
A macOS voice-control app that lets you operate your Mac through natural spoken English, combining OpenAI's Realtime API for speech with native Accessibility APIs and optional Jev-driven browser automation, built on Electron and React.
An asynchronous supervisory layer for Hermes agents that adds typed System One decisions, ranking, verification, token-aware oversight, and an opt-in tool gate, powered by either TypeSafe's Jev or the open Laya model — acting as a watchdog and forecaster while leaving the final stop/continue call to the main Hermes orchestrator.
A self-hosted Gmail add-on that uses Jev to classify incoming email, auto-apply custom labels, and filter spam, with built-in cost and confidence controls and no third-party backend handling your mail.
A macOS floating command bar for voice and text control where Jev picks the next UI action from the Mac's live on-screen controls, executes it, and repeats in a continuous observe-act-verify loop toward the stated goal.
A Chrome extension that cleans up a LinkedIn feed by sending every post through Jev's typed classification, collapsing posts flagged as engagement bait, self-promotion, off-topic, or sponsored into a single-line bar, with the reasoning behind each collapse shown to the user.
An unofficial Go client for the TypeSafe API, built by a community contributor to fill the gap left by the lack of an official Go SDK.
An MCP server that hands browser-page control to a decision model so a whole automation flow costs one tool call instead of one call per click, using reference-based element tables, code-checked assertions, and zero-model macro replay, speaking CDP directly to Chrome.
An experimental Go tool that wraps any CLI and, when you type an undocumented subcommand, reads the CLI's own help output and asks TypeSafe's Jev to match your typo by intent rather than plain edit distance — explicitly not meant for production-critical use.
A tool that plugs Jev, TypeSafe's System One classifier, directly into Claude Code, Codex, Pi, and OpenCode, exposing typed classify/check/score/rank/ask operations with calibrated probabilities in a few hundred milliseconds and one-command setup.
A three-layer prompt-injection and abuse filter for nginx/OpenResty that runs typed judgment calls to TypeSafe's Jev at the traffic edge itself, designed to fail open, cache results, and hot-reload without restarting the server.
An unofficial, from-first-principles PyTorch reconstruction of the ideas behind TypeSafe AI's Jev, explicitly a research implementation with random, untrained weights rather than a reproduction of the real production model.
A speed-focused Pi extension that pairs a local coding model with hosted Jev judgments, using Jev-assisted file retrieval to shrink the context sent to the generator and caching exact-match results to reduce repeated network calls.
A source-linked collection of public examples of Jev being used for robot control, 3D modeling, and related control tasks, where every entry links back to the original post, names the author and date, quotes the specific claim, and archives the demo media locally so it stays viewable if the original disappears.
A Chrome/Edge browser extension (documented in Chinese) that uses TypeSafe's Jev to flag low-quality, spam, and promotional posts on the X/Twitter timeline, overlaying a visible semi-transparent watermark on the post text — framed explicitly as a personal browsing aid, not a fact-checker or platform moderation tool.
A curated list of resources, open-source clones, integrations, and engineering playbooks for Jev, TypeSafe AI's non-generative System One decision model.
A curated 'awesome list' cataloguing tools, integrations, and experiments built around Jev, TypeSafe AI's fast typed-decision model.
A guardrail for coding agents built on Jev that checks tool calls, tool outputs, and agent replies for prompt injection, missing approvals, and leaked secrets, shipped as one shared rule set across a Pi extension, a Claude Code plugin, and a Codex CLI plugin — built on the premise that a README telling an agent to `curl | sh` is just more text the model needs to be checked against.
A layer combining TypeSafe's Jev with get-fable's deterministic lifecycle engine to give autonomous coding agents sub-100ms 'reflex' decisions for the small, frequent choices that don't need full model reasoning.
An OpenAI-compatible local cache proxy that asks Jev whether a new request has the same intent as a previously cached one, skipping the expensive downstream LLM call when it does.
A TypeScript library that treats probabilistic AI decisions as a composable backend primitive, letting developers define typed judgments (yes/no, score, choice) with explicit thresholds and deterministic policy layered on top, defaulting to TypeSafe's Jev but built to be provider-agnostic.
An evidence-first, long-term memory skill for AI coding agents on research projects, keeping every claim traceable back to the evidence that produced it and every session resumable without having to reconstruct what happened, with optional Jev decision-model layers built in — available in English and Chinese.
A module for the Nushell shell that wraps TypeSafe's Jev API, letting you pipe text through typed questions and get back numeric, filterable, sortable answers directly in shell pipelines.
A browser Minesweeper demo (documented in Japanese) where Jev evaluates every unopened cell adjacent to a revealed number as a single batched request, using TypeSafe's parallel fan-out pattern to get mine-probability for every cell at once. A bundled exact solver double-checks Jev's probabilities and handles cases where Jev isn't confident.
An enhancement pack for the MiniMax Code CLI adding continuous context renewal, a context-usage progress meter, browser tooling, and local decision integrations (Syntra and djev-spark), built and tested on a 4x NVIDIA DGX Spark cluster running a fully local model with zero API token cost.
A real-time captioning tool (documented in Chinese) that combines a streaming speech-recognition model with Jev, judging each sentence live to bold key points, color-code emotion, and stamp intent onto the transcript as it's spoken, with an optional DeepSeek integration for discovering new label categories — aimed at meetings, interviews, podcasts, and livestreams.
An independent, dependency-free Swift package implementing TypeSafe's Jev System One HTTP API, with async/await support, batching, retries, and Swift Package Manager distribution.
A Minecraft bot where the Hermes Agent handles planning, Jev picks one bounded action at a time, and a Mineflayer harness validates and executes those actions — no screenshots, keypresses, or generated code involved — including a reproduction of an existing Ender Dragon fight run from another project.
A Claude Code plugin that offloads Claude's small in-the-loop judgment calls — classifying a prompt, checking rule violations, deciding what's worth keeping when context fills up — to Jev instead of the expensive model, since Jev returns a typed verdict rather than generated text.
A browser-based Snake-style arena (documented in Chinese) pitting a human player against four AI snakes driven by an open-source mini replica of Jev's System One model, plus a mode simulating up to 100 competing agents at once.
An unofficial, independent Go client for TypeSafe's System One API, explicitly disclaiming any affiliation with or endorsement by TypeSafe.
A racing game where TypeSafe's Jev drives an F1 car live — choosing the racing line and pedal inputs and adapting to each corner's limits between laps — while a human can race against it.
A visual workbench (documented in Portuguese) for building decision funnels against the Jev/TypeSafe API by dragging and connecting nodes, where each node asks Jev a question and its possible answers branch to other nodes or in-game actions, with live probability display on the connecting wires.
A self-hosted, open-source alternative to TypeSafe's Jev and its System One API: a small Python server that sits in front of your own llama-server or llama-swap instance and serves the same wire protocol, so an existing Jev client only needs to change its base URL.
A small Python library that takes a JSON Schema, sends it through TypeSafe's Jev API, and returns matching JSON.
A Chrome extension (documented in Chinese) for Chinese shopping sites like Taobao and JD that uses Jev to guess, from a product's listing, store, and brand signals, whether the item was likely made under two-rest-day labor conditions, stamping a 'PASS' warning directly over listings it suspects were not.
A Polymarket trading bot whose pricing oracle is Jev, called through OpenRouter.
A Swift package for typed decisions — yes/no probabilities, choices among options, and ordinal scores — with two interchangeable backends: one running a small model locally on Apple silicon via MLX, reading the decision straight from next-token probabilities with no text generation, and the other calling TypeSafe's Jev API.
A Claude Code plugin that scores what the model is about to do — and what it just claimed to have done — with a probability model, denying the action outright when the risk score is high enough, moving rules that would otherwise be ignored once a CLAUDE.md gets buried by a long context into enforced hooks instead.
A local-first coding-agent memory tool where every stored fact is a verbatim quote graded by TypeSafe Jev's calibrated confidence, keeping SQLite-backed receipts so each memory can be traced back to its source with no external dependencies.
A community-maintained directory site tracking GitHub projects and posts built around TypeSafe's Jev/System One model, automatically counting and listing well over a thousand related projects.
A compiler that turns natural-language agent rules — like a CLAUDE.md instruction the agent keeps ignoring — into narrow evidence questions for Jev plus a deterministic verdict computed in ordinary code, so soft policy prose becomes a testable gate.
A fast, drop-in Node.js profanity and toxicity screener powered by System One models like Jev and Laya, built to catch leetspeak, spaced-out characters, and romanized profanity across multiple South Asian languages including Kannada, Telugu, Tamil, Hindi, and Bengali, typically in 50-500ms.
A local, privacy-first gateway compatible with the Jev/System One request format but explicitly not TypeSafe's own Jev — built for fast, offline decision-making inside autonomous agent loops.
A Chrome extension that uses Jev to judge which YouTube videos look distracting versus useful and covers up the distracting ones, with a manual override to reveal them when you actually want to watch.
A demo (documented in Traditional Chinese) contrasting what someone says with what they likely mean — an 'emotional lie detector' that runs the same input through both Jev and a general LLM via OpenRouter, using a single API key, to show the difference in how each responds to the same emotional-intent question.
A dependency-free Python CLI for experimental semantic line search using TypeSafe's Jev via OpenRouter — meant to complement exact keyword search by finding lines that express a searched-for intent even when the wording differs.
A unifying TypeSafe-compatible API that lets an application send the same data and questions to either local or hosted decision models — Jev-like classifiers — choosing a specific backend or letting a router decide which one should handle each request.
An agent skill giving the ego-browser project an inner decision loop powered by Jev, making one roughly 0.4-second typed decision per DOM step instead of spending a full LLM turn on it.
A WeChat reply-assistant that reads the current chat screen via local OCR, drafts three candidate replies with DeepSeek, and can optionally route them through TypeSafe's Jev for structured review and ranking before a human sends one. An unofficial fork building on an existing Windows-only tool, adding an early macOS preview.
A conversion tool that scans prompts originally written for GPT, Claude, or Gemini, finds the bounded decisions hiding inside them, and proposes equivalent Jev Choice/Score/Noul question definitions — aimed at classification-style prompts.
A Claude Code plugin that turns questions about your code — is this review finding real, is this debugging hypothesis worth pursuing, which of these design options is better — into typed Jev queries, giving Claude a second, independently-calibrated opinion instead of just another guess from the same model.
A browser-automation demo that uses no language model at all: the code builds every clickable option from the page itself, and Jev's job is only to pick among them, which turns out to be enough to complete tasks like filling out a flight search or editing a Wikipedia page.
A tiny web tool that takes up to 40 characters of text and returns emoji matched to it, each scored 0 to 3 by Jev rather than picking just one best guess.
A no-signup web app where Jev, TypeSafe's System One model, plays chess against Stockfish, any OpenRouter-hosted LLM, or a human — showing each move's probability live and keeping a saved history of past games and win rates.
A wrapper around Grok Build (the `nitro` command) that asks Jev, once per turn, whether each available tool will actually be needed to finish the request — all in one fast batched call — then strips the tools Jev says no to out of the model's context, cutting cost 22-40% on the same tasks.
An experimental prototype (documented in Chinese) that has Jev pick which GPT model and reasoning tier should handle each individual call within a Codex session, routed through a local proxy that keeps the session and tool loop continuous, with task correctness checked independently afterward to see whether using fewer flagship-model calls still gets the job done at lower cost.
A Kotlin DSL and client library for TypeSafe's Jev model, published to Maven Central.
A Pi extension that curates which context gets sent to the LLM before each call, using TypeSafe's Jev to decide which grouped message units (a tool call plus its results) are actually still needed.
A skill and plugin that helps an AI agent build with TypeSafe's Jev, upgrade existing LLM-only workflows to use it, and measure the resulting difference.
A pre-compaction advisor for DeepSeek Harness that runs before the standard compaction backend and uses TypeSafe's Jev to decide which low-value tool results can be safely pruned from the model's visible context, while the original session log stays intact and only the model-facing view is replaced with compact markers.
A Rust engine that gets System One-style typed judgments (noul/choice/score) out of any LLM in a single prefill pass, wire-compatible with TypeSafe's Jev `/v1/systemone` endpoint, and exposed to coding agents as an MCP tool.
A plugin suite bringing Jev, the System One decision model, into DeepSeek Harness, documented in both English and Chinese.
A Go gateway (Korean name '헤아림') that exposes a Jev-compatible System One endpoint backed by ordinary autoregressive models — Ollama Cloud, llama.cpp, vLLM, SGLang, or any OpenAI-compatible server — by compiling Choice/Score/Noul questions into single-token multiple-choice problems and reconstructing a probability distribution from the result.
Labels GitHub pull requests automatically using Jev's typed decisions via OpenRouter, sizing changes by their real conceptual scope rather than lines changed — so a small but far-reaching protocol tweak can outrank a large mechanical rename.
A curated gallery of Jev demos and launch posts sourced from X, organized by industry use case with preview media and direct links back to the original posts — over 2,000 curated posts and 1,300 original videos at last count.
A Windows-focused installer for wiring Jev into Codex's context-compaction hooks — Jev screens which tool-call history is worth preserving right before Codex compacts a session, then reinserts the kept material after compaction, with an isolation check against stale sidecar data.
A Chrome extension that scores posts and comments on X, LinkedIn, and Reddit with Jev and hides the ones it flags as AI-generated, aiming to cut down on low-effort synthetic content across the feed.
A local, fully offline server that speaks the same wire protocol as TypeSafe's hosted Jev API, so existing SDKs and client code can point at it unchanged. It answers yes/no, category, and score questions using small open models instead of a hosted endpoint.
An unofficial, community-maintained Chinese translation of TypeSafe's official Jev documentation, kept as a mirror of the English docs at docs.typesafe.ai for Chinese-speaking developers.
A calibrated alignment checker for LLM outputs and agent plans that scores them with a single fast Jev call, returning an auditable probability rather than another block of prose to interpret.
A HackSpain 2026 hackathon project that monitors sandboxed LLM agents for malicious behavior by classifying whole chains of actions rather than single tool calls, combining Jev with a rules engine for chain-level detection, an escalate-only five-level containment response, Neo4j-backed forensics, and a live dashboard — deliberately built so no automated system can pull the plug itself.
An open-source, bring-your-own-key arena for comparing Jev against other AI judges — you ask a question, pick candidate answers and an opponent judge, vote on the result, then see which model was faster, cheaper, and more accurate.
A fully local, open-source alternative to Jev for browser automation: it uses Laya, an open System One model, to drive browser-agent decisions over Playwright/CDP with no cloud calls, no API key, and no screenshots sent anywhere. Documentation is available in English, Chinese, Japanese, and Spanish.
A short, community-written quickstart and FAQ for getting started with Jev, TypeSafe AI's typed-decision model, pointing newcomers to a free no-waitlist demo site.
An evaluation of Jev 1.13 used as a reward model across eight benchmark tracks, published as an interactive report with a 54-row comparison against other state-of-the-art models.
A set of tools (documented primarily in Chinese) that plug Jev's judgment — not generation — into the DeepSeek Harness pipeline at four points: trimming long tool output, screening fetched web pages for injected instructions, recommending relevant skills, and gating whether a task is actually ready to be marked complete.
An independent head-to-head benchmark comparing two System One decision models — the open-weights Laya and TypeSafe's closed Jev — on byte-identical inputs and seeds, verifying the question hashes match exactly before any results are compared.
A driver for the ego lite browser (documented primarily in Chinese) that replaces the usual per-step LLM round trip with a single Jev call per step: Jev reads one indexed table of page elements and returns one operation plus target, which the author measured as roughly 2x faster than a per-step LLM loop.
A text-extraction library built on Jev covering field extraction, PII detection, and returning exact quoted spans rather than paraphrased text.
A dynamic, confidence-aware router for Agent Skills that keeps a full skill library offline and uses Jev to load only the verified skills actually needed for the current task, avoiding the prompt bloat of loading everything up front.
A CLI and agent-command tool that audits a git diff hunk-by-hunk against editable YAML coding-standards packs using TypeSafe's Jev, so a 500-line diff can be checked in seconds for a fraction of a cent while your agent fixes only the flagged hunks.
A fully local Pygame tactical arena (documented in Chinese, with English/Japanese/Korean/Russian translations) built around the NanoJev decision model, supporting multiple levels and local training on a GTX 1660S GPU.
An inference engine that turns existing LLMs into fast Jev-like decision machines, optimizing them specifically for lightweight, accurate classification and scoring rather than open-ended generation.
An R client for TypeSafe's Jev System One API, returning typed probability answers (yes/no, choice, or ordered score) instead of generated prose so results can be used and aggregated directly in R code.
A Chrome extension that scores every Gmail message using TypeSafe's Jev, surfacing category, priority, spam likelihood, and how much the message actually needs a reply — either as inline badges in the Gmail thread list or in a separate dashboard view of the whole inbox.
A self-hosted Feishu bot and web workbench powered by Jev, letting you ask a question and compare candidate answers by probability, or experiment with generative writing by repeatedly picking the next word or character.
A Windows/macOS desktop app where paper-trading agents watch a live market tape and decide up, down, or flat every second, using TypeSafe's Jev as the decision model while the app enforces your stops and targets — no real money ever touched.
A WordPress plugin connecting the CMS to TypeSafe's Jev System One model, letting PHP code get structured choice/score/noul answers about a piece of state instead of generated text.
An early, unofficial Rust client for TypeSafe AI's System One API, by the same author as the genai crate, currently a minimal 0.0.x release intended to be cherry-picked from as needed.
A TypeScript browser-automation agent where Jev chooses which action and page element to interact with on each step, only invoking a small language model when it actually needs to type text. Ships with two interchangeable browser engines.
An Android chat assistant that reads your current chat window and hands back a typed verdict — whether a reply is expected, the other person's intent, and how risky a misstep would be — without ever drafting or sending a message itself. Tested working inside QQ, Feishu, and Douyin.
A guardrail for coding-agent hooks (Claude Code, Cursor, and others) that combines hard structural denials with a Jev-powered sidecar to catch reward-hacking behavior — tampering with graders, hidden tests, or the evaluation process itself.
An MCP server exposing Jev as a decision layer for coding agents — ship/no-ship gates, risk checks, and file triage that keeps irrelevant files out of context — plus a browser-verification tool, all with calibrated confidence scores. Built for Claude Code, Codex, and Cursor.
A multi-account manager and API gateway that pools several official TypeSafe accounts behind one endpoint, handling authentication, rate/token quotas, usage tracking, and automatic failover between accounts, while staying wire-compatible with the official System One protocol.
A local control center that sits over OpenAI Codex, using Jev to analyze each incoming ticket, identify the relevant parts of the project before work starts, and route it through a defined path from understanding to implementation, verification, and review — aimed at cutting token usage while keeping the process traceable.
A macOS menu-bar app that converts spoken voice commands into system actions by routing them through Jev, holding a key to record and releasing it to send — a public reliability-focused release built in Swift.
An unofficial showcase of TypeSafe's Jev model built around its Choice, Score, and Noul question types plus parallel fan-out querying, framed explicitly as a decision engine rather than a chat interface.
A browser-based form for constructing Jev API requests without writing raw JSON: pick a template, fill in the blanks, and copy out a runnable request — no installation needed, everything runs client-side.
A reproducible benchmark comparing TypeSafe's Jev against LLMs, fine-tuned BERT, the open Laya model, and zero-shot NLI on text classification, reporting accuracy, calibration, latency, throughput, and cost side by side across three public datasets.
A Kotlin Android SDK for UI automation where either TypeSafe's Jev or DeepSeek selects actions from the controls visible on the current screen, and an Android accessibility service carries them out; either backend works independently, so a DeepSeek key alone is enough without a Jev account.
A native C++ CPU-only port of the Dohnuts System One model, built on llama.cpp, that runs a merged Qwen3.5-0.8B-plus-LoRA model and returns decision probabilities from a single forward pass with no GPU and no text generation involved.
A CUDA-native inference engine, written in C, that implements a Jev-compatible API for System One-style decisions — taking one state and returning many typed decisions from a single request — with no PyTorch dependency at runtime.
A Chrome extension and Workers-based API that scores X (Twitter) posts and replies in real time for AI-generated text, solicitation/spam content, and low-effort paraphrase-bot replies, with the scoring judged by Jev.
A tool that scores a URL or draft for traditional search, answer engines, and generative engines by having fixed code-based rules measure what can be measured and asking Jev only the parts that genuinely require judgment, returning three scores plus an evidenced, ranked list of fixes in about two seconds.
A local, unofficial toy implementation of a System One-style decision API running on a 0.5B parameter model — it takes application state plus typed questions and returns one discrete answer per question by scoring option tokens directly, not by generating JSON text.
A safety gate that sits in front of AI coding assistants' shell-execution tools (Antigravity, OpenCode, and others), first applying fast structural rules and then having Jev or any chat LLM judge what a borderline command actually does — reported as certified with zero dangerous commands allowed through in testing.
An open-source, Jev-API-compatible decision engine that runs open models to produce typed Choice/Score/Noul decisions in a single forward pass, packaged with a Claude-Code-style REPL and documentation in both English and Chinese.
An unofficial Java SDK, published to Maven Central with Spring Boot and WebClient support, for turning application state into typed Jev judgment calls via TypeSafe or the Vercel AI Gateway.
A Next.js app that scores how well an uploaded resume (PDF, DOCX, or TXT) matches a target job description using Jev, returning an overall score plus per-criterion and per-bullet scores and a suggested reordering of experience bullets, instead of a wall of generated feedback text.
An unofficial, community-built .NET port of TypeSafe AI's JavaScript SDK, kept behaviorally aligned with the original client and TypeSafe's own documentation.
An experimental OpenTelemetry Collector processor that calls TypeSafe's Jev model to help assess and decide retention for incoming metrics.
A .NET client for TypeSafe's System One (Jev) that takes typed questions and returns typed answers with probabilities and confidence, without requiring manual prompt engineering or output parsing.
A life-and-civilization simulation where every voluntary action taken by a simulated being is a typed, auditable decision made by TypeSafe's Jev, while separate LLMs (OpenAI-compatible APIs, local Ollama/LM Studio models, Claude Code, or Codex) handle higher-level planning.
A native macOS menu-bar companion app for Notion, written in pure Swift and SwiftUI, staying under 3MB and supporting eight languages.
A quant-research project (documented in both Chinese and English) that uses typed System-1 decisions from Jev or the open Laya model as a judgment layer, paired with Claude for higher-level reasoning, covering the full path from requirements through design, code, and experiments, with results reported honestly including the failures.
A community-maintained integration bringing a Jev-based runner into Midscene Test, providing a direct Playwright helper and a strict jevAct node for Midscene Test pipelines, independent of the official Midscene project.
A Turkish/English Electron app that lets you control a Windows 10/11 PC through natural spoken commands, prioritizing Microsoft's UI Automation for interacting with the interface and falling back to screenshot-based vision when a particular UI can't be reached that way, with Jev involved in the decision pipeline via OpenRouter.
An MCP server and companion Chrome extension that lets an agent (Claude, ChatGPT/Codex) drive a real Chrome browser, with Claude handling the overall plan and Jev picking each individual click, keystroke, or scroll in about half a second.
An automatic Pi extension that has Jev score older tool outputs in a session and stops resending the ones no longer needed, while keeping the original conversation messages intact and retrievable without rerunning the underlying command.
WERR, a zero-memory System-1 decision engine wire-compatible with TypeSafe's Jev, using Mandelbrot wave dynamics as its underlying mechanism and reporting the top spot on the JevBench benchmark at time of writing.
A reference project aiming to cover everything about Jev, TypeSafe AI's System One model for typed decisions, in one place.
Semantic test matchers for Vitest and Jest that let you write test expectations in plain English; jevtest asks TypeSafe's Jev a single narrow question about the actual output and turns the returned probability into a pass or fail, typically in well under two seconds.
A zero-dependency, unofficial bridge that exposes TypeSafe's Jev decision model as an OpenAI-compatible endpoint, so tools like 9Router, Claude Code, Cursor, and Cline (or any OpenAI SDK) can get typed yes/no, choice, and score judgments through a CLI or HTTP without native Jev support.
A Claude Code model router that, before each turn runs, asks Jev two questions at once — which model tier should answer and how hard it should think — then sends that turn's request to the model Jev named, supporting both TypeSafe's direct API and the Vercel AI Gateway.
A collection of Go utilities for the TypeSafe API, including `qgrep`, a grep-like CLI that answers natural-language yes/no and multiple-choice questions about piped-in text.
An experimental character-level language model built entirely out of a Jev classifier: since Jev already returns a calibrated probability over a fixed set of choices, the vocabulary becomes 28 Choice options (a-z, space, stop) and text generation is just the normal autoregressive loop run over that classifier.
A context-compaction tool for DeepSeek Harness that keeps the existing two-layer compaction algorithms unchanged but swaps in structured Jev judgments as the pluggable backend deciding what to prune, combining semantic tool-result pruning with deterministic receipt compaction.
A trading-research dashboard that feeds live stock news and company profiles into Jev, letting the model turn headlines and tickers into ranked trade ideas. Every number shown in the UI traces back to one typed Jev request, and a Requests tab exposes exactly what was asked.
An installable Codex skill that routes tasks to the right model and reasoning-effort level, packaged so the whole routing logic can be shared as one portable skill; documentation is in Chinese.
An interactive PDF question-answering demo: it extracts text from a PDF, uses Jev to rank which passages actually answer a given natural-language question, and lets you inspect each candidate match's confidence and location on the page.
An MCP server, written in Rust and published to both crates.io and npm, that wraps TypeSafe's Jev model as a single typed 'evaluate' tool for MCP-compatible agents.
A 3D football game where all 22 players on the pitch are independently controlled by their own Jev instance making live decisions, while the user can take over any single player, including the number 9, mid-match.
A CLI and MCP server for AI coding agents that answers 'where is this in the codebase' and 'which part actually matters' in about two seconds, using Jev to rank semantic search results and narrow down which files are worth reading — benchmarked against SWE-bench tasks.
A decision-support plugin for Hermes and other AI agents that reviews proposed tool calls for risk, recommends when a human should approve an action, checks supporting evidence, and keeps a local journal of past decisions for later audit.
A trading agent (documented in Portuguese) for Polymarket's five-minute Bitcoin up-or-down market, where a coded pricing model sets the trade and Jev acts as a sense-check gate that can veto it; maker-only orders and paper-trading shadow mode are both supported, and it never trades live by default.
Taiafox, a HackSpain 2026 hackathon project (documented in Spanish) that acts as a crisis-response agent: it filters a flood of incoming messages down to the handful that matter, coordinates human responders by voice, and re-plans within about a second as a situation changes.
An unofficial, community-maintained archive tracking the history of TypeSafe's Jev/System One APIs, SDKs, and agent-building guidance, built by watching TypeSafe's own public documentation sources over time.
A Claude Code plugin that scores the quality of your prompts to a coding agent over time and shows whether your prompting habits are improving, using Jev for the scoring so it adds no noticeable latency.
An exploratory project pairing Jev's decision-making with formal ontologies, recently pivoted toward a visual-ontology approach as of September 2026.
A dependency-free Python tool that offloads an agent's repetitive small classification calls — ticket triage, file tagging, routing to one of several teams — from the main LLM's context to Jev instead, with the author reporting 78% fewer tokens and better accuracy (96.1% vs 93.7%) in an A/B comparison.
A weekend demo project simulating a Mars rover navigating real USGS Jezero Crater terrain data, splitting its decision-making between Claude (for slower, deliberate reasoning) and Jev (for fast, reflexive calls) to make the seam between the two kinds of thinking visible. Explicitly not flight software or a validated research result.
A local experiment where Jev chooses moves from the legal-move list generated by chess.js and Stockfish grades each choice, built purely to see how good Jev's chess judgment actually is rather than to make it look good.
A Claude Code plugin that adds TypeSafe Jev-based semantic judgment to tool execution — reviewing Bash/Write/Edit calls before they run and reviewing their output afterward — communicating directly with TypeSafe's API with no MCP server involved, explicitly framed as a semantic guardrail rather than a security sandbox.
An unofficial community MCP plugin for both Codex and Claude Code that adds a bounded semantic-judgment layer powered by Jev — routing, ranking, extraction, verification, and escalation signals — while leaving orchestration, permissions, and actual code changes to the agent itself.
A GitHub Action for issue and pull-request triage that assigns calibrated labels and flags spam or duplicates, but is deliberately built to stay silent — abstaining from a verdict — whenever it isn't confident enough.
A Turkish-documented demo where TypeSafe's Jev decision model plays a real online 2048 website, making one API call per move and showing each direction's calibrated probability alongside the live game.
A teleprompter for talking points rather than a fixed script: you speak in your own words and any order, and each point gets checked off automatically once Jev's Score questions determine you've covered it.
A collection of production-oriented TypeScript patterns for building on TypeSafe AI's Jev, covering confidence-based routing, fallback handling, evaluation, and RAG-style retrieval workflows.
A TypeScript npm package providing chess move generation, position evaluation, persona-based opponents, and game classification, all built on top of TypeSafe AI's System One models.
A CLI that lets you describe, in one plain-language sentence, which changes you want staged; it classifies each changed hunk against that description, shows you the plan, and stages only the matching hunks after confirmation, leaving the actual commit and its message entirely up to you.
A Claude Code plugin that filters long Bash command output down to the lines relevant to the current task, keeping the retained lines in their original text and order rather than summarizing them away.
A hands-on teaching project (documented in Chinese) with six runnable examples and four written field notes covering Jev's three primitives and six combination patterns, running entirely offline from the Python standard library with no API key required, and including real recorded output from jev-1.13.0.
A provider plugin bringing TypeSafe's System One models, starting with Jev, into the RubyLLM library — typed judgments, evaluations, and reranking answered with calibrated probabilities instead of generated text.
A tool for categorizing and sorting text and PDF files, using either TypeSafe AI's Jev or a local calibrated decision model to decide where each file belongs.
Companion code for an article series comparing Google's Agent Development Kit against Microsoft's Agent Framework for building structured-output agents, using the same Pydantic schema in both and TypeSafe's Jev as a vendor-neutral quality-control gate over the results.
A WordPress plugin connecting to TypeSafe's Jev API, giving PHP code typed, confidence-scored answers it can branch on directly.
A port of the fast-jev-compaction tool to the Pi agent framework's non-destructive context hook, using Jev to decide tool call by tool call which old results still need to stay in context, without summarizing or rewriting any of the actual conversation text.
A Claude Code plugin for Rust code review that goes beyond what rustc, Clippy, and cargo-semver-checks already catch, using Jev and Claude to focus specifically on subtler issues like data loss in a cancelled select! branch or a check-then-act race across two separate locks.
A sub-100ms security gate for AI agent tool calls built on TypeSafe's Jev, doing single-request Choice/Noul/Score evaluation with a dual-factor blocking matrix, confidence-based routing, fail-closed parsing on errors, and a zero-config local fallback; designed to plug into LangChain.
A cost-optimized router for OpenRouter that uses TypeSafe's Jev to classify each incoming request and pick the cheapest model in the live full catalog that can actually handle it, rather than routing against a hardcoded model list.
A Turkish chat toy where, no matter what you type, the reply is always one of five fixed colloquial words — which one is chosen each time by TypeSafe AI's Jev model.
A Neovim plugin that classifies AI commands using Jev via OpenRouter's Decisions API, sending the user's prompt as state and asking a single typed question to decide which command handler should run.
A research project (documented in Chinese) exploring open-weight typed-decision models in the Jev class, taking a state plus a bounded rubric and returning calibrated probabilities per option in a single forward pass with no generation or parsing; its metask-jev-4b model is reported to outperform both Bespoke's Nimble-9B and Jev itself on the JevBench benchmark.
A Japanese-language demo quiz where you're shown a cloud feature name and Jev judges, with a probability for each option, which of AWS, Azure, or Google Cloud it belongs to; the 30 questions deliberately avoid obvious brand names and pair up similar-role features across providers to make the guess genuinely hard.
A local, natural-language task-workspace demo for a fictional team that lets you compare TypeSafe's Jev against GPT-5.6 Luna and Gemini 3.8 Flash for turning plain requests into workspace changes — switching between board, table, card, and calendar views, rescheduling, and note-taking.
A framework-agnostic PHP client for TypeSafe's Jev System One API, compatible with PHP 8.1+, any PSR-18 HTTP client, and Laravel 8 through 13, returning typed answers with calibrated confidence instead of text to parse.
Jev-AV, an antivirus and endpoint-detection scanner powered by TypeSafe's Jev that inspects binaries, running processes, scripts, documents, and web links, extracting structural features like Shannon entropy and file hashes to triage threats.
A model router for the Paseo coding-agent interface that uses TypeSafe's Jev or the local Laya model to classify each incoming message and start the following Codex turn with a matching model, reasoning effort, and work mode, while keeping the same underlying Codex thread across the switch.
An open-source runtime authorization gateway for AI agent tool calls that evaluates each proposed action against deterministic policy plus a Jev judgment, issuing exact-action, single-use permits, enforced at both the MCP and HTTP layers.
A FastAPI server implementing TypeSafe's System One (Jev) wire protocol, runnable locally with `uv` and testable via a simple curl request against a `/v1/systemone` endpoint.
An MCP server wrapping TypeSafe's Jev System One models, giving agents typed noul/choice/score judgments directly instead of having to prompt a model and parse its text response.
A find(1)-like CLI that locates files by a plain-English description rather than a filename pattern, using TypeSafe's Jev model to answer a semantic '--like' predicate for each candidate file.
A calibrated tool-call firewall for AI agents powered by TypeSafe's Jev, shipped as a Claude Code hook to provide an open, auditable version of an agent's automatic tool-approval mode.
A Cucumber testing tool that lets you write only the .feature file and skip step definitions entirely — Jev resolves each Gherkin step into an action and Playwright carries it out.
A proof-of-concept mailbox triage tool that reads email over a fake IMAP server and classifies each message with a single batched Jev call answering 11 questions at once, turning the results into dashboard labels — it only reads and labels, never sends or acts on anything.
An unofficial, single-file, dependency-free port of browser-use's jev-ultrafast to the Ego Lite browser, where Jev makes one typed-choice decision per automation step, with added multi-model benchmarks and extra safety guardrails.
A local MCP server (documented in Chinese) that exposes TypeSafe's Jev as a native tool for Claude Code, Codex, and other MCP clients, positioned specifically for the frequent small in-reasoning-chain decisions — routing, classification, scoring, validation — rather than as a replacement for high-volume direct API integration.
A PHP bridge connecting the TypeSafe platform to the Symfony AI framework.
A benchmark and architectural showcase arguing that System-One models like TypeSafe's Jev beat autoregressive LLMs at triage and email workflows, reporting roughly 75ms inference with no output tokens generated.
A browser game where eight AI-controlled snakes, all driven live by a single Jev call per game tick deciding every snake's move in parallel, compete against one human player, with each snake's confidence displayed above it.
A snapshot of TypeSafe AI's System One and Jev documentation extracted into Markdown files, preserving 110 documents in their original order from before the source pages were taken down, intended for use as LLM training or reference material.
A Chrome extension that reads articles and YouTube videos ahead of you and recommends read, skim, save, or skip with an attached confidence score tuned to your stated goals, using Jev for the underlying judgment.
A community node for the n8n automation platform that lets workflows classify, route, and score text using Jev-defined questions, returning a probability for every answer so low-confidence items can be routed to manual review.
A Claude Code Stop hook that checks an AI assistant's factual claims against the evidence it actually read during the session, using TypeSafe's Jev as a fast, cheap judge, and blocks the turn with the specific unsupported claims listed if something doesn't hold up.
An MCP server for Jev exposing the three official question types — choice, score, noul — plus a batch-classify tool, returning calibrated probabilities in roughly half a second per call for a fraction of a cent.
A public site where anyone can ask a short question and Jev answers yes, no, or it depends in about 100 milliseconds, with every judged question appearing on a live public wall alongside a running count and running cost toward one million questions.
A French-documented Symfony demo app that reads real support requests submitted to French public services and has Jev, TypeSafe's System One model, qualify each one — what the person wants, how urgent it is, and whether it's a bug that needs escalating to developers — built with Symfony Messenger, Live Components, Turbo, and the shadcn UX Toolkit.
A streaming event bus, written in Rust, where routing, subscription, and consumption decisions are made by a probabilistic judge — by default TypeSafe's Jev — sending each event's payload and a set of typed questions and getting back calibrated probabilities instead of generated text.
A fork of the OpenPoke agent that swaps its chat-model decision step for Jev, with published benchmarks showing the swap cuts latency roughly 6x and input cost by nearly two orders of magnitude on a 36-screen task.
A Magic 8-Ball novelty for pull requests: click the ball and it answers whether to approve, but the answer isn't random — it comes from Jev actually reading the PR's real signals, and responds in about 200ms.
An unofficial, community-maintained Ruby client for the TypeSafe/Jev API, porting the patterns of the official JavaScript SDK — typed questions, retry handling, and typed error responses.
A Next.js demo site deployed to Vercel with six live demonstrations of Jev, TypeSafe's System One model — including parallel yes/no judgments and a citation checker — each demo built so its output can be checked against Gemini or Claude in the open.
A small web chat interface where Jev, acting as a routing layer, picks which underlying LLM should answer each incoming message, with both the routing decision and the chosen model's reply going through the Vercel AI Gateway under one API key.
A consensus kernel wrapped around Jev's probabilistic output, built and tested like a database: formally model-checked in TLA+, generated into Rust contracts, and run through 1,680 simulated pharmacy decisions under seeded chaos testing with zero wrong verdicts recorded.
A self-hosted, hybrid long-term memory MCP server that runs entirely on Cloudflare Workers, combining vector and full-text search for retrieval with a JEV-based (Choice/Noul/Score) reasoning layer that re-ranks results and decides what's worth remembering.
A 119-row instruction dataset covering Jev's Choice/Noul/Score question types, compiled from TypeSafe AI's public documentation and mirrored on HuggingFace.
An MCP server with two tools — one that records a fact the moment it happens, and one that recalls facts for a new task — using Jev via the Vercel AI Gateway to decide which past facts are actually relevant right now, without summarizing or deleting anything.
A Go toolkit for TypeSafe's System One API offering a readable scripting language (SysOneScript), semantic code-checking (semlint), a direct Go client, and a Studio interface — designed to work offline first and add Jev judgments only when needed.
A Go SDK for TypeSafe AI's API, distributed as a standard Go module with its own API-key configuration.
A Jev-powered technical-analysis workspace (documented in Chinese) for China A-share stocks, pulling data via AKShare/Tushare to run market scans and produce Buy/Hold/Sell assessments with defined time horizons and evidence you can trace back to the underlying price and volume data.
The public contribution surface (issues, PRs, discussions) for modelsystem.one, a curated catalog site tracking System One / decision models — AI systems that return typed, calibrated decisions instead of free-form chat text.
An independent, source-linked research document examining TypeSafe AI's Jev model, backed by a rubric-scored survey of 947 public repositories that use it, covering recurring build patterns and available datasets, with bilingual (English/Turkish) documentation.
A zero-dependency Python browser agent built on agent-browser where Jev makes each click decision in about 150 milliseconds, only escalating to a full LLM when its confidence in the 'hunch' drops too low.
A fully local multimodal decision tool for Mac that produces Jev-compatible typed probabilities by running Qwen through llama.cpp on Metal, so image-and-text judgments can run without any cloud API call.
A per-turn router for agent harnesses that answers four setup questions — model tier, effort, tools, and skill — in a single roughly 350ms Jev call made under a hard deadline, falling back to regex matching if that deadline is missed; includes a Claude Agent SDK adapter.
A real-time firewall for AI coding agents that checks every Claude Code or Codex tool call before it's allowed to reach your machine.
A skill (documented primarily in Polish) that offloads a coding agent's routine context-heavy decisions to Jev via OpenRouter or TypeSafe directly, claiming a 99.3% reduction in input tokens with accuracy holding up in the author's A/B test, and shipping a reversible reduction step plus a ledger that learns when using Jev actually pays off.
A plugin for Claude Code, the Claude desktop app, and Codex that picks the best model and reasoning effort for a given task in about a second, using TypeSafe's Jev alongside live OpenRouter pricing to balance intelligence, speed, and cost according to your stated priority.
A side-by-side comparison of TypeSafe's Jev against DeepSeek-flash on speed, token usage, cost, and accuracy across three tasks: invoice extraction, email classification, and reranking.
A TypeScript library that lets React and backend programs treat typed Jev judgments as reactive, composable state — ambient meaning that updates like any other piece of application state.
A bilingual (Chinese-first, 8-language) documentation and best-practices site for Jev, TypeSafe's System One decision model, explaining its typed primitives and how to use them in production code rather than as chat output.
An open-source, non-autoregressive decision model (documented in Chinese and English) built on Qwen3.5-2B, positioned as an alternative to TypeSafe's Jev for O(1) tool routing and DOM automation with roughly 25ms inference.
A local Go proxy (with a Japanese README) that sits between a coding-agent CLI — Claude Code, Codex, Grok Build, or Devin CLI — and the upstream LLM API, reshaping the agent's outgoing requests in place rather than replacing the agent itself; not an MCP server.
A zero-dependency Node CLI (plus a Claude skill and Codex agent) that takes a messy pile of company files and classifies each one by department, type, sensitivity, date, counterparty, and PII using one Jev call per file, producing an organized, indexed folder tree at roughly 17 cents per thousand files.
An experimental, harness-neutral substrate (explicitly unfinished) that tries to turn Jev's bounded typed judgments into increasingly general expression through explicit semantic representations, composition, deterministic compilation, search, and verification.
A Neovim popup that, right after Claude Code finishes an edit, tells you whether you actually need to review the diff, which specific files matter, and flags leftover debris — before you open a single file.
A .NET library that lets you ask Jev yes/no, choice, and score questions and get back a C# enum with calibrated probabilities attached, published on NuGet.
A reproducible, recorded 100-case demo comparing three models — Jev, OpenAI's Terra, and Anthropic's Opus — on identical synthetic security-triage evidence, run five passes each, with results shown in a static, inspectable dashboard.
A small web tool, built on Jev, that reads a draft social post before you publish it and gives back three quick reads: what tone it conveys, how far it might spread, and whether it risks coming across as cringe.
An interactive Chicago traffic simulator running one fixed experiment — the same car, trip, and driver crossing real city geography — decided in turn by Jev and by two deterministic baseline models, so you can directly compare how differently each one drives the same scenario.
A browser-only testbed for trying out Jev through the Vercel AI Gateway, letting you feed in a piece of state and typed questions without installing anything.
A reproducible benchmark testing TypeSafe's Jev on a real agent-infrastructure task — classifying a proposed tool call as readonly, destructive, privileged, or exfiltration — measuring accuracy, latency, and whether the confidence score is actually reliable enough to route decisions on.
A TypeSafe SDK for the Jev model built on the tinystruct Java framework, with documentation translated into eleven languages.
A first-class, NativeAOT-ready .NET SDK for TypeSafe AI's System One, auto-generated with AutoSDK to provide both low-level transport and an ergonomic typed API.
A WebGL demo where you play the card game Speed against a CPU opponent controlled by TypeSafe AI's Jev, built specifically to measure and visualize Jev's decision speed and accuracy in real time as you play.
A community-maintained Go SDK for the TypeSafe HTTP API, filling the gap left by the lack of an official Go client and following idiomatic Go conventions like contexts, scoped functional options, and concrete error types.
A fail-open hook that runs before every Codex task, asking TypeSafe's Jev to estimate the task's type, complexity, risk, and execution mode ahead of time — purely advisory information that is validated but never allowed to block the task from starting.
A repository named for combining a Grok-based bot with Jev; no description or README content was available to summarize further.
A repository exploring using Jev to choose between different LLMs; no description or README content was available to summarize further.
A repository related to TypeSafe account registration; no description or README content was available to summarize further.
The Decision Graph Protocol, an open-source specification from Numerous ApS defining contracts for decision-based AI agents — covering Jev orchestration, guarded actions that require explicit permission, and batched assessment of multiple decisions at once.
A dependency-free, Codex-first CLI for delegating bounded judgments to Jev: it takes a JSON state plus named Noul/Choice/Score questions and returns typed answers, usage, and timing, without echoing the input state back out.
An addition to chrome-devtools-mcp that adds a single 'reach' tool: Jev picks each click needed to navigate the browser to a target location, so the agent only needs to make one DevTools call once it's there instead of one call per click along the way.
Page Verdict, a Chrome extension that answers one question about the page you're currently reading — is it trying to sell you something, or is it a genuine first-hand account — using Jev's judgment-only model.