Skip to content
JevFinder
Submit
← Back to All builds
Ecosystem

Tools Built with Jev

SDKs, MCP servers, routers, Chrome extensions, and developer primitives powered by Jev's fast decision layer.

youtubeLive demo

Jev is HERE. How to use it

Guide·youtube.com/@GregIsenberg

Decision: Evaluate input state and return typed decision for Jev is HERE. How to use it.
Sub-100msSource
youtubeLive demo

wtf is jev?

Guide·youtube.com/@syntaxfm

Decision: Evaluate input state and return typed decision for wtf is jev?.
Sub-100msSource
youtubeLive demo

Livestream: coding with Jev

Guide·youtube.com/@avb_fj

Decision: Evaluate input state and return typed decision for Livestream: coding with Jev.
Sub-100msSource
youtubeLive demo

Build anything with Jev

Guide·youtube.com/@DavidOndrej

Decision: Evaluate input state and return typed decision for Build anything with Jev.
Sub-100msSource
youtubeLive demo

Jev AI just dropped

Guide·youtube.com/@Itssssss_Jack

Decision: Evaluate input state and return typed decision for Jev AI just dropped.
Sub-100msSource
youtubeLive demo

It really is. No joke.

Guide·youtube.com/@maximilian-schwarzmueller

Decision: Evaluate input state and return typed decision for It really is. No joke..
Sub-100msSource
youtubeLive demo

I tested the new Jev model

Guide·youtube.com/@albertolgaard

Decision: Evaluate input state and return typed decision for I tested the new Jev model.
Sub-100msSource
youtubeLive demo

I paired Jev with Astra

Guide·youtube.com/@TheHunterBohm

Decision: Evaluate input state and return typed decision for I paired Jev with Astra.
Sub-100msSource
youtubeLive demo

Jev: full tutorial

Guide·youtube.com/@promptwarrior

Decision: Evaluate input state and return typed decision for Jev: full tutorial.
Sub-100msSource
xpostLive demo

Hide posts on X in plain language

I built a browser extension with Jev @typesafeai that can hide/collapse posts on X based on natural language. It's so fast that it's not noticeable and insanely cheap...this must be the future of "ad blockers" and content firewalls.

Decision: Evaluate input state and return typed decision for Hide posts on X in plain language.
Sub-100msSource
xpostLive demo

What Jev is, and the businesses it unlocks

Jev is HERE and this is the CLEAREST explanation of what it is and what NEW businesses it unlocks. (and at the end I'll tell you how to get Jev even if you're on the waitlist) WHAT IT IS You know how you open your inbox and have to decide what's junk, what needs a reply, and what can wait? Jev does that part. It looks at each thing and says "this is junk, I'm 94% sure." It doesn't write anything back to you. It just sorts. 1,700 emails for 18 cents, instantly. That sounds kinda trivial but the important part WHAT IT UNLOCKS My explanation of Jev sounds small until you realize HOW MANY jobs are exactly this. Someone reading a stack of applications. Someone deciding which support ticket goes to which team. Someone looking at inbound and deciding who's worth calling back. A few ideas on what it unlocks: 1/ Instant quotes that are actually instant. Every quote form on the internet says "we'll email you by end of day." Build the version that answers in under a second, for roofers, movers, insurance, legal intake. 2/ Lead scoring as a product. Every agency and service business has a contact form full of junk. Score every submission and send the real ones straight to the owner's phone. 3/ Support triage for companies with no support team. The ticket gets classified and routed before anyone opens it. 4/ Clipping tools. Pass in a transcript, get the best moments scored in three seconds. Every clipping product just got a cheaper engine. 5/ Application piles. Grants, permits, insurance claims, job apps, loan docs. Someone reads that stack one item at a time today. 6/ Marketplace matching. Someone types what they need and gets matched to the right local business instantly instead of waiting for callbacks. 7/ Browser agents that actually move FAST. That makes bulk browser work practical: pulling quotes from five carriers, filing the same form for 200 clients, checking supplier inventory in real time etc. TLDR; find an expensive queue and put Jev at the front of it. HOW TO GET IT I didn't realize you can skip the waitlist because Jev is live on the Vercel AI Gateway right now, so you can start calling it today. In this episode, we share how. Episode now live on @startupideaspod (thanks to @ryanvogel for coming on and spilling the sauce today) Watch: https://www.youtube.com/watch?v=4mTLpuQpB80 Jev is a big deal because this is a whole new way to do AI Really cool Happy Jev day.

Decision: Evaluate input state and return typed decision for What Jev is, and the businesses it unlocks.
Sub-100msSource
xpostLive demo

Instant compaction for Claude

found the perfect use case for @typesafeai Jev: instant compaction in 2026, why is compaction still a summarization prompt? Jev can make it instant by scoring every tool call and dropping what’s irrelevant

Decision: Evaluate input state and return typed decision for Instant compaction for Claude.
Sub-100msSource
xpostLive demo

jev() for PostgreSQL

I think I just cooked something 🔥 jev(): a PostgreSQL extension that searches your whole database in natural language. No index, no embeddings, just one function. WHERE jev(people, 'could work from home') or WHERE jev(people, 'name sounds european') 129 rows judged in ~1s for $0.0009. Second run: 6ms from cache.

Decision: Evaluate input state and return typed decision for jev() for PostgreSQL.
Sub-100msSource
xpostLive demo

jev-review

built `jev-review` @typesafeai it's an experimental, local-first MCP plugin that gives coding agents a score quality feedback loop across different metrics. agents call jev while they work, get scored, make improvements, and repeat the loop try below 👇

Decision: Evaluate input state and return typed decision for jev-review.
Sub-100msSource
xpostLive demo

Keystroke oracle

Also have been playing with @typesafeai Jev, insane! So many immediate use cases and new apps are possible. What a time to be a builder! Sharing some experiments here starting with: Keystroke oracle / predictive launcher: Your launcher ranks by aliases, fuzzy match, and habit. Jev reads intent: type "the pdf I just downloaded" and the newest PDF is already the top hit with a full confidence on every keystroke, in ~100 ms

Decision: Evaluate input state and return typed decision for Keystroke oracle.
Sub-100msSource
xpostLive demo

Jev Calc

i made a smart calculator notebook using jev it can calculate ANYTHING!! 😅

Decision: Evaluate input state and return typed decision for Jev Calc.
Sub-100msSource
xpostLive demo

Hard-coded rules moved to Jev

Now using @typesafeai Jev in http://aiseotracker.com, http://linkdr.com, http://genppt.com, etc AI ends up vibe coding so much AI regex slop if you don't read the code, so I can finally move all this hard-coding to Jev and it's insanely fast! Also for regular LLM calls, it is around 10x faster, 50% cheaper

Decision: Evaluate input state and return typed decision for Hard-coded rules moved to Jev.
Sub-100msSource
xpostLive demo

Predictive spreadsheets

Another crazy @typesafeai Jev example: Predictive spreadsheets Spreadsheets recalculate numbers, not meaning. Jev reads intent. Type "Urgency" at the top of a column and, as you type, it figures out you want each row rated from "no follow-up needed" to "urgent" in ~100 ms.

Decision: Evaluate input state and return typed decision for Predictive spreadsheets.
Sub-100msSource
xpostLive demo

A real-time ad blocker

I build an undetectable realtime adblocker extension with typesafe It checks every dom element and classifies as ad/non-ad and removes it if true Extremely fun to work with, expecting an incredible shift in how AI is being used in the future

Decision: Evaluate input state and return typed decision for A real-time ad blocker.
Sub-100msSource
xpostLive demo

One-click invoice finder

Jev is fun! One-click invoice finder for any website 🧾 - Automatically finds billing pages using @typesafeai's Jev - List/download all invoices with 1 click - Works with Stripe billing portals too - Remembers where invoices live for next time Should I open-source it?

Decision: Evaluate input state and return typed decision for One-click invoice finder.
Sub-100msSource
xpostLive demo

A Downloads folder that sorts itself

Jev unlocks SO many awesome new ideas. I built a macOS app that monitors my Downloads folder along with a customisable set of rules. Is the downloaded file an invoice? Move it to a special folder with the correct filename. No other LLM calls involved - just Jev!

