Browse builds

Jev: a "System One" model that only makes decisions, $0.042 per million tokens with output free. 40-second explainer of why it matters for automation Jev launched on Sep 15 from TypeSafe AI (founder Diogo Almeida, ex-OpenAI, credited on ChatGPT/InstructGPT). It does not generate text; it returns typed decisions (Choice / Score / true-false) with confidence. Price is $0.042 per million input tokens, output free. In its first week it became the fastest-adopted model on Vercel's AI Gateway, TypeSafe paused signups on Sep 22, Browser Use released jev-ultrafast (a web agent where Jev picks each action; Google Flights search in 7.1 s), and jaredpalmer/kev is an Apache-2.0 clone built on Qwen3.5 you can run yourself. My take in the video: the expensive part of automation was never the writing, i

There's a new AI model that refuses to talk. While everyone debates what a "decision model" is even for, builders already shipped the answer. 7 things people built with Jev in 9 days. Number 5 broke my brain 👇

I loved this idea so much that it deserves a share ❤️ I recently asked people to share what they’ve built with JEV, and then this guy 👤 shows up with an entire website dedicated to different JEV use cases! That’s honestly pretty cool. If you’re curious about JEV and want to see how it can actually be applied, definitely check this out. Huge shoutout to Animesh Mishra (@thatcasualvc) for the wonderful share 🙌 This is exactly the kind of stuff I love seeing from builders. 🚀

I built a Jev-based model router for Pi for automatic model selection When Jev came out, one of my first thoughts was: could something this fast and cheap pick which model should handle an agent’s next turn? So I built plugin for Pi that uses Jev to choose the model and thinking effort. The idea is to send routine work to cheaper models and reserve the expensive ones for harder tasks. In Pi, the model mappings are configurable, and you can pin a model when you disagree with the router. I’ve been using them for a few days, and so far they’ve been working well for me. In my own evaluation, routed usage came to $141 at list prices versus an estimated $166 for Opus 5.5 on every request - about 15% less. That’s one developer’s data, though. The baseline is a pricing comparison, not a separate

Site search that recalls candidates locally, then uses Jev to score and rerank them.

Probability-tree and graph runtime for verifiable multi-step Jev decisions.

Local Jev-compatible typed decisions from unstructured state in one forward pass.

Local Jev-compatible proxy that learns an application’s typed decisions and serves them with a Laya head.

Training and inference stack for calibrated Jev-style choice models with dynamic candidate sets.

Open visual decision model that encodes an image once and answers multiple structured questions.

Solar Mini–based local model for Jev-style typed decisions.

Open-weight Jev alternative that returns typed decisions with probabilities in one forward pass.

Open-model semantic-if engine for local Jev-style decisions.

Go SDK and CLI for TypeSafe Jev typed yes/no, Choice, and Score decisions.

Swift client for TypeSafe Jev typed judgments instead of generated text.

npm install is the scariest command in your terminal. One typo → lookalike package → malicious postinstall → secrets gone. jev-sec-audit flags it in milliseconds using Jev, a System 1 model built for fast decisions, not chat. One step in GitHub Actions. Open source. https://t.co/PhC7TLRwCt

Built a tool that searches Google Icons using JEV (Laya-MLX) Should I publish it? 👀 https://t.co/97qw7oIkOt

I built an app that uses Jev to classify your entire query workload and tell you which queries to EXPLAIN ANALYZE first I posted here last month about RDST, the free desktop app that runs the slow query to EXPLAIN to index recommendation loop. The biggest change since then is what happens before EXPLAIN. When a database has thousands of distinct query shapes, you can't EXPLAIN ANALYZE all of them, and sorting queries by their performance doesn't always tell you which ones are actually badly written. RDST now answers that with Jev, a small classification model from TypeSafe that answers fixed multiple-choice questions about a query in a fraction of a second. Every query shape it discovers gets classified from its SQL and the schema, without executing anything, on five structural questions:

we're sponsoring https://t.co/QMtLnAp5i5, the gallery of everything built with jev by @kraayenjon. #2 on the board, right next to @openjevai . if you built something with jev, it belongs there. and on https://t.co/ac59bsQKFk. https://t.co/Bg1mMNCjnF

Built an AI slop finder for @X using Jev @typesafeai . • Tweet → Content script extracts text • Text → Backend API → Jev • Jev → AI-slop score • Score → Badge displayed on the tweet #jev #aislop #newmodels https://t.co/VMzJA1Tyde

I used Jev to make Claude actually follow my CLAUDE.md, checked on every turn in ~350ms CLAUDE.md is context, not a constraint. It holds for a few turns, then a handler shows up with raw SQL in it and a failing test quietly becomes it.skip. Nothing checks the output against the rules you wrote. So I added the check. A Stop hook takes the final reply, a PostToolUse hook takes each edit, and every rule in your CLAUDE.md becomes one typed yes/no question in a single Jev request. All rules answered in parallel, anything over the threshold goes back to Claude with the rule quoted, and it fixes it in the same turn. Benchmark (59 labeled examples, 19 rules): 93.3% precision, 93.3% recall, 348ms p50, ~$0.045 per 1,000 checks. What it's bad at is in the repo too: exact characters, dataflow rules l

Have been wanting to try Jev from typesafe AI all week. hopefully we will get some time to do so this weakend. What have you built with Jev? Info dump us please.

How we're using Jev frrom @typesafeai at @knowyourcompani - Rendering exact citation on a document page -> upgrade from chunk box mapping to more precise citations https://t.co/5pUBxNcLS7

This might be the most useful thing I’ve built with Jev so far. A Chrome extension that quietly analyzes what I’m seeing and classify them as Opinion, Engagement bait, etc... So clean you may think it is a new feature on X :) https://t.co/POUtFhxGkD

Workbench that converts Chat Completions requests into editable Jev State and Questions, compares text generation with typed judgments, and exposes reusable proxy routes.

Configurable semantic linting powered by Jev, with file-level NOUL judgments and a magic-strings plugin.

Jev-powered relevance filtering and reranking for RAG in Python.

Probabilistic control flow for Ruby and Rails - powered by TypeSafe's Jev.

Ask typed questions about text or JSON and inspect model-derived probability distributions in a browser. One container runs the model, the original Decision Lab explorer, and a TypeSafe-shaped API.

Run Jev-style typed decisions locally on your Mac with low RAM usage and fast responses.

Run SemIf (Jev-style semantic-if decisions) on a CPU — no GPU. Reads typed option probabilities straight from an open model in one forward pass, plus a web UI.

Super fast Jev like server, model agnostic, working with any OpenAI compatible endpoint.

open-jev is a browser-focused TypeScript library for typed decisions: one piece of text (the state) plus any number of typed questions go in, and one forward pass returns a calibrated probability distribution per question. Nothing is generated, so an answer is always one of the options you provided.

Supersimple way to serve LLMs as a Jev-like endpoint.

Jev-style structured decisions on DiffusionGemma: the example server from vLLM PR 57250.

Open reproduction of TypeSafe Jev: a 150M typed decision engine (noul/choice/score in one non-autoregressive pass, calibrated confidence). 0.697 vs Jev's 0.727, 2.5x better calibrated, 4x faster, free. Trains on a Colab T4 in 30 min.

Train small, insanely fast local classifiers from Jev-compatible examples. Run locally in your browser or Node.js.

Turn any LLM into a Jev-style decision model: typed decisions, real probabilities, no training. (continue updating).

Run Laya, the open-source Jev-compatible System-1 decision model, from Node.js / TypeScript via ONNX Runtime.

TypeScript library that maps Jev Choice, Score, and Noul questions onto classification, ranking, extraction, verification, and array workflows.