Browse builds

Tried using Jev to check what an agent should remember We've been trying Jev for agent memory, mostly to catch cases where the saved note says more than the original conversation did. Think "we might use Postgres" turning into "we chose Postgres." Once that gets saved, the next conversation starts from a decision nobody actually made. We gave Jev the original text and a proposed memory, then used its judgments to decide whether to save it, skip it, or leave it undecided. We ran the same setup with Luna as a comparison. On 100 synthetic cases, using a .40 cutoff, Jev kept 39 of the 50 memories labeled worth keeping. Luna kept 41. Neither saved a candidate labeled skip or defer. Median gate latency was 250 ms for Jev and 1,593 ms for Luna, including network time. Then we checked what happen

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

🤔 Where do #Jev and other "Decision Models" fit into your current agentic or non-agentic pipelines? The short answer: anywhere you might have LLM calls with a #pydantic model or json schema to type-cast your raw data into structured categories, Likert-scale numerical scores, or true/false decisions. I ran three benchmarks with @flyteorg on https://t.co/WczbNQoVLn in the context of three use cases: - Customer support - Code review - Legal contract review In all three cases, using Jev was faster (up to x2.6) and cheaper (at least x10) with no loss in quality compared to using a "System 2"

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

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).

Open probability decisions with Qwen3.5-2B, Qwen3.5-9B and Qwen3.8-27B.

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

DiffusionGemma NVFP4 structured decisions on a DGX Spark: container recipe No repository-level license file was found during review.

The open, local take on Jev: typed decisions from an LLM, without generating a single token

Type-safe Java 21 client for the TypeSafe AI Jev (System One) decision API

Self-hosted Jev-compatible System One server backed by GLiNER-family models, with batching and typed question support.

Adapter that turns local language models into Jev-style Choice, Score, and Noul decision engines with typed probabilities.

Local Jev-compatible System One API that converts typed questions into DiffusionGemma classification prompts and probabilities.

Open-model Jev-style server that reads next-token logits to return typed choices, rubric scores, and truth judgments.

Pi extension with a batched Jev evaluation tool, terminal playground, and typed API for other extensions.

Jev-compatible API server built on open models and SGLang, with prefill-only inference and typed decision endpoints.

Trainable family of small Qwen-based Jev-like decision models with typed primitives, datasets, evaluation tools, and local inference.

I gave 12 residents the ability to gossip. Whisper “Free Coffee in cafe for next hour” to one person. Watch the 12 resident rush to the cafe shop. Built with Jev. Try your own rumor: https://t.co/KsNhS9DG5U https://t.co/Io8KfbNKKa

i genuinely don't understand why anyone is using combo of "Jev + Polymarket" as trading router. i just built jev layer with agenkit in my trading system that gave me edge to create alpha. i am openly leaking the cheatsheet. Bookmark before it's too late and start using Jev in your trading system.

Been experimenting with using jev as an attention layer over code retrieval. On 356 held-out SWE-Explore tasks, adding Jev reranking to the same 100 zvec candidates improved core recall@1k lines from 11.96% → 22.95%. More here: https://t.co/ZNp3AnD8Bn #jev #TypeScript

Jev the Band: I made a jam band using jev. (🎧on) I taught jev how to read and write music Guitar, Bass, Drums, and Keys controlled by jev lights controlled by Jev soundboard, yup, it's Jev I've been obsessed with recording Jev's jams this weekend and now I'm sharing them with you

A fully autonomous real-time trading bot built with Jev in one evening and morning, ingesting onchain and offchain data for rapid decisions, has lost $31,680 so far. https://t.co/lYAShIq9cg

A tiny open source browser agent using Jev instead of an LLM for every click. Found a flight search in 7 SECONDS. Total cost: $0.0039. Here's why that's not a typo. A normal browser agent asks a chat model "what should I click" on every single step. That's a full generation call, just to pick a button. Mine doesn't. The DOM state at each step becomes the input. Jev gets the available actions as a typed choice question. It picks the action, not by generating text, by classifying against what's actually on the page. The only place a language model still runs is typing free text into a fie

Community Go client for the TypeSafe System One API with typed question builders, retries, examples, and jev-latest as the default model.

Anyone else playing with JEV? Feels like that’s all I’m seeing today 😅 I built a small PoC using JEV as a pre-screening step for reverse engineering, before sending the APKs to an LLM for deeper analysis. The flow is pretty simple: `APK → static analysis + Quark → JEV → score → reverse or skip` The goal is to avoid burning LLM tokens on samples that don’t really warrant deeper reversing. It’s still early, but the token savings are already pretty interesting when you’re triaging a bunch of samples. #Reversing #LLM #JEV #Malware

Okay so we also built something else. So we are using @Muse & @typesafeai Jev together now. I’m using Jev to grade my AI assistant Sarah on her own work before I ever see it. So (Jev by Typesafe) will act as the judge. Every caption draft gets scored against my actual writing voice: my hooks, my outro style, my banned words, all of it. And It's bigger than captions. Before she states a fact, the judge checks it against her own records, it caught a wrong number tonight before I saw it. Before she acts on a vague instruction, the judge decides: act, or ask me first. A checklist that never

using Jev to score 2,952 museum objects on "is this architecture?" https://t.co/GaJgJtMvdb

I found the "Internet" moment in using Jev Jev analyzed every LLM and chose the BEST-VALUE one for each prompt It cut my costs and time by ~80% - and it’s probably the best way to use Jev... here's how to setup it in 10 min: step 1 → open @typesafeai , create API key (keep it off chat paste) step 2 → store TYPESAFE_API_KEY in a local .env step 3 → clone the Github below, then npm install && npm test && npm run demo step 4 → test Jev before connecting an agent: npx tsx sdk-runner/cli.ts --route-only "Rename a button label" step 5 → dry-run first: npx tsx sdk-runner/cli.ts --dry-run "you

i've built an extension for twitter that ranks every tweet by relevance based on your interests using @typesafeai 's Jev, highlights very recent tweets to maximize engagement and assesses your tweets based on your goal (also using Jev) should I open source it? https://t.co/GgQjTT2NWy

I wanted to post a preview of our Jev benchmark dropping tomorrow. We are using Jev to generate symbolic programs (state machines) through an iterative process. The results so far have been amazing! The old process took ~2–10 seconds. With Jev, it’s ~0.3–2 seconds. The costs have also dropped by an order of magnitude. Jev is also used in control flow, removing the need for brittle heuristics.