Quick Hits

• @drewdil posted the day's most substantive test: benchmarking Jev against production judges for a day, it matched or beat existing small-model classifiers on fixed-label tasks at up to ~100x lower cost, but found none of 13 human-identified code-review problems and only 2 of 12 real contradictions between decisions.
• Model routing is the most-repeated build pattern across the day's posts, from @ephraimduncan's working router demo to @agentnative_'s copy-paste prompt and @da_fant's case for using Jev to triage which events should wake an expensive orchestrator agent.
• Open-source lookalikes landed fast: @harshagundal released Qwen-2.5-1B-RLCD ("They were building in stealth for 2 years, I was building in stealth for 2 hours"), Shopify's @kshetrajna built a Qwen-based variant running on WebGPU in the browser, and @mmastrac reports third-party reproductions of DiffusionGemma-as-Jev.
• @Dorialexander flagged "synthetic pretraining spotted," and Jev co-founder @CompleteSkeptic confirmed in a reply that 100% of the project's data is synthetic and that the team considers itself a data research lab.
• Latency demos keep escalating: @moritzkremb drove a browser by voice at $0.0002 per decision, and @maubaron had Jev control four Smash Bros characters playing against itself for a few cents.

A benchmark separates what Jev can and can't do

@drewdil's post is the most useful thing published about Jev today, because it draws a clean line through the hype. After a day of testing against his company's production judges, his conclusion: Jev excels at "picking a label from a fixed list, when the list is defined by you and the evidence is in the input," and fails when the answer depends on a model's own sense of quality.

The wins are specific. Classifying sales-call transcripts into one of 32 call types: 35 of 36 correct including 20 adversarial cases, versus 34 of 36 for the current classifier, at roughly 100x lower cost. Typing knowledge-graph relationships from a fixed vocabulary passed all four quality gates at ~65x lower cost and 15x lower latency. Slack channel categorization went 16 of 16. Median latency ran 100 to 200ms across ~3,700 calls, with nine server errors and no throttling. Notably, when Jev was wrong its confidence score was usually low, while a frontier model claimed 95% confidence on both of its misses.

The failures cluster around judgment. On grading agent outputs against a written rubric, Jev would have let 27 of 71 real production rejections through. On code review of 14 merged PRs, it found none of the 13 human-identified issues and generated 24 noise notes on cleanly approved PRs. Six rewrites of the question changed nothing. @isaac_flath's post independently lands in the safe zone: his six "still using in 60 days" use cases (fact-checking scripts, ranking a news feed, finding text in PDFs, checking citations, grouping review notes, running evals over agent traces) are all fixed-answer tasks where the evidence is in the input.

Model routing becomes the default demo

If one application pattern dominated the day, it's using Jev to pick which model handles a request. @ephraimduncan built and demoed a router where Jev matches requests to the best-fitting model. @agentnative_ went further and published a full prompt for building such an agent with Vercel's eve and its AI gateway, cheap models for simple queries and frontier models for hard ones, with the Jev selection shown inline.

@da_fant's thread argues the bigger prize is subagent orchestration: long-running agents get woken by every user message, email, or subagent reply, and waking "gpt 6 astra" with 100k input tokens costs about $1. Jev can decide whether each event routes directly to a subagent, queues for later, or wakes the orchestrator. @Saccc_c makes a similar case from the Codex side, claiming Jev makes Codex operations roughly 10x faster and cheaper and listing computer-use judgment, context compression, routing, and auto-moderation as the fit scenarios, including moderation that is cheaper and more precise than "5.6 luna."

@thekitze wired Jev into his skillbox tool so agents skip multi-turn skill discovery, then open-sourced the whole thing under MIT. And @AM09_21 points Japanese-speaking users to the official Jev use-case page for anyone stuck on what to do with it.

Millisecond decisions: compaction, browsers, spreadsheets, games

The second cluster exploits Jev's latency directly. @tamarajtran's instant-compaction idea replaces summarization prompts with per-tool-call scoring; @SUOHA_AI reports the open-sourced Claude Code plugin clears useless terminal output and redundant logs in milliseconds, and says co-founder Diogo Almeida publicly endorsed it as a way for coding agents to bypass traditional KV cache limits.

Real-time control demos built on the same property. @moritzkremb's voice-to-browser loop returns probabilities in ~300ms at $0.0002 per decision, fast enough to complete a "go back" request before he finished the sentence. @maubaron had Jev play Smash Bros against itself, controlling all four characters, burning 22 million tokens for cents. @dabit3 showed predictive spreadsheets where typing "Urgency" gets every row rated in ~100ms, plus a keystroke-aware launcher that surfaces "the pdf I just downloaded" on every keystroke. @dotpem sketched a DAG prototype that classifies input as Python or bash and routes accordingly. @vimota proposes qualitative linters with free-form rules checked at chosen granularities, and @rafalwilinski runs a parallel browser-based adversarial test suite against each release "for pennies."

Clones, reproductions, and scrutiny of the origin story

The open-source response was immediate. @harshagundal's Qwen-2.5-1B-RLCD claims every LLM can already batch-inference JSON keys and output category probabilities without new training, with a demo on an M4 MacBook; @ScarletKc amplified the two-years-versus-two-hours contrast. At Shopify, @kshetrajna built Reflex, a Qwen-based structured-decision experiment running on WebGPU, which @tobi shared with "have jev running in your browser." @mmastrac reports reproductions of DiffusionGemma-as-Jev coming in, with @nordiconco confirming a first small test ran well.

Meanwhile @Dorialexander spotted synthetic pretraining, and @CompleteSkeptic's reply confirms 100% synthetic data framed as building a "cognitive core." @MatijaSosic, whose 45-second Jev explainer passed 400k views, argues the launch's big language (AGI, 200x faster, by a ChatGPT creator) was deliberate, preempting dismissal as "just a classifier" and letting the community do the explaining work. The original launch claims of 20-200x faster and 40-400x cheaper remain the founders' own.

Predictions and adjacent tooling

@obie predicts all major frontier labs will ship JEV-style offerings within months and that decision models could outgrow LLMs, drawing on three years putting LLMs into production codebases. @kunchenguid's joke that he'll pass his remaining $5 signup credit to his son is a decent mascot for the token-frugality moment. @dabit3 also boosted @mvanhorn's article on the nine things people are building with Jev. Off the Jev beat, @dexhorthy open-sourced a visual-PR skill for humanlayer to cut agent PR noise, and @mattpocockuk's tip on classifying merge danger (one-way versus two-way door, blast radius) sits right in the fixed-label shape @drewdil found Jev handles well, though the post itself doesn't name Jev.

Practical Takeaway

If you're evaluating Jev, copy @drewdil's methodology rather than the demos: pilot it only on fixed-label tasks where your own taxonomy defines correctness (routing, triage, compaction scoring, moderation), gate on its confidence score and escalate low-confidence answers to a frontier model, and keep it away from quality grading and code review until you've validated against your own labeled fixtures. The cheapest starting point is a routing layer, since several working implementations were published today and the failure mode is only a misrouted request, not a wrong verdict.