Decision: Evaluate input state and return typed decision for A Downloads folder that sorts itself.
Sub-100msSource
xpostLive demo

Real-time Clippy

I built real-time Clippy with Jev. It quietly watches how you use the product and only wakes up when it thinks you’re struggling. Hesitating? Confused? Stuck? Clippy knows. Even its reactions are controlled by Jev. 👀

Decision: Evaluate input state and return typed decision for Real-time Clippy.
Sub-100msSource
xpostLive demo

An always-on assistant with no wake word

Ai is evolving. Jev can be armed at all times. I can speak freely and it knows ( from probabilities ) if im asking my computer to do something or blaberring away at something else. no wake word. speed + affordability + intelligence is getting to the point where an always on ambient jarvis style assistant is possible. Im loving where we are going. CNVS is still the future of vibecoding.

Decision: Evaluate input state and return typed decision for An always-on assistant with no wake word.
Sub-100msSource
xpostLive demo

Full Jev tutorial

Full Jev Tutorial What it is, how you can build with it and what new applications it can unlock → 0:00 Intro → 0:34 Jev explained → 4:06 API setup → 5:59 Demo 1: Voice-controlled browser → 11:33 Demo 2: AI memory → 17:27 Demo 3: YouTube predictor

Decision: Evaluate input state and return typed decision for Full Jev tutorial.
Sub-100msSource
xpostLive demo

A hype-free explanation of Jev

hype-free explanation of jev: jev does not replace gpt / claude jev is just a *really* smart switch statement like if 2016 ml classifiers got 2026 levels of intelligence it's a new* type of tool that will make a lot of workloads insanely fast, cheap, and accurate * = and by new, i mean rebranded ~~~ it needs a predefined set of options and it will tell you which one to take it cannot: - write code - generate natural language - reason step by step / show its work - produce any output you didn't define in advance - pick from more than ~255 options in one shot but it can: - classify, route, score, rank - give confidence - pick the right branch, tool, model, or sub-agent - judge / verify / guardrail an llm's output - label tons and tons of rows ~~~ i'd imagine a lot of workflows that look like: llm proposes options → jev decides → code executes and i see this fitting *really* well with code mode and mcp ~~~ implying this will lead to agi seems incredibly far fetched to me, but i don't want to discount the types of applications that this will make possible

Decision: Evaluate input state and return typed decision for A hype-free explanation of Jev.
Sub-100msSource
xpostLive demo

Arbitrary classification as a primitive

Jev is cool not because it re-invented classification, but because it makes ARBITRARY classification into a type-safe programmable primitive. A general purpose zero shot decision model whose native interface is RUNTIME-DEFINED typed decisions, optimized for that exact interface

Decision: Evaluate input state and return typed decision for Arbitrary classification as a primitive.
Sub-100msSource
xpostLive demo

LLMs generate answers, Jev makes decisions

this is the easiest way to understand Jev: LLMs generate answers. Jev makes decisions. that sounds like a small difference, but it actually changes the entire use case. say you give a normal LLM this: “here’s a user, their account history, payment behavior, support chats, device data, etc. tell me if this looks risky.” the LLM might reason through it and return: “yes, this looks high risk.” maybe in JSON if you ask nicely. with Jev, you define the possible decisions upfront: risk: * low * medium * high manual review: * yes * no and Jev returns something closer to: risk = high (96%) manual review = yes (91%) that’s basically the product. it’s not trying to be another ChatGPT. it’s more like an AI-native if statement. instead of: if transaction > $10,000: review() you can start thinking more like: if “does this behavior look suspicious?” > 95%: review() and that opens up a pretty interesting category of software. a few assumptions I had at first that turned out to be wrong: 1. “so it’s just a classifier?” kind of, but that undersells it. the input can be messy real-world context, and you can ask multiple typed questions about that state at once. fraud? churn? escalate? eligible? priority? all from the same input. 2. “so it replaces GPT / Claude?” not really. I actually think the interesting architecture is: Jev decides WHAT needs to happen Claude / GPT reason or generate WHEN deeper intelligence is needed normal code executes the deterministic stuff. Jev becomes the routing layer. 3. “it can’t hallucinate?” this one needs nuance. if your allowed answers are: LOW MEDIUM HIGH Jev won’t suddenly invent: “EXTREMELY HIGH 🚨” the output structure is constrained. but it can still be wrong. HIGH at 92% can still be the wrong decision. so “no hallucinations” doesn’t mean “always correct.” 4. “why not just force an LLM to return JSON?” you can. we already do this everywhere. but you still deal with generation latency, schema validation, retries, weird outputs, confidence estimation and a lot of glue code. Jev is designed around the decision itself rather than text generation. 5. “why should I care?” because most software is ultimately a giant tree of: if this → do that if this → route here if this → escalate if this → reject if this → ask a human Jev is basically asking: what if those if statements could understand messy human context? that’s a much more interesting framing than “another AI model.” I can see this being very useful for: fraud / risk support routing moderation PR / QA automation lead scoring compliance workflow orchestration agent routing especially as the cheap + fast decision layer sitting in front of larger reasoning models. early tech, obviously. but the category itself makes a lot of sense.

Decision: Evaluate input state and return typed decision for LLMs generate answers, Jev makes decisions.
Sub-100msSource
xpostLive demo

LLMs vs. Jev, clearly explained

LLMs vs. Jev, clearly explained! TL;DR The key difference is not that Jev generates faster. Jev does not generate text at all. A traditional LLM receives context and produces an answer one token at a time. Even when the output is a small JSON object, every token depends on those generated before it. Jev receives the same context but evaluates predefined decisions directly. When those decisions are independent, it can evaluate all of them in parallel. Consider an agent handling a failed deployment. It may need to determine: → Whether the incident is urgent → Which team should handle it → Whether the proposed command is risky → Whether the task is complete An LLM generates a response containing these answers sequentially. The application then parses and validates it. With Jev, you define the questions and expected answer types upfront. It evaluates them together and returns typed answers with probabilities. Jev supports three decision primitives: 1. **Choice** selects from known options, such as engineering, billing, or sales. 2. **Score** places the input on an ordered scale, such as low, medium, or high risk. 3. **Noul** evaluates a yes-or-no condition and returns the probability that it is true. The probabilities matter as much as the selected answers. If engineering receives 91% probability and billing receives 9%, automatic routing may be reasonable. If the probabilities are 52% and 48%, the system can escalate, gather more context, or call a stronger model. This keeps control inside ordinary software. Code owns the thresholds and consequences. Jev supplies the semantic judgment that a normal `if` statement cannot derive from unstructured text. It works best when the possible answers are known, the decision depends on meaning, and a careful person could judge the input quickly. It is not designed for writing, summarization, code generation, arithmetic, or decisions requiring several dependent reasoning steps. Independent questions can run in parallel, but decisions that depend on earlier results must remain sequential. Jev also cannot return an option outside the declared schema, but it can still select the wrong valid option. Type safety prevents malformed outputs, not incorrect judgments. The clean mental model is this: LLMs generate new language when the answer space is open. Jev evaluates known paths when the answer space is bounded. I wrote the full breakdown explaining Jev and where it fits. The article is quoted below.

Decision: Evaluate input state and return typed decision for LLMs vs. Jev, clearly explained.
Sub-100msSource
xpostLive demo

How Jev makes agents faster and cheaper

jev will make agents 10x faster and cheaper, here's how: 1/ model routing: pick the right model for each task, without training a custom router https://x.com/mdlahfir/status/2100314182201802811?s=20 2/ computer use: faster, cheaper and more reliable for action-heavy tasks https://x.com/gregpr07/status/2100411066966749359 3/ auto review: ask jev whether an action is safe, instead of using a slow and expensive LLM https://x.com/fazxes/status/2100300097695232164?s=20 4/ less obvious: subagent orchestration long-running agents (cursor projects, grokbot, energy) parallelize work with subagents. but every user message, email, or subagent reply can wake the expensive orchestrator. example: it costs $1 to wake up gpt 6 astra w 100k input tokens jev can decide what each event needs: - route directly to a subagent - queue for later - wake the orchestrator

Decision: Evaluate input state and return typed decision for How Jev makes agents faster and cheaper.
Sub-100msSource
xpostLive demo

WTF is Jev, and 9 things people are building

TL;DR of my new article: WTF is Jev by @typesafeai, and the 9 things people are already building with it. The thesis: 𝗮 𝗰𝗼-𝗰𝗿𝗲𝗮𝘁𝗼𝗿 𝗼𝗳 𝗖𝗵𝗮𝘁𝗚𝗣𝗧 𝘀𝗽𝗲𝗻𝘁 𝘁𝘄𝗼 𝘆𝗲𝗮𝗿𝘀 𝗶𝗻 𝘀𝘁𝗲𝗮𝗹𝘁𝗵 𝗼𝗻 𝗮 𝗺𝗼𝗱𝗲𝗹 𝘁𝗵𝗮𝘁 𝗰𝗮𝗻𝗻𝗼𝘁 𝘄𝗿𝗶𝘁𝗲 𝗮 𝘀𝗲𝗻𝘁𝗲𝗻𝗰𝗲, 𝗮𝗻𝗱 𝗶𝗻𝘀𝗶𝗱𝗲 𝟳𝟮 𝗵𝗼𝘂𝗿𝘀 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀 𝘄𝗶𝗿𝗲𝗱 𝗶𝘁 𝗶𝗻𝘁𝗼 𝗲𝘃𝗲𝗿𝘆 𝗰𝗵𝗲𝗮𝗽 𝗷𝘂𝗱𝗴𝗺𝗲𝗻𝘁 𝗰𝗮𝗹𝗹 𝗮𝗻 𝗮𝗴𝗲𝗻𝘁 𝗺𝗮𝗸𝗲𝘀. Think AI multiple choice, not AI essay writing. It doesn't chat. You hand it app state plus a typed question, it hands back a decision with a probability attached. 𝟯𝟭.𝟰𝗠 𝘃𝗶𝗲𝘄𝘀 on the launch post in two days (@CompleteSkeptic, who co-invented RLHF). I ran @slashlast30days on it 11 times, then checked every big post by hand. 🌐 𝗔 𝘁𝗶𝗻𝘆 𝗼𝗽𝗲𝗻 𝘀𝗼𝘂𝗿𝗰𝗲 𝗯𝗿𝗼𝘄𝘀𝗲𝗿 𝗮𝗴𝗲𝗻𝘁 𝗳𝗼𝘂𝗻𝗱 𝗳𝗹𝗶𝗴𝗵𝘁𝘀 𝗶𝗻 𝟳 𝘀𝗲𝗰𝗼𝗻𝗱𝘀 𝗳𝗼𝗿 $𝟬.𝟬𝟬𝟯𝟵. New action space every step, DOM as state, Jev picks the click, a small LLM only wakes up to type. The Browser Use founder built it (@gregpr07, 7.2K likes, 1.8M views) and had to note the video is 1x speed 🧹 The sleeper: instant compaction. Score every tool call, drop the junk, skip the summarization prompt entirely. "𝘪𝘯 2026, 𝘸𝘩𝘺 𝘪𝘴 𝘤𝘰𝘮𝘱𝘢𝘤𝘵𝘪𝘰𝘯 𝘴𝘵𝘪𝘭𝘭 𝘢 𝘴𝘶𝘮𝘮𝘢𝘳𝘪𝘻𝘢𝘵𝘪𝘰𝘯 𝘱𝘳𝘰𝘮𝘱𝘵?" asked @tamarajtran, 5K likes, then shipped the answer that afternoon. Run as a Claude plugin it took a session 𝗳𝗿𝗼𝗺 𝟭𝗠 𝘁𝗼𝗸𝗲𝗻𝘀 𝘁𝗼 𝟴𝟲𝗞 𝗶𝗻 𝗼𝗻𝗲 𝘀𝗲𝗰𝗼𝗻𝗱 (@altryne). Diogo's reply: "𝘧𝘳𝘦𝘦 𝘤𝘰𝘥𝘪𝘯𝘨 𝘢𝘨𝘦𝘯𝘵𝘴 𝘧𝘳𝘰𝘮 𝘥𝘦𝘴𝘪𝘨𝘯𝘪𝘯𝘨 𝘢𝘳𝘰𝘶𝘯𝘥 𝘵𝘩𝘦 𝘒𝘝 𝘤𝘢𝘤𝘩𝘦" 🛡️ Vercel put it in production as the safety reviewer in fx auto mode. 𝗨𝗽 𝘁𝗼 𝟭𝟴𝘅 𝗳𝗮𝘀𝘁𝗲𝗿 𝗮𝘁 𝗽𝟵𝟱 𝗮𝗻𝗱 𝗺𝗼𝗿𝗲 𝗮𝗰𝗰𝘂𝗿𝗮𝘁𝗲 than the model it replaced, per @rauchg, 3.7K likes. LangChain open-sourced the same idea the next day as AutoModeMiddleware. The closed danger classifier inside every coding harness is now a 100ms primitive 🚦 Model routing as middleware instead of a paragraph in a system prompt. About a dozen lines, probabilities left in agent state so you can audit the choice. The LangChain writeup by @sydneyrunkle is the cleanest how-to-wire-it piece anyone has published 🔎 RAG precision, solved the dumb way: retrieve as usual, run Jev on every chunk, delete the irrelevant ones. "𝘢𝘭𝘴𝘰 𝘥𝘪𝘥 𝘢𝘯𝘺𝘰𝘯𝘦 𝘳𝘦𝘢𝘭𝘪𝘻𝘦 𝘫𝘦𝘷 𝘴𝘰𝘭𝘷𝘦𝘥 𝘱𝘳𝘦𝘤𝘪𝘴𝘪𝘰𝘯 𝘪𝘯 𝘙𝘈𝘎?" (@kushbhuwalka, 416 likes) 🎮 Minecraft in real time: 𝗝𝗲𝘃 𝗿𝗲𝗮𝗰𝘁𝘀, 𝗚𝗣𝗧-𝟲 𝗔𝘀𝘁𝗿𝗮 𝗽𝗹𝗮𝗻𝘀, and they fight multiple zombies at once (@wuyang_zhou). A launcher that reads intent on every keystroke in about 100ms (@dabit3). TypeSafe's own demo is Doom at 10 decisions a second, roughly $7 an hour 📬 Email triage at scale: 1,500 emails in batches of 100 with 8 workers, 60,996 views on the demo. "𝘞𝘦 𝘰𝘯𝘭𝘺 𝘩𝘢𝘷𝘦 𝘢 𝘣𝘢𝘭𝘢𝘯𝘤𝘦 𝘰𝘧 $5 𝘥𝘰𝘸𝘯 𝘩𝘦𝘳𝘦, 𝘸𝘩𝘪𝘤𝘩 𝘫𝘶𝘴𝘵 𝘴𝘩𝘰𝘸𝘴 𝘩𝘰𝘸 𝘤𝘩𝘦𝘢𝘱 𝘵𝘩𝘪𝘴 𝘮𝘰𝘥𝘦𝘭 𝘪𝘴" 🗂️ 𝟳𝟳𝟳 𝗷𝘂𝗱𝗴𝗺𝗲𝗻𝘁𝘀 𝗶𝗻 𝘂𝗻𝗱𝗲𝗿 𝟬.𝟳 𝘀𝗲𝗰𝗼𝗻𝗱𝘀 𝗳𝗼𝗿 𝗮 𝗾𝘂𝗮𝗿𝘁𝗲𝗿 𝗼𝗳 𝗮 𝗰𝗲𝗻𝘁. Every's head of evals asked 21 questions of 37 documents in one request, and that is what came back 🧪 Jev in your browser: Reflex, a Qwen model doing structured decisions on WebGPU, built at Shopify by @kshetrajna and passed around by @tobi. Three independent clones inside 72 hours. 𝗧𝗵𝗲 𝗶𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲 𝗶𝘀 𝘁𝗵𝗲 𝗶𝗻𝘃𝗲𝗻𝘁𝗶𝗼𝗻, 𝗻𝗼𝘁 𝘁𝗵𝗲 𝘄𝗲𝗶𝗴𝗵𝘁𝘀 🔌 Already behind the gateways you use: @vercel AI Gateway inside 48 hours (2,341 likes, the company's second-biggest post), Cloudflare, and @OpenRouter in beta 💸 𝟱,𝟬𝟬𝟬 𝗿𝗲𝗾𝘂𝗲𝘀𝘁𝘀 𝗳𝗼𝗿 𝗮𝗯𝗼𝘂𝘁 $𝟮. That was one developer counting his bill on day one (@MichaelLee04, 3,060 likes). Input is $0.042 per million tokens. Output is free 🧨 The honest part: Every's second test came out 𝟮𝟱𝘅 𝗳𝗮𝘀𝘁𝗲𝗿, 𝗻𝗼𝘁 𝟮𝟬𝟬𝘅, and Jev caught 6 of 7 planted defects to Fable 5.1's 7. The HN launch thread (1,863 points) spent most of its length on "can't hallucinate." Top critical comment: "𝘪𝘵 𝘤𝘢𝘯'𝘵 𝘦𝘮𝘪𝘵 𝘢𝘯 𝘪𝘯𝘷𝘢𝘭𝘪𝘥 𝘵𝘺𝘱𝘦, 𝘣𝘶𝘵 𝘪𝘵 𝘤𝘢𝘯 𝘴𝘵𝘪𝘭𝘭 𝘦𝘮𝘪𝘵 𝘢 𝘤𝘰𝘮𝘱𝘭𝘦𝘵𝘦𝘭𝘺 𝘸𝘳𝘰𝘯𝘨 𝘷𝘢𝘭𝘪𝘥 𝘷𝘢𝘭𝘶𝘦." Diogo called the "it's a zero-shot classifier" read "𝘷𝘦𝘳𝘺 𝘢𝘤𝘤𝘶𝘳𝘢𝘵𝘦!" And the biggest Reddit thread is someone who open-sourced the same architecture a year ago, 1,568 upvotes. Top reply: "𝘉𝘶𝘵 𝘥𝘪𝘥 𝘺𝘰𝘶 𝘱𝘰𝘴𝘵 𝘪𝘵 𝘴𝘢𝘺𝘪𝘯𝘨 𝘪𝘵'𝘴 𝘵𝘩𝘦 𝘯𝘦𝘹𝘵 𝘣𝘪𝘨 𝘵𝘩𝘪𝘯𝘨? 𝘙𝘰𝘰𝘬𝘪𝘦 𝘮𝘪𝘴𝘵𝘢𝘬𝘦" Bonus: the name is not Kahneman. It's William Stanley Jevons, of Jevons paradox. Make a resource cheaper and people consume far more of it. Naming your decision model after that is a thesis statement. 𝗞𝗲𝗲𝗽 𝘁𝗵𝗲 𝗯𝗶𝗴 𝗺𝗼𝗱𝗲𝗹 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗵𝗮𝗿𝗱 𝘁𝗵𝗶𝗻𝗸𝗶𝗻𝗴 𝗮𝗻𝗱 𝘄𝗿𝗶𝘁𝗶𝗻𝗴. 𝗨𝘀𝗲 𝗝𝗲𝘃 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗿𝗮𝗽𝗶𝗱-𝗳𝗶𝗿𝗲 𝗱𝗲𝗰𝗶𝘀𝗶𝗼𝗻𝘀 𝗶𝗻 𝗯𝗲𝘁𝘄𝗲𝗲𝗻. That's the whole article.

Decision: Evaluate input state and return typed decision for WTF is Jev, and 9 things people are building.
Sub-100msSource
xpostLive demo

Jev Engineering: a 10-step roadmap

Jev is the "Internet" moment for the AI industry It tells your agents and LLMs what to do next, in milliseconds and at almost zero cost If you set it up correctly, you will have the AI engineer’s stack for 2028 In this article, I show you how x.com/i/article/2077…

Decision: Evaluate input state and return typed decision for Jev Engineering: a 10-step roadmap.
Sub-100msSource
xpostLive demo

Giving your agents a decision brain

Jev could become the control layer AI agents have been missing. Instead of spending 5–20 seconds and expensive LLM calls deciding every next step, it can route actions in milliseconds at near-zero cost. In this article, I break down how x.com/i/article/2101…

Decision: Evaluate input state and return typed decision for Giving your agents a decision brain.
Sub-100msSource
xpostLive demo

The 10-step roadmap, summarised

Jev might genuinely be an “Internet moment” for AI. TypeSafe reports up to 193x faster and 444x cheaper performance in tests with Claude Fable 5.1 and GPT-6 Astra. @0xCodila just wrote a great 10-page article explaining what Jev is, how to use it, and where its 100x advantage comes from. Here are the 10 steps: 1 → LLMs create. Agents act. Jev decides the next move. 2 → Turn agent forks into three primitives: Choice, Score and probability. 3 → Build with OpenAI, Anthropic or xAI first, then swap Jev in without rebuilding the graph. 4 → Start with shared state, parallel decisions, risk thresholds and an execution queue. 5 → Batch decisions instead of making them sequentially. In one test, 13 questions were 10x faster and 12.2x cheaper. 6 → Put Jev at bounded forks: agent, model, tool, browser action or human escalation. 7 → Benchmark the whole loop, not just individual model calls. 8 → Rank wide, read narrow: shortlist first, then spend compute on what matters. 9 → Reuse the same system: State → Questions → Action → Verify. 10 → Keep Jev out of math, writing and irreversible execution. Code computes, LLMs create, Jev decides. The result: A slow, expensive agent loop becomes a much faster decision system that can route, score and escalate in milliseconds. Full breakdown below ↓

Decision: Evaluate input state and return typed decision for The 10-step roadmap, summarised.
Sub-100msSource
xpostLive demo

Diogo Almeida’s tech talk

Jev Founder, Diogo Almeida (ex-OpenAI): "The next era is not the Claude Code or Codex era, they are still part of the assistance era with human in the loop - JEV is what comes next for LLMs x200 faster, x400 cheaper, 0 hallucination, no human in the loop - that's JEV, this is how LLMs will look like" in 36-minute tech talk, Jev Founder explained why RLHF isn't a thing anymore and how modern LLMs will be built this talk is worth more than a Stanford Machine Learning degree watch today no matter what, then learn how to become a Jev Engineer in the article below

Decision: Evaluate input state and return typed decision for Diogo Almeida’s tech talk.
Sub-100msSource
xpostLive demo

Diogo Almeida in five minutes

Jev Founder (ex-OpenAI): "I believe JEV is the biggest breakthrough we've ever worked on This sounds too good to be true but it's beating everything" In 5 minutes, he breaks down why older LLMs were great at talking and terrible at deciding and building. Watch it and then read the guide below on how to use it at it's fullest 👇🏼

Decision: Evaluate input state and return typed decision for Diogo Almeida in five minutes.
Sub-100msSource
xpostLive demo

Custom Jev-style models for agent workflows

Prediction: millionaires will be made using custom Jev style models (parallel constrained decoding) to make the agent systems companies already run more token efficient. Let me explain with a scenario: Imagine a company already has an agent workflow running where an llm reviews every item before it moves on: a support ticket gets triaged, an invoice gets approved or held, a claim gets flagged. Every one of those goes through a frontier model today, a few seconds and a few cents each, on the way to a decision that in most cases is obvious. Behind that flow sits years of humans (or agents) making the exact same call, with the outcome attached. Now imagine you first run each item through a custom PCD or similar model that costs a fraction of the llm and returns a classification of what to do at that step, with a mathematically accurate probability attached. When it's confident, the item skips the llm entirely. When it isn't, the llm handles it as normal. The model has seen years of your team making this exact decision, usually a constrained set of decisions, so it should be right most of the time. Say it comes back confident on 6 out of 10 items. That's more than half your llm spend potentially gone from that step, likely with comparable accuracy. This pre processing idea works in a bunch of other use cases too, such as: - model/request routing: cheap model, frontier model, or a human - picking which skill or subagent to load for a turn instead of stuffing the whole catalog into context - reranking retrieved context so only the relevant chunks reach the window - guardrails on every agent turn: contradictions, policy issues, prompt injection - extracting typed fields from unstructured data emails, PDFs and transcripts before anything expensive touches them Every one of those is a decision an llm makes today, that could potentially be done by another, cheaper model class. Very excited to see Jev/PCD-based pre processing use cases get deployed to agents at scale.

Decision: Evaluate input state and return typed decision for Custom Jev-style models for agent workflows.
Sub-100msSource
xpostLive demo

The compaction plugin, tried

This is actually insane. This uses @typesafeai Jev model, as a plugin in Claude to review all the un-nesseasary tool calls, and it takes 1s to run! Like, literally, 1 second to take my Claude session from nearly 1M to ... 86K tokens! 😮 Ask your claude to install it and be amazed Use this prompt ``` Install, and configure : https://github.com/tamaratran/fast-jev-compaction ```

Decision: Evaluate input state and return typed decision for The compaction plugin, tried.
Sub-100msSource
xpostLive demo

The case against Jev compaction

This is a terrible compaction strategy that fundamentally doesn't understand how compaction and context management work. Seems like a lot of people are confused so let's break this down. 1. Compaction isn't a filter The role of compaction is to clean up history to keep the agent focused, not just deleting noise. It should be used sparingly when context gets too long, not constantly to keep context small. 2. Jev doesn't even know what it's deciding on! Models use the context of the thread to decide what to keep or not keep in a summary. This implementation goes through on a "line-by-line" (per tool call) basis to decide what should be left or deleted. Not only does this 32k token context model know very little of what happened before, but (in this implementation) it doesn't even know what the result of the tool call is! Deleting these things randomly will keep the model from knowing what it's tried and dooms you to end up in "stupid loops" where the model keeps trying the same thing over and over. 3. You're giving up the reasoning entirely Frontier models from OpenAI, Anthropic, XAI, and Google do not share reasoning traces over the API. They share encrypted payloads, which Jev cannot see (and often will drop). Anthropic is even stricter with this, requiring you to preserve the entire history in order to get any of the reasoning data. As a result, using this in Claude Code guarantees the model will act way dumber. 4. Models are tuned on their compaction flows For the last year, Frontier Labs have been including compaction and long runs as part of the training process. These models have learned ways to compact that are more effective than any rudimentary solution. Fun fact: If you switch models in Codex and compaction is necessary, compaction will run on the model that was previously used in the thread. 5. Cache writes are more expensive than cache reads. Cache writes are the biggest cost by far for agents. I often see cache write costs go over 60% of my total LLM spend in my personal use of Claude Code and Codex. Cache writes are insanely expensive when data earlier in the history is changed (because the old cache is invalidated when things change at the top). Every history edit requires a cache rewrite for ANY data past the history edit. If your history is "1,2,3,4,5,6" and you delete "2", you have to rewrite "3,4,5,6". This is more expensive than leaving "2" in the history. Good news. Since we're already killing all of the reasoning tokens by doing this stupid compaction strategy, the rewrite cost won't actually be that high because the model is missing so much data! 🙃🙃 6. The implementation is hot garbage. > "Whatever is not kept is deleted permanently, but the assistant can always re-run a tool or re-read a file." Good luck with that one. To be clear: this is a cool experiment and I find it genuinely interesting. That said, if you think this style of bs filtering on a probability threshold is actually a compaction strategy, I highly recommend you just use the defaults in tools like Claude Code and Codex. You're much less likely to hurt yourself that way.

Decision: Evaluate input state and return typed decision for The case against Jev compaction.
Sub-100msSource
xpostLive demo

Website to App

Introducing Jev for 'Website to App' Turn any website into a native mobile app. Just paste a URL. jev-1.13.0 decides how to build the original website as a *native* mobile app, then shipper submits to the app stores for you. We’ve been using this internally a ton for iOS/Android apps.

Decision: Evaluate input state and return typed decision for Website to App.
Sub-100msSource
xpostLive demo

The use cases Jev unlocks

You still don't understand the use cases Jev unlocks. I've been waiting for something like this since early ChatGPT models. prediction: we will see the fastest-growing SaaS by MRR in history within the next month or two

Decision: Evaluate input state and return typed decision for The use cases Jev unlocks.
Sub-100msSource
xpostLive demo

Getting started: install the skill

Unsure how to get started with Jev? Install the skill: npx skills add typesafe-ai/skills --skill typesafe-ai Then prompt in your project: use /typesafe-ai to see how Jev can be used to replace slow, expensive LLM usage and find possible new features it would enable for users.

Decision: Evaluate input state and return typed decision for Getting started: install the skill.
Sub-100msSource
xpostLive demo

Jev on OpenRouter

Jev by @typesafeai is now on OpenRouter, in beta. Jev is a System One model. Instead of generating text, it takes your app's state plus a typed question and returns a typed decision with a probability attached. There is no JSON prompting, parsing layer, and nothing to validate against.

Decision: Evaluate input state and return typed decision for Jev on OpenRouter.
Sub-100msSource
xpostLive demo

Jev on Cloudflare AI Gateway

Jev from @typesafeai is now live on @CloudflareDev AI Gateway. Try the first System One model — send state and typed questions; get structured answers your code can use directly. developers.cloudflare.com/ai/models/type…

Decision: Evaluate input state and return typed decision for Jev on Cloudflare AI Gateway.
Sub-100msSource
xpostLive demo

Jev, explained like you’re five

WTF is Jev by @typesafeai? Here’s the tl;dr ELI5: Think AI multiple choice, not AI essay writing. It doesn’t chat. It makes decisions your software can act on: “Spam or not?” “Which tool should this agent use?” “Does this need a human?” The exciting part: roughly 200x faster and 400x cheaper than frontier LLMs in TypeSafe’s own workflow benchmarks, with responses in a fraction of a second. Why that’s powerful: imagine an app or agent making hundreds of little judgment calls without hundreds of expensive, slow conversations with an LLM. Keep the big model for the hard thinking and writing. Use Jev for the rapid-fire decisions in between. Excited to dig in.

Decision: Evaluate input state and return typed decision for Jev, explained like you’re five.
Sub-100msSource
xpostLive demo

Six things I will still use Jev for

I've been using Jev by @typesafeai Here's the six things i've tried and am confident I'll still use Jev for 60 days from now. There's many more experiments, ideas, and things I think I will use it for. It's a big deal (more on why in next post). But I am only sharing things that I am 99% sure will lead to stuff I will still be using Jev for in 60 days. That means I started with small, boring, but useful, stuff. - Fact-checking my scripts - Ranking my news feed - Finding the right text in PDFs - Checking citations - Grouping my review notes - Figuring out why agents fail (eval over traces) https://isaacflath.com/writing/six-things-i-tried-with-jev

Decision: Evaluate input state and return typed decision for Six things I will still use Jev for.
Sub-100msSource
xpostLive demo

Jev for security engineering

This made me rethink where AI actually fits into security engineering. For purely engineering work, forget about ChatGPT or Claude. TypeSafe AI just released Jev, and I think it’s going to change how we build AI into security workflows. Instead of asking an LLM to “investigate this,” you define the questions and possible outputs, then get structured probabilities and decisions your code can actually use. For security, the possibilities are huge. Think of the below use cases 🤯: Threat Hunting: ➡️ Rank broad hunt results by relevance ➡️ Score users, hosts, processes, or sessions based on how suspicious their surrounding activity looks ➡️ Classify noisy activity at scale. Think thousands of rundll32.exe executions automatically grouped into expected admin activity, software execution, suspicious usage, or unknown Detection Engineering: → Classify historical alerts for FP analysis → Add context-aware scoring on top of deterministic detections → Validate whether an alert actually supports the behavior the rule claims to detect Incident Response: → Reduce massive timelines down to the events most relevant to the intrusion → Continuously score hosts/users for possible compromise → Help prioritize scope expansion, triage, and response decisions This feels much closer to how AI should be integrated into security engineering. I'm currently working through most of the above, mostly focusing on instant response, but at the same time doing some of the threat hunting use cases that I mentioned. Typesafe AI can be basically a decision engine sitting inside the workflow while being x200 fast and cheaper. Don’t sleep on this... This is huge! 👉 https://typesafe.ai/

Decision: Evaluate input state and return typed decision for Jev for security engineering.
Sub-100msSource
xpostLive demo

deepseek-v4.1-flash-jev

you can make any open source model behave like jev with just a bit of inference engineering. it's shockingly easy. to prove it, we built a new endpoint we're calling deepseek-v4.1-flash-jev. see the demo below. here's how it's done: sglang (an inference engine) offers a scoring endpoint in addition to the normal generation one. in scoring mode, given an input & set of possible answers, it forces the model to produce probabilities for each one. example: > input: what is most common letter in abcccde? > possible answers: a, b, c > output: (c, 0.9), (b, 0.0.5), (a, 0.05) getting the above behavior instead of streamed output is as simple as using sglang's /v1/score endpoint instead of /generate. there's just one other trick required. for deepseek, you have to add a closing think tag before the response. this forces a direct answer instead of a reasoning trace. if you want reasoning, you can do that too, but imo that makes things too slow to be worth it. dsv4.1 flash is not as good as jev, but if we had enough spare compute to experiment with this same approach for a larger model then i think the decision quality would be at least as good, if not better. also, somewhat unrelated, i think decision-making models kill all prospecting & sourcing work. i would have absolutely killed to have jev or similar when i was recruiting @mintlify. absolutely incredible.

Decision: Evaluate input state and return typed decision for deepseek-v4.1-flash-jev.
Sub-100msSource
xpostLive demo

The coolest Jev projects on X

All of the coolest Jev projects I could find on X today 🧵

Decision: Evaluate input state and return typed decision for The coolest Jev projects on X.
Sub-100msSource
xpostLive demo

Jev against Fable 5.1, 100 builders

Jev is INSANE. I asked 100 Indie Hackers to build a post scheduler with: Jev vs Fable 5.1. The results are unexpected 🤯 (You can clearly see Jev is faster at doing stuff)

Decision: Evaluate input state and return typed decision for Jev against Fable 5.1, 100 builders.
Sub-100msSource
xpostLive demo

Magic Jev Ball for code review

I made a Magic Jev Ball for code reviews 🎱 Click it on any GitHub PR and ask: "should I approve this?" It checks CI, diff size, and reviews, then lets @typesafeai Jev decide your fate in ~200 ms No more thinking. Just shaking.

Decision: Evaluate input state and return typed decision for Magic Jev Ball for code review.
Sub-100msSource
xpostLive demo

Awesome Jev, in Chinese

思维怪怪

Decision: Evaluate input state and return typed decision for Awesome Jev, in Chinese.
Sub-100msSource
xpostLive demo

talkr

today i built talkr, a speech analyzer using @typesafeai > talkr gives you a topic > you talk about it for 30s > jev analyzes your speech: pauses, filler words, repetitions, confidence, clarity > you get a score and feedback to improve can’t wait to 10x my speaking skills

Decision: Evaluate input state and return typed decision for talkr.
Sub-100msSource
xpostLive demo

Jev Clearly Explained

Akshay 🚀

Decision: Evaluate input state and return typed decision for Jev Clearly Explained.
Sub-100msSource
xpostLive demo

Copy and paste, with a decision in between

what if copy/paste was smart? powered by @typesafeai jev it feels like every computer interaction will get rewritten

Decision: Evaluate input state and return typed decision for Copy and paste, with a decision in between.
Sub-100msSource
xpostLive demo

YouTube sponsor skipper

Just trying out Jev, I made a Chrome extension that: - Listens to your YouTube audio (optional) - Detects if it gets to a sponsor segment - Skips it ➡️➡️➡️ - All in real-time while costing ~$0.005 per video Prototype project, BYOK, open-source: github.com/trungdq88/yout…

Decision: Evaluate input state and return typed decision for YouTube sponsor skipper.
Sub-100msSource
xpostLive demo

Awesome Jev

Guide·github.com

Decision: Evaluate input state and return typed decision for Awesome Jev.
Sub-100msSource
xpostLive demo

jev-mcp

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-mcp.
Sub-100msSource
xpostLive demo

typesafe-mcp

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for typesafe-mcp.
Sub-100msSource
xpostLive demo

unclutter

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for unclutter.
Sub-100msSource
xpostLive demo

jev-axi

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-axi.
Sub-100msSource
xpostLive demo

jev CLI

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev CLI.
Sub-100msSource
xpostLive demo

daf-jev

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for daf-jev.
Sub-100msSource
xpostLive demo

typesafe-sdk-go

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for typesafe-sdk-go.
Sub-100msSource
xpostLive demo

TypeSafe AI playground

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for TypeSafe AI playground.
Sub-100msSource
xpostLive demo

maza

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for maza.
Sub-100msSource
xpostLive demo

patdown

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for patdown.
Sub-100msSource
xpostLive demo

fast-jev-compaction

Guide·github.com

Decision: Evaluate input state and return typed decision for fast-jev-compaction.
Sub-100msSource
xpostLive demo

is-malicious

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for is-malicious.
Sub-100msSource
xpostLive demo

guesswork

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for guesswork.
Sub-100msSource
xpostLive demo

capture

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for capture.
Sub-100msSource
xpostLive demo

TypeSafe agent skills

Skill·Tools and apps

Decision: Evaluate input state and return typed decision for TypeSafe agent skills.
Sub-100msSource
xpostLive demo

skillbox

Skill·Tools and apps

Decision: Evaluate input state and return typed decision for skillbox.
Sub-100msSource
xpostLive demo

skillranker

Skill·Tools and apps

Decision: Evaluate input state and return typed decision for skillranker.
Sub-100msSource
xpostLive demo

jev-agent-skill-router

Skill·Tools and apps

Decision: Evaluate input state and return typed decision for jev-agent-skill-router.
Sub-100msSource
xpostLive demo

jev-judgment

Skill·Tools and apps

Decision: Evaluate input state and return typed decision for jev-judgment.
Sub-100msSource
xpostLive demo

tenbin

Skill·Tools and apps

Decision: Evaluate input state and return typed decision for tenbin.
Sub-100msSource
xpostLive demo

Augustus

Skill·Tools and apps

Decision: Evaluate input state and return typed decision for Augustus.
Sub-100msSource
xpostLive demo

jev-superpowers

Skill·Tools and apps

Decision: Evaluate input state and return typed decision for jev-superpowers.
Sub-100msSource
xpostLive demo

Building with Jev

Skill·Tools and apps

Decision: Evaluate input state and return typed decision for Building with Jev.
Sub-100msSource
xpostLive demo

jev-rules

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-rules.
Sub-100msSource
xpostLive demo

Simple Jev

love jev, but upset it - isn't open source? - it lack vision capability? We fixed all of that, introducing SimpleJev.ai A fully open source library which takes any HF model and Jev-ify it, with an API endpoint Now on github, and live in production at @FeatherlessAI

Decision: Evaluate input state and return typed decision for Simple Jev.
Sub-100msSource
xpostLive demo

Jevinci

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for Jevinci.
Sub-100msSource
xpostLive demo

Jev Review

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for Jev Review.
Sub-100msSource
xpostLive demo

Hunch

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for Hunch.
Sub-100msSource
xpostLive demo

jev-oxlint

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-oxlint.
Sub-100msSource
xpostLive demo

jevcumber

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jevcumber.
Sub-100msSource
xpostLive demo

siftr

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for siftr.
Sub-100msSource
xpostLive demo

jev-pruner

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-pruner.
Sub-100msSource
xpostLive demo

winnow

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for winnow.
Sub-100msSource
xpostLive demo

Yoshi

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for Yoshi.
Sub-100msSource
xpostLive demo

Jev Sift

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for Jev Sift.
Sub-100msSource
xpostLive demo

pi-jev

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for pi-jev.
Sub-100msSource
xpostLive demo

mcp_jev

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for mcp_jev.
Sub-100msSource
xpostLive demo

jevkit

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jevkit.
Sub-100msSource
xpostLive demo

Semantic Bookmark

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for Semantic Bookmark.
Sub-100msSource
xpostLive demo

Port Cleanup

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for Port Cleanup.
Sub-100msSource
xpostLive demo

Laravel TypeSafe Jev

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for Laravel TypeSafe Jev.
Sub-100msSource
xpostLive demo

kev

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for kev.
Sub-100msSource
xpostLive demo

Open Alternative to Jev

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for Open Alternative to Jev.
Sub-100msSource
xpostLive demo

OpenJev (Verdict)

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for OpenJev (Verdict).
Sub-100msSource
xpostLive demo

jev-skill-router

Jiaqi Gu

Decision: Evaluate input state and return typed decision for jev-skill-router.
Sub-100msSource
xpostLive demo

NanoJev

Geek Lite

Decision: Evaluate input state and return typed decision for NanoJev.
Sub-100msSource
xpostLive demo

awesome-typesafe

Guide·github.com

Decision: Evaluate input state and return typed decision for awesome-typesafe.
Sub-100msSource
xpostLive demo

yibie/awesome-jev

Guide·github.com

Decision: Evaluate input state and return typed decision for yibie/awesome-jev.
Sub-100msSource
xpostLive demo

jev-e2e

JEV is changes the world of E2E testing! Same eBay test flow, completed-run medians: Jev: 47s / $0.0067 GPT-5.6 Luna: 62s / $0.0277 Claude Sonnet 5: 79s / $0.4062 Try jev-e2e. github.com/perixtar/jev-e…

Decision: Evaluate input state and return typed decision for jev-e2e.
Sub-100msSource
xpostLive demo

cobanov/awesome-jev

Guide·github.com

Decision: Evaluate input state and return typed decision for cobanov/awesome-jev.
Sub-100msSource
xpostLive demo

fatwang2/awesome-jev

Guide·github.com

Decision: Evaluate input state and return typed decision for fatwang2/awesome-jev.
Sub-100msSource
xpostLive demo

compact-adviser

almost every day i hear people ask "when should i /compact my session" there's no easy answer because it depends on how likely your future action will need detailed context in the existing window but we have Jev now! introducing compact-adviser - an agent plugin you can use in claude and pi today to help determine whether you're likely at a task boundary that's safe to compact https://github.com/kunchenguid/compact-adviser i built a private eval set from 40 real sessions and manually labeled all the safe vs unsafe checkpoints to evaluate this, and hillclimbed the Jev prompt till it performed quite well i also made it so that the classifier will - optimize for precision (not triggering a compaction prematurely) when context window is small - and gradually shift to optimize for recall (not missing an opportunity to compact) when context window fills up, because the cost of not compacting becomes higher, and at the end the agent will be forced to compact anyway it supports a "hint" mode (just give you a hint and it's up to you to run /compact) vs "auto" mode which runs compaction whenever Jev says it's safe to do so if you have Jev and want to put your compaction on autopilot, try this out and let me know how it goes! support for more harness is coming soon as well

Decision: Evaluate input state and return typed decision for compact-adviser.
Sub-100msSource
xpostLive demo

jev-semgrep

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-semgrep.
Sub-100msSource
xpostLive demo

awesome-jev-projects

Guide·github.com

Decision: Evaluate input state and return typed decision for awesome-jev-projects.
Sub-100msSource
xpostLive demo

live-jev

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for live-jev.
Sub-100msSource
xpostLive demo

jev-crawlers

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-crawlers.
Sub-100msSource
xpostLive demo

jev-oas-sentinel

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-oas-sentinel.
Sub-100msSource
xpostLive demo

jev-router (skill)

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-router (skill).
Sub-100msSource
xpostLive demo

hermes-typesafe-jev

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for hermes-typesafe-jev.
Sub-100msSource
xpostLive demo

大声读 (dasheng)

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for 大声读 (dasheng).
Sub-100msSource
xpostLive demo

jev-dsh-decision

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-dsh-decision.
Sub-100msSource
xpostLive demo

jevgrep

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jevgrep.
Sub-100msSource
xpostLive demo

typesafe-mcp (PyModel)

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for typesafe-mcp (PyModel).
Sub-100msSource
xpostLive demo

pi-jev-router

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for pi-jev-router.
Sub-100msSource
xpostLive demo

arbiter

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for arbiter.
Sub-100msSource
xpostLive demo

jevalyn

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jevalyn.
Sub-100msSource
xpostLive demo

jev-spring-boot-starter

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-spring-boot-starter.
Sub-100msSource
xpostLive demo

J++

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for J++.
Sub-100msSource
xpostLive demo

jev-auto-approve

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-auto-approve.
Sub-100msSource
xpostLive demo

pi-jev-skill-picker

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for pi-jev-skill-picker.
Sub-100msSource
xpostLive demo

pi-jev-router (win4r)

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for pi-jev-router (win4r).
Sub-100msSource
xpostLive demo

jev-cli

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-cli.
Sub-100msSource
xpostLive demo

jev-architect

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-architect.
Sub-100msSource
xpostLive demo

JevPR

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for JevPR.
Sub-100msSource
xpostLive demo

jev-spec

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-spec.
Sub-100msSource
xpostLive demo

jev-skill

Guide·github.com

Decision: Evaluate input state and return typed decision for jev-skill.
Sub-100msSource
xpostLive demo

jev-design

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-design.
Sub-100msSource
xpostLive demo

Jcyber

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for Jcyber.
Sub-100msSource
xpostLive demo

jev-search-mcp

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-search-mcp.
Sub-100msSource
xpostLive demo

perfectrecall

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for perfectrecall.
Sub-100msSource
xpostLive demo

JevGuard

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for JevGuard.
Sub-100msSource
xpostLive demo

The Jev-enator

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for The Jev-enator.
Sub-100msSource
xpostLive demo

jev-turn-analysis

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for jev-turn-analysis.
Sub-100msSource
xpostLive demo

UXRay

GitHub·Tools and apps

Decision: Evaluate input state and return typed decision for UXRay.
Sub-100msSource
xpostLive demo

askjev.ai

Ask Jev anything. Give it a try at askjev.ai It won't answer. It will judge. Let's see if we can get to 1 million questions. @typesafeai 🤝 @convex work great together. @hmartenjoyer @CompleteSkeptic @justKDeng @mikeysee

Decision: Evaluate input state and return typed decision for askjev.ai.
Sub-100msSource
xpostLive demo

A syntax highlighter on Jev

built a highlighter on jev paste any language → my code tokenizes → jev names the lang, colours every word, then says which of 9 lint rules fire and where nine rules in code. jev just answers. near instant lab.saeed.sh/highlight

Decision: Evaluate input state and return typed decision for A syntax highlighter on Jev.
Sub-100msSource
xpostLive demo

JevForm

introducing JevForm, a form that dynamically branches and chooses what to ask next usinng @typesafeai’s Jev in my life i’ve made hundreds of forms with crazy if/then logic. Jev solves it. built with @vercel json-render (by @ctatedev), so theoretically it can support any generative form UI, and @DavidKPiano’s xstate for the actual state Play with it here: https://jevform.spiritt.app/

Decision: Evaluate input state and return typed decision for JevForm.
Sub-100msSource
xpostLive demo

What is Jev, on one page

The call, the three question types, the ticket example, the evals and the limits.

Decision: Evaluate input state and return typed decision for What is Jev, on one page.
Sub-100msSource
xpostLive demo

Jev Engineering, on one page

The three-way split, the seven rules, the confidence threshold and the price.

Decision: Evaluate input state and return typed decision for Jev Engineering, on one page.
Sub-100msSource
xpostLive demo

What is Jev?

Our explainer: what a System One model is, the three question types, what it costs, what it cannot do, and the builds that show it working.

Decision: Evaluate input state and return typed decision for What is Jev?.
Sub-100msSource
xpostLive demo

What is Jev Engineering?

Our guide to the term: split an agent into an LLM that writes, Jev that decides and code that acts, with the rules the builds on this site have in common.

Decision: Evaluate input state and return typed decision for What is Jev Engineering?.
Sub-100msSource
xpostLive demo

The Jev Build Report

Our own count: every public Jev build in week one, with the median published cost per decision, the median decision time, and the stars and languages of every repository created since launch. Free to cite, with the rows as JSON.

Decision: Evaluate input state and return typed decision for The Jev Build Report.
Sub-100msSource
xpostLive demo

Cookbook: skill suggestion

Guide·docs.typesafe.ai

Decision: Evaluate input state and return typed decision for Cookbook: skill suggestion.
Sub-100msSource
xpostLive demo

Workflow evals

Guide·evals.typesafe.ai

Decision: Evaluate input state and return typed decision for Workflow evals.
Sub-100msSource
xpostLive demo

Jev on Cloudflare

Guide·developers.cloudflare.com

Decision: Evaluate input state and return typed decision for Jev on Cloudflare.
Sub-100msSource
xpostLive demo

Building a harness with Jev

Guide·langchain.com

Decision: Evaluate input state and return typed decision for Building a harness with Jev.
Sub-100msSource
xpostLive demo

Let’s look at Jev

Guide·blog.lepine.pro

Decision: Evaluate input state and return typed decision for Let’s look at Jev.
Sub-100msSource
xpostLive demo

Jev on Hacker News

Guide·news.ycombinator.com

Decision: Evaluate input state and return typed decision for Jev on Hacker News.
Sub-100msSource
xpostLive demo

Jev on Netlify AI Gateway

Guide·netlify.com

Decision: Evaluate input state and return typed decision for Jev on Netlify AI Gateway.
Sub-100msSource
xpostLive demo

Jev through LiteLLM

Guide·docs.litellm.ai

Decision: Evaluate input state and return typed decision for Jev through LiteLLM.
Sub-100msSource
xpostLive demo

Jev in Pydantic AI

Guide·pydantic.dev

Decision: Evaluate input state and return typed decision for Jev in Pydantic AI.
Sub-100msSource
xpostLive demo

langchain-typesafe

Guide·pypi.org

Decision: Evaluate input state and return typed decision for langchain-typesafe.
Sub-100msSource
xpostLive demo

jev.directory

Guide·jev.directory

Decision: Evaluate input state and return typed decision for jev.directory.
Sub-100msSource
xpostLive demo

awesomejev.com

Guide·awesomejev.com

Decision: Evaluate input state and return typed decision for awesomejev.com.
Sub-100msSource
xpostLive demo

Jevable

Guide·jevable.com

Decision: Evaluate input state and return typed decision for Jevable.
Sub-100msSource
githubOpen source

jev-demo: TypeScript Decision Benchmark

A clean TypeScript showcase testing Jev parallel decision sampling against GPT-4o-mini and Claude 3.5 Haiku, measuring latency and JSON schema fidelity.

Decision: Is the incoming payload valid according to strict business invariants?
~48 ms · $0.0001Source
githubOpen source

typesafe-python: Async Python SDK

Official and community extended Python client library for TypeSafe AI Jev with async batch support, Pydantic model integration, and automatic retries.

Decision: Route incoming request batch through optimal concurrency pool.
Sub-60ms P95 · Pydantic v2Source
githubOpen source

langchain-typesafe: System 1 Router

LangChain and LangGraph integration introducing Jev as a System 1 fast-path node before costly multi-turn LLM reasoning loops.

Decision: Does this agent step require heavy reasoning or immediate deterministic execution?
~35 ms · ~68% token savingsSource
githubOpen source

openjev: Local Non-Autoregressive Decision Engine

An open-source PyTorch / vLLM implementation experimenting with RLCD (Reinforcement Learning for Calibrated Decisions) on small base weights.

Decision: Classify document sentiment and topic category simultaneously.
1800 rps · 3.2 GB VRAMSource
skillOpen source

shadcn/ui + Jev Form Guard

Zero-regex real-time form validation component for React and Vue forms that detects disposable emails, fake names, and address formatting anomalies.

Decision: Is this user input genuine, disposable, or bot-generated?
28 ms · <0.2% false positiveSource
skillOpen source

Cursor & Claude Code Jev Router

CLI hook that analyzes user prompts and workspace file diffs to automatically inject the exact rules, prompt snippets, and skills needed.

Decision: Which cursor rules or agent skills apply to the current editor context?
~19 ms · 40% tokens savedSource
githubOpen source

Solari Sentinel: Microsecond Crypto Risk Gate

A sub-15ms risk checking layer sitting between automated trading algorithms and order book execution to abort rogue orders.

Decision: Is this trading execution within calibrated portfolio drawdown boundaries?
~14 ms · 0.01% false positiveSource
githubOpen source

JevArm: 6-DoF Manipulator Intent Gate

Physical computing project embedding Jev as an intermediary state arbiter between vision cameras and robotic arm trajectory planning.

Decision: Select the optimal grasping orientation based on bounding box point cloud.
16.6 ms cycle · 60 Hz loopSource
engineeringBuild report

Introducing Jev: The System One Model

Diogo Almeida announces Jev after 2 years in stealth. 20-200x faster, 40-400x cheaper with output tokens free.

Decision: Non-autoregressive calibrated decisions for software workflows.
20-200x faster · Free output tokensSource
githubOpen source

supabase-jev-guard: Postgres Database Filter

Postgres pg_net webhook trigger that validates user text entries against toxicity and spam policies directly upon DB insert.

Decision: Does this user comment violate community guidelines?
22ms trigger executionSource
githubOpen source

Linear Issue Auto-Labeler

GitHub action & webhook that automatically triages, estimates, and assigns incoming Linear tickets with zero manual sorting.

Decision: Which team and priority label should be assigned to this Linear issue?
0.0002$ per issueSource
skillLive demo

Raycast Keystroke Oracle

A Raycast command extension predicting your next desktop workflow based on current active window title and clipboard content.

Decision: What action is the user most likely attempting next?
Instantaneous UI reactionSource
githubOpen source

YouTube Sponsor Auto-Skipper

Chrome Manifest V3 extension streaming YouTube audio transcripts into Jev in 5-second windows to automatically leap over sponsored segments.

Decision: Is this video timestamp part of a sponsored advertisement segment?
$0.005 per 20min videoSource
githubOpen source

Voice-to-Intent Pipeline (Whisper + Jev)

Speech interface translating live microphone stream to typed hardware controls in under 80 milliseconds without waiting for an LLM answer.

Decision: Map speech audio transcription to discrete device command opcode.
72ms total latencySource
githubOpen source

Jev CI Selector: Predictive Test Runner

GitHub Action that inspects git commits and PR diffs to select ONLY the 5% of test suites relevant to the changed code paths.

Decision: Which test suites need to run for this specific git commit diff?
Cuts CI runtime by 65%Source
githubOpen source

FastAPI Jev Micro-Gateway

Production Python microservice featuring automatic semantic response caching, rate limiting, and fallback fallback routing for Jev API calls.

Decision: Can this inbound decision request be satisfied by the localized LRU cache?
Handles 10k req/sec with RedisSource
githubOpen source

Android On-Device Jev Runtime

Quantized INT8 decision model running natively on Snapdragon NPU hardware inside an Android service without internet connection.

Decision: Classify user screen state for accessibility voice navigation.
14ms on Snapdragon 8 Gen 3Source
githubOpen source

Cloudflare Worker Jev Edge Router

Global serverless worker executing fast A/B test branch routing and geo-targeted personalization at edge points of presence.

Decision: Which variant experience should be served to this incoming HTTP request?
Sub-8ms routing at 300+ edge PoPsSource
githubOpen source

Unity Dynamic NPC Branch Arbiter

C# plugin for Unity 6 engine that selects responsive NPC dialogue branches and emotional states in real-time without stalling render frame rates.

Decision: Select NPC dialogue response and animation stance matching player tone.
60 FPS guaranteed · Zero frame dropsSource
githubOpen source

Jev Trader: Autonomous Micro-Arbitrage

A sub-second paper trading algorithm reading Binance and Coinbase order books to exploit cross-exchange spread anomalies.

Decision: Execute buy or sell order based on order book depth imbalance.
70ms latency at $0.004 per cycleSource
githubOpen source

typesafe-rag-router: Semantic Hybrid Search Gate

A sub-10ms decision layer that decides whether user queries need dense vector embeddings, BM25 exact match, or direct cache.

Decision: Which retrieval index is optimal for this query complexity?
9.4 ms routing · 80% embedding cost savedSource
engineeringBuild report

What is Jev Engineering? The 3-Tier Architecture

The foundational architectural paradigm: an LLM that writes, Jev that decides, and deterministic code that acts. Eliminates hallucinated actions and brittle regex.

Decision: Partition complex AI software loops into generative, decision, and actuation layers.
5x faster development · 99.9% reliabilitySource