Jev's Picks

Popular posts about Jev on X, best ones first

13.9KPosts
404.4MViews
158.9KReplies
211.8KReposts
2.3MLikes
xsmryze
@xsmryze

THIS IS AN ACTUAL F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: run Sonnet, Haiku 5.5 and Opus 5.5 at once, each one doing only the job it's best at. Better results and way fewer tokens, because every task lands on the right model. You just launch Claude Code like this: claude --model sonnet --advisor opus here's the split: → Sonnet 5.5 runs the session, writes the code and applies the fixes → Haiku 5.5 swarms the repo in parallel: search, grep and diff audits → Opus 5.5 stays on call as advisor for the big calls and signs off on the diff → you stop burning Opus context on work that doesn't need it Opus only steps in at three moments: → before a plan locks → when the same error shows up twice → before calling it done Sonnet builds. Haiku swarms. Opus reviews. JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Sonnet 5.5 runs the main session and coordinates the work > search maps the repo on Haiku 5.5, read-only > grep finds call sites on Haiku 5.5 in its own context > audit checks the diff on Haiku 5.5 in a throwaway worktree > Opus 5.5 on call as advisor, reviews the synthesized diff before sign-off > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Run the main session on Sonnet 5.5 with Opus 5.5 as advisor. 2. Create three Haiku 5.5 subagents in .claude/agents: search (maps the repo), grep (finds call sites), audit (checks the diff). 3. Set isolation: worktree on audit so its checks never touch my working branch. 4. Add one rule to CLAUDE.md: delegate every repo search and test run to the Haiku 5.5 subagents to keep the main context small. 5. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, it'll come in handy.

this is pure f*cking treasure... Anthropic just released the most dangerous model they've ever shipped everything you need is inside: what it built, the real costs, when it's a waste, and 5 prompts that build anything read before you burn your limits:

Nathan Flurry 🔩
@nathanflurry

quick tip we learned the hard way @ rivet: jev does not reason ...which is by design ...and we should have rtfm first ~ we started by prompt-engineer to ask something like: ``` 𝚜𝚎𝚟𝚎𝚛𝚒𝚝𝚢 = 𝚊𝚜𝚔( "𝚐𝚒𝚟𝚎 𝚖𝚎 𝚝𝚑𝚎 𝚜𝚎𝚟𝚎𝚛𝚒𝚝𝚢 𝚘𝚏 𝚝𝚑𝚒𝚜 𝚒𝚜𝚜𝚞𝚎. 𝚏𝚘𝚛 𝚎𝚡𝚊𝚖𝚙𝚕𝚎, 𝚜𝚎𝚟-𝟷 𝚒𝚜 𝚇, 𝚜𝚎𝚟-𝟸 𝚒𝚜 𝚈, 𝚜𝚎𝚟-𝟹 𝚒𝚜 𝚉, 𝚎𝚝𝚌", 𝚘𝚞𝚝𝚙𝚞𝚝𝚜=[𝚂𝙴𝚅𝟷, 𝚂𝙴𝚅𝟸, 𝚂𝙴𝚅𝟹, 𝚂𝙴𝚅𝟺] ) 𝚛𝚎𝚝𝚞𝚛𝚗 𝚜𝚎𝚟𝚎𝚛𝚒𝚝𝚢 ``` normally, an llm would spend reasoning tokens to come to a descent conclusion but doing this with jev gives meh results, and defeats what makes jev awesome ~ after rtfm, we split it up in to tiny prompts like this: ``` 𝚒𝚜_𝚍𝚘𝚠𝚗 = 𝚊𝚜𝚔("𝙳𝚒𝚍 𝚝𝚑𝚎𝚒𝚛 𝚙𝚛𝚘𝚍𝚞𝚌𝚝𝚒𝚘𝚗 𝚜𝚎𝚛𝚟𝚒𝚌𝚎 𝚐𝚘 𝚍𝚘𝚠𝚗 𝚘𝚛 𝚋𝚎𝚌𝚘𝚖𝚎 𝚞𝚗𝚞𝚜𝚊𝚋𝚕𝚎?") 𝚒𝚜_𝚋𝚕𝚘𝚌𝚔𝚎𝚍 = 𝚊𝚜𝚔("𝙰𝚛𝚎 𝚝𝚑𝚎𝚢 𝚋𝚕𝚘𝚌𝚔𝚎𝚍 𝚠𝚒𝚝𝚑 𝚗𝚘 𝚠𝚘𝚛𝚔𝚊𝚛𝚘𝚞𝚗𝚍?") 𝚒𝚜_𝚋𝚛𝚘𝚔𝚎𝚗 = 𝚊𝚜𝚔("𝙸𝚜 𝚜𝚘𝚖𝚎𝚝𝚑𝚒𝚗𝚐 𝚒𝚗 𝚁𝚒𝚟𝚎𝚝 𝚋𝚛𝚘𝚔𝚎𝚗 𝚘𝚛 𝚏𝚊𝚒𝚕𝚒𝚗𝚐?") 𝚒𝚏 (𝚒𝚜_𝚋𝚕𝚘𝚌𝚔𝚎𝚍) 𝚛𝚎𝚝𝚞𝚛𝚗 𝚂𝙴𝚅𝟷 𝚒𝚏 (𝚒𝚜_𝚍𝚘𝚠𝚗) 𝚛𝚎𝚝𝚞𝚛𝚗 𝚂𝙴𝚅𝟸 𝚒𝚏 (𝚒𝚜_𝚋𝚛𝚘𝚔𝚎𝚗) 𝚛𝚎𝚝𝚞𝚛𝚗 𝚂𝙴𝚅𝟹 𝚛𝚎𝚝𝚞𝚛𝚗 𝚂𝙴𝚅𝟺 ``` which works like a charm (example screenshot of real-world classifier below) ~ any time we find a ticket that isn't weighted well: - we give the ticket to an llm with what we expected - llm adds it to a test suite - llm adjusts decision logic - backtests new decision logic on old issues within a few tickets the classifier logic was really solid ~ this is a feature of jev, not a limitation in practice, it gives more control over how each decision is weighed than a generic llm which makes it easier to reason about, monitor, and back test how agents will behave ~ for reference, this is how many jev questions we ask for a few of our classifiers in our internal support tool: support classification and customer status: 13 severity: 6 team replies and problem identification: 6 follow-up timing: 6 linked dependencies and later conversations: 4 addressed teammate: 2 conversation grouping: 2 ~ all that to say, jev is awesome

Quoted on Jev-X by @allietheicon and 2 others
Diogo Almeida
@completeskeptic

now 50% of my most favorite software companies use jev (🫶 @posthog )

Building a product that requires constant LLM calls gets real expensive, real fast. Fortunately, decision models like Jev can do some of the work up to 444.6x cheaper and 193.6x faster. Here's how we use them at PostHog:

Monid
@monidhq

What if your agent can stalk every brand riding GTA 6for you... Introducing Social API for agents, powered by Jev @typesafeai One key. Any social data. - TikTok, Instagram, Reddit, YouTube, LinkedIn, the Ad Library, one skill file - Search a trend, decode the top video, track the creators, read what people say, see who's advertising, find who got paid - Pay per call. GTA VI launch day, all six answers: $0.12 0% markup. No subscription.

Thread · 1 moreFree credit trial
Quoted on Jev-X by @shengkunye and @jasperli0122
Mr. Buzzoni
@mr_buzzoni

this PDF is an unfair f*cking advantage for anyone building with coding agents Diogo Almeida, founder of Jev and co-author of InstructGPT, released a PDF on how to build a Jev harness the pitch: > as much as 200x faster > as much as 400x cheaper both the speed and the savings come from the harness wrapped around the model how to put it to work: > feed the PDF and the article below to Claude Code or Codex > let it rewire its own setup one evening of work and your agent runs on a harness hardly any team has 👇

xsmryze
@xsmryze

THIS IS ACTUAL F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code. The idea: run Sonnet, Haiku and Opus 5.5 together, each one doing only the job it's best at. Opus-level judgment on every big call, without paying Opus rates for every routine turn. You just launch Claude Code like this: claude --model sonnet --advisor opus here's the split: → Sonnet 5.5 runs the session and writes the code → Haiku 5.5 explores files and docs in parallel → Opus 5.5 stays on call as advisor for the big calls → you stop spending Opus on work that doesn't need it Opus only steps in at three moments: → before a plan locks → when the same error shows up twice → before calling it done Sonnet builds. Haiku explores. Opus reviews. JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Sonnet 5.5 runs the main session and edits code > search maps the repo on Haiku 5.5 > grep finds call sites on Haiku 5.5 > docs pulls the API reference on Haiku 5.5 > Opus 5.5 on call as advisor, reads the whole transcript when consulted > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Sonnet 5.5 with Opus 5.5 as advisor. 2. Create three read-only Haiku 5.5 subagents: search (maps the repo), grep (finds call sites), docs (pulls the API reference). 3. Add one rule to CLAUDE.md: consult the advisor before locking a plan, after the same error twice, and before calling a task done. 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, you'll use this every single day.

this is pure f*cking treasure... Anthropic just released the most dangerous model they've ever shipped everything you need is inside: what it built, the real costs, when it's a waste, and 5 prompts that build anything read before you burn your limits:

kwindla
@kwindla

The first really big adoption of conversational voice AI was in simple, customer-facing interactions: customer support, scheduling, and semi-scripted outbound calls to do things like remind people about appointments or qualify sales leads. There's now a lot of interesting new stuff being built that pushes into more complex use cases and architectures. Voice experiences have to: 1) be fast, responsive, and natural, 2) perform tool calls and instruction following very accurately across long, multi-turn interactions. Most of the voice applications we build, today, use multiple models doing different kinds of inference in parallel, to achieve both 1 and 2. Here's a demo from Jon and Dom showing multiple people talking, with a voice agent in the call weighing in only when it's spoken to directly, or there's a semantic gap in the conversation. This uses Jev alongside a couple of LLMs.

We often get asked whether it's possible to build an AI experience with multiple users and one (or more) agents in the loop. This is where good diarization and a fast classifier model come in clutch. The only real prerequisites these days are good orchestration (Pipecat!), good STT (Deepgram!) and a transport and infrastructure that support multiple tracks (Daily!). Here's a one-shot Claude demo. The agent joins a meeting, and the conversation passes through Jev, which decides whether the agent is being addressed. If it isn't sure, it waits 2.5 seconds, and if no one else answers, it offers a response. All of these thresholds can be tuned. Clearly, I haven’t tuned them in this video 😅 For some use-cases, you might prefer a more natural speaking companion that is chatty and joins the conversation, for others (like this demo) you might want something that stays quiet unless spoken to. Jev adds ~100ms of latency to each turn, which is fine. You could also use a tiny classifier like P

Read thread · 2
Santiago
@svpino

This is a new open decision model with 31B parameters built on Gemma 4. • The model is #1 on the Jev Decision Index leaderboard • 2x faster than Jev • 20% cheaper than Jev • Built on Gemma 4 but outperforms Gemini Decision You can run this locally! • Input: text and images • Output: structured answers + confidence scores You can use this model to ask: • yes/no questions • multiple-choice questions • rate different options

Picking the next tool shouldn’t take a paragraph. We built Karpo Decision. A family of six open-weight models, from 0.8B to 31B.Give it the context, a question, and the options. It returns a probability for each option in one forward pass. Karpo Decision 31B 🏆 73.9 on Decision Index, tied for #1 on the Nov 12 board ⚡ 94 ms median per request on a single RTX PRO 6000 📊 87.2 on JevBench Capability vs. 78.5 for Google’s Gemini Decision 1 🤗 Hugging Face huggingface.co/MachinePulseAI… 📝 Technical write-up karpo.ai/blog/karpo-dec… Here’s where I’d try it first: Search. Recommendations. Tool choice. Model routing. Browser actions. Point it at the slowest decision in your stack and tell us what breaks.

Thread · 1 moreModel Link
Koder
@koder_dev

The overall picture of Claude Code, with 147 skills and 150 subagents, is a different order of magnitude, lol Narrowing the entry point to just Claude Code and inserting a harness that judges with Jev before routing to other AIs, skills, or MCPs, the design is really elegant Looking at my own setup, I realize my entry points are all over the place... I'll start by drawing out the overall picture

mirku
@mirku21

holy sh*t. Official Anthropic pattern for Claude Code: stop burning Opus 5.5 context on tasks Haiku 5.5 can swarm, while Sonnet 5.5 builds put the architect on call with /advisor claude --model sonnet --advisor opus Sonnet 5.5 drives the primary session on high effort, writing diffs and running test suites Haiku 5.5 subagents swarm the repo in parallel at 340 tok/s, handling file discovery and spec docs lookup Opus 5.5 stays on call in the background as the advisor, only stepping in at three critical moments: → before a plan locks: does the implementation plan miss auth invariants or schema contracts? → when a test breaks twice: are we fixing the root cause or falling into a recursive rabbit hole? → before calling done: did the full diff introduce hidden regressions or break pre-flight rules? Opus 5.5 reviews. Sonnet 5.5 builds. Haiku 5.5 swarms Jev engineering runs the identical pattern one layer down: mechanical decisions that need no reasoning (which file to open, which tool to invoke, retry or abort) execute in 16ms, so the frontier models only wake up when execution paths actually diverge Plan on high. Delegate on medium. Keep Opus on call. - the full advisor setup > Opus 5.5 on call reads full session history and catches deep architectural traps > Sonnet 5.5 lead drives edits, writes core logic, and executes test harnesses > Haiku 5.5 subagents swarm AST parsing, grep scans, and API docs in parallel > JEV micro-fork layer resolves 1,500+ mechanical routing branches in under 16ms > advisor stays completely silent on routine bash execution to protect context paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for hierarchical advisor orchestration: 1. Audit ~/.claude/settings.json and project config for model roles fitting lead, subagents, and advisor: > Pin main session model: sonnet with effortLevel: high for primary execution > Pin subagents model via CLAUDE_CODE_SUBAGENT_MODEL: haiku for file discovery and docs retrieval > Pin advisor model: opus on call for strategic review 2. Enable the advisor tool in ~/.claude/settings.json: > Set advisorModel to claude-opus-5-5 > Set subagentPromptCacheTtl to 5m 3. Configure automatic advisor consultation checkpoints in ~/.claude/CLAUDE.md: > Consult the advisor tool before finalizing multi-file architecture plans > Automatically summon the advisor when the same test or compiler error fails twice > Enforce advisor diff contract audit before declaring tasks complete or staging git commits 4. Constrain subagent scopes in ~/.claude/agents/: > Haiku subagents use read-only tools (Read, Grep, Glob) and return structured summaries without editing files Show every configuration diff first. Do not apply edits until confirmed" ↳

Stop letting unmanaged Claude Code runs fail at turn 14 Set up the harness before launching multi-file tasks Isolate worktrees, enforce contracts, verify with Fable 5.5 The complete production agent architecture below ↓

Browse by category

Jev topics

Explore the latest discussions on X.

FAQ

About the Jev model

What is Jev?

Jev is the first System One model from TypeSafe AI, built for automation and software decisions. Rather than generating conversational text, it takes an input state and directly returns typed decisions with calibrated confidence that software can use. Its training method is called RLCD (Reinforcement Learning for Calibrated Decisions). The official website claims that Jev is 193.6 times faster and 444.6 times cheaper than conventional LLMs for automation tasks. These figures come from the official website and have not been independently verified by this site.

How does a System One model differ from chat models such as ChatGPT and Claude?

Chat models excel at generating long text and performing multistep reasoning. System One models focus on quick decisions: given some content and a question with a clearly defined output type, they return a choice, a score, or a true-or-false judgment, along with the probability of each outcome. They suit decisions that software makes repeatedly, such as classification, routing, scoring, moderation, and tool selection.

What is RLCD?

RLCD stands for Reinforcement Learning for Calibrated Decisions. It is the method TypeSafe AI uses to train Jev. The goal is to align a model's confidence with its actual accuracy. For example, judgments made with 90% confidence should be correct about nine times out of ten, allowing software to use confidence to decide whether to act automatically or hand the decision to a person.

What kinds of questions can Jev answer?

The official documentation defines three question primitives: Choice (selects one option from a set and returns each option's probability and confidence), Score (assigns a score against a rubric with 2 to 10 levels), and Noul (judges whether a statement is true and returns a probability from 0 to 1). A single request can ask multiple questions.

How do I get started with Jev?

Get an API key from the TypeSafe console, send a POST request to https://api.typesafe.ai/v1/systemone, and set the model name to jev-latest. See the official documentation for details. Official Python and JavaScript SDKs are also available. According to announcements on X, Jev has also been integrated with OpenRouter, Cloudflare AI Gateway, and Vercel AI Gateway.

How much does Jev cost?

As of September 2026, the official documentation lists input at $0.042 per million tokens, with free output and a limit of 64k tokens per request. Prices and limits may change; refer to the official documentation for the current terms.

About this site

What does this site do?

This site curates quality discussions in Chinese and English about the Jev model on X (Twitter), including open-source projects, integrations, tutorials, hands-on reviews, use cases, interviews, and news. It also tracks discussion activity by date. The site is maintained by the community and curated by @Web3wr. It is not affiliated with TypeSafe AI.

Where do the posts come from, and how often are they updated?

Posts are retrieved through twitterapi.io's advanced search API. The search includes posts mentioning both Jev (or System One or RLCD) and TypeSafe, excludes reposts, and also includes the latest posts from the official @typesafeai account. Popular picks refresh every hour, while daily statistics are collected in batches by the backend every 5 minutes.

What should I do if a category or ranking seems wrong?

Email hello@jev-x.com, or send feedback through Telegram or message @Web3wr on X. You can also recommend quality posts that we have missed.

Why do videos in posts sometimes fail to play?

Videos load directly from X's video servers. If your network cannot access X or X restricts playback, the card displays a notice and directs you to the original post on X to watch the video.

Ranking and statistics

How are posts ranked?

Daily picks and the 3-day hot list are ranked differently. Daily picks are ordered by Jev quality score from high to low, with newer posts first when scores are tied. The 3-day hot list only includes posts published in the last 3 days and is ordered purely by X engagement score from high to low, with newer posts first when scores are tied; the quality score is only used to filter out noise and does not affect the order. The X engagement score uses weights based on the recommendation ranking model X open-sourced in 2023: 0.5 per like, 1 per repost, and 13.5 per reply. How popularity is ranked → Picks rules

Why not rank posts directly by views?

Views reflect exposure, and large accounts get many views regardless of what they post. Replies also carry a high weight in X's model, but posts such as giveaways asking people to reply with "1" can inflate their scores through reply farming. So this site ignores views: daily picks use Jev to judge how informative the content itself is and are ordered directly by quality score; the 3-day hot list is ordered by X engagement score, but first uses the quality score to filter out noise such as giveaways and engagement farming (posts with a quality score below 50, a failing grade, are not shown).

How does Jev assign quality scores?

Each post is sent to Jev for classification and a Score question with 5 levels, then converted to a score from 0 to 100: noise (giveaways, engagement farming, or irrelevant content), pure emotion, an opinion, specific information (news, integrations, demos, or measured results), and worth saving (original insights, tutorials, open-source tools, or data). Jev also sees the types of links attached to the post, such as articles, GitHub, and videos, as well as engagement data such as the bookmark rate. Exaggerated promotion in all caps does not earn extra points. Post quality → Picks rules

Do quality scores change over time?

Each post receives a quality score only once. The X engagement score is recalculated from the latest numbers on each refresh, and the 3-day hot list is ordered by it, so a post can still rise in the rankings if it becomes popular later.

How are the post, view, reply, repost, and like totals at the top calculated?

Since Jev's release on September 15, 2026, the site has counted qualifying discussions about Jev on X each day: related posts with at least 10 likes, excluding reposts. The numbers are snapshots taken when posts are collected; view counts can continue to grow afterward. Long-tail posts with 0 likes are not included. Dates and times follow your time zone, matching X: each post is grouped under its publication date in your local time. Statistics use your local date from October 2, 2026; earlier statistics only exist as UTC-day totals and are kept as originally recorded.

Content categories and picks

What content categories are available?

Official (posts by @typesafeai), Integrations (platforms or frameworks integrating Jev), Open source (GitHub projects, CLIs, plugins, Skills, and open-source recreations), Competitors (comparisons with ChatGPT, Claude, Codex, and others), Tutorials (getting started, study notes, and explanations of concepts), Use cases (applications and demos built with Jev), Reviews (measured speed, cost, and accuracy), Interviews (podcasts, interviews, and talks), News (releases, funding, and user growth), and Opinions (other views).

How are categories assigned?

Jev assigns categories through a Choice question. Each category includes a definition of what belongs and what does not, along with real examples. Jev's result is used when its confidence is at least 50%; below 50%, keyword rules provide a fallback. Hover over a card's category label to see the source and confidence.

How are daily picks selected?

Each day, classified qualifying posts are ordered by Jev quality score from high to low (newer posts first when scores are tied), and the top 50 are selected. Posts with a quality score below 50 (a failing grade) are not shown. The current day's data updates every 8 hours, is collected again after the day ends, and is finalized after another 24 hours.

Share preview · Jev-X

Image preview