A PPO-trained reinforcement-learning decision brain for the CONNECT TYCOON company simulator from CONNECT AI LAB: it runs staffing, inventory, marketing, refund and security judgments and answers in the JEV request format with probabilities.
A 6.5M-parameter independent chess policy model built from Jev's public description: it returns a calibrated distribution over legal moves in one forward pass, with a self-reported held-out top-1 of 36.5%, ECE 0.036 and Elo 1239 plus or minus 51.
mradermacher's static GGUF quantizations of IqSantiagow's 0.8B edceleste decider for llama.cpp, from Q2_K (0.5 GB) to f16 (1.6 GB), with Q4_K_M and Q4_K_S marked fast and recommended; no imatrix quants are planned by this quanter.
Mapika's vision decider: decider-2b v5 text weights transplanted into the Qwen3.5-2B vision-language model, tuned so an image plus a lettered question returns a calibrated probability at one answer slot with no generation. Breakout from pixels scores 41, above its teacher's 22.
Makes NPCs in games talk back: skills, a self-hosted Fish Audio voice server and tools that let a coding agent wire up in-character dialogue, with TypeSafe Jev picking each NPC action and a full GTA V example.
An open-source turtle-soup (situation-puzzle) game where Jev hosts: every yes, no or irrelevant answer and the final verdict on a reconstruction come from Jev live, with confidence gating a cannot-be-sure reply. Single-player, 8-player rooms and UGC submissions.
Pac-Man where the characters are driven by System One decision models: TypeSafe's jev (typesafe/jev-1.13.0, the default) and others Opper serves, with the model's odds drawn on the board and a leaderboard benchmark.
A Korean-language reinforcement-learning game that trains a company decision model: it reads a situation, a question and options, then answers with a choice plus probability and confidence, and asks a human when unsure. Built for a CONNECT AI LAB class; Apache-2.0, Python and Pygame.
An inhabited science-fantasy take on Houston's River Oaks District with mapped streets, boutiques and residents — NPCs powered by Jev per the repository description. Play as Jevica in third person, fly her bubble, and use Camera mode to compose and share photos.
A mineflayer-based Minecraft bot whose decisions are made entirely by TypeSafe's Jev System One model: code lists the legal actions and Jev picks one in about 0.2 seconds for roughly 1.7 cents per bot-hour. Fifteen of 40 fresh worlds reached the Nether; none has beaten the game.
A Python experiment that lets TypeSafe's Jev play Factorio from screenshots alone: each tick the vision model looks at the screen, decides, and presses keys or moves the mouse, aiming to craft 10 automation science packs from a fresh freeplay game.
A Super Mario Bros agent whose only brain is a remote vision model on the other side of an API: screenshots in, button out, and no memory peeking. It runs on the OpenAI Decisions API by default and supports TypeSafe's Jev (jev-preview) as an alternative.
An experimental Factorio agent in which Jev chooses goals and actions as typed questions while deterministic code owns the game rules and actuation; an offline mock loop runs with no API key and no game copy, with live and hierarchical modes documented.
A real-time 3D runner game where up to six decision models race each other: each model answers one move at a time at its own speed while the world keeps moving, and the last runner standing wins.
A one-hour, six-step workshop built around a fighting game that teaches TypeSafe's Discriminative (Jev) decision model and puts it next to Gemini in a Google ADK workflow. It runs in Cloud Shell or anywhere signed into gcloud, with hosted Jev, a local DiffusionGemma VM, or a rehearsal stand-in.
A benchmarking studio and real-time simulator that pits Jev (remote TypeSafe System One), a local Laya model and the optimal blackjack Basic Strategy against each other on identical deterministic shoes. It scores every deviation turn by turn and runs headless batches of up to 100,000 rounds.
A four-step experiment asking whether Jev, a fast model that picks among named options, can act as the policy in StarCraft multi-agent micro (SMAC), comparing every step against baselines that had the same information but no Jev.
A French 3D browser defense game used as a test bench for decisions under uncertainty: JEV (TypeSafe AI) estimates from a text description whether a silhouette is a zombie or a survivor, and deterministic code decides whether to shoot.
A Bun workspace pairing a typed decision API over System One providers with a React arcade where decision models play games and every call is stored and ranked. The sample code calls Jev through OpenRouter with boolean, choice and score questions.
A browser playground where N drones fly on one shared 16x11 grid, each controlled by a System One decision model through OpenRouter. Mock mode runs with no key, and every rule number is editable in the panel without code changes.
A browser Crossy Road clone where you play with keyboard or touch, or hand the controls to Jev (TypeSafe jev-latest) and watch it play live. Jev reads a structured screen description, never pixels, and picks one of five actions.
A browser game for exploring fast, structured decisions with Laya: play the bird yourself, race a rule-based baseline, or watch a real decision model choose between flap and wait on seeded pipe sequences.
A small, mechanics-free System One decision core for game NPCs: the adapter supplies an observation and opaque legal actions, and a scripted or Jev provider picks one, with a deterministic offline provider for tests.
A real-time alien shooter whose player is driven by Jev System 1: instead of hard-coded movement and shooting logic, the AI reads the game state and makes deterministic picks between left, right or stay, and between firing or holding fire.
A multiplayer, cross-platform terminal RPG that implements the Jev System-One decision engine as tri-state stochastic dice, with a shared terminal session across PC and mobile and bring-your-own-compute through Edge, Ollama, WebLLM or cloud keys.
Sol vs Jev in a Clash Royale-style tower battle where every move is a real model call through OpenRouter and the clock keeps running while a model thinks; Jev (typesafe/jev-1.13) beat the frontier model 3-0 at far lower cost per decision.
Tiny System One decision models trained from scratch in Rust with MLX on a MacBook and played live in the browser via WebAssembly: s3-pico packs 445k parameters into a 251 KB ternary file and decides in about 50 microseconds per frame.
The documentation site for OpenDecision, an open-source decision engine that runs locally and answers typed questions about text, JSON, documents and images, exposing Python, HTTP and TypeSafe-compatible interfaces with Choice, Noul, Score and Relation primitives.
A 3D chess game played against TypeSafe Jev, described as realistic and mobile-friendly with Beginner, Pro and Legendary levels, free in the browser. Only the page's metadata could be recovered; the game itself is client-rendered.
A community re-upload on ModelScope of NanoJev, the 0.6B Qwen3-based parallel decision model: full probability distributions over 2-255 dynamic choices in one batched forward pass with zero output-token decoding, approval-gated and license-free.
Agent tooling that turns a model idea into a buildable LEGO model: the agent writes a plan and a generator script that produce LDraw source, plus a 3D viewer, a Blender-editable glTF file and a Meta Quest 3 VR view. Part search uses jev-rerank, a semantic search reranked by TypeSafe's Jev.
A playable Three.js driving simulator where Jev-powered autopilot picks steering and speed up to four times per second: compact tables of eligible paths, traffic and road boundaries go to Jev while geometry and control math stay local.
A Python benchmark that evaluates LLMs' reasoning and instruction-following by making them play chess against a random player or the Komodo Dragon engine in multi-turn dialogs, separating chess skill from protocol durability.
A MoonBit and TypeScript playground for Jev: an API client for noul, choice, and score questions, a single-question CLI, Jev-vs-Jev gomoku with real-time GIF replay, and experiments like an ESLint plugin whose verdicts come from Jev.
A Three.js first-person garden game where a glowing fly hunts goblins and TypeSafe's Jev steers: about five times per second it answers four typed questions on turning, sidestepping trunks, climbing and diving, and every flight is logged.
ProphetLab's Texas Hold'em benchmark and playground for decision models: separate cash and sit-and-go leaderboards, hand replays, a Jev-backed advisor, and bring-your-own-agent tables, all with virtual chips.
Browser-only Laya demo suite: four Vite apps — a Traditional Chinese decision playground, Gomoku, Big Two and a 3D maze — run the Laya ONNX model on-device through Transformers.js, downloading fp16 weights from Hugging Face on first use.
An autonomous ViZDoom agent that decouples Doom's simulation from Jev SystemOne inference: the game runs at 35 ticks/sec while Jev is queried asynchronously at about 10 Hz for macro goals, targets, movement and firing decisions.
A pygame Flappy Bird that hands the bird to Jev: each new pipe becomes one multiple-choice question about simulated flight paths, and Jev answers with a typed choice plus a probability distribution.
A harness for evaluating TypeSafe Jev as a policy in Gymnasium and Atari environments: adapters turn observations into structured JSON and Jev picks a legal action through a single Choice question, with no training.
Autonomous gaming agent pairing Laya's local sub-30 ms System One inference with TypeSafe Jev Choice, Score and Noul decisions. Plays Windows PC games with hardware scan codes and Android games through ADB touch injection.
A playable Tetris where Jev never sees the board: code enumerates every legal placement as a sentence and Jev returns a probability for each in about 380 ms. The field glows with the whole distribution before the piece drops.
A runnable reward-model laboratory that trains DQN agents on CartPole, MountainCar, Acrobot and FrozenLake with official JEV scores as rewards: 36 runs across 3 seeds and 3.24 million steps, with checkpoint replays and a recorded JEV cost of about $0.00241.
TypeSafe's Jev plays the real Steam game Vampire Survivors - it picks the character, stage, every level-up and the walking direction four times a second, with a live decision dashboard. A BepInEx plugin and Python brain; native Linux only.
A demo that walks a real Pokémon FireRed ROM: the code reads the overworld out of RAM, works out every reachable destination, and Jev picks where to go — and how to fight wild encounters — through typed decisions, not screenshots.
Live demo of Jev playing Flappy Bird: about twenty times a second the game asks one question, flap or wait, and applies Jev's choice exactly as returned — no thresholds, no backup rules, no retries.
TypeSafe Jev plays NetHack 5.0 with no LLM in the loop: each turn the code lists the legal moves, Jev picks one as a choice question, and a small motor translates the answer into keystrokes, with a live dashboard and Hardfought support.
A public operator lab for TypeSafe Jev: a chess match as the flagship page, a row of smaller judgment booths, and one shared client that keeps the API key out of the browser via a local Python server or a Cloudflare Worker.
A use-case directory of 838 Jev builds across 21 use cases where each entry links to its source and shows the cost and speed its author reported, with category filters and free tools.