Latest repository pushes from our saved GitHub snapshot. Each repository has its own metadata check time; the list changes when that snapshot is refreshed.
398repositories with a recorded push
404indexed repository addresses
2 redirected addresses are merged into their current repositories. 4 repositories have no usable push metadata in this snapshot. Browse all repositories → · Activity JSON
Pydantic AI merged a TypeSafe model provider: `TypeSafeModel('jev-latest')` with confidence thresholds, a FileUnderstanding capability and fallback to an LLM for tool calls; docs cover jev-latest, jev-preview and pinned releases.
Treg ('OpenRouter for agent tools') with Jev on the decision step across fraud detection and signup screening, buying-signal triage and viral-content monitoring.
The LiteLLM proxy scores older tool results with Jev and replaces low-relevance ones with short removal notices before the request reaches the LLM; a TypeSafe pass-through endpoint is documented too.
OpenHarness ships a Jev Sheets harness for trying typed questions on table rows. Its Question Lab compares two formulations on a frozen sample and records answers, provider usage and review notes.
A Python package that traces TypeSafe System One calls as OpenInference LLM spans (request, response, model, token counts) for Phoenix and compatible backends; a JS package is documented in Phoenix.
OpenMausBot can use Jev to select an agent for a collaborative room. The decider validates offered choices and probability values before forwarding a decision to the surrounding routing system.
AgentScope exposes Jev through its classifier interface, translating binary, choice and score questions into TypeSafe primitives. The adapter converts structured answers back into framework classifier results.
Opik instruments synchronous and asynchronous TypeSafe SDK clients. Evaluation states, questions, returned answers and usage can be captured in application traces.
OpenCodex adds Jev decision services to its provider and combo-routing system. Optional automatic routing chooses a configured model and reasoning effort before the main coding request.
A vLLM pull request adding a Jev-like structured-decision path on Gemma, cited by testers comparing open alternatives on the Pareto frontier with reflex and DiffusionGemma.
A Rust runtime that lets any agent operate desktop apps through their real UI structure (OS accessibility trees) with stable element refs, from the author of the hook-based routing demo.
Claude Code orchestration includes optional Jev judgment points alongside existing heuristics. The registry defines question schemas and distinguishes blocking decisions from background observations.
Surf provides optional semantic commands that ask Jev to choose from allowed browser actions and check progress toward a goal. The controller validates each selected action against the current page.
A tutorial that replaces an LLM-as-judge with Jev to score Langfuse traces, with a full Python example detecting user disagreement per conversation turn.
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.
A desktop office suite indexes local document text in SQLite and can use Jev to reorder search results. The optional reranker evaluates candidate files against the search question before showing the ranked list.
A Rust agent harness uses Jev to rank deferred tools against the current intent. Its TinyHumans-connected evaluator combines a tool Choice with a Noul question about whether a tool is needed.
XERJ can send retrieved documents to Jev for query-relevance judgments and reorder the result list. Its search implementation keeps the decision step separate from ordinary retrieval scores.
AgentConnect provides a TypeSafe decision service inside its local agent daemon. It validates Noul, Choice and Score responses before using them in agent coordination.
Pi MCP Adapter can rank MCP tools by meaning using a System One evaluator. Project policy specifies which servers may share data for semantic search, alongside the existing word and regex search modes.
A self-hosted API gateway forwards Jev requests through the native System One endpoint and manages TypeSafe API-key accounts. Choice, Noul and Score answers keep their structured response format.
A Pi extension collection includes TypeSafe decision tools, Jev-assisted context compaction and searchable local conversation history. The compaction evaluator scores bounded batches of history units.
Needle uses Jev to rank passages and select the strongest source sentence for a natural-language query. Its Chrome extension highlights those sentences on the original webpage, and a React interface also accepts pasted text.
Composio includes a TypeSafe provider for selecting tools and binding arguments with explicit choices. Its implementation separates closed argument sets from values that require an open-ended companion model.
Braintrust added Jev as a scorer with a confidence-threshold pattern (accept above 0.95, route 0.70–0.95 to an LLM judge, flag below 0.70 for humans) and auto-instrumentation of TypeSafe client calls in its Python SDK.
DeepEval offers Jev-based evaluation metrics and a TypeSafe model configuration. Custom evaluation criteria are converted into structured judgments for individual responses and conversations.
An mmBERT-based 0.3B typed decision model published a year before Jev and rediscovered during launch week; weights and a demo Space on Hugging Face, plus a multilingual variant. Ports to MLX and Core ML followed within days.
A Python package that traces TypeSafe System One calls as OpenInference LLM spans (request, response, model, token counts) for Phoenix and compatible backends; a JS package is documented in Phoenix.
Bounded TypeSafe Jev workflows for coding agents: small-model judgments combined with deterministic workflows so coding work stays bounded, from the author of jev-review.
An OSS library from the LlamaIndex founder: give a document plus natural-language category rules and Jev predicts the category (classify) or the boundaries between sub-documents (split). OCR backends: liteparse (fast, free) or LlamaParse for complex layouts.
A local SQLite memory system exposes retrieval through MCP and can rerank a candidate pool with Jev. Its implementation uses Noul relevance judgments before returning selected memories.
The source repository contains an experimental composer that uses Jev to select elements from a prepared UI grammar. A bounded composition loop builds a JSON render specification from those decisions.
OpenMuse represents Jev decisions as interactive controls inside its assistant interface. Server adapters and shared schemas connect typed answers with selectable actions and human review.
ReqLLM adds a TypeSafe provider for structured evaluation requests in Elixir. Its evaluate operation handles state and questions separately from the library’s text-generation operations.
A browser and macOS computer-use harness that checks completion claims against observed state and gates irreversible actions with Jev. Its dual mode also delegates mechanical steps to Jev while a driver handles broader decisions.
Native MLX and Core ML runtimes for Laya typed decisions: `pip install 'laya-mlx[demo]'`, no text generation, no PyTorch, no cloud API. A Rubik's-cube demo runs 100 moves locally.
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.
Native MLX and Core ML runtimes for Laya typed decisions: `pip install 'laya-mlx[demo]'`, no text generation, no PyTorch, no cloud API. A Rubik's-cube demo runs 100 moves locally.
A multi-robot harness CLI (Microduck, Open Duck Mini, LeRobot, XLeRobot, AlohaMini and more) where each robot has an LLM brain and Jev handles the cheaper decision steps; a LeRobot SO-101 setup takes about five minutes.
A Python code-navigation library builds a structural index and composes small Jev judgments into best-first source searches. Its commands can trace known workflows or find matching functions while saving source provenance and partial results.
LLPhant exposes Jev through a PHP classifier and typed request objects. Applications can send a state with classification questions through the native TypeSafe endpoint.
GoModel includes a Jev provider that forwards native System One decision requests. Its passthrough path preserves request and answer structures through the gateway.
Agents can write code but struggle to understand what they built at runtime; Reticle gives web and desktop apps a Jev-style runtime perception layer so agents know which interface they are looking at.
TradingAgents optionally screens social posts with Jev before a sentiment analyst reads them. It removes unrelated company mentions and groups remaining posts by their stated stance.
One-pass option scoring with a local Gemma 3 4B via MLX: pre-written options are batched against a cached context; implements the System One API contract and includes a Doom terminal demo.
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.
A Taboo-style game where a player describes a UI component without its forbidden words and Jev ranks the component library. A second mode finds a component from the job the player needs it to perform.
A local Markdown-vault second brain for Linux, macOS and Windows with Claude Code, Codex and Antigravity adapters and optional Mem0 / Jev; one-command setup that also installs Obsidian.
Jev scores each request on eleven dimensions (difficulty, stakes, safety and more) and YAML thresholds map the scores to model tiers; TypeScript and Python SDKs plus an HTTP proxy.
QuantDinger can apply Jev checks before live entry orders, combining strategy context with account exposure and risk information. The application records individual choices, confidence and timing in a decision timeline.
The macOS Agent! application can ask Jev for advisory judgments about its planned actions. A Swift middleware layer defines the questions and converts returned verdicts into application decisions.
A Python package for Jev-powered relevance filtering and reranking, with a Hugging Face blog walkthrough covering the API, filtering and evaluation results.
A mathematics-to-animation pipeline uses Jev to review checkpoints while a separate authoring model develops explanations and Manim scenes. Typed questions assess evidence, blocking defects and the proposed repair target.
An independent model inspired by Jev evaluates text, images and video against supplied candidate decisions. A Qwen backbone and decision head produce candidate probabilities without generating answer text.
A Terraria tModLoader mod with a Jev combat layer. Typed judgments select movement intent, danger and dash, grapple or jump decisions while deterministic controls handle aiming, available movement tools, timing and expired-intent fallback.
A family of tiny Jev-like decision models — 0.5B at launch, now 0.6B, 4B and 8B on Qwen3.5 — using the same LoRA-plus-pointer-head recipe with block-causal masking so questions run in parallel; the HTTP API mirrors System One, so the official SDK works with only a base_url change.
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.
A drop-in replacement for the TypeSafe client that answers the same state-plus-questions contract with an ordinary LLM API, useful for comparing Jev against OpenAI- or Anthropic-compatible models on identical calls.
Jev-powered model routing, memory, context compaction, skill selection and computer/browser use for Hermes agents (also Claude Code and Codex), with a routing dashboard and shadow mode that shows what Jev routing would have saved before you switch it on.
Bespoke Labs' open take on a Jev-like model: local typed decisions plus a contrastive data-curation recipe and evaluation code, released as data, weights and training recipe together.
A pull request on the TrainLCD Functions repository adds Jev-based re-ranking of suggested stations and measured spikes; the author says Jev is also going into part of the app's AI chat.
A proof-of-concept MCP server exposing three tools: verify a claim against evidence, screen text for injection or relevance, and rank candidates semantically.
An experimental Photoshop chat router uses Jev to select supported direct editing commands and short recipes. Complex requests, visual checks and ambiguous instructions are routed to the configured language model.
MemSearch includes an optional Jev reranker for project-memory passages. Candidate excerpts are scored against the query before the application chooses which memories to return.
A TypeScript browser SDK combines native Playwright actions with Jev decisions over observed elements. Its CLI, MCP server and library share the same execution and verification core.
GPT Researcher can use Jev to score scraped passages for usefulness to a research question. Its compressor selects context from the same chunk pool and output budget used by the alternative retrieval pipeline.
A CLI that uses Jev to judge relevance across repository folders, files and declarations, returning file leads and verbatim source excerpts to a coding agent.
Home Assistant integration: ask the house a typed question and get a number back — Jev answers exposed as sensors, four actions for automations, and a conversation agent for Assist.
ThoughtDAG searches local agent sessions and visual conversation canvases. Its optional Jev layer helps select relevant excerpts and topics before the chosen language model develops an answer.
An experimental semantic router for Hono by its creator: routes are described in plain language and Jev matches incoming requests to them from method, URL, headers and body.
A local TypeScript library and CLI where Jev chooses exploratory browser actions and assesses observed results. Playwright executes configured actions, exact assertions decide outcomes, and saved traces support replay.
SimpleJev.ai from Featherless: a fully open-source library that takes any Hugging Face model and 'Jev-ifies' it behind an API endpoint, with public no-key endpoints, vision via chat-format images (Gemma, Qwen) and an RFDT tuning recipe to distil your prompts into a smaller production model.
A TypeScript System One runtime provides shared Choice, Noul and Score builders for Jev, Reflex and compatible endpoints, with a companion Pi extension.
Agent Squad includes JevClassifier implementations in TypeScript and Python. A typed Choice question selects among configured agents using the request and conversation context.
A browser agent where Jev picks the operation and target element from a numbered element table each step, and a small LLM is called only when text has to be typed.
The official Python client (`uv add typesafe-sdk`) with sync and async variants; the quickstart classifies support tickets into billing, technical or other.
The official TypeScript/JavaScript client, shipping ESM, CJS and type declarations for Node 20+; same ticket-classification quickstart as the Python SDK.
A local daemon and CLI for downloading and running open decision models behind a TypeSafe-compatible API. It includes an MCP interface and model definitions for typed Choice, Score and Noul workflows.
The investment-agent framework includes a native TypeSafe adapter for its structured result contract. Jev answers are converted into the compatibility JSON expected by the surrounding agent pipeline.
An MCP connector that gives any MCP-capable agent direct Choice / Score / Noul calls to Jev; the Chinese roundups call it the first thing to install after getting an API key.
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.
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 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.
An Android chat assistant that uses Jev or a compatible decision endpoint to judge message intent and risk, then offers drafts from a separate generative model.
An open-source CLI that builds calibrated classifiers from human feedback on top of Jev, using GEPA prompt optimisation — because a foundation model still needs aligning to your own criteria.
An OpenAI-compatible local cache proxy (`npx @kushalicious/jevcache`): agents that re-ask the same thing get the cached answer when Jev judges the intent identical.
Turns plain-language critical-path tests into bounded UI actions chosen by Jev. The runner checks a fresh screenshot after each action and records a step-by-step result.
Screens agent tool calls for destructive, exfiltration, privilege-escalation and off-task actions using Jev probabilities, ships as an npm package and a Claude Code PreToolUse hook, and logs an audit trail.
A self-hosted router asks Jev to assess fresh coding tasks and applies YAML policies to choose an upstream model and reasoning effort. Strict sessions retain their admitted model, provider and limits through later tool calls.
A browser extension (and web version) that classifies the news article you are reading by political framing, article type, topic and how loaded the language is, using Jev as a fast probabilistic classifier.
A Telegram moderation bot that uses Jev for optional text, bio, advertising and language judgments. Image moderation runs through a separate local detector.
A curated list of official and community TypeSafe / System One / Jev resources, 50+ entries in six categories, with a GitHub Pages site; reviewed 2026-09-17 per its page.
A museum stealth game where Jev estimates threat, suspicion, tactical intent and attention from each guard's observations. A server owns the world, checks every proposed action and records the complete decision trace for inspection.
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.
Jev as a decision layer for the Pi coding agent: a measured tool-call gate plus a jev_ask tool for typed, calibrated answers; distinct from madeye/pi-jev.
An MCP server uses Jev to drive Chrome through observed page elements, either in an existing browser through an extension or in a separate profile. Tasks expose progress, questions and extracted results to the host agent.
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.
A WXT browser extension that asks Jev whether page elements are clutter (ads, cookie banners, upsells), then saves reusable per-template hiding rules; sends snippets rather than full pages, bring your own key.
An open-sourced decoding engine for autoregressive LLMs inspired by Jev: one output token per decision, no out-of-schema outputs, KV-cache reuse; demoed on SGLang with Qwen 27B.
A local MCP server gives coding agents Jev judgments for loop routing, patch review, evidence checks and candidate ranking. Its prepared-call router selects an exact host-supplied tool call while retaining the original arguments locally.
TypeSafe's public skills repository with the `typesafe-ai` SKILL.md used by Claude Code, Codex and other agent environments to design bounded Jev decisions.
A Playwright reporter asks Jev which discovered browser tests are relevant to a code change before browser execution. It combines changed paths and patches with test metadata and optionally test source.
A local Rust search tool combines keyword discovery with Jev ranking and delivers source excerpts through a CLI or MCP. Its setup command connects Codex, Claude Code and OpenCode and can supply retrieval context when a code question is submitted.
A music playground in which Jev selects closed plan labels such as form, key, tempo, register, accompaniment and harmony phrases. Deterministic code expands the plan into notes, engraves the score, plays audio and exports MIDI.
A llama.cpp fork with a `jev` branch and docs/jev.md that runs Jev-style typed decisions on local models; the author's size-by-size picks are Qwen3.8-27B, Gemma 4 12B, Qwen3.5-4B and two tuned 'jwenv' Qwen3 PoCs.
A non-autoregressive decision engine on ModernBERT (151M) with calibrated uncertainty, an audit of the Jev benchmark, and an in-browser WebGPU playground; Apache-2.0 with PyTorch and ONNX weights on Hugging Face.
A non-autoregressive decision engine on ModernBERT (151M) with calibrated uncertainty, an audit of the Jev benchmark, and an in-browser WebGPU playground; Apache-2.0 with PyTorch and ONNX weights on Hugging Face.
A native DuckDB extension for Jev classification, scoring and semantic predicates from SQL: vectorized input, batching, bounded concurrency, dedup and cross-query TTL/LRU caching. Distinct from colliber/duckdb-jev.
An extension for bentlegen's hunk that classifies the files in a diff (core, tests, docs…) with Jev and reorders the review so the important changes come first.
`pip install von`: a non-autoregressive local decision model claiming wire-protocol compatibility with Jev (`von serve`), with ModernBERT or Laya-421M backends; Apache-2.0.
A native CPU server serves an independent decision model through the TypeSafe wire format. Yes/no predictions are also composed into option distributions and ordered scores, with shared-state reuse and packaged OpenVINO or GGUF weights.
A Pi extension applies deterministic policies before asking Jev to judge uncertain bash, write and edit calls. It records semantic decisions and blocks calls when the default policy cannot reach a decision.
An LLM gateway that mimics TypeSafe's structured output so local models can be scored against Jev; Needle 3 on an M4 Pro came out worse than Jev, Qwen3.8 27B and OSS 120B.
A Claude Code plugin sends instruction checks, context retention and subagent routing judgments to Jev. Context compaction retains selected original blocks instead of writing a new summary, with a Pi compaction adapter also included.
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 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.
An end-to-end research toolkit builds decision records, trains and calibrates candidate scorers, and serves a Jev-compatible API. Its released Qwen3.5-0.8B model ranks supplied web actions, while the public demo presents recorded Mind2Web decisions.
JevHarness lets a language model author task-specific code that builds Jev questions and combines typed answers into actions. A frozen harness can execute without calling the authoring model for every decision.
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 open-source macOS pointer companion driven by Jev or Gemini Live: a local OmniParser build on CoreML reads the screen, Jev picks where the pointer goes, Ctrl+K takes a typed task. Bring your own keys.
A local semantic engine answers typed questions about application state and documents using an NLI model. It adds evidence retrieval and a Relation primitive alongside a Python API and TypeSafe-compatible HTTP server.
A TypeScript workspace containing Hundred, a town of 100 NPCs, and Jev Shogi, a human-versus-model board game. Each Jev request carries compact state and engine-legal next actions.
A Qwen3.5-4B LoRA adapter answers multiple typed questions without generating answer tokens. Its runtime combines label-token readout with a learned candidate head, option-order averaging and saved calibration profiles.
A benchmark compares Jev and other typed decision systems using frozen tasks, explicit adapters and published result artifacts. Its score views combine capability, calibration, latency and estimated cost, with public and sealed evaluation material.
A Clash Royale experiment on an Android device that converts screen video into structured game state. Jev selects a strategy, card and placement, while the replay viewer exposes the questions and option probabilities.
A Chinese X Article sorting the early ecosystem into things that actually ship: jev-ultrafast, mobile-jev, typesafe-computer-use, AskJev, a Twitter timeline analyzer, a tax-document classifier, jevdetector and newsjack, plus the OpenRouter and DataCamp explainers.
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 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.
A Rust CLI searches source trees and text documents with local BM25 recall, then uses Jev to filter and order candidate files. Results carry paths, line ranges and relevance scores in a grep-style interface.
A Chinese-language learning repository with five runnable Python demos and the author's Jev 1.13.0 experiments on question fan-out and decision boundaries.
An open reproduction that answers noul/choice/score in one non-autoregressive pass with calibrated confidence, at 150M parameters — a non-LLM route to the same interface.
Fifty-nine small open-source projects exploring what changes when AI returns a typed decision instead of a paragraph — agent safety, RAG, research, games, public data — mapped in one repository.
PyGPT offers an inline Jev plugin for structured semantic decisions inside its assistant workflows. It supports classification, selection, verification and scoring over supplied state.
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 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 React and Three.js arena shooter built around coffee deliveries and Jev-selected NPC tactics. Deterministic TypeScript owns the simulation, while recorded decisions can be replayed without model calls.
An independent family of LoRA adapters and scalar decision heads returns Choice, Noul and Score outputs over pinned Qwen backbones. The project publishes training data, evaluation records, a CPU classification workbench and interactive saved-decision replays.
Open-source log triage for OpenTelemetry: Jev scores each log line's signal so only what matters reaches the expensive LLM analysis; a write-up covers Jev vs a fine-tuned alternative.
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.
A DeepSeek Harness plugin uses Jev for tool relevance, pre-execution call assessment, skill hints and model-route selection through a reusable decision core.
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.
Risk-scores every tool call (rm, curl, bash…) with session context into deny / ask / allow, flags prompt injection in tool results and checks skills and plugins; works with Claude Code, Codex and others.
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 server that implements the TypeSafe/Jev HTTP API on Qwen3.6-35B-A3B with SGLang: prefill-only, one extra token per question, radix caching, deployable on Modal.
A CLI, MCP server and library combine ripgrep recall with Jev judgments over candidate files and passages. Results contain original source excerpts with paths, line numbers and explicit omitted ranges.
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 Manifest V3 port of jev-ultrafast that lets Jev choose clicks, keystrokes and dropdown actions in the user's existing Chrome tab; a separate text model handles typed content.
A Claude Code and Codex CLI plugin that intercepts Bash output above roughly 10K estimated tokens, chunks it and asks Jev which lines are still needed, dropping progress logs and boilerplate.
A computer-use agent that OCRs the screen, asks Jev to pick the next action, and clicks; the author says the loop generalizes across operating systems.
An open typed-decision model on DeBERTa-v3-large answering Choice (up to 255 options), Score and yes/no questions from one forward pass, trained on 18K states and 42K questions.
A Chinese X Article sorting the early ecosystem into things that actually ship: jev-ultrafast, mobile-jev, typesafe-computer-use, AskJev, a Twitter timeline analyzer, a tax-document classifier, jevdetector and newsjack, plus the OpenRouter and DataCamp explainers.
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.
Pro Workflow can add Jev judgments to coding-agent correction hints and risk suggestions. Its optional classifier also supports a compatible local Laya server.
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 self-driving simulation built to test Jev: structured sensor state in, typed decisions out (steer, brake, overtake, pedestrians, speed limits); the prompt is published.
A seven-step setup that puts Jev between Grok Bot and its actions: a jev-usage-router skill is consulted before browser, research, retry or extra-bot steps; it starts in shadow mode with logs, then goes active, with a kill switch. Repository included.
A Windows companion that collects visible WeChat messages with local screenshots and OCR, then uses Jev to rank three draft replies for the user to send manually.
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 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 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 Claude Code plugin that asks Jev which standing rules and codebase maps are relevant to the current prompt or file edit, injects only those, and falls back to all rules if the API is down.
An independent agent skill for spotting Jev opportunities, designing typed questions, preserving source evidence and testing a small decision workflow.
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.
An OSS library from the LlamaIndex founder: give a document plus natural-language category rules and Jev predicts the category (classify) or the boundaries between sub-documents (split). OCR backends: liteparse (fast, free) or LlamaParse for complex layouts.
Seven independent writing checks (hedging, filler, passive voice and more), each returning its own verdict, confidence and the driving sentence; runs simulated without a key.
A task-specific pipeline generates or labels data with an LLM teacher, trains a LoRA and decision head, then evaluates and serves Choice, Score and Noul probabilities. A public support-triage replay shows saved model outputs and review routing.
A Chrome extension that labels every post on X (Substance, Humor, Chit-chat, Promo, Junk, AI-written) plus an AI-probability score, and folds the ones you don't want.
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.
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 System One style layer that returns typed, calibrated decisions from any open-weights LLM in a single forward pass (Hugging Face and vLLM), with benchmarks against Jev in the README.
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.
A layered controller: classical vision at 15 Hz, a 50 Hz reflex safety layer, and Jev at about 2.5 Hz choosing tactical maneuvers from JSON scene descriptions.
An independent Jev-like model fine-tuned from Qwen3.5-0.8B-Base to choose legal actions from raw game frames. The project publishes model weights, training records and a gallery of ten browser games.
A bilingual (Traditional Chinese / English) evidence map of where Jev holds up and where it breaks, with API-call receipts under suites/. Its thesis: success tracks whether the answer is derivable from the supplied state rather than from outside knowledge.
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.
For the Pi coding agent: every code edit is checked by Jev against the repository's Markdown rules (agents.md and friends) so the agent stops ignoring them.
Jev scores prepared subtitle or transcript segments; the tool assembles highlight and shortened videos with ffmpeg and exports a timestamped selection report.
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 container recipe for structured decisions with DiffusionGemma in NVFP4 on an NVIDIA DGX Spark, offered as the 'or just use this' route to a local Jev-like.
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 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.
Runtime `if (Jev::is($body, 'spam'))` and `Jev::choose($msg, [...])` for Laravel, with `Jev::fake()` for offline tests and `Rule::jev()` for form validation.
A Python routing engine combines inspectable YAML rules with Jev judgments to assign requests to agents or skills. Its Claude Code hooks can discover the installed roster and turn confidence bands into routing, suggestion or confirmation verdicts.
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 bilingual puzzle application where Jev classifies player questions and judges proposed explanations through typed outputs. It includes hints, private puzzle authoring, revocable share links and configurable TypeSafe, OpenRouter or Vercel AI Gateway access.
LangChain tested Jev against LLM judges on accuracy, repeatability, latency and cost to see whether System One models offer a new approach to online agent evaluation; evaluator code in the repository.
An interactive 3D Rubik's cube: turn it by hand, Jev watches each move, stays quiet while you progress, warns on a break and steps in with the next algorithm.
An independent Jev-inspired model and serving project for Apple Silicon. Fine-tuned open backbones return Choice, Score and Noul probabilities through a Jev-shaped API, with calibration artifacts and worked use cases.
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.
An independent reranking benchmark paired with a live natural-language search over Y Combinator companies. The app uses Jev for query routing and reranking after keyword and embedding retrieval.
A local MCP server for Windows that combines UI Automation actions with checkpointed web-research jobs. Jev selects from a bounded desktop action list and can rerank stored evidence or check a claim against an exact passage.
A Chrome extension that applies BAIT, CORP and BRAG labels to LinkedIn posts using Jev, with a local server for the API key and heuristics to reduce calls.
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.
Doom played by the Laya System-1 model via ViZDoom: one forward pass per decision, fully local, live model probabilities on screen; the model advises, deterministic rails enforce.
An open-source Chrome extension (store review pending) that labels posts on X, Threads and Weibo with rules you define, powered by your own TypeSafe account.
A Chrome extension that uses Jev to estimate a page's purpose and the writer's position (ad, testimonial, explainer…) and colour-codes Google search results accordingly.
Maps visible UI states to bounded action options so Jev can select the next browser step. The repository includes a food-ordering demonstration with action limits in code.
An open-source Codex skill: install it, set a Jev API key, and Codex drives desktop apps with Jev making the per-step calls — the author reports the biggest gains on tasks with frequent checks and tool calls.
Adapts first-token logprobs from any OpenAI-compatible endpoint (cloud or local) into bounded Jev-style choices and scores; text, image or audio in when the backend exposes logprobs. Node + Python, with agent skills and a 2048 demo.
Say it and the Mac does it: the loop reads the accessibility tree, asks Jev which element to act on, acts, repeats — deliberately naive, no screenshots, no vision model.
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.
An independent evaluation site and data repository for Jev and LLMs answering the same typed questions. Public boards link accuracy, calibration, costs and latency to human-labelled tasks and individual decision logs.
An independent Jev-style project that freezes a language-model backbone and trains a small decision head over cached candidate features. It publishes typed probability outputs, datasets and browser presentations of its benchmark and game policies.
Jev-inspired sim with a local 2B model driving a PiPER robot in MuJoCo: the cube is relocated three times per run and the robot detects, interrupts and recovers.
An educational experiment: one image, dozens of questions answered at once by scoring candidate outputs directly instead of generating, running Qwen3.5-0.8B on MLX.
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 configurable LIBERO robot-control experiment that combines Jev decisions with reversible physics previews. An interactive replay follows intent, motion family and control choices alongside saved trajectories.
A local NLI backend scores caller-defined Choice, Score and Noul questions, with temperature scaling and low-confidence abstention. Python, CLI and MCP interfaces expose the same decision layer.
A Chinese aggregator of X long-form posts and demo videos about Jev, categorised with original links and authors kept; GitHub Pages site plus repository.
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.
LoRA fine-tuning experiments for Jev-like typed judgments on Qwen3.5-0.8B, published with datasets, adapters, evaluations and a full write-up of why it was abandoned.
Speeds up Pi coding-agent workflows by letting a decision model pick which files matter and cache requests; the author also tried DiffusionGemma in place of Jev and documents the results in VALIDATION.md.
A preregistered audit compares English and Spanish state and instruction combinations for Jev on paired human-labelled datasets. The repository publishes the runner, frozen prompts, response-derived results and a CLI for repeating the protocol on other labelled data.
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 Chrome side panel discovers WebMCP tools exposed by the current page and uses Jev to predict a tool and its arguments from the user's input. Questions are derived from the tool schema, including choices, booleans and spans of the user's own words.
Split like gpu-lexer, classify every token with Jev, render Shiki-compatible tokens to HTML and ANSI — a language-agnostic highlighter, experimental only.
Born from Claude Code changing an auth check to return true with tests still passing: eight risk axes scored by Jev in one request, with one optional re-inspection before the agent declares done.
A deterministic restaurant simulator that replays the same seeded dinner under rule-based, camera-assisted and Jev-planned service. Servers choose from feasible task tours, and the app logs the observations, candidates, confidence, latency and resulting service metrics.
A Minecraft agent that plans with Astra and lets Jev control step-by-step actions, with native recording, tested routes and run verification; the Jev decision rules live in models.mjs.
A drop-in for TypeSafe's API powered by a 400M GLiFormer model; point the official SDK's base URL at it. Deploys on Modal or CPU via ONNX Runtime and ships a bench folder.
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 Jev-style decision model built on IBM Granite 4.1 3B with an RHCD training recipe — 'when's IBM or Red Hat going to build their own Jev? I got it for them.'
A Redmine plugin that asks Jev, while you fill in the form, whether the chosen tracker matches the title and description, using the project's recent trackers as options.
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.
Jev routes each ticket to a specialist agent (general / account / billing / technical) and decides whether a human should take it instead — all typed — while Cerebras writes the reply.
Adds `jev()` semantic predicates to plain Postgres through a CLI, HTTP and SDKs, with a SQLite cache and an `--explain` cost preview; a playground is hosted.
A 3D football match in which Jev selects each player's intent from locally generated candidates. Geometry, physics and reflexes stay in code; a tactics board and JSON inspector expose the options, probabilities, chosen actions and fallback policy.
The ielab document-ranking toolkit gained a jev module, with code that uses TREC human relevance judgments to test whether Jev's probabilities are actually calibrated.
GitHub Next's 'poor man's Jev': a Jev-compatible local API built in a morning on top of DiffusionGemma (swappable via config), so team members without Jev access can run the same call shapes locally.
A portable agent plugin and MCP tool for batch text classification: the agent asks Jev whether a file is worth reading, a tool worth calling, a website worth browsing — before spending tokens on it.
A proof-of-concept MCP server exposing three tools: verify a claim against evidence, screen text for injection or relevance, and rank candidates semantically.
An X Article roundup of early projects: jev-ultrafast, jevlike, mini-jev, reflex, awesome-jev-by-typesafe, the Every vibe-check test and several video demos, with the official docs and use-case map linked.
A bring-your-own-key API with /v1/scan (prompt injection, jailbreak, credential leaks) and /v1/moderate (nine categories) returning calibrated probabilities; free tier live.
Outgoing relationships become choices, Jev returns next-hop probabilities, and a beam search walks the graph; shipped as a library, notebooks and a Streamlit app on Neo4j's public Companies knowledge graph.
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 DuckDB extension with jev_choice(), jev_score(), jev_noul() and jev_ask() returning real SQL types, batching 16 rows per request and caching identical queries.
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 CLI evaluates Jev against labelled application data, chooses per-question thresholds on one split and checks them on held-out examples. It writes a threshold lock and report, supports low-confidence fallback, and fails CI when accepted accuracy or coverage drifts.
Reimplements a System One decision model on Gemma 3 270M with a LoRA of 2.6M trainable parameters, scoring all options in one forward pass; trains in a free Colab and ships weights in the repo.
Constrains token selection to choice indices so any open LLM answers many questions in one pass; includes Doom and Wikipedia-racing demos on Qwen models.
An experimental browser harness for the original Civilization II that asks Jev to choose empire, city, research, diplomacy and unit actions. It records player-visible observations and model probabilities in a spectator display.
A Three.js drone simulator that uses Jev through the Vercel AI SDK provider. Code calculates flight telemetry and describes the situation; one model request chooses the four stick axes and whether to commit to landing or stop the motors.
A Go controller uses Jev to select native macOS actions from Accessibility observations provided by a persistent Swift worker. Closed target tokens keep selected actions tied to the current app and window state.
Upload a research-paper PDF; text is extracted in the browser, split into roughly 1,000-word passages, and a fixed set of small questions is asked per passage in parallel, then combined into weighted scores.
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.
Sits between MCP clients and servers with three layers: structural allowlists, semantic hazard detection via Jev, and session taint tracking; targets poisoned tool descriptions, injection, exfiltration and secrets.
A Chinese X Article sorting the early ecosystem into things that actually ship: jev-ultrafast, mobile-jev, typesafe-computer-use, AskJev, a Twitter timeline analyzer, a tax-document classifier, jevdetector and newsjack, plus the OpenRouter and DataCamp explainers.
A text game where you talk your way past a border inspector whose actions are chosen by Jev from your typed replies; dialogue and consequences are authored game code, Jev only decides.
An experimental protocol where a worker agent sends requirements, code and test results to Jev, which returns an evidence verdict for the team-lead agent before results are accepted.
A small archipelago flight simulation that asks Jev about diversion, emergency broadcasts, traffic response and approach clearance. A tower decision orders waiting aircraft, while ordinary code enforces runway occupancy and the monitor exposes API exchanges and usage.
Pydantic AI merged a TypeSafe model provider: `TypeSafeModel('jev-latest')` with confidence thresholds, a FileUnderstanding capability and fallback to an LLM for tool calls; docs cover jev-latest, jev-preview and pinned releases.
Validates state locally with Zod-style schemas, bundles all questions into one parallel Jev request and projects typed answers; built on the official SDK.
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 framework comparing hosted Jev with a local GLiNER2.5 on zero-shot single-label classification (AG News, Banking77, DAIR Emotion) for accuracy, calibration, selective-automation coverage and latency, with bootstrap intervals.
An open replica trained on 92 public datasets plus synthetic generators, on Gemma 4 E2B (LoRA) and Gemma 3 270M, served via FastAPI on Modal with a live demo.
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 Pi extension exposing TypeSafe judgments as five tools (choice / bool / score and friends) so the model makes narrow semantic calls while your code keeps thresholds and weights.
An OpenAI-compatible router that uses Jev to pick a model on top of LiteLLM, filtering candidates by capability and falling back to the cheapest model without a TypeSafe key.
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.
An async LangGraph workflow that classifies mock emails (invoice versus general) with the Choice primitive and routes them to handlers, with unit tests; pins jev-1.12.
Jev scores file and folder names so an ensemble of walkers is allocated across the most probable paths; a Bun CLI with recursive and multi-walker modes and JSON traces.
A Rust crate with enum responses and confidence, async or blocking backends, batched questions and observable retries; examples cover PR questions and semantic search.
A harness for the original StarCraft shareware campaign that gives Jev structured visible game state and executes its choices through keyboard and mouse inputs. The release includes a probability-overlay video and an inspectable run bundle.
Jev picks NES controller inputs from object-centric JSON telemetry rather than screenshots, choosing among seven legal actions and logging latency and probabilities per decision.
Last push records repository activity across branches and tags. Release announcements and descriptions of individual changes need their own sources. Dates are shown in UTC; “Metadata checked” belongs to that repository alone.