Jev's First Week: 15 Projects Show How Agents Separate Generation from Judgment

On September 15, TypeSafe AI released Jev, its first System One Model. Unlike conventional LLMs, Jev does not generate free-form text. Instead, it receives state and predefined questions and returns three judgment types — Noul (yes/no with probability), Choice (candidate distribution with confidence), and Score (scale score with distribution/confidence) — handing probabilities and confidence back to code. TypeSafe positions it bluntly: not for generating content, but for making decisions inside software.

By September 20 (day 6), Made with Jev had catalogued 239 public builds spanning browser agents, coding agents, content analysis, data processing, real-time games, and robotics. Only 102 of those disclosed cost, latency, or throughput figures. The author filtered 15 representative projects and experiments — ranging from hundred-line prototypes to public benchmarks and self-reported metrics — to surface the emerging pattern: developers are re-architecting agents by assigning "generation" and "judgment" to different models.

01 Browser Agents: LLMs No Longer Drive Every Click

1 | Jev Ultrafast (Browser Use team). The current DOM state is fed to Jev; click, scroll, back, etc. become candidate actions for Jev to choose. A small LLM is invoked only when text generation is needed. In a flight-search demo, a full task completes in ~7 seconds at ~$0.004.

2 | Jev + WebMCP. On the public WebMCP benchmark, Jev selects the exposed tool while Mercury 2.5 fills parameters. All 49 tasks succeed. A modified Ultrafast harness without WebMCP solves only 25/49; with WebMCP it reaches 49/49. The author reports model inference cost at roughly 1/112 of a GPT-6 Astra + Computer Use + Code Execution baseline. Crucially, Jev did not suddenly gain complex web reasoning; WebMCP compressed multi-click sequences into single, well-defined tools, shrinking the decision space where Jev excels.

3 | Stagehand. The accessibility tree serves as state, executable actions as candidates; Jev picks the next step, Stagehand executes. A remote-browser demo costs ~$0.001.

4 | Jev Browser Use. Explicitly splits Codex and Jev: Jev handles navigation, click, toggle, scroll; Codex handles text input, visual understanding, sensitive operations, and final verification. In the EZCollegeApp workflow, browser-operation speed improves 5–10×. The project deliberately restricts Jev: it cannot type text, generate URLs, interpret screenshots, or decide sensitive actions. Together these four projects reveal a clear pattern: LLM decides what to do, Jev decides which predefined step to take next, Tool executes. The old optimization loop — making the model see more accurately and think faster — now has an alternative: some mechanical decisions need not wake the strongest model every time.

02 Coding Agents: "Reclaiming Authority" over Skill, Context, and Tool

5 | fast-jev-compaction. When a coding agent's context window fills, the usual approach asks a large model to rewrite history into a summary — risking detail loss or semantic drift. This project instead asks Jev to judge each tool call and tool result for retention. Unimportant items are dropped; important ones stay verbatim. Compaction shifts from a generation task to a selection task. However, controversy is significant: a subsequent Codex port warns "not recommended for real work," citing risks of breaking the model's native compaction flow and invalidating prompt caches. It remains a context-engineering experiment, not a validated replacement.

6 | jev-skill-gate. Agents with dozens or hundreds of skills burden context with all skill descriptions. Jev scores every skill for relevance after the prompt arrives and hides irrelevant ones. In a 217-skill environment, the skill manifest shrinks from 12,750 tokens to 3,185 tokens (~75% reduction) at ~$0.0009 per session. The mindset shifts from "more skills are better" to "skills can be many, but the agent sees only the few it actually needs each turn."

7 | pi-warden. Acts as a coding-agent foreman. Jev judges whether a tool call is irreversible, whether the agent has drifted from the user task, whether it is stuck in a loop, or whether it declares "done" without test/build/lint evidence. Typical failure modes: user asks to edit README, agent modifies config; tests still running, agent claims completion; a command fails and the same strategy repeats. Running a strong model for every review is costly and slow; Jev fits as a lightweight, continuous "is this step reasonable?" check. Self-reported eval: 150 paired agent runs, control group had 6 rule violations, warden group had 0; a stability test covered 13,952 guard cases over 109 cycles. These are project-specific benchmarks, not a general coding-agent standard.

8 | jev-shield. Implements a semantic MCP firewall: tool descriptions, calls, and results pass through Jev before reaching the agent. Author reports 94% block recall, 0 false positives, ~$0.00002 per check. Numbers come from internal tests, not a universal security benchmark, but the architecture is noteworthy.

Across skill gating, context compaction, and tool permissions, Jev is entering the harness layer . Traditionally harnesses relied on hard rules: allow-lists, token limits, mandatory confirmations. Now a new primitive appears: Semantic if statement.

03 Batch Processing: Hundreds to Thousands of Judgments in One Go

9 | 1kpapers. Developer Hassan collected 1,018 AI papers. DeepSeek V4 Flash generated summaries; titles, abstracts, and 24 candidate topics were sent to Jev for classification. Jev classified all 1,018 papers for ~$0.08, median end-to-end latency 256 ms per paper; DeepSeek summarization cost $3.99. A textbook division of labor: DeepSeek reads and writes, Jev picks categories. The author explicitly notes that evaluation of Jev's classifications is ongoing and the existing pipeline will not be replaced until verification completes. The $0.08 proves such classification can be extremely cheap, not that quality is proven.

10 | 500-email classification. Riley Brown classified 500 emails with Jev for 3.5¢ total. Another developer replicated with 1,500 emails. Email classification itself is not novel; the shift is economic: when per-judgment cost and latency drop this low, semantic judgment becomes viable for every email, every support ticket, every alert — not just high-value items.

11 | Jev + Kimi K3 fraud detection cascade. 100 emails (50 legitimate, 50 fraud). Jev classifies all in 1.42 s, then escalates the 31 emails with confidence <95% to Kimi K3. Combined pipeline achieves 96/100 accuracy in ~16 s at ~$0.07 total ($0.068 Kimi K3, ~$0.003 Jev). This case is more copy-worthy than "Jev is cheap": it demonstrates a cascade workflow — Jev handles easy cases → inspect confidence → escalate uncertain few to a large model — a pattern likely closer to what production systems will adopt than sending everything to the strongest model.

04 Content Industry: Not Writing, But Scoring Relentlessly

12 | Matthew Berman: 724 ads. 724 ads from 37 brands fed to Jev, decomposed into hook, format, offer, CTA, awareness stage, landing-page mismatch, etc. ~40 seconds, ~$0.09. Previously, competitive analysis meant sampling 10 representative ads and asking an LLM to summarize patterns. Now, if judgment is cheap enough, full-coverage analysis replaces sampling.

13 | SuperX. Does not ask Jev to write tweets. Instead, each draft answers 61 questions simultaneously: hook strength, information density, reply-bait likelihood, viral potential, etc. ~1 second per draft, ~$0.0004. Method fitted on 9,481 real posts from 207 creators. This epitomizes the content-industry fit: GPT/Claude excel at "write me a post"; Jev excels at "is this hook strong enough?", "any over-promising?", "which segment reads like an ad?", "which of these 100 headlines best matches criterion X?" One model generates, the other judges continuously. Made with Jev data also shows a run analyzing 3,282 posts with 8 questions each for ~$0.1282, and another processing 100,000 X posts with 14 yes/no judgments each in 20.4 s for $0.67 (all self-reported, not a unified benchmark). The takeaway: when marginal cost of a semantic judgment is low enough, "full-volume judgment" becomes a new option, not just sampling.

14 | YouTube Sponsor Skipper. Chrome extension that analyzes video content during playback, asks Jev continuously "is this segment a sponsor read?", and auto-skips when Jev says yes. Cost ~$0.005 per video. Looks like a toy but perfectly matches Jev's boundary: it writes nothing, performs no open-ended task, only repeatedly answers one binary question — "is this an ad right now?" — and code executes the skip.

05 The Wildest One: Natural Language Directly Inside SQL

15 | pg-jev. Embeds Jev inside PostgreSQL. Previously, filtering "angry customers" required hand-written rules or embedding + vector search. pg-jev allows: WHERE jev(tickets, 'the customer is angry') Or "which department — Billing, Technical, Security, Sales — should handle this ticket?" then GROUP BY the Choice result. It combines precise SQL predicates (age, date, amount) with fuzzy semantic predicates ("is the customer angry?", "how luxurious does this product look?"). README benchmarks: 2,000-row table, first full run ~3.5 s, 100 requests, ~296k input tokens, ~$0.012; subsequent runs in-session ~50 ms; LIMIT 3 with new condition ~0.6 s. The author did not blindly increase batch size: structured ground-truth tests show 100% accuracy at 1–20 rows/batch, dropping to 92–98% at 40 rows, and 77–94% at 80 rows. Default batch size set to 20. This demonstrates that packing more rows into a single state to reduce requests can directly sacrifice judgment reliability.

pg-jev highlights the Jev vs. LLM distinction. Classic AI-to-database flow: User question → LLM writes SQL → DB executes → LLM summarizes answer. pg-jev flow: SQL itself contains a semantic judgment function. Precise computation stays in code; fuzzy judgment goes to the model. This may be the true niche of a System One Model.

Clear boundaries exist: pg-jev sends row data to a third-party API — README warns against use with data that cannot leave the environment; it requires plpython3u and PostgreSQL superuser privileges, so not all managed databases support it.

06 After 15 Projects, Jev's Real Value Isn't Speed

Looking only at demos, Jev appears to be "a very fast, very cheap small model." But the 15 projects reveal a recurring architectural pattern: LLM generates, Jev judges, Code executes.

Browser agents: large model no longer handles every click.

Coding agents: large model no longer judges every skill, context slice, or tool call.

Batch processing: large model no longer classifies thousands of documents one by one.

Security systems: no longer spins up a full reviewer agent for every tool call.

TypeSafe's own Workflow Evals follow the same logic: tasks are decomposed into Noul, Choice, Score, while deterministic rules, calculations, thresholds, and workflow orchestration remain in code. In the published Invoice Processing example, exact fields — amount, date, account, status — are computed by code, not asked of the model.

This also means Jev is not universally suitable. It does not write articles, cannot perform complex open-ended planning, and its type-safety guarantees only that output falls within the predefined answer space — not that semantic judgments are 100% correct. Official Workflow Evals show Jev, Sol, and Opus each disagreeing with reference labels (themselves aggregated from GPT-6 Astra and Claude Fable 5.1 under high thinking, not absolute ground truth).

Precisely because of these constraints, Jev surfaces a question the field has largely ignored for two years: we have defaulted to stuffing all agent intelligence into a single, ever-stronger LLM. Planning, writing, tool selection, result judging, permission review — all the same model. Jev's early ecosystem suggests another answer: Agents may not need one model to package all cognitive work. Some problems need Astra/Claude-grade slow reasoning; some need only yes/no; some need to pick 3 out of 200 skills; some need to verify "does this tool call exceed permissions?"; some need to choose the next action from a candidate list. As models grow stronger, the next competitive frontier for agents may not be cramming more into the strongest model, but slicing judgment types finer and finer.

Jev is one week old; most projects are experimental; many impressive numbers come from authors' own demos and test environments, far from production hardening. Yet 239 public builds in six days signals why developers are drawn to this new interface. They may have found not just a cheaper classifier, but a dedicated layer for judgment — extracting a capability previously scattered across prompts, rule engines, small models, and the main model into its own stratum. Generation goes to LLMs; precise logic goes to code. The fuzzy judgments in between — too fluid to hard-code, too cheap to wake a full LLM every time — finally have a dedicated home.

Source: TypeSafe AI, TypeSafe Workflow Evals, Made with Jev, and public GitHub repositories of each project. Performance and cost figures, unless otherwise noted, come from developers' public test results and are not third-party benchmarks under unified conditions.