Projects, posts and guides about Jev, the System One model from TypeSafe AI. Each entry links to its source and shows the cost and speed its author reported.
After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI?
I’ve spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev
• 20-200x faster
• 40-400x cheaper (w/ output tokens free)
• Frontier composable intelligence optimized for decisions
AFAICT the shortest path to AI-based economic revolution
The launch post, 15 Sep 2026
Gregor Zunic
@gregpr07
Breaking: Browser Use + Jev = Ultrafast ⚡
Findings flights took 7s and cost only $0.0039 🤯
> new action space every step
> DOM state space
> small LLM fallback to type
(this video is at 1x speed btw)
Built a tiny open source browser agent. try it below ↓
jev is INSANE.
in 40 seconds it broke down 724 live ads from 37 brands.
every hook. every format. offer. cta. awareness stage. landing page mismatch. used 9 cents of tokens.
(will be avail in @stealads + mcp)
Jev + SuperX = virality solved ✅
Every post gets 61 questions in ~1s for $0.0004 🤯
> fitted on 9,481 real posts from 207 creators
> picks the viral post 2 in 3 times
> never rewards reply bait
So: write, score, rewrite, stop when it peaks.
Free, no signup. try it below ↓
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.
Romàn
@romanbuildsaas
JEV is INSANE.
We gave it 700 high-intent leads and personalised outreach messages.
In 40 seconds, it predicted how each message would perform, assigned a confidence score and detected lead-message mismatches.
All for just $0.09.
JEV can also score leads, analyse buying signals, match each prospect with the best message and identify the campaigns most likely to perform based on data.
Coming soon to @GojiberryAI+ MCP.
Comment “JEV” for early access.
got @typesafeai’s new model Jev to play Super Mario Bros.
fast inference + structured outputs makes it surprisingly good for real time use cases.
I'm excited to see what can be done with these new models!
jev is INSANE.
in 243 ms it checked a website for 35 tells of ai slop.
purple gradients. emoji headers. "seamlessly". fake testimonials. bento grids. the works. used $0.00015 of tokens.
paste any url, get a slop score. free:
madewithjev.com/free-tools/ai-…
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.
Marcel Pociot 🧪
@marcelpociot
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.
I gave Jev 3,282 of my X posts across 100M views and asked it to find what actually works for growth.
4,252,330 tokens $0.1282 for the full 8m 34s run!
Each post got 8 questions about the topic, hook, tone, whether it teaches something, etc.
How-to posts got 150 median likes vs the average median of 44.
AI and coding was a 1.9x multiplier topic compared and SEO, despite recent posts, was right at base median 1.0x - surprisingly.
The recommended topic + angle + voice formula was:
AI coding + teach something + provocative
We just ran Jev on our WebMCP benchmark.
The result: basically broke the benchmark.
Jev + Mercury 2.5 (a fast, low-cost LLM) using WebMCP solved 100% of the tasks at roughly 112× lower model cost than GPT-6 Astra using computer use with code execution. Compared to Astra using screenshot-based computer use, the model cost was 245× lower (!).
We also compared Jev operating the browser with and without WebMCP.
We used Browser Use’s open-source Ultrafast, with some improvements to the harness to make it more reliable across the benchmark.
Jev’s browser-control accuracy on its own was not amazing - adding WebMCP nearly doubled the number of solved tasks, from 25/49 to 49/49, while reducing model cost by 18% (more on why below).
The benchmark and methodology are fully open and reproducible.
Full results: https://webmcp.com/benchmark
A few words on how the Jev + WebMCP harness works and why this is exciting:
Jev receives text as input and a set of discrete options it can choose from. With WebMCP, those options are the tools exposed by the website. At each step, Jev sees the task, the available tools and previous results, then picks what to do next.
The limitation is that Jev can’t generate arbitrary text, which you need for tool arguments. For example, it can choose the search_products tool, but it can’t generate the search query itself.
So we split the work: Jev picks the tool and Mercury 2.5 generates the arguments if needed.
This works well because turns out most of the cognitive load in these tasks is around choosing the right action. The argument generation itself is relatively simple, so we can delegate to a small and very fast model. We used Mercury, which outputs 1,000+ tokens/sec and is very cheap.
The result is a pretty simple combination: Jev for tool selection + Mercury for arguments + WebMCP for the interface. It ends up being very reliable, very fast, and very cheap.
A few words about Ultrafast and why do we think it underperforms:
Without WebMCP, Jev chooses from the page’s controls: which button to click, which field to fill, or which option to select.
But choosing a valid button is different from choosing the right next step. The agent still has to navigate menus, understand forms, recover from errors and recognize when the task is actually complete.
Our hypothesis is that WebMCP makes the decision space much simpler. Instead of figuring out a sequence of clicks through a website, Jev chooses explicit actions that directly advance the task.
@typesafeai itself documents weaker accuracy on questions requiring multiple reasoning steps. WebMCP moves much of that complexity into the website’s tools, leaving Jev with clearer decisions and fewer opportunities to go wrong (in a sense WebMCP "compresses" a sequence of clicks into one tool call).
Our modified Ultrafast setup solved 25/49 tasks - that is a result for our particular implementation and benchmark, not a universal limit on Jev or Browser Use. We are open to more harness optimization to get this result to perform better, feel free to directly contribute to the benchmark here: https://github.com/nekuda-ai/WindTunnel
Browser-use ultrafast: https://github.com/browser-use/jev-ultrafast
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.
Riley Brown
@rileybrown
Yeah Jev by @typesafeai is very cool. It classified 500 emails in seconds. And it costed 3.5 cents.
I used Jev to classify 1,018 AI research papers.
The result: $0.08 total cost and 256ms median end-to-end latency per paper.
The pipeline was:
1. Summarize each paper with DeepSeek V4 Flash
2. Send the title + summary + 24 possible topics to Jev
3. Use Jev to classify each paper
4. Visualize everything on http://1kpapers.com
The summaries cost $3.99 on @togethercompute. The classifications cost $0.08 on @typesafeai.
So for just over $4 of inference, I ended up with a pretty useful way to explore the top AI research papers from the past year.
I think this is where things are heading: different models for different parts of the workflow, instead of using one model for everything.
I’m running evals on the Jev classifications before replacing the current ones, but the site is already live: http://1kpapers.com
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…
TypeSafe’s launch post: the model, the evals, and their caveats.
Riley Brown
@rileybrown
Just created this with Jev by @typesafeai. A live viral post analyzer. As soon as you stop typing for .5 seconds it analyzes the viral potential.
Going to try and actually make this good, will need to scrape a lot of twitter data...
Notice how it also categorizes the tweet live... I could have it surface similar tweets on the right side for inspiration... idk just experimenting.
Browser Use’s browser agent, with Jev choosing each next step.
BUBrowser Use
~2.9k
Kyle Jeong
@kylejeong
we built blazing fast computer/browser use with Jev + @Stagehanddev.
this task cost $0.001 and executed at near instant speed (in a remote browser btw)
the loop: observe the page, send a11y tree as state + actions as questions, Jev decides the next action, then Stagehand executes it.
Computer use on macOS, with one Jev decision per step.
ALAndrew Levin
~$0.0002
GREG ISENBERG
@gregisenberg
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.
Greg Isenberg: find an expensive queue and put Jev at the front of it. Seven ideas, from instant quotes to lead scoring, plus a Startup Ideas Pod episode with Ryan Vogel.
Jarrod Watts
@jarrodwatts
I built a trading bot with Jev!
Jev decides if it should "buy" or "sell", given the price feed of an asset pair, and executes real trades.
It uses Monad to place the orders on Kuru's on-chain order book in every 300ms block.
Demo link → jev-trader.vercel.app
The three question types, Choice, Score and Noul, in one support-ticket example.
Dan Shipper
@danshipper
we almost never test new foundation models but we've been testing this for ~a week @every and it's pretty wild.
the kind of things that will be obviously indispensible in 6-12 months
it doesn't produce words as output, it produces probabilities. so it can efficiently act as a judge in cases where you'd need a Fable-level model—but in our testing was 25x faster and 600x lower priced
excellent vibe check by @hammer_mt on @every:
https://every.to/also-true-for-humans/mini-vibe-check-typesafe-s-jev-judged-everything-i-ve-written-in-0-7-seconds?utm_cta_source=home_main_a_3
Jev picks from the legal moves, compared with reasoning models.
MSMaxim Saplin
tamara
@tamarajtran
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
TypeSafe’s recipe for picking at most one skill per agent turn out of 182: one request ranks them all, a second reads the top three.
Hassan
@nutlope
Jev + Kimi K3 for fraud detection!
TLDR: Jev classified 100 emails in 1.42 seconds, then I routed the uncertain cases to Kimi K3. The full pipeline got 96/100 correct for only ~$0.07.
Video is not sped up, check out the live run!
Here was my process:
I gave Jev 100 emails to classify (a mix of 50 legit & 50 fraudelent emails). It classified all of them in 1.42 seconds.
An underrated feature about Jev is it will give you the confidence score for a classification, so I routed any prediction under 95% confidence to Kimi K3 to be fully sure.
31 emails fell below that threshold. After routing those to Kimi K3, the combined pipeline reached 96% accuracy.
The full run took 16 seconds & ~$0.07 in inference costs:
- $0.068 from Kimi K3 on @togethercompute
- $0.003 (1/3 of a cent) from Jev on @typesafeai.
I think this is a really interesting pattern: use a fast specialized model like Jev for the narrow task, then route the uncertain cases to a larger LLM.
I feel like this kind of approach could be a game changer for use cases like fraud or anything realtime. You can use the speed & low cost of Jev while having a larger LLM as a fallback to ensure high accuracy.
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.
Okay so Jev can actually do computer use really well
Without any screenshots, or LLMs and no Pixels leave my mac
I dont even read the Dom elements
A local CoreML model segments every button and UI element on screen.
On-device OCR reads the labels. That text is all Jev gets.
It returns a probability across those elements and tells me the best one to click.
Then it clicks, re-runs detection, and decides again. In a loop until the goal is done.
~90ms per decision. Faster than any LLM computer use I've tried.
Blazing fast computer use, without any latency
@typesafeai is building something really interesting
Cloudflare Workers has Jev now so I'm putting it to the test on keep.md
- 7x faster search rerank compared to the current hybrid
- 50x faster tagging of content vs GLM 4.7 Flash with no failures
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 👇
Examples for support routing, refund decisions and risk escalation.
Milind S
@milindlabs
got @typesafeai's new model Jev as a chief of staff for bots
Jev reads the task, wakes the right teammates off the bench
and gives each one the right model
It is possible on OpenMausBot as it supports all the LLMs from your existing subscriptions
Jev as a decision engine is great
Acabo de terminar la implementación de @typesafeai + Chromium Headless para que mis agentes puedan navegar por internet a una buena velocidad!
En este ejemplo le pido al agente que entre a la página del término "Café" en Wikipedia y navegue por los hipervínculos hasta terminar en la página "Inteligencia artificial"
Logra completar la prueba en 20 segundos. Creo que pocos humanos podrían hacerlo en ese tiempo.
A browser you control by voice, from Moritz Kremb’s Jev tutorial.
MKMoritz Kremb
nader dabit
@dabit3
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
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
Jean-François Lépine on Choice, Noul and Score, calibrated confidence and batching questions, with a complete Python project.
Alan Daitch
@AlanDaitch
Claude me integró Jev con Playwright para buscar usados. Lee unos 26 artículos por minuto y decide qué hacer con cada uno en 406 milisegundos
Descartó los que no encajaban con lo que busco, ofertó por los que sí y hasta les mandó un mensaje a los vendedores cuando faltaba algún dato en la publicación.
Toda la búsqueda salió USD 0,00085. O sea: con un dólar revisás unas 26.000 publicaciones.
Una IA que por fin puede navegar por internet más rápido que nosotros es un game changer
I built a chat bot with jev, no LLM at all! Responses are instant, no hallucinations.
I hooked it up to web search, wikipedia, weather, todoist and home assistant.
Jev decides what tool to call and what args to use based on the prompt. Instant answers cite sources as well!
jev is insane 🤯
Here is Jev playing subway surfers at super human speed, and also playing 50 games at once.
cost less than a cent to do this run.
Jev does not replace llms like astra or fable, but opens up an entirely new world of capabilities.
Valyu’s practical guide to TypeSafe’s System One model, on DEV.
Mau Baron
@maubaron
jev is insane 🤯
here is jev playing smash bros against itself
he is controlling all 4 different characters.
and literally deciding whats the best
move to play against itself
all within a fraction of a second
i used over 22 million tokens to play this match
and it only cost me a couple of cents...
jev does not replace gpt6 astra
but the possibilities with its instant response time
are endless
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.
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
Skills Agentes’ guide in Spanish: what Jev does, what it costs, what the evals say, and where it fits in an agent.
Farouq Aldori
@FarouqAldori
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?
I built a Chrome extension for agentic browsing using Jev by @typesafeai, fx.sh including AI Gateway by @vercel.
Now agents can browse, click, and interact with websites directly in your browser. Cost effective and fassst.
Decision-making by Jev.
Announcing Jev Detector
The world's fastest AI slop detector, built on jev from @typesafeai
~10,000 words scanned for slop in ~2 seconds
Best part, its free, no sign up required, enjoy!
jevdetector.com
Archer Hume probed Jev with 10,000 API calls to work out roughly how it is built.
Sarvagya Kulshreshtha
@sarvagya_kul
JEV is INSANE.
We gave it 400 companies and one candidate profile.
In 12 seconds, it predicted which jobs the candidate had the highest chance of getting, assigned a confidence score and detected job-candidate mismatches.
All for just $0.0005 It can also score companies, analyse your experience, match you with the right roles and identify the opportunities you’re most likely to get based on your profile.
Coming soon to @textbackdoor
Comment “JEV” for early access.
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!
Puse a Jev, la nueva IA de @typesafeai, a jugar al Tetris en modo súper difícil.
Decidió cada jugada en unos 0,3 segundos. Acomodó 357 piezas e hizo 134 líneas en solo 2 minutos.
Increíble.
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. 👀
I got access to Jev by @typesafeai today morning and I built a cool use case for it
Introducing DiffJury - simply paste any public PR link and Jev tells you immediately if it's safe to merge or does it require review ✅
🔗 Feel free to try it out here - http://diffjury.up.railway.app
Imagine Jev being able to tell you if you should merge a PR with grounded context of your codebase. that's what we're building at @graphify 👀
It's fascinating how insanely fast Jev is... the model architecture in itself is quite interesting and this has opened up a plethora of new use cases and I'm sure the internet will pick up on it sooner than anyone'd expect
LayerX ran a 30-minute internal session on Jev. More than 50 engineers came, and they left with more than 50 ideas for their products.
John Yeo
@johnyeo_
Jev made our Slack agent 2x faster ⚡️
Our agent can be quite slow because it needs to read skills and figure out which tools to call.
We used @typesafeai's new model to speed this up by first passing it the prompt and classifying the best skill, tool and params to use before handing it to the agent
I built a voice controlled computer-use for my mac using @typesafeai's Jev and it's INSANE how fast it is!
I can dictate "open the notes app and create..." and the app opens before I even finish my sentence.
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.
A community list of projects, wrappers and examples.
nader dabit
@dabit3
Jev is really good at intent-based search!
How it looks in Gmail:
(for a huge inbox you'd prob let semantic search / embeddings pull first but still much better experience)
The launch discussion, including the doubts about the benchmarks.
Oskar
@o_kwasniewski
e2e + jev from @typesafeai ⚡
I'm building an open-source framework for running e2e tests with agents. supports web, mobile (and more!)
available soon: tester.army/e2e
building a computer assistant with Jev
local whisper listens to everything I say which then gets classified by Jev to determine what actions to take
it uses a small Swift app to provide the full accessibility tree to Jev (i.e. tell its what's on my screen, what can be clicked, etc)
still super early, but promising and all real-time
which Jev was also local though. then it would be completely private
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
First @typesafeai use case, live in our Mac app: setup and troubleshooting help when no model is loaded.
Model downloading, load failed, API returning 503, phone won't pair: the user asks, Jev reads the question with the whole built-in manual as state and decides, with probabilities, what it is and which article answers it, or that nothing does. The app then shows the real documentation and live status. Jev decides, the app answers from its own docs. No model loaded, nothing invented.
42/42 on a held-out set: paraphrases, typos, French, German, Spanish, features that don't exist, follow-ups. Median 0.93 s.
Great breakthrough by the TypeSafe team. Thank you.
Inspired by @typesafeai , here is a Jev-compatible public API to play with
It runs a comparable open model (Qwen3.6-35B-A3B), and just uses SGLang radix cache to preserve the prefill reuse / really fast parallel systemone generation - 64 tasks in <1s.
github.com/ekzhang/openje…
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
Tested TypeSafe’s Jev (no-text, probability-only model) as an AI agent safety monitor.
Checking each action first worked well caught most attacks with almost no false blocks, and much faster than Gemini.
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
An MCP connector that gives your agent direct access to Jev.
MMostafa
62
cocktail peanut
@cocktailpeanut
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
A Discord moderation bot with Jev making the calls.
BBrainstormity
25
Paarangat
@paarangatrai
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.
An agent-first SEO and GEO CLI in Rust, with DuckDuckGo and Jev.
APAkash Priyadarshi
Akshay 🚀
@akshay_pachaar
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.
A Python toolkit: question builders, confidence gates and calibration.
DADaniel Ari Friedman
david fant
@da_fant
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
Browser automation where an LLM plans and Jev decides.
YLYing-Kai Liao
Matt Van Horn
@mvanhorn
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.
Browser use for coding agents, with Jev deciding each step in ~300 ms.
BKBrian Kim
~300 ms
codila
@0xCodila
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…
Movez’s X article on Jev Engineering: move every yes-or-no, routing and scoring call out of the LLM, then add a model router and a gate for risky tool calls.
Checks every side-effecting tool call against what you asked for.
BXBowen Xu
Ricker
@0xRicker
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…
A Codex plugin where Jev trims bulky tool results.
KBKonstantinos Botonakis
Charly Wargnier ♨️
@DataChaz
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 ↓
Charly Wargnier’s thread condenses codila’s article: batch decisions, put Jev at bounded forks, and keep it out of math, writing and irreversible actions.
An MCP server that puts Jev on the coding loop in Cursor and Codex.
Bburnigtm
Codez
@0xCodez
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
A 36-minute talk by TypeSafe’s founder, shared by Codez: why he thinks agents with no human in the loop come next, and how models like Jev are trained.
One batched call picks model tier, tools, skill and effort for each turn.
JMJoaquin Marcoff
darkzodchi
@zodchiii
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 👇🏼
A codebase scanner that helps you not run malicious code.
PPaul
Scott Williams
@swill1ams
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.
Tamara Tran’s Claude Code plugin: Jev scores every tool call and result in one request, drops or truncates the stale ones, and keeps the rest word for word.
A stock terminal: Valyu brings the evidence, Jev gives the status.
POProsper Otemuyiwa
Alex Volkov
@altryne
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
```
Jev picks the plan; code renders the sheet music, audio and MIDI.
SWStephen Wu
Erick
@ErickSky
Este tipo de herramientas empieza a hacer que el contexto de los agentes parezca menos una ventana limitada y más una memoria que se administra dinámicamente.
[fast-jev-compaction]
No resume, hace que Jev analice cada tool call y su resultado para decidir qué sigue siendo necesario.
- Lo que importa se queda verbatim.
- Lo que ya no aporta, se elimina.
- Y los resultados que todavía pueden ser útiles permanecen intactos.
Además:
• Funciona como plugin de Claude Code
• También puedes usarlo como librería npm
• Las decisiones se toman sobre el contexto completo
• Puede truncar resultados o eliminarlos junto con su llamada
• Mantiene intactos los mensajes de usuario y assistant
• Tiene fallback al compaction tradicional de Claude Code
En otras palabras:
En vez de resumir tu memoria, intenta podarla.
REPOOO👇
The official skill for building with Jev, installable with one command.
TATypeSafe AI
215
Theo - t3.gg
@theo
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.
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
AICodeKing tests support routing, refund detection, prompt-injection resistance and browser automation.
Daniel Ch
@chddaniel
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.
thanks to @typesafeai jev I no longer have fill out all of those fields on prompt boxes. It picks the agent / model / computer / folder for me.
- For a major rewrite it uses Fable + Claude Code.
- Changes to an ios app run on one of my macs
I made a DuckDB extension where you can use @typesafeai 's Jev to do quick classification of rows in any csv/parquet file or duckdb table
about 10sec for 1k rows ~ better than using an LLM, way more ergonomic than a classifier
game-changing for data analysis!
A context sieve for Claude Code: Jev judges each tool result before it lands.
GDGhaleb Dweikat
~17
Tonino Catapano (tonnoz)
@tonnoz
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
A Pi extension: Jev picks the file excerpts, a local model writes the code.
MLMax Lv
Ian Nuttall
@iannuttall
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.
A prose linter for AI writing tells: regex rules plus Jev for judgment.
DWDaniel Willoughby
~14
OpenRouter
@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.
The live Bluesky firehose, judged post by post, with a lane for humans.
LMLeo Mata
~$0.00003
Cloudflare Developers
@CloudflareDev
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…
The LangChain package with TypeSafeClassifier, to use Jev inside a LangChain app.
Kai
@hqmank
I rebuilt my job crawler with Jev.
The task: start at a company's official homepage, find Careers, and identify jobs that match my profile.
Before, with an LLM: ~5 minutes.
After, with Jev: just over 20 seconds in my test.
Every company organizes its website differently. Jev identifies the Careers entry point, chooses which links to follow, recognizes job pages, and scores each role against my profile.
This is where Jev makes sense to me: automation that needs lots of small decisions, with faster responses and lower costs than calling an LLM at each step.
Packaged it as a skill: jev-job-hunter. Demo below.
everyone's making demos with Jev
but nobody is making real products
introducing lurk.so
find and monitor reddit threads to get cited by AI
> FREE
> 4000 reddit threads scanned
> email, discord, slack
only possible to give for free bc of Jev & @getanyapi
I made a chrome extension to label all the X posts on my timeline. It tells me if each post is clean, engagement bait, promo, secondhand or filler.
$0.03 for 1000 posts.
Open sourced if you want to try it out.
Jev dropped the price of SEO/GEO fixes by 90%
Agents that audit and fix a client's SEO/GEO used to cost us ~$250
Here's where the savings come from:
1/ 30x faster reads of Search Console and PostHog/Mixpanel data
2/ 30x faster checks of what ChatGPT searches on Bing
3/ 30x faster modeling of what users ask Gemini and Claude
4/ 30x faster scans of who ChatGPT and Claude cite
5/ 30x faster analysis of the sources behind those citations
6/ 30x faster gap analysis: why they get cited and we don't
7/ 30x faster fixes across 1,000s of pages on large client sites
8/ 30x faster sorting of which page types ChatGPT cites
9/ 20x faster creation of the pages that make ChatGPT pick you
Available in the Ryze AI app and MCP/Claude Connector, link in the 1st comment 👇
Jev just solved doomscrolling.
You pick a niche, Jev reads 3 days of posts and asks 8 questions each.
It runs in ~2s for $0.007 😅
> removes bait and hidden ads
> judges the text and like/reply/repost ratios
Free, no signup, go try it then touch grass ↓🌲
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.
Matt Van Horn: think AI multiple choice, not AI essay writing. Keep the big model for the hard thinking.
Pierre-Eliott Lallemant
@pierreeliottlal
JEV is insanely fast.
We gave it a massive dataset based on thousands of outreach messages and asked:
Which intent signals generated the most booked demos?
40 seconds later, we had the answer.
Cost: less than $0.20.
JEV can also rank leads, measure prospect-message fit, and uncover what actually drives campaign performance.
Coming soon to @GojiberryAI + MCP.
jev is an insanely cool product
Saw a post about jev and decided to check it out
This thing is straight up gold whoever built it is a genius
jev is the future
Scanned over 700 live ads in 40seconds flat, and it cost me just 4 cents.
If you're in marketing, this kind of crazy fast data crunching is hands down the best thing out there.
Doing this through Opus 5 would run around 2 to 4.5 million tokens, set you back $15 to $50, and take anywhere from 10 minutes to an hour. That’s 200 to 500 times more expensive than Jev, and way slower.
Jev killed 7 more SEO/GEO workflows 👇
1/ Assess which competitor pages to copy
-> It scores every competitor page on answer, depth, proof and freshness, then checks its rank in Google and ChatGPT to show which ones are worth copying
2/ Identify which page elements to change to get cited
-> It reads the title, meta, H1, FAQ and schema on every page and returns keep or change for each, with a confidence score
3/ Check if your pages answer what people ask AI
-> It matches real buyer questions to your best page, which shows the questions you have no page for and who AI cites instead
4/ Rate how likely each page is to get cited
-> Every URL gets a citation chance and the first fix to make, like adding a compare table
5/ Sort search terms
-> It asks "is this query from a buyer?" across the full Search Console export, so you write only for terms that convert
6/ Build the internal link map
-> For every page it checks the 15 closest candidates and links only the ones with an honest reason
7/ Verify AI-written pages
-> Each draft goes through 20 yes/no checks, and only the ones that pass reach a human
Available in the Ryze AI app and MCP/Claude Connector, link in the 1st comment 👇
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
Isaac Flath’s shortlist: fact-checking scripts, ranking a news feed, finding text in PDFs, checking citations, grouping notes, and evals over agent traces.
Marc Köhlbrugge
@marckohlbrugge
Using Jev to filter through my @wip todos
It allows me to super quickly find all the instances where I increased revenue, got stuck, switched to a different SaaS provider, etc
Things a regular keyword search would never catch
Jev can serve as better natural language search on websites.
It can scan thousands of Zillow listings and classify properties by things you can't normally filter for - e.g. architecture, renovation status, proximity to freeways.
This was done in <20 sec and costs $0.18 👇
today i'm releasing Jev for content marketing.
still doomscrolling to figure out what to post on social media?
that's over now...
Jev watches EVERY video in your niche and judges it before it ever reaches you:
1. research: pulls every video in your niche from a database of 12.8M viral videos
2. analyze: Jev watches, studies, and judges each one, the hooks, the formats, the angles, and why they worked
3. create: turns it into a data-backed script, based on proven winners (via Claude)
no more guessing on TikTok & Instagram
currently available for free in @virlomain + MCP.
link below ↓
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/
I just built a Jev X Viral Post Analyser.
100,000 viral X posts. 20.4 seconds. $0.67.
Claude Opus 5, same corpus, same clock, got through 214 posts and spent $0.98.
per post that is ~680x cheaper the full Opus pass would have run $458.
viral analysis is the perfect Jev job.
• it is not writing, it is 14 yes/no calls per post:
> does the hook open a loop,
> is there a number in the first line,
> is the proof real or claimed.
classification, not prose.
• what it found:
1,220 posts broke into the top 1%. baseline 1.22%.
> superlative claim - 2.34% viral. 1.92x baseline
> contrarian take - 1.59%. 1.31x
> launch / tool drop - 1.46%. 1.19x
and numbered lists, the thing everyone writes: 0.55%. below baseline.
the most used hook is the least viral one. full stop.
• what you are watching:
left is the post under analysis, right is Jev answering 14 typed questions about it, each with a confidence score.
the run stops at 20.4s because that is when Jev finished all 100k.
pulled the corpus through a few X APIs, one parallel pass into Jev.
should I drop it to public?
Read my latest article on Jev Engineering below and turn your ideas into reality.
We turned Jev into a general browser skill for agents: jev-browser.
Give it a website and a task. The browser opens automatically, and Jev decides every click based on what's on the screen.
Here's a demo:
Jason Zhu tested Jev reranking on 164 real queries. Alone it did not clearly beat vector search; fused with it, it did. In Chinese.
Paulius 🏴☠️
@0xPaulius
Jev brought us closer to JARVIS
it instantly does things like launch agents on a canvas - without awkawardly waiting for slowGPT LLM loop
@clonkapp is now the fastest agent orchestrator on the planet
JEV IS INSANE.
I gave it 80 real exam questions and 297 practice ones. In 80 seconds, it told me which ones are most likely to appear on the real exam and which ones aren’t.
All for $0.0256.
Can't stop playing with @typesafeai 😁
Jev classified 1,315 X posts for about $0.086 in estimated model cost 😂
seeing everyone's Jev demos made me want to build something for my own content research.
i'd collected a lot of posts, but figuring out what they had in common still meant opening them one by one and taking notes.
so i built a dashboard around Jev. it labels each post across 8 dimensions, including topic, hook and writing style.
now i can filter by topic and hook, compare engagement, and open the original posts to see the examples behind each pattern.
my archive is a lot easier to learn from now.
Jiayuan Zhang: a faster classifier that an LLM can also be, but a good fit for computer use, games and robotics where the options are known.
keno
@kenonews
JEV makes competitor research feel like a cheat code.
Give it your competitors’ ads. Break them down by hook, angle, offer and format.
Then turn recurring combinations into a shortlist for your next creative test.
From an endless swipe file to “here’s what we should try next.”
Your competitors just became your creative department.
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.
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)
Jason Zhu’s roundup of 19 open-source Jev projects with about 6,800 stars between them. In Chinese.
t0t0
@t0t0_build
Un JEV me está monitoreando más de 25 grupos de whatsapp con clientes en tiempo real y evaluando si tengo que saber algo por urgencia problemas, pedidos irresueltos etc.
Si tengo algo que saber, le avisa a una LLM que me escriba.
🔥
ESTA HERRAMIENTA ACABA DE ROMPER TODO EL MERCADO DEL AD SPY
Maxfusion ha cogido JEV, el modelo nuevo de TypeSafe, y le ha metido la ad library entera de una marca
→ 1.891 anuncios clasificados
→ 19 segundos
→ 0,12 $
Y no es un resumen: cada anuncio etiquetado por etapa del funnel y estilo creativo, más la radiografía completa de la cuenta
Llega pronto al MCP de maxfusion
Moritz Kremb’s thread of the best Jev projects he found on X in one day.
Anusha
@acharyaagamya
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.
Took Gregor’s Ultrafast idea and wired it into Grok Bot. @bot @OpenRouter @typesafeai @gregpr07
Your bots can now use Jev to drive the real Chrome on the machine instead of slow look-and-click. Drop in the API key you already have (OpenRouter or TypeSafe), and it gets going.
It also walks your existing bot workflows and flags which decisions Jev can take over — the quick yes/no and “pick one of these options” calls — so you’re not guessing where it helps.
Share link if you want to try it: https://x.ai/bot/sM_Xi4OF09cGU8KGyLvlC
Built a construction plan-set classifier with Jev.
Proq turns civil and building plan sets into bills of materials using an LLM pipeline we built on GPT-4.1. Jev classified an entire 26-sheet plan set in 2.9 seconds for $0.0052.
It matched GPT-4.1 and GPT-6 Astra on 100% of sheet-level classifications while running 17–21x cheaper and 5x faster than our production pipeline.
Jev is WILD
I gave it two launch tweets and fed it over 4000 demographic profiles of real survey participants
Twelve seconds later, a simulated A/B test tied to actual personas voting on the best tweet
you can just do things
i made it 100% free (link below)
思维怪怪’s hand-checked list of early Jev projects, with a walkthrough of each.
Izzuddin
@Izzuddin_Shafi
1/8 Saw Jev from @typesafeai on my feed, so I made it play Pokemon Showdown. Codex built the harness.
It was damn fast. Its choices were a mixed bag.
Full match, video 1/2. This is a saved replay with decision data, latency and added reading pauses.
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
okay Jev is an INSANE unlock, I just gave Mario a multiverse.
built "Mario Never Dies" with @typesafeai's Jev + microsandbox
Jev picks every move and every time Mario dies, we fork the entire VM into 4 timelines and try again.
whichever Mario survives becomes canon. it is like the others never happened.
built askjev on typesafe jev for all-site navigation with claude
you talk to claude in plain english and askjev runs your real browser on any site. jev decides every next click — open pages, switch tabs, scroll feeds, fill forms, run multi-step goals without you babysitting the DOM.
mcp server + chrome/brave extension. auto-connect once, then stay in chat while the browser moves.
claude handles the conversation. jev handles the decision on each step. askjev is the hands on the web.
install:
load the extension → paste your typesafe key → auto-connect → restart claude → talk
example:
use askjev, open http://x.com and scroll my feed and find the best posts
http://github.com/ranjan2829/AskJev
npx -y askjev-mcp
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/
Official resources and community projects for TypeSafe, System One models and Jev.
aniol
@0xaniol
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
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…
@typesafeai's Jev controls the 2 hands and each finger to play the piano in real-time.
Jev only "sees" what we see and plays this from the "note waterfall". It uses @browser_use's jev-ultrafast and some decision scheduling to make this happen in real-time.
Sound on 🔈🔉🔊
Public Jev projects, integrations and discussions, sorted by category.
Ateeq
@TPateeq
I used Jev to solve a problem every agent eventually runs into: reading logs.
22.8M lines, and running an LLM on every one would've cost $1,120.
Tocsin groups them into 11,812 repeating patterns, then asks Jev about each pattern once.
6 minutes, 64 cents, 123 patterns that actually needed to be looked at.
http://github.com/TPAteeq/tocsin
The paging policy is just a prompt.
You tell it what should wake someone up at 3 am and what's just another log line.
I built a tool that finds App Store keywords by reading the competition, and uses Jev to judge them.
What it actually does:
1. Turns the app's own listing into a handful of search queries, with Jev filtering out the ones nobody would type.
2. Runs those searches on the App Store. Whatever ranks is the candidate pool.
3. Jev judges each candidate: is this really an alternative to the app, or does it just share a word? The lookalikes get dropped.
4. The strongest survivors become the competitor set it mines for keywords.
No competitor list to maintain, nothing hallucinated: competitors are whoever Apple already ranks, minus the ones Jev rules out.
We built a plugin that gives Jev a browser in Cline, and have been blown away by the results.
1. Install it in our new desktop app: Customize > Marketplace > Plugins > search 'jev-browser'
2. Create a Vercel AI Gateway API key, then save it to ~/.cline/plugins/cline-jev-browser.config.json as {"gateway": {"apiKey": "..."}} and restart Cline.
3. Ask any browser task and it will launch Chrome in the background to complete it.
I made this for fun. Wired a mic over Fusion 360: click, speak, Fusion runs the feature. @typesafeai ‘s Jev only decides if the utterance is a command.
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
1/ Introducing CUA-S1: a family of System One Models, small, specialized, and built for computer use.
Today we're open-sourcing CUA-S1-FORMS, the first in the family: github.com/trycua/cua
An Astra planner with Jev as the controller, playing Minecraft.
Rrmalde
Milind S
@milindlabs
Aaaaaand this is now open-source here:
A tiny AI pointer companion for your Mac driven by JEV or Gemini Live
- Bring your own keys
- Local OmniParser running on CoreML
- Jev drives the pointer
- Ctrl + K to type a task
Voice mode next if people want it!
https://github.com/milind-soni/tiptour-macos
Moritz starts from the API key, then builds three prototypes: a voice-controlled browser, memory retrieval, and a YouTube topic scorer, and says where Jev still needs an LLM or plain code around it.
AI Jason pairs Jev with Treg and builds automation on top of the two.
Matthew Berman
@TheMattBerman
jev KILLED the focus group.
it scrolled 723 ads as 30 buyer personalities
21,690 stop or scroll decisions. 22 cents.
(will be avail in @StealAds + mcp)
1/ Jev, a decision model by @typesafeai, sparked a burst of projects and discussion. We tested it using Ori Eval against popular LLMs on OpenRouter at judging.
Jev was >5x faster than the next fastest model, and even its slowest requests beat every other model's median.
Jev + GrokBot is the best AI agent system I’ve built in my life
It just made my setup CHEAPER and FASTER than what 95% of people are running...
setup takes literally 7 minutes:
prompt → GrokBot → Jev decision → GrokBot execution → result
step 1 → open @typesafeai , create API key (keep it off chat paste)
step 2 → tell Grok Bot: store TYPESAFE_API_KEY in the secure field
step 3 → prompt Grok Bot: install typesafe-sdk on Agent Computer + smoke system_one (Choice)
step 4 → tell Grok Bot: build the usage lab (router, dry-run, config, logs) - or clone Github below
step 5 → add skill jev-usage-router: before browser / research / retry / extra bot → call the router, honor action
step 6 → stay shadow first, read logs, then active when you trust it - kill switch: bypass jev or enabled: false
step 7 → flip active: GrokBot obeys route - Jev decides - GrokBot executes - humans control irreversible actions
the result: Jev + GrokBot the best and fastest agent running directly on your computer rn, I’ve already tested it on routine tasks - and the results are genuinely incredible
You can come up with endless ways to use Jev + GrokBot - but the most important thing is to install it as soon as possible
Copy this 2028 setup, explore my repo below - then read the full Jev deep dive ↓
you can turn any low-cost open-source LLM into a Jev like fast decision model without training it. Here's how to do it:
An LLM doesn't write text directly. At every step it scores every word in its vocabulary for how likely that word is to come next, and then it picks one. Those scores are called logits.
Suppose you want to know whether a customer email is angry.
The usual way is to ask the model, wait while it writes a paragraph, and then try to pull a yes or no out of the response.
The trick is to never let it write anything. Give it the email content and the question, and end your prompt with "Answer:". Your full prompt will look something like this:
[
Message: "Third time I've contacted you. Still broken."
Is this customer angry? Answer yes or no only.
Answer:
]
The model reads the prompt once and scores every possible next word. You look at two of those scores.
"yes" scores 8.1
"no" scores 5.9
Convert those two scores into probabilities and you get 90% yes and 10% no. (Use softmax function -- google it)
Your code then uses that number directly. If it's above 0.8, escalate the ticket.
Congrats, you have created your own Jev!
Here’s why it works:
1. It's fast. Reading a prompt happens in one parallel pass. Writing is the slow part because the model writes one word at a time. Here the model never writes.
2. It's cheap. Output tokens are the expensive ones, and this produces none.
3. There's nothing to parse. You always get a fixed output, and never a paragraph.
4. You get a confidence level along with the answer. A 0.55 means the case should go to a human or a bigger model. A 0.98 means you can act on it.
I tried running the code on llama 3.3 70b (via openrouter) and the accuracy was 21/22 (95%).
Cost per query: $0.000013, latency: ~500ms
Built a stock market scoring and decision engine and invested for the first time! 🚀
It includes portfolio-aware suggestions. Used @typesafeai's JEV for non-mathematical data analysis.
Open to the following positions btw.
👨💻 Senior Front-end | Product | Mobile (RN) Engineer.
Prompt Engineering puts Jev in the reranking step of a RAG pipeline: why vector search and cosine similarity fail, how a steerable reranker works, and how it compares with LLM rerankers and cross-encoders. A Colab notebook comes with it.
Julian Goldie’s hour-long course: the three question types, many decisions batched in one request, and ten use cases, from email sorting and lead scoring to internal linking across 586 pages and a browser agent finding flights.
Ramarao Kadiyala
@broadrangeAI
Reviewing Jev: fast, structured decisions for AI workflows.
Vendor figures: 70–500 ms, $0.042/M input tokens, $0 output.
My takeaway: pair low-cost decisions with clear controls and measurable outcomes.
Full post:
linkedin.com/posts/activity…
#AIEngineering #BroadrangeAI
Kev makes Jev the decision maker inside HyperEdit, his open-source AI video editor, and walks through the whole setup with Claude Code. The repository is free on GitHub.
Hosting a demo + hack night in SF showcasing the coolest projects built with Open-Weights Jev.
Come see what’s possible, hack, or hang out.
Reach out for an invite or get involved!
Coderone on Laya, the open System One model from Convai Innovations: what typed decisions are, why they replace a share of LLM calls, and Laya run locally to see if its figures hold up.
さよ☆マギカ
@MajoSayo
I wanted Jev-style decisions with my own models, so I built LogJev.
Text, images or audio in; choices/scores from logprobs. Node + Python, agent skills, cloud or local (requires modality + logprobs support).
2048 demo: github.com/DumoeDss/logjev
Dave Ebbelaar in Python: a support-ticket classification first, then Choice, Score and Noul, several questions in one call, and latency and price next to Claude Haiku, Opus 5 and Fable 5.1.
Jev lleva toda tu operación de marketing de anuncios por menos de 3$.
→ Escanea cada anuncio activo de la competencia y lo etiqueta por hook, formato y tasa de supervivencia
→ 430 anuncios leídos por segundo. 0,6$ gastados.
Jev is incredible - built an email classifier that is capable of classifying 50 emails in under 2 secs. That too, when Jev is hosted in us-west, and I am in India.
Idea credit - @ryanvogel
@typesafeai #Jev
Our explainer in Spanish, on LinkedIn: what a System One model is, what Jev decides, and where it fits.
Zhilin Wang
@zhilinjerrywag
#Jev made one thing very clear:
Not every AI model needs to generate.
Some models should just make really good decisions.
So we’re cooking Mev at @metix_ai , a recruiting-native decision model built around job-candidate matching, ranking, and hiring signals.
Jev → Mev.
More soon.
Had CowAgent build a batch ticket analysis tool on Jev.
Jev doesn't generate text. You send content and typed questions, it returns classifications, scores and booleans, each with a probability distribution.
One call per ticket, 7 judgments, ~500ms.
Great article from Hrishi!
So despite all the hype, JEV is a great observer for agent runs (progress, time/cost-to-finish, trace labeling), but not a security gate, and not yet a laziness detector.
Still sounds good to plan JEV into our roadmap and explore some use cases for onchain agents!
the natural endpoint of coding agents is adhd maxxing
while my other agents are working i’ve been building a nintendo ds game with gpt-6 astra, fable 5.1 and jev
today i added perry the platypus so he can push you off a ledge
side quests are getting out of hand
Can #Jev really control embodied robots? @Anno_YanzheChen showed ShowHarness in #VLA. @Vanzllll told me: as DoF scales toward humanoids, discrete actions may struggle, while continuous policies scale better with #diffusion. Without AR, how do we model cause and effect? #Robotics
للمبرمجين 👨💻✨
Jev من TypeSafe AI يقدم فكرة مختلفة عن نماذج الذكاء الاصطناعي المعتادة.
بدل التركيز على المحادثات وتوليد النصوص، تم تصميمه لمساعدة التطبيقات على اتخاذ قرارات واضحة وسريعة داخل النظام ⚙️🤖
مناسب للمهام المتكررة مثل التصنيف، التوجيه، والأتمتة.
I think Jev and Laya were the missing pieces to algorithmic trading. Sure you can hardcode gates and adjust variables, but being able to add a real time decision maker within your algorith is a game changer. I can smell and taste an early retirement.
Stop settling for mediocre AI outputs. 🤖
Introducing slop-grader: The new Jev-AI CLI tool designed to audit text against your specific rulesets. It’s time to take control of the "slop." 🛠️
Here is the breakdown 🧵
#AITools #ProductivityAI
The useful engineering lesson is the async split: planning can continue while Jev selects the next action. That makes sense without assuming it proves AGI. We explain the roles using this demo in our 105-second video: x.com/vertr_ai/statu…
The small-LLM fallback for typing is an important detail: Jev chooses actions, while text generation stays with an LLM. We featured your 1x demo, with credit, in our short explainer of that division of labor: x.com/vertr_ai/statu…
154ms vs 860ms is a useful routing result, scoped to these 200 synthetic classification cases—not a blanket ChatGPT comparison. We credited your latency and cost charts in our Jev video, alongside the game/browser demos: x.com/vertr_ai/statu…
ChatGPT thinks through the plan. Jev helps pick the next move. ⚡
Minecraft, browser automation, speed and cost—Jev explained in under 2 minutes. 👇
Featuring demos by @rronak_ and @gregpr07, benchmarks from @OpenRouter, and Jev by @typesafeai.
#Jev #AI
$10k/month just to decide which agent should answer.
not to answer. to decide.
group chat + @mentions: fast, cheap, terrible UX.
an LLM orchestrator: nice UX, 4-7s and $0.00046 a message.
@typesafeai jev: 0.29s median, $0.00002.
same decision, $20/month.
just shipped jev-studio v0.2.0
@typesafeai Jev in one pip install
- MCP tools for Choice / Noul / Score
- `jev` CLI now with dry-run provenance
- ready-made prompt libraries + slash commands for every cookbook
- Claude Code + Codex plugin manifests
pip install jev-studio
Most AI models are built to generate.
But Jev is trying something different:
Don’t generate. Decide.
Give it some context and a specific question, and it returns a structured decision with a probability.
I found this interesting for things like model routing, agent workflows, tool safety and RAG.
The idea is simple --Instead of calling a big LLM for every small decision, let your code handle the workflow and use a smaller model where human-like judgment is actually needed.
Honestly, this feels like an interesting direction for AI systems.
🚨 A LOCAL 421M MODEL JUST ATE CLOUD JEV ON SPEED
Laya is an open-source System 1 decision model that runs on your machine.
Laya: 86.5 decisions/sec, P50 ~9ms, score 46
Jev: 3.2 decisions/sec, 317ms API round-trip, score 1
Ships with:
— 421M params
— ~1GB inference memory
— Millisecond local calls, no network
— Typed decisions in one forward pass
— Apache-2.0 and self-hosted
While the cloud waits, local decides.
Agent memory is usually just an append-only Markdown file that grows forever, and most frameworks load the whole thing into context on every single run. That has been bothering me for a while, but never quite enough to fix it for our agents. Jev feels like it might be a low effort patch to this, by simply scoring each memory against the prompt first, then load only the relevant bits for that specific request.
Yes but not with Jev. I used another classifier, locally, just as fast, just as good.
Example: setup a "server" in python that loads the classifier model. Add a hook in Claude that fires on "pre-tool-use" and next time you ask Claude a random question like "how do I lint check a project?" and it tries to freelance and read your entire repo only to intoxicate itself and pollute its context, the classifier will slap its hand, say "no sir, you answer from knowledge" and deny the tool call.
I tested this yesterday with success, but need to refine it as it misfires.
Basically I was able to identify general queries, instances where I would ask something and Claude would rush ahead and run pip install without me asking or just write code instead of answering.
A classifier is hypercheap compared to a regular LLM and would catch all of these.
The model I used was DeBERT large. It's still stupid fast, I tested it on an Apple with M1 (regular) and you don't feel it running.
Created a slop detector extension with Jev
It scans all the post on the screen in the real time and classifies it on categories like scam, slop, clean, etc. Shows a minimal badge on the post with the confidence score.
Comment bellow if you want to try the extension.
Jev is live in New API now!
Choice. Score. Noul.
Structured judgments that drop straight into code.
Same TypeSafe SDK. Point it at your New API gateway.
One plugin. No rewrite.
newapi.pro/zh/plugins
Creators saying their new tool “killed” another is understandable. It’s marketing and rage bait.
But people retweeting it without even trying the tool? That’s the worrying part.
I’ve seen at least 10–20 “Jev killers”(@typesafeai) on my timeline already. Tried a few myself. Most weren’t even close.
We’re amplifying opinions before forming our own.
I keep seeing the same fix across agent stacks this week: teams are ripping the expensive model out of the middle of their decision loops.
TypeSafe shipped Jev in early access on September 15. Not a chat model. They call it a System One model: hand it a state and typed options, it returns calibrated probabilities, no text generation at all.
The mechanism is simple. Most agent loops burn a full LLM call on decisions that never needed generation: route to worker A or B, is this result relevant, approve or block this action. TypeSafe claims up to 200x faster inference and 400x lower cost on that class of decision. Ricker's own tests below land at 193x and 444x.
What happened next is the real story. Within four days, Cognition's Jared Palmer shipped Kev, a LoRA adapter on Qwen2.5-0.5B trained in 1 hour 45 minutes on a MacBook Pro, with an API close enough to point TypeSafe's own SDK at it. Kev now scales up to a 9B version that trails Jev by about 4.5 points on held out evaluation. Laya-MLX arrived the same week targeting millisecond decisions on Apple Silicon. A community leaderboard, JevBench, already ranks a dozen of these models.
The adoption signal convinces me this is not a toy. TanStack AI shipped a native decide() API for typed choices, scores and booleans. Beacon, an open source memory layer, uses Jev to score which coding sessions are worth turning into reusable lessons. Three teams, one primitive, inside a week.
RouteLLM out of Berkeley showed back in 2024 that routing simple queries to a cheap model cuts cost over 85% while holding 95% of GPT4 quality, and production semantic routers report 40 to 90% savings today. What changed is that the router stopped being a side project and became a shipped, benchmarked model category with a name.
The bottleneck this solves is real: every agent framework has a model sitting in a loop answering questions that never needed a sentence back. My read is that the decision layer becomes as standard a piece of the agent stack as the vector database became for retrieval, and whoever owns the default there owns a lot of the unit economics conversation for the next year of agent infrastructure.
https://x.com/0xRicker/status/2101705843200721203
1,000 AI papers sorted into 24 topics for $0.0585. Then Opus 5 graded the labels.
@nutlope's Jev paper map went viral, but the pipeline never shipped and the eval was "still running". So I rebuilt both and opened them.
The first judge run came back empty: Opus spent its whole budget thinking and answered nothing. Reasoning off, second run: it agreed with Jev on 85 of 100 papers, at 153x the cost and 1.9s against 57ms per paper.
The 15 misses are not random. One number Jev already returns tells you which labels to recheck.
Cheap models sort. Expensive models audit only what the cheap one flags.
Repost if you classify anything at scale, because the eval rows are public and anyone can rerun them with their own judge in one command.
Code in the reply.
🔥 looks like Jev just got an open-source alternative.
Laya is a 421M parameter model built for making decisions instead of generating text.
the interesting part:
- runs locally on your laptop or phone
- uses less than 1GB of memory
- supports structured decisions (yes/no, scoring, multiple choice)
- free + open source
in a 30-second Snake benchmark against cloud-based Jev:
Laya: 86.5 decisions/sec, score 46
Jev: 3.2 decisions/sec, score 1
the catch? Laya has a 512–1024 token context window and doesn't generalize as well as Jev without additional tuning.
so we already have an open source alternative to jev... and it's 6-7x faster?!
it's a typed-decision classification system: no chat, no generated text, just fast yes/no, scoring, or choice answers.
> runs in under 1gb of memory
> free on hugging face
> runs on a laptop, or even a phone
there's a real demo where it plays snake live, making a fresh decision every single move.
two honest limits, straight from the project itself:
> only 512-1,024 token context, some cases won't fit
> weaker generalization than jev out of the box
Jev is playing Minecraft.
I built a bot powered by Jev that can construct houses, towers, lakes and castles on command.
It also fights mobs, uses a sword, and tries to dodge skeleton arrows in real time.
Still rough, but genuinely fun to watch.
@typesafeai Jev
This Jev experiment is fun, but the reliability question is actually the interesting part.
Snake is simple enough to understand, but unforgiving enough to expose bad decisions fast.
Play alone, play with Jev, veto its moves, or race it.
A playful way to test decision quality, corner after corner. 🐍
@typesafeai @CarolMonroe
http://jevplayssnake.lovable.app
Jev Skill Suggestion for Claude Code is a smart idea.
Instead of loading every skill into context, Jev decides which one is actually relevant and injects only that.
My takeaway: better context hygiene, less clutter, and potentially more efficient agent workflows.
@typesafeai @vercel
Jev doesn't write. It only decides.
Yes/no, choices, scores — each with calibrated confidence in 70–500ms.
Input is $0.042 per million tokens. Output is free.
The first System One model. This is the plumbing agents were missing.
firecrawl.dev/blog/what-is-j…
Introducing Jev + OpenRouter + tools.
You can now use Jev with 2,000 tools on Monid. Your agent picks the tools, Jev speeds the work up 30x.
> Score 2,000 leads
> Scan the TikTok viral video hooks
> Research fundraising of 200 companies
> Audit a site's SEO and rebuild the internal links on every page
> Sort every Reddit thread about your category
For marketing $SCRAPS, I’m trying something I haven’t seen anyone else do.
I’ve been experimenting heavily with the latest AI tools (JEV from @typesafeai), burning through 178M+ tokens and nearly 48,000 requests testing different ideas.
One of those experiments is focused entirely on marketing: finding the fastest path to high engagement and the best ROI possible.
Now that SCRAPS is live on Google Play, it’s time to put it to the test.
The experiment starts now.
🎇 I made a small Chrome extension: a side panel that drives any site's WebMCP tools with Jev!
When you type, on every keystroke it picks the relevant page's tool, fills in the arguments, and tells you how sure it is.
Here it is grocery shopping:
I built a Chrome extension that judges every post in my feed before I reach it. READ, MAYBE or SKIP, in about 300 ms, using Jev by @typesafeai. No scripted rules, no selectors, no LLM. Real time, my X feed:
Jev CEO, Diogo Almeida (ex-OpenAI):
"It's not Claude Code because Claude Code is still part of the assistance era."
He co-authored GPT-4, ChatGPT, InstructGPT and RLHF.
Now he's building what comes next:
200x faster. 400x cheaper. A decision brain for AI agents.
His argument is simple: frontier LLMs are insanely good at creating, but we're wasting them on thousands of tiny decisions:
Which agent goes next? Is this relevant? Does this need approval?
Those calls don't need generation. They need a model built to decide.
In 18 minutes, Almeida explains why today's AI was built for assistance, not real automation, and why "tomorrow's AI will be for automation."
This makes most $500 agent engineering courses look obsolete.
Watch it today, then steal my 10-step guide to giving your agents a decision brain below ↓
Jev hype is not about chat.
it’s about decisions
everyone is trying to compare it to ChatGPT / Claude / Cursor
wrong frame
Jev doesn’t need to write you a beautiful paragraph
it needs to answer questions like:
should this agent act now?
which tool should run next?
is this signal worth trading?
is this market mispriced?
should this wallet be ignored or watched?
that is the interesting part
prediction markets are basically endless small decisions under uncertainty
not one giant “AI intelligence” moment
thousands of tiny calls:
price changed
liquidity moved
wallet entered
news dropped
odds lagged
edge appeared
edge disappeared
you don’t want a slow model writing essays for that
you want something cheap, fast, typed, and measurable
that’s why Jev is interesting.
not because it replaces frontier models
because it makes the boring decision layer cheap enough to run everywhere
I'm reading up on Jev (typesafe.ai/blog/introduci…) and learning how it differs from "regular" classification ML models.
I gave a bunch of articles to @googlecloud Gemini Enterprise and asked it for a breakdown. Helpful. Still digging in before going hands-on.
all things Jev in one place
a GitHub collection just dropped packed with hundreds of tools, libraries, and projects built on top of Jev, from teams treating decision-making as its own primitive, separate from language generation entirely.
github.com/AnotiaWang/awe…
Strike Robot wiring Jev into its Physical AI stack is not a model announcement or a new UI layer. it is an autonomy architecture shift.
the signal that usually separates real autonomy from scripted behavior is where the decision loop lives. when a robot queries a remote model for every action, the latency budget is visible in the motion. there is a pause between stimulus and response that teleoperation hides but autonomous operation cannot. what you want is local inference for routine actions and remote calls only when confidence drops.
staging tells are easy to spot if you know what to look for. when Jev is actually routing decisions, the robot will execute most movements without a cloud round trip. the moment to watch is at decision boundaries. an unexpected obstacle, a grip that slips, a path that changes mid stride. if the system freezes or the motion cadence stutters, the model just got called. if it flows, Jev stayed local and the confidence threshold was high enough. latency in continuous runs is the honest signal.
the gap this closes is always-on large-model inference burning compute on decisions that a smaller local model handles with 95% confidence. a credible in-the-wild demo would show the robot moving fluidly through a routine task, hitting an edge case, pausing once while Jev fires, then resuming without a second stall.
Nitpicky, an AI generated photo detector powered by jev
AI generated photos can be told from nits. That's why we build something to zoom into every detail:
faces, fingers, characters, numbers, poses, where common senses fall apart, judged by jev
i just merge Grok 4.7 + Jev and got the smartest thing i've ever owned
grok 4.7 does the thinking. jev does the deciding. together they cost less than my coffee
prompt → grok bot → jev asks 6 questions → grok 4.7 opens only the good ones → campaign
jev doesn't write anything. it only answers simple questions: yes or no, pick one, or a score. it can't make things up, because it can only pick from answers you allowed
i gave it 3,412 leads from x, linkedin and youtube. 6 questions each is 20,472 decisions, done in 15.7 seconds for $0.41
the same reading by hand took me 6h 12m. people say 400x faster. i did the math and it's 1,421x
that's $0.00012 per lead, and grok 4.7 only reads the ones worth reading
the big mistake: sending everything straight to the new model. you pay the smartest thing you own to say "skip" all day
setup took me 9 minutes: key in the secure field, sdk on the agent computer, one router skill, test mode first
jev decides, grok bot does the work, and i still press the button on anything i can't undo
everyone is talking about the new model. the cheap one deciding what it reads is where the money is
𝐖𝐡𝐞𝐫𝐞 𝐉𝐞𝐯 𝐁𝐞𝐥𝐨𝐧𝐠𝐬 𝐢𝐧 𝐚𝐧 𝐀𝐠𝐞𝐧𝐭 𝐇𝐚𝐫𝐧𝐞𝐬𝐬 (𝐍𝐨𝐭 𝐚 𝐌𝐨𝐝𝐞𝐥 𝐒𝐰𝐚𝐩)
Your agent harness needs a decision model. Where you place it depends on one brutal fact: Jev's ordering is trustworthy. Its confidence numbers are not.
Most placement guides skip this distinction entirely. They tell you to pick a threshold and execute above it. That works if you actually have a probability. You might not.
𝐓𝐡𝐞 𝐜𝐨𝐫𝐞 𝐩𝐫𝐨𝐛𝐥𝐞𝐦: A model can rank beautifully and lie about magnitude simultaneously. When you gate execution on if confidence >= 0.85: approve_transfer, you are trusting a number that was never calibrated to your prevalence, your cost ratio, or your queue. Move the threshold up and you trade recall you never measured for precision you cannot state. You have no idea how far along an unmarked axis you moved.
𝐓𝐡𝐫𝐞𝐞 𝐝𝐞𝐜𝐢𝐬𝐢𝐨𝐧𝐬, 𝐭𝐡𝐫𝐞𝐞 𝐝𝐢𝐟𝐟𝐞𝐫𝐞𝐧𝐭 𝐧𝐞𝐞𝐝𝐬:
Routing and ranking consume ordering only - which answer is best matters, the number beside it does not. Gated execution consumes magnitude - the threshold is your boundary and it must land on a calibrated scale. Relative logic like if top1 - top2 < 0.1: escalate consumes differences - and rescaling the score axis will flatten margins unevenly, breaking your code.
The sepsis alert systems of 2020 learned this hard way. Michigan switched off alerts when COVID shifted patient prevalence beneath a fixed threshold. No weights changed. The denominator moved, the promise broke silently, and nurses drowned in false alarms.
𝐓𝐡𝐞 𝐟𝐢𝐱 𝐢𝐬 𝐬𝐞𝐪𝐮𝐞𝐧𝐜𝐞, 𝐧𝐨𝐭 𝐭𝐮𝐧𝐢𝐧𝐠:
First question: is this number admissible as a probability at all? Run a calibration study on a few hundred labelled cases from your own queue. Samuel Sacco's measurements from 18 September and Adil Muhammad Pervez's 8,000 judgments both reach the same conclusion: fit your own map. The weights are shared across every account by design - there is no per-customer adaptation - so a deployer-side calibration map is your only mechanism.
𝐒𝐞𝐜𝐨𝐧𝐝 𝐪𝐮𝐞𝐬𝐭𝐢𝐨𝐧: given that the number is calibrated, where does your cost ratio put the line? That part of the familiar advice still works.
Run them backwards and you are tuning a dial with no markings.
Read the full analysis on calibration, harness placement, and where Jev actually fits:
https://ranjankumar.in/jev-system-one-model-agent-harness-placement
Follow for more practitioner insights on agentic AI systems and production AI engineering.
#AgentiveAI #AIEngineering #SystemOne #Calibration #MLOps #DecisionModels #HarnessEngineering #Jev
Jev has some invisible use cases that won’t be clickbaity but hella useful :
- auto performance checks on your shipped websites
- personal tools like using it for super quick chat compaction
- user feedback prioritisation against most relevant data in your company
- lots and lots of data sorting - quickly
- pairing it with codex / claude to optimise decision making while you code with your agents etc