Last updated 2026-09-22 · facts and likes checked 2026-09-22
Jev is a "System One" model — one that only makes fast judgements. A language model writes its answer token by token; Jev evaluates every question you ask against the same state in parallel, and each answer lands inside a range you defined up front, with a calibrated probability attached. That makes it very different from an LLM in two ways: adding questions barely changes speed or cost, and an answer can never come back malformed. The price is that it cannot say anything outside the range you gave it.
This page is about what people built with it. For pricing, the API reference and copy-paste code, see Jev API: pricing and how to call it.
Taken from TypeSafe's documentation and launch post, checked on 2026-09-22. Rows marked as a claim are the vendor's figures, not our measurements.
| Maker | TypeSafe (typesafe.ai), founded by Diogo Almeida source |
|---|---|
| Released | 15 September 2026, as TypeSafe's first "System One" model source |
| Current version | Jev 1.13 — the alias jev-latest points to jev-1.13.0 source |
| Endpoint | POST https://api.typesafe.ai/v1/systemone (its own shape, not Chat Completions) source |
| Price | $0.042 per million input tokens; output tokens are free source |
| Per-request budget | 64k tokens in total; state plus the longest question must fit in 32k source |
| Rate limit | 250,000 tokens/s or 1,200 requests/min, currently adjusted dynamically because of demand source |
| Input | Text only (string, JSON object or array). No images, audio or video. English first; other languages at variable accuracy source |
| Latency (TypeSafe's claim) | 70–500 ms end to end source |
| Access | Open to everyone since 20 September 2026 — no waitlist — through console.typesafe.ai source |
| Adoption | Also offered by OpenRouter, Vercel AI Gateway and Cloudflare within its first week; Vercel reported that about 13% of its gateway's paid teams used Jev within 24 hours (Vercel, 18 September 2026) |
| On apimodels.app | Available at POST /v1/systemone, wire-compatible with TypeSafe's API — $0.05 per million input tokens, output free, billed per token with no per-call minimum how to call it |
Jev answers exactly three shapes of question, and one request can mix many of them:
| Type | Returns | Typical use |
|---|---|---|
| Choice | One option out of up to 255, plus the full probability distribution and a confidence | Routing, classification, picking the next action |
| Score | A probability-weighted value on a scale of 2 to 10 levels you define | Quality ratings, urgency, lead scoring |
| Noul | A single probability between 0 and 1 that a statement is true | Yes/no checks such as "does this diff touch auth?" |
Within a week of launch, these platforms and developer frameworks either added Jev or demoed and evaluated it in public. The ones that added it made the same choice: not to run it as an autonomous agent, but to put it at one fixed decision point inside a workflow.
| Platform | What they did | Date |
|---|---|---|
| LangChain | Published a study of Jev as a judge for agent evals, calling it through the langchain-typesafe package, and co-hosted a livestream with TypeSafe on 22 September | 2026-09-20 |
| Box | CEO Aaron Levie demoed Jev triaging incident reports stored in Box — severity, customer impact, folder and metadata | 2026-09-18 |
| Pydantic AI | Supports Jev for structured output, announced by Pydantic founder Samuel Colvin | 2026-09-18 |
| TanStack AI | Added a decide() API for typed choices, scores and booleans, with Jev as its first model | 2026-09-20 |
| Dify | Jev is available in Dify's Question Classifier node for routing inputs across workflow branches | 2026-09-18 |
| Stagehand (Browserbase) | Uses Jev as the decision layer inside its Act, Extract and Observe browser primitives — which element to click, field to fill, text to extract | 2026-09-18 |
These are not weekend demos: each is running inside a product, an agent or a developer library, shipped within days of Jev's launch. What they have in common is a decision that used to need an LLM call — mapping fields, picking a tool, routing a request — now made in a fraction of a second at a fraction of the cost.
Bannerbear published its first Jev feature. When a template's fields (photo, name, company_name) and a data source's columns (avatar, full_name, business in Airtable) use different names, Jev matches them in one click. Fuzzy field mapping is a textbook choice problem: every column picks one field.
Jon Yongfook @yongfook · 2026-09-18 · 134 likes
The agent was slow because it had to read its skills and work out which tools to call before doing anything. Now Jev first classifies each prompt into the best skill, tool and parameters, and the agent starts from there. The team reports it is twice as fast.
John Yeo @johnyeo_ · 2026-09-18 · 166 likes
minirouter/fusion went live two days after Jev launched: every request is classified with Jev, then sent to a hand-picked model that matches the task's type and complexity. The same update made its routers selectable in Codex's model picker.
Zhe @iamzhe · 2026-09-17 · 72 likes
TanStack AI shipped decide(), a new API for typed choices, scores and booleans, with Jev as the first model behind it. The API is designed to work with more models later — a sign that "decision" is becoming its own primitive in AI SDKs, next to "generate text".
TanStack @tan_stack · 2026-09-20 · 649 likes
Rather than building an autonomous agent, the Stagehand team put Jev inside its Act, Extract and Observe browser primitives. Jev decides which element to click, which field to fill or which text to extract; the surrounding code stays in charge of the workflow.
Kyle Jeong @kylejeong · 2026-09-18 · 112 likes
Compliance alerts, fraud screening, training-data QA, recruiting, sales outreach, document routing: the unglamorous, high-volume decisions that make up most of a company's automation budget. The numbers come from the builders themselves, but the pattern is consistent — thousands of items, fixed questions, cents instead of dollars.
Box's CEO demoed Jev on documents stored in Box: pull an incident report, ask whether it is customer-facing and how severe it is, move it to an escalate, monitor or review folder, and write the result into a metadata template — nearly instantly and at almost no cost. He names insurance claims, contract management, loan processing and security reviews as the same pattern.
Aaron Levie @levie · 2026-09-18 · 680 likes
agentrun() is a harness built on Jev that learns a repetitive job while it runs and moves steps from LLM calls into code. The team's figures: working through 100,000 compliance alerts would cost more than $290K on Opus 5; with agentrun() it came in under $26K, about 90% less.
AJ Asver @_aj · 2026-09-21 · 1,049 likes
Jev paired with Treg runs three workflows: fraud detection and sign-up screening on a website, triaging buying signals, and monitoring viral content. The author reports $8k a month saved and shares the flow for others to copy.
Jason Zhou @jasonzhou1993 · 2026-09-21 · 484 likes
A team building first-person training data for physical AI had Jev check 58,643 action labels in under three minutes for 90 cents — a fraction of what the same review costs with Claude or GPT models. Label QA at this volume is repetitive checking that is hard to justify paying LLM prices for.
Peter Wang @the_cyw · 2026-09-18 · 18 likes
Jev looks at a PDF page by page and decides which pages actually need OCR; the rest are extracted locally. Fewer pages go through the paid OCR step and documents finish sooner. A small decision in front of an expensive step is one of the most reliable ways Jev pays for itself.
Misbah Syed @MisbahSy · 2026-09-18 · 483 likes
Starting from a company's homepage, the crawler has to find the careers page and pick out roles that match a profile. Every site is organised differently, so each navigation step becomes a choice for Jev. With an LLM it took about five minutes; with Jev, just over 20 seconds in the author's test.
Kai @hqmank · 2026-09-18 · 75 likes
Thousands of outreach messages went in with one question: which intent signals led to the most booked demos? The answer came back in 40 seconds for under $0.20. The same setup ranks leads and scores how well each message fits its prospect.
Pierre-Eliott Lallemant @pierreeliottlal · 2026-09-18 · 114 likes
The papers already carried tags from an earlier open model (DeepSeek V4 Flash). Jev re-organised about 2,300 of them in roughly 83 seconds for $0.14 in total, and the author calls it a production use case — a common pattern of using Jev to clean up what a cheaper LLM labelled first.
elvis @omarsar0 · 2026-09-21 · 78 likes
Asked to find viral content for one brand in a library of more than 11 million TikTok and Instagram videos, Jev returned 384 videos in 20 seconds, with the hook, format and angle of each broken down — $0.09 in tokens.
jaffa @dsqjaffa · 2026-09-18 · 150 likes
3,000 products scored against multiple criteria in 28 seconds for $0.11. Multi-criteria scoring maps directly onto how Jev works: each criterion is its own question, and all of them are answered against the same product description in one call.
Nikunj Kothari @nikunj · 2026-09-18 · 742 likes
40 support tickets routed to nine desks — billing, access, bugs, shipping, trust and safety and more. Every ticket gets a probability for every team plus one primary route, with no LLM essay in between; about $0.0016 in tokens for the batch.
K2S @k2sbhai · 2026-09-21 · 51 likes
Given one candidate profile and 400 companies, Jev predicted which jobs the candidate was most likely to land, attached a confidence to each and flagged mismatches between job and candidate — 12 seconds and $0.0005 in total.
Sarvagya Kulshreshtha @sarvagya_kul · 2026-09-18 · 1,765 likes
Pointed at a competitor's ad library, Jev classified 1,891 ads by customer-journey stage and ad style in 19 seconds for $0.12, feeding a full analysis of the account. The author says it is coming to the maxfusion MCP server.
Stav Zilbershtein @mightyking · 2026-09-18 · 433 likes
Only cases whose original post gave concrete numbers, with the commercial ones first. These are the builders' own figures and we have not reproduced them; click a task to jump to its card and the original post.
| Task | Scale | Speed | Cost / result | By |
|---|---|---|---|---|
| Work through compliance alerts | 100,000 alerts | — | Under $26K vs over $290K on Opus 5 | @_aj |
| Fraud screening, buying signals, viral monitoring | 3 workflows | — | Saves $8k a month | @jasonzhou1993 |
| QA robot-training labels | 58,643 labels | Under 3 min | $0.90 | @the_cyw |
| Re-tag research papers | ~2,300 papers | ~83 s | $0.14 | @omarsar0 |
| Classify a competitor's ads | 1,891 ads | 19 s | $0.12 | @mightyking |
| Score products on several criteria | 3,000 products | 28 s | $0.11 | @nikunj |
| Find viral videos for a brand | 11M+ library, 384 found | 20 s | $0.09 | @dsqjaffa |
| Analyse outreach intent signals | Thousands of messages | 40 s | Under $0.20 | @pierreeliottlal |
| Crawl a company site for matching jobs | One company site | ~20 s vs ~5 min with an LLM | — | @hqmank |
| Match a candidate to jobs | 400 companies | 12 s | $0.0005 | @sarvagya_kul |
| Route support tickets | 40 tickets, 9 desks | — | ~$0.0016 | @k2sbhai |
| Pick skill and tool for a Slack agent | Every prompt | 2x faster | — | @johnyeo_ |
| Robot arm pick-and-place vs GPT-6 Astra | One task, arm at 10% speed | 27 s vs 71 s | "Much cheaper" | @MarianPogran |
| Classify AI papers into 24 topics | 1,018 papers | 256 ms median per paper | $0.08 total | @nutlope |
| Fraud email triage, LLM fallback | 100 emails, 96 correct | 1.42 s for all 100 | ~$0.07 total, Jev $0.003 | @nutlope |
| Break down live ads | 724 ads, 37 brands | 40 s | $0.09 | @TheMattBerman |
| Predict outreach performance | 700 leads | 40 s | $0.09 | @romanbuildsaas |
| Classify tax documents | Full corpus | 6x faster than their LLM setup | $0.001 per page, 34x cheaper | @nedwize |
| Review a pull request (14 checks) | 6 real PRs | ~0.5 s per PR | $0.00007 per PR | @redp314 |
| Score a social post | 61 questions per post | ~1 s | $0.0004 per post | @robj3d3 |
| Browser agent: find flights | One search | 7 s | $0.0039 | @gregpr07 |
| Voice-controlled browser | Per decision | ~300 ms | $0.0002 | @moritzkremb |
| Tetris vs two LLMs | 200 pieces each | 300 ms/move vs 1.13–1.52 s | Score 9,200 vs 8,900 / 9,000 | @ashutoshftw |
| Solve a Rubik's cube | 94 moves | ~250 ms per decision | ~4 s of model time | @redp314 |
| Memory retrieval for an assistant | Quick test | 2–3x faster | 94% fewer tokens | @moritzkremb |
| Rate spreadsheet rows by intent | Per keystroke | ~100 ms | — | @dabit3 |
| Skip YouTube sponsor segments | Per video | Real time | ~$0.005 | @tdinh_me |
| Play Slay the Spire 2 | Per move | ~0.7 s | — | @coolish |
| Real-money intraday trading | ₹1,00,000 at 5x leverage | — | Hit the ₹1,000 stop loss on day one | @IndraVahan |
Two things to keep in mind when reading this table. First, the low costs come from output being free: only input tokens are billed, so asking more questions of the same item barely adds anything. Second, the last row is a real-money trade that hit its stop loss on day one — speed and price say nothing about whether a decision was right, which is what the independent evaluations below get at.
Beyond vendor and builder numbers, these are third-party tests with a stated method and data — including results that go against Jev. The common thread: when the question and its rules are fully written down, Jev is accurate and cheap; when it has to rely on rules nobody wrote down, it is confidently wrong.
Jev vs GPT-5.6 Luna, GPT-5.6 Terra and Claude Sonnet 4.6 as a judge of agent runs; 5 captured runs × 100 repetitions, human labels as the oracle
Matched the human verdict on all 500 pass/fail decisions (Terra 99.8%, Luna 96.4%, Claude 80.0%); score variance 92–913x lower; 0.44 s and $0.00035 per call ($0.34 total vs $28.17 for Claude). LangChain calls it a narrow, early test.
50 deliberately tricky invoices and related documents across 10 languages, with OCR errors and misleading keywords; six models compared
Jev 50/50 at $0.025 per 1,000 decisions — best accuracy at the lowest cost (Claude Haiku 4.5 50/50 at $0.39). But on support messages whose house rules were left out of the request, Jev got 5 of 24 right, and 15 of the wrong answers came back above 0.90 confidence.
Reproducible compaction eval for the Hermes agent: can Jev decide which tool results to drop from context?
Jev 75.5% recall at 115K tokens vs Hermes's production approach at 78.9% recall at 55K tokens. At its default threshold Jev dropped all 851 tool-call candidates; at equal budget its ranking tied "keep the most recent". Hermes kept its existing approach and published the eval.
Probed Jev with classic trick questions such as counting letters
Documented a set of confident wrong answers and argues Jev hallucinates at a rate similar to other models — a useful counterweight to "cannot hallucinate" claims, which TypeSafe itself words carefully.
Two posts that look at Jev from the outside: a real robot arm doing the same task as GPT-6 Astra, and a collection of confident mistakes. Read them together with the independent evaluations above.
The same task on a physical AgileX arm — "put the red cube in the box" — driven once by Jev and once by GPT-6 Astra. Jev finished in 27 seconds, Astra in 1 minute 11 seconds, and Jev cost much less. The arm was capped at 10% speed for safety; the author expects a wider gap at full speed.
Marian Pogran @MarianPogran · 2026-09-19 · 274 likes
A widely shared thread of questions Jev gets wrong, starting with the classic "how many r's are in strawberry". The author notes that TypeSafe words its hallucination claims carefully, but argues Jev does hallucinate, at about the rate of other models. Read it before you trust any single high-confidence answer.
Dan @danman314 · 2026-09-20 · 1,868 likes
The strongest builds on this page share one shape: Jev only chooses among options it was given, ordinary code executes and verifies, and the probability Jev returns decides which items get escalated. The pull-request reviewer sends any critical check that scores between 0.35 and 0.65 to a person or a bigger model; the fraud pipeline sent the 31 emails below 95% confidence to Kimi K3 and reached 96 out of 100, with Jev's part costing a third of a cent. Box, Stagehand and agentrun() follow the same idea: code owns the workflow and Jev acts only at fixed decision points.
This is where a calibrated probability earns its keep: it is not decoration, it is a routing signal. Huryn's test also shows its limit — when a mistake comes from a business rule missing from the request, the probability stays high anyway. Write the rules into every request; a confidence threshold only catches the mistakes the model knows it might be making.
Below are the community's first builds from 15 to 18 September, grouped by what they do. Many are demos rather than products, but they tested thoroughly what Jev can and cannot do — most of the commercial patterns above first appeared here.
An agent loop is mostly small choices — which element to click, whether the page changed, what to do next — and each one costs a full LLM round trip in a normal setup. Builders swapped those choices for a Jev call and kept an LLM only for the rare step that has to type free text. This was the single most common thing people built in the first week.
The Browser Use team built a small open-source agent where the page's DOM is the state and the clickable elements become a fresh set of options at every step; a small LLM only steps in to type. A flight search took 7 seconds and $0.0039, shown at real speed.
Gregor Zunic @gregpr07 · 2026-09-17 · 8,953 likes
A computer-use agent built on Jev that the author reports is about 155 times cheaper than Opus 5 and roughly 20 times faster, and that generalises across operating systems. The thread explains how the screen is turned into choices.
aaron @awlevin · 2026-09-16 · 2,303 likes
Speech is transcribed, the transcript goes to Jev, and the returned probabilities decide what the browser clicks — about 300 ms per decision at $0.0002 each. It even handled relative commands like "go back".
Moritz Kremb @moritzkremb · 2026-09-17 · 3,792 likes
A local CoreML model segments every button on screen and on-device OCR reads the labels; only that text reaches Jev. No screenshots, no DOM and no LLM — a design that keeps pixels private while still letting a remote model decide.
Milind S @milindlabs · 2026-09-17 · 1,999 likes
Jev paired with AXe, a command-line tool for the iOS Simulator, to tap through an app quickly at a fraction of what an LLM-driven loop would cost — the kind of thing mobile QA automation has wanted for a long time.
camsoft2000 @camsoft2000 · 2026-09-17 · 1,264 likes
A side-by-side of adding a macOS Calendar event with Codex's built-in computer use versus a Codex + Jev version. The Jev run moves with almost no pauses while token spend stays about the same.
Sac @Saccc_c · 2026-09-18 · 1,758 likes
Trading is the cleanest fit on paper: price comes in, the answer is buy, sell or hold, and the loop repeats every few hundred milliseconds. The demos below range from paper trading to real money — and one of them hit its stop loss on day one, which is the reminder that a fast decision is not a correct one.
Given a live price feed for a trading pair, Jev answers buy or sell and the bot places real orders on Kuru's on-chain order book, deciding once per 300 ms Monad block. It is a demo with a public link, not an investment strategy.
Jarrod Watts @jarrodwatts · 2026-09-16 · 5,095 likes
The popular AI Hedge Fund project added Jev for its trading decisions: set a strategy, pick tickers, backtest. The author says the system now runs in seconds instead of minutes, about a hundred times faster and cheaper than with an LLM.
Virat Singh @virattt · 2026-09-18 · 1,069 likes
A public experiment that lets Jev make every decision for a $10,000 paper-trading account via the Alpaca brokerage API. Paper trading is the right way to try this: it shows behaviour without risking money.
Marcel Pociot @marcelpociot · 2026-09-17 · 452 likes
Not paper trading: ₹1,00,000 in a real brokerage account, intraday on India's NIFTY at 5x leverage. After a green morning it hit the preset ₹1,000 hard stop. We include it deliberately — it is the honest counterweight to every demo above.
Indra @IndraVahan · 2026-09-18 · 883 likes
Games are the easiest way to see latency with your own eyes. Each frame asks one question — jump, dodge, which card — and a model that answers in a few hundred milliseconds can keep up where a chat model visibly stalls. Most of these are demos rather than products, but the Tetris run is a proper side-by-side against two LLMs.
One of the first demos after launch. Fast inference plus answers that are always one of the allowed moves make a platformer surprisingly playable, which is exactly the property real-time software needs.
Faadil Shaik @faadilhshaik · 2026-09-16 · 2,900 likes
Jev plays Subway Surfers faster than a person, then plays fifty games in parallel, for under a cent for the whole run. The author is careful to say it does not replace frontier LLMs — it opens a different kind of capability.
Max Blade @_MaxBlade · 2026-09-17 · 4,080 likes
The author had previously used GPT-6 Astra to play Slay the Spire 2 — strong but slow. With Jev each think-and-act step took about 0.7 seconds, fast enough that the moves happen before you can follow them.
paulwei @coolish · 2026-09-17 · 1,169 likes
Four characters, all controlled by Jev and fighting each other, each choosing a move in a fraction of a second. The match used more than 22 million tokens and cost a few cents — possible only because input is cheap and output is free.
Mau Baron @maubaron · 2026-09-18 · 3,674 likes
The same 200 pieces and the same legal moves for all three, in real time. Jev scored 9,200 at 300 ms per move; Claude Haiku 4.5 scored 8,900 at 1.52 s; Gemini 3.5 Flash-Lite 9,000 at 1.13 s. All three made zero illegal moves — the difference was speed, not correctness.
Ashutosh Mathore @ashutoshftw · 2026-09-17 · 126 likes
Two minutes of automatic Minecraft play for about one cent (150k tokens). Without being told to, it learned to keep away from zombies when night fell — the decision came from the game state it was shown, not from a prompt.
Just_Lingonberry_352 @JustLingonberry · 2026-09-16 · 267 likes
Control loops need an answer before the world moves on. These builders wired Jev to simulators and a real cube, with ordinary code doing the maths and Jev picking the case at each step. Everything here is simulation or a toy — none of it is evidence that Jev should drive a real car.
A simulated self-driving setup the author put together in less than an hour, with Jev making the driving decisions. The title the author used is a joke about Tesla FSD; what it really shows is how quickly a control loop can be prototyped.
Justin Schroeder @jpschroeder · 2026-09-16 · 4,797 likes
A drone application made in about fifteen minutes that cost ten cents to run, with the code published on GitHub. A useful template if you want to see how state is packed into a request for a moving vehicle.
Roman Slack @RomanSlack1 · 2026-09-16 · 360 likes
Full launch to landing with no autopilot, no scripted trajectory and no safety override — every decision is Jev's, and they are printed along the bottom of the video. The booster lands. It is a simulator, which is exactly where this belongs.
Utkarsh Agrawal @uttkarsh_42 · 2026-09-17 · 139 likes
Jev is wired to the raw controls of a driving simulator that keeps running while it thinks. That is the real test: asking a model every 50 ms and stitching the answers into a video is easy, reacting inside a world that will not wait is not.
Toran Bruce Richards @SigGravitas · 2026-09-16 · 288 likes
The beginner method lives in code; at every step Jev looks at the cube and picks which case it is in, and code checks each pick. It solves in 94 moves, not the optimal 22, with about 4 seconds of model time at roughly 250 ms per decision.
Paolo Rosson @redp314 · 2026-09-17 · 716 likes
This is where the economics are hardest to argue with: thousands of documents, ads or leads, each asked a dozen fixed questions, for cents in total. Output tokens are free, so asking more questions of the same item barely changes the bill. The fraud example shows the pattern that makes it safe — send the low-confidence cases to a bigger model.
Every ad was broken down by hook, format, offer, call to action, awareness stage and whether it matches its landing page — 40 seconds and nine cents of tokens for the whole set.
Matthew Berman @TheMattBerman · 2026-09-17 · 6,726 likes
A cheap LLM (DeepSeek V4 Flash) summarises each paper, then Jev picks one of 24 topics from the title and summary. Total cost $0.08, median end-to-end latency 256 ms per paper — a clean example of an LLM and Jev each doing the part it is good at.
Hassan @nutlope · 2026-09-17 · 1,976 likes
Jev classified 100 emails (50 legitimate, 50 fraudulent) in 1.42 seconds. The 31 it was less than 95% confident about went to Kimi K3; the combined pipeline got 96 of 100 right for about $0.07, of which Jev's share was a third of a cent.
Hassan @nutlope · 2026-09-17 · 865 likes
Replacing an LLM pipeline built the previous tax season, Jev classifies the team's entire tax-document corpus at $0.001 per page — the author reports 34 times cheaper and 6 times faster than before. The code is on GitHub.
Nakshatra Saxena @nedwize · 2026-09-18 · 3,365 likes
Each draft is asked 61 questions in about a second for $0.0004, using a scorer fitted on 9,481 real posts from 207 creators. The author says it picks the post that went viral two times in three and does not reward reply bait. Write, score, rewrite, stop when it peaks.
Rob Hallam @robj3d3 · 2026-09-17 · 1,369 likes
700 high-intent leads, each with a personalised message. In 40 seconds Jev predicted how each message would land, attached a confidence score and flagged leads whose message did not fit them — $0.09 in total.
Romàn @romanbuildsaas · 2026-09-18 · 3,333 likes
Inside coding agents there are decisions nobody wants to pay LLM prices for: which model should take this task, which tool calls can be dropped from context, which memory is relevant. Builders moved those to Jev and reported large drops in tokens and time. The PR reviewer is the most complete example: fourteen checks, one call, and a rule for escalating anything uncertain.
Instead of asking an LLM to summarise a long agent history, Jev scores every tool call for relevance and the irrelevant ones are dropped. A popular idea — but when Nous Research tested it on its Hermes agent with a reproducible eval, Jev reached 75.5% recall at 115K tokens against 78.9% at 55K for Hermes's existing approach, and at its default threshold it dropped all 851 tool-call candidates. Treat it as something to measure, not a proven win.
tamara @tamarajtran · 2026-09-17 · 10,760 likes
A diff goes in; fourteen typed checks come back as probabilities — hard-coded secrets, SQL injection, touches auth, deletes tests, breaks the API, leftover debug code, whether the description matches the diff, blast radius. Code turns them into block, security review, nits or merge, and anything a critical check scores between 0.35 and 0.65 goes to a human or a bigger model. About $0.00007 per PR.
Paolo Rosson @redp314 · 2026-09-17 · 2,759 likes
Many browser sessions run in parallel, each with Jev choosing actions meant to break the app, on every release. Because each decision costs a fraction of a cent, running a crowd of hostile testers becomes affordable.
Rafal Wilinski @rafalwilinski · 2026-09-18 · 5,378 likes
Jev reads the incoming request, decides which model fits it best, and the request is forwarded there. Routing is a pure choice problem, which is why it keeps showing up as a first Jev project.
Duncan @ephraimduncan · 2026-09-17 · 1,864 likes
Delegation used to be rules in a system prompt. Now a hook asks Jev before each hand-off: mechanical tasks go to Haiku, harder ones to Opus sub-agents, long implementation work to an external harness. The author reports it matches task difficulty well.
Lahfir @mdlahfir · 2026-09-16 · 837 likes
Jev decides which stored memories are relevant before anything is sent to the main model. In a quick test the author measured 94% fewer tokens and memory retrieval two to three times faster.
Moritz Kremb @moritzkremb · 2026-09-17 · 477 likes
When a model answers in about a hundred milliseconds, it can run on every keystroke, every cell edit or every downloaded file without the user noticing. That turns "AI features" from a button you press into behaviour that is simply there. These are small, shippable ideas rather than research demos.
Type "Urgency" as a column header and, while you are still typing, each row gets rated from "no follow-up needed" to "urgent" in about 100 ms. Spreadsheets recalculate numbers; this one recalculates meaning.
nader dabit @dabit3 · 2026-09-18 · 1,197 likes
Describe what you do not want to see, and posts matching it are hidden or collapsed as you scroll — fast enough that you do not notice the check. The author's point: this is what ad blockers and content firewalls could become.
Marcel Pociot @marcelpociot · 2026-09-17 · 1,102 likes
An open-source Chrome extension that optionally listens to a video's audio, notices when a sponsor segment starts and skips it, at roughly $0.005 per video. It is bring-your-own-key and explicitly a prototype.
Tony Dinh @tdinh_me · 2026-09-18 · 1,093 likes
A macOS app watches the Downloads folder against a set of rules you write. Is this file an invoice? It is moved to the right folder with a proper name. No LLM calls at all — only Jev.
Marcel Pociot @marcelpociot · 2026-09-18 · 1,143 likes
Jev follows the intent and arguments as you type and runs the function as soon as everything it needs is present — and stays quiet when nothing is needed. Latency this low changes where in the interface a model can sit.
Yoshiki Miura @miiura · 2026-09-17 · 343 likes
As the presenter talks, the slide that matches the current point appears on its own — no clicker, no keyboard. A Japanese demo whose author sums it up as "anyone can present like Steve Jobs now".
Rinte @rinte0321 · 2026-09-18 · 420 likes
Jev cannot write text, so people made it write text anyway — one character or one word at a time, as a chain of choices. These are clever and slow, and they are the best illustration on this page of why Jev is not a replacement for a language model.
Each pixel is a separate question and all of them are asked in parallel, so an image appears at once. It works because Jev evaluates many questions against the same state in a single call; it is a demonstration of that parallelism, not an image model.
Anshu @anshuc · 2026-09-16 · 1,563 likes
For every next character Jev is asked 29 yes/no questions — a to z, space, comma, period — the most likely one is appended, and the text is fed back in. An autoregressive loop made from a classifier: fun, instructive, and far slower than just using a language model.
vogel @ryanvogel · 2026-09-16 · 889 likes
"Jev can't generate text" — so the author gave it a couple of hundred common English words plus punctuation as options and let it pick one at a time. It says things; it just cannot say anything outside the list it was handed.
Isaac Tai @hi_im_isaac_ · 2026-09-17 · 4,495 likes
The official announcement, a 45-second community summary, and a full tutorial that covers API setup and three builds.
TypeSafe's founder, who describes himself as a co-inventor of ChatGPT, introduces Jev and the training method behind it (RLCD) after two years in stealth, claiming 20–200x faster and 40–400x cheaper than LLMs for decisions, with output tokens free.
Diogo Almeida @CompleteSkeptic · 2026-09-15 · 74,862 likes
A short community explainer made because the official launch video was hard to follow. If you want the core idea before reading anything else on this page, start here.
Matija Sosic @MatijaSosic · 2026-09-16 · 9,598 likes
A longer walkthrough: what Jev is, how to set up the API, then three builds — a voice-controlled browser, an AI memory system and a YouTube performance predictor — with timestamps for each part.
Moritz Kremb @moritzkremb · 2026-09-17 · 3,050 likes
Within a week the community released several decision models you can host yourself, mostly built as a small open model plus LoRA plus a decision head. The accuracy figures below are each author's own eval with no shared benchmark, so they do not compare across rows. They are worth a look when data must stay on your own hardware; when you want the stronger model without running GPUs, the API is simpler.
| Project | What it is | Versus Jev |
|---|---|---|
| Kev Jared Palmer | 0.6B / 4B / 8B decision models on Qwen3 (LoRA plus a small pointer head), Apache 2.0, with a drop-in TypeSafe-compatible API. Kev-4B trains in 40 minutes on one H100 and serves on a 32 GB Mac. | Out of domain: Kev-8B 79.6% vs Jev 85.7% (author's eval) |
| Bespoke Nimble Bespoke Labs | Open data, open model and open recipe: a LoRA fine-tune of Qwen3.5-9B trained on synthetic "contrastive" data where facts are slightly changed to create negatives; about 100 ms on an H100. | Their eval: base Qwen 66% → Nimble 90%, Jev 93% |
| Open-Jev Zefan Cai | 2B and 9B open decision models built from LoRA adapters plus decision heads, with code, data and weights on GitHub and Hugging Face. | No head-to-head numbers published |
| Laya community (shared by Paul Couvert) | A small open classification system that runs in under 1 GB of memory on a laptop or phone — shown playing Snake at 60 decisions per second. | Easy to fine-tune, but only a 1k-token context and, by the poster's own account, weaker generalisation than Jev |
apimodels.app serves Jev at POST https://api.apimodels.app/v1/systemone, with requests and responses identical to TypeSafe's API field for field. It costs $0.05 per million input tokens with output free, billed per token with no per-call minimum, and failed calls are not charged — the two-question request below is billed as 385 input tokens, about $0.00002. If you already use TypeSafe's official SDK, point base_url at https://api.apimodels.app and swap in your apimodels key.
curl https://api.apimodels.app/v1/systemone \
-H "Authorization: Bearer $APIMODELS_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "jev",
"state": "Support ticket: I was charged twice for my September invoice and need one of the payments refunded.",
"questions": {
"queue": {
"type": "choice",
"instructions": "Which support queue should handle this ticket?",
"criteria": {
"billing": "Payments, invoices, charges and refunds",
"bug": "Something in the product is broken",
"account_access": "Login, password or permission problems",
"other": "Anything else"
}
},
"urgent": {
"type": "noul",
"instructions": "The customer needs a response within the hour."
}
}
}'Response (passed through unchanged):
{
"model": "jev-1.13.0",
"answers": {
"queue": {
"type": "choice",
"choice": "billing",
"confidence": 1.0,
"probabilities": { "bug": 0.0, "other": 0.0, "account_access": 0.0, "billing": 1.0 }
},
"urgent": { "type": "noul", "noul": 0.29 }
},
"usage": { "input_tokens": 385, "output_tokens": 63 }
}The same key also calls the LLM, image and video models on the site, so the cases Jev is unsure about, or anything that needs words, do not need a second provider. Python and SDK examples and a price comparison with TypeSafe are on /access/jev-api.
Jev is a decision model from TypeSafe, released on 15 September 2026. You send it your application's state and a set of typed questions, and it returns an answer for each one — a choice, a score or a yes/no probability — with a calibrated probability attached. It does not generate text. TypeSafe calls this category "System One" models, after the fast, intuitive mode of thinking.
TypeSafe lists $0.042 per million input tokens, and output tokens are free. On apimodels.app Jev costs $0.05 per million input tokens, output free, billed per token with no per-call minimum — a typical 400-token decision costs $0.00002, and a failed call costs nothing. That is why builders report cents for thousands of decisions. TypeSafe's rate limits are 250,000 tokens per second or 1,200 requests per minute, adjusted while demand is high.
No and no. Jev cannot write text, code or explanations, so it cannot replace a language model; it replaces the many small decisions an LLM is often used for inside software. The most successful builds on this page use both: Jev for high-volume choices, a language model for anything that needs words and for the cases Jev is unsure about.
Anything where the answer is one of a known set and you need it often: routing requests to the right model or queue, labelling documents, scoring leads or content, choosing the next action in an agent loop, and filtering what goes into an LLM's context. Start with a task you already solve with an LLM and a fixed list of labels — it is the easiest to compare.
Since 20 September 2026 there is no waitlist: you can sign up with TypeSafe at console.typesafe.ai, and several API gateways also carry Jev. On apimodels.app it is POST /v1/systemone with the same request and response as TypeSafe's, so one apimodels key covers Jev alongside the LLM, image and video models you already call. Either way, the API is its own shape — a state plus a map of questions — not the Chat Completions format most SDKs expect.
Yes. Send POST https://api.apimodels.app/v1/systemone with your apimodels key and "model": "jev". The request and response match TypeSafe's API field for field, so the official typesafe-sdk works by pointing base_url at https://api.apimodels.app. Pricing is $0.05 per million input tokens with output free, billed per token; failed calls are not charged. A copy-paste example is on /access/jev-api.
Yes, and the results cut both ways. LangChain found Jev matched a human reviewer on all 500 pass/fail judgments of agent runs, with far lower variance and cost than LLM judges, while calling its test narrow. Paweł Huryn found it the most accurate and cheapest of six models on tricky invoices, but only 5 of 24 right when business rules were left out of the request, often with high confidence. Nous Research found it did not beat their existing context-compaction method. The pattern: strong when the question and its rules are fully stated, weak when they are implied.
Several appeared within a week of launch: Kev from Jared Palmer (0.6B, 4B and 8B on Qwen3, Apache 2.0, with a TypeSafe-compatible API), Bespoke Nimble (a Qwen3.5-9B fine-tune), Open-Jev (2B and 9B) and Laya (under 1 GB). You host them yourself. Their authors' own evals put them below Jev — Kev-8B 79.6% vs Jev 85.7% out of domain, Nimble 90% vs Jev 93% — and there is no shared benchmark. Choose them when data must stay on your own hardware; choose the API when you want the stronger model without running GPUs.
They are public posts on X from 15 to 21 September 2026. The first batch came from the community collection at https://github.com/Hiwoniu/Jev-Case; the business, shipped-product and evaluation posts came from our own searches of X after 18 September. We read every candidate and left out promotional posts, crypto token shilling and other gateways' announcements. The titles and summaries are our own; each card links to the original post, and the video plays through X's official embed. Speed and cost figures are what each builder reported — we have not reproduced them.
The launch-week experiments come from the community collection Hiwoniu/Jev-Case of 202 X posts from 15 to 18 September 2026. We read the 98 with more than 20,000 views one by one, removed promotions by other API platforms, posts with no information, political content and ethically fraught demos, and grouped the rest by what they build.
The commercial, evaluation and open-source sections come from our own searches of X after 18 September, using keyword groups for launches, customers, savings, integrations and business use: we read all 130 candidates and kept only posts with a product, numbers or a method, leaving out crypto token shilling, marketing posts without detail and other API gateways' promotions. That leaves 62 use cases and 3 explainers, all rechecked on 2026-09-22 and still live. Titles and summaries are ours, written separately in English and Chinese; the videos and original text belong to their authors and are shown through X's official embed.