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
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
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 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…
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
Akshay Pachaar’s worked example: evaluate a refund-support agent with Jev instead of a generative judge, and record the verdicts in Opik. Separates the judge from the evaluation system, and is explicit that a 0.98 is a probability about one proposition, not a percentage of the answer.
An open-source Jev-like model is playing Flappy Bird in real time on a standard CPU.
Laya is a 421M-parameter System-1 decision model running on a 12th-gen Intel i7 with OpenVINO INT8.
No GPU. No token-by-token generation.
It receives the game state and chooses an action in a single forward pass.
LLMs can handle planning and reasoning. Small decision models can provide the fast reflexes.
The best agent stack may not be one giant model.
It may be a slow brain paired with fast reflexes.
Laya is making a pretty strong case for local AI agents.
On a 16GB MacBook Air, local Laya is reportedly making decisions in around 45ms.
Cloud-based Jev is closer to 300ms per decision.
That puts Laya roughly 7 to 11x faster in this Tetris setup.
And the hardware is just a MacBook Air.
No dedicated GPU server.
No API round trips.
No per-token bill.
Laya runs locally, so once the model is on the machine, the inference cost is effectively $0 per decision.
Jev has the opposite tradeoff. You get a cloud model, but every decision depends on the network and the API response coming back.
Tetris makes this painfully obvious.
The agent has to constantly:
see the board → decide → act → see the new state → decide again.
When every move takes hundreds of milliseconds, the delay compounds.
At 45ms, Laya can keep that loop moving much faster.
And there’s another piece I find important:
Laya’s weights are open-source.
That means you’re not just renting access to an AI agent through an API. You can actually run the model yourself, inspect the setup, and build around it locally.
For benchmarks, you can argue about accuracy and scores all day.
But put two agents inside a real-time environment and latency becomes impossible to ignore.
Same Tetris board.
One model waits on the cloud.
The other is sitting on your laptop making decisions almost immediately.
In this particular test, the difference is pretty brutal.
Local inference isn’t just about saving API costs.
Sometimes the biggest advantage is simply that the model is already there when you need it.
Laya just mogged Jev at Tetris.
The interesting part isn’t just that a local model won.
Laya is an open-weights System One model running locally on a 16GB MacBook Air.
Jev, meanwhile, is cloud-based and built with Grok 4.7.
Same game. Same objective. Completely different setup.
And Laya was making decisions about 11x faster.
That matters a lot in games like Tetris.
The model has to constantly look at the board, decide where the next piece should go, and act before the situation changes.
Every bit of latency gets exposed.
With Jev running through the cloud, each decision has network and API overhead.
Laya keeps the entire loop on the machine.
No round trip to a server.
No waiting for another request to come back.
The model sees the board, reasons about the move, and acts locally.
And this is happening on a 16GB MacBook Air.
That’s the part I find more interesting than the Tetris score itself.
We’re getting closer to a world where you don’t necessarily need a massive GPU server sitting somewhere in a data center to run useful AI agents.
A laptop can run an open model locally, interact with an environment, and make decisions fast enough for real-time tasks.
Tetris is obviously a toy environment.
But the underlying test is much more interesting:
How much can local inference accomplish when latency becomes almost irrelevant?
Laya vs Jev is a pretty fun way to show the difference. https://x.com/atomic_chat_hq/status/2102160983409955244/video/1
Someone built a way to run Jev on Cloud Run with an RTX PRO 6000.
~47s cold start.
~117ms end-to-end.
100+ req/s at concurrency 32.
And somehow, they turned it into Snake, Dino & Tetris 💀
Jev is getting real interesting
Introducing LeJudge (JEPA x Jev): Natural-language constraints for JEPA world-model planning, judged by a decision model instead of an LLM.
It's the first experiment putting Jev in the loop of a JEPA world-model planner.
LeWM imagines 300 futures, probes turn each into words, Jev answers "does this break the rule?", code adds the penalty.
Rules in plain English. No LLM, no generated text.
Results + code + paper 🧵👇
Whichever new model has you most excited, Pydantic AI has you covered.
Claude Opus 5.5 from @AnthropicAI and GPT-6 Sol and Luna from @OpenAI, supported on launch day. And Jev from @typesafeai, not even a week old.
Upgrade, then change one string.
github.com/pydantic/pydan…
I don’t know if people still remember Jev. Things move so fast here.
I’ve spent the last few days testing it, and found a few things I think builders should see.
Prompt injection is one of the most interesting things to test in AI, so I made a little demo to show how it could change Jev’s answer.
Jev is a great model. I just want people to know what to watch out for when they use it.
GROK 4.7 IS $2/$6 IN CURSOR. Jev now decides if the model even wakes up
same sticker as 4.6. live in Cursor and Grok Build.
CursorBench 4.0: 46.3. DeepSWE v1.1: 71.0. Terminal-Bench 4.0: 37.6.
the loop: repo state → Jev Noul/Choice/Score → allow / ask / skip → only then grok-4.7
1 → dump the tool call as state, not a prompt essay
2 → Jev Noul: is this user-requested
3 → Jev Score: blast radius 0-3
4 → Jev Choice: allow, ask, or skip
5 → hard rules still veto. model never gets last word
6 → shadow 200 tool calls. log pick vs what 4.7 would have billed
7 → flip live. you still approve the risky ones
no auto-merge. no wallet. no "just send every bash to Fable"
result: Jev on OpenRouter is $0.042/MTok in, output free, p50 ~270ms
a ~1k-token gate is about $0.00004. 4.7 stays $2/$6 for the work that survives
Vercel Jev promo ends Sep 25
the EXACT system is in the article below
What people posted on X while they built with Jev. Every card plays the original video or shows its images here, so you see the demo before you open the thread.