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
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 short clip shared by darkzodchi: TypeSafe’s founder on why older LLMs were good at talking and bad at deciding.
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.
Scott Williams on using parallel constrained decoding to make existing agent systems use fewer tokens.
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
```
梭哈.AI’s write-up of Tamara Tran’s compaction plugin for Claude Code.
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👇
Erick on fast-jev-compaction: instead of summarising the context, Jev prunes it, keeping what matters word for word.
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.
Theo on why per-tool-call filtering is not compaction: lost reasoning, higher cache-write costs and agents stuck in loops.
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)
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 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
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
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.
Ian Nuttall: add the official skill, then run /typesafe-ai in your project to find where Jev can replace slow, expensive LLM calls.
Wahiduzzaman Hridoy
@hridoy43
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.
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.
Jev + Laya + any AI agent is an absolutely insane stack
Jev became one of the most talked-about AI releases almost overnight, but most people still have no idea how to use it beyond isolated demos - especially together with Laya, Grok Bot, Claude Code and Codex
So I mapped the complete architecture into a 12-page guide explaining how to combine all of them into one decision-and-execution system - and the result is genuinely ridiculous:
step 1 → stop asking one LLM to do five different jobs: state, judgment, generation, execution and authority should be separate layers
step 2 → use Jev as the escalation layer: it handles difficult routing, evidence verification, completion checks and high-consequence decisions through typed answers
step 3 → use Laya as the local fast path: it handles frequent classification, scoring, filtering and worker selection without sending every decision to a cloud model
step 4 → put both behind one decision gateway: Laya and Jev can accept similar choice, score and yes-or-no questions, but their confidence values need separate thresholds
step 5 → keep project state outside the agents: goals, artifacts, evidence, gaps, risks, budgets and approvals become the shared source of truth
step 6 → build the worker menu before asking a model to choose: only include agents that exist, are available, have the required tools and are allowed to access the data
step 7 → give every executor a different job: Grok Bot handles apps, browsers and routines; Claude Code handles deep repository work; Codex handles implementation, testing and review
step 8 → turn every assignment into a bounded packet: one owner, one objective, approved inputs, expected artifacts, forbidden actions and an exact definition of done
step 9 → run the hybrid decision loop: Laya answers locally first, Jev receives uncertain or high-risk cases, and a human reviews consequential disagreements
step 10 → never average confidence blindly: if Laya and Jev disagree, preserve both distributions, inspect the evidence and route the case through an explicit review policy
step 11 → gate effects instead of tool names: reading, searching, testing and drafting can run automatically; publishing, deploying, spending, deleting and exposing secrets still require approval
step 12 → test the whole system before giving it autonomy: run shadow mode, measure disagreements, inject failures, test rollback and automate only the safest branches first
the result: Laya filters routine decisions, Jev judges difficult boundaries, Grok Bot, Claude Code and Codex execute the work, deterministic code controls the system and you approve the consequences
Save this, then send the complete 12-page Jev + Laya + AI Agents guide to your Claude Code or Codex instance and build the stack ↓
rari’s guide to one decision-and-execution stack: Laya answers routine decisions locally, Jev takes the uncertain and high-risk ones, and Claude Code, Codex and Grok Bot do the work behind approval gates.
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…
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
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.