Ten ways people use Jev, the model that only decides

In mid-September 2026, TypeSafe released Jev: a model that writes no prose and returns only typed decisions. Give it application state and one narrow question, and it answers with a choice, a yes-or-no, or a score carrying a calibrated probability, in a few hundred milliseconds. The official price is $0.042 per million input tokens, with output free. A month later, ten open-source projects orbit that idea, from a browser agent to a Postgres extension, together worth about 42,000 GitHub stars (as of 2026-10-12, GitHub API). This article walks through them by asking one question of each: which decision did Jev make inside this project? Two of the ten never call Jev at all, and their absence draws the boundary of the paradigm usefully well.

Key points

• Jev splits judgment into three primitives — Choice picks one option, Noul answers yes-or-no, Score places an item on a described dimension — and every answer carries a probability. TypeSafe claims 70–500 ms end-to-end, 40–200x faster than frontier models of comparable intelligence (official blog, September 2026).
• The ten projects put Jev in ten different places: jev-ultrafast lets it pick each browser action and target, pg-jev makes it a SQL predicate, fast-jev-compaction lets it decide which tool calls may be deleted, and jev-trader asks it buy-or-sell every 300 ms.
• Every performance number here is self-reported: TypeSafe refuses to publish benchmarks, and jev-ultrafast’s own controlled comparison ran three pairs, with a sign-test p of 0.25.

What Jev is

Jev is TypeSafe’s first System One model. The name borrows from Kahneman’s thinking, fast and slow: system 1 is fast, intuitive, and does not explain itself. Accordingly, Jev does no autoregressive text generation. It samples all outputs in parallel within a single request and returns type-safe structured values — the possible outputs are defined before the call, so the model cannot produce a type error, and because it never generates strings, it cannot hallucinate. Training uses RLCD, reinforcement learning aimed at calibrated decisions, and every answer ships with a calibrated probability and confidence. The model’s name honors economist William Stanley Jevons; the company’s framing leans on Jevons’ paradox — cheaper intelligence should unlock more uses of it.

The business side moved faster than the technical one. As we reported on October 3, TypeSafe left stealth on September 15 with a $40 million seed round led by DCVC at a roughly $200 million valuation, followed by talks at a valuation above $10 billion; TechCrunch covered OpenAI’s “Jev clone” on September 30 and Amazon’s on October 1. One startup’s paradigm copied by two giants inside two weeks is rare in foundation-model land — the most expensive part of agent planning is exactly the generation that branch decisions do not need.

In practice, Jev looks like three API primitives: Choice selects one of up to 255 options, Noul answers a yes-or-no, Score returns a probability-weighted position on a described dimension. No prompt templates, no JSON parsing, no retry loops.

Ten projects, ten judgments

The table below is the map for the rest of this article. Star counts are from the GitHub API on 2026-10-12; the right column is where Jev sits in each project — watch the last two rows.

Project	Stars	What Jev decides there
jev-ultrafast	22.7k	The browser operation and target element each step
fast-jev-compaction	7.6k	Which tool calls may be deleted
jev-trader	3.0k	Buy or sell, roughly every 300 ms
typesafe-ai/skills	2.7k	Nothing directly; it teaches agents the method
agent-desktop	1.8k	Nothing; the project does not integrate Jev
typesafe-computer-use	1.2k	The next desktop action from a safe list
hermes-jev-skills	1.1k	Eleven classes of small decisions
pg-jev	1.1k	Acts as a semantic SQL predicate
jev-review	683	Staged judgments over a diff, ending in severity
foreman	443	Nothing directly; it schedules Claude Code

The top six have their own entries on this site; this article covers them and the other four at the point each makes best.

Browsers and desktops

jev-ultrafast is the highest-starred project of the ten, from the browser-use team, open-sourced on September 17 and on the Hacker News front page the same day, with Chinese media covering it within days. It attacks the old cost structure of browser agents: ask a multimodal model “what do I click now” at every step. Instead, each observation produces a numbered element table, and a single TypeSafe request answers two questions at once — which operation, and which element. Speculative target questions mean that when the operation is CLICK, only click_target can execute. The default loop never sees a screenshot; the model consumes structured state.

The numbers come from the project’s own performance.md (version of 2026-09-30): the full Google Flights task, Zürich to London, completes in 7.073 seconds; across six alternating runs, median task time fell from 9.450 s to 7.092 s (25% lower), median TypeSafe requests from 22 to 17, and median browser protocol calls from 1,092 to 101; median Jev latency was 178 ms; the two city-name strings took 581 ms and 346 ms to generate. The document is equally clear about the limits: three repeats of one task, not a general reliability benchmark, and a sign test over three pairs gives p = 0.25, which proves nothing statistically. The protocol-call drop is the more believable number, because it describes one atomic DOM snapshot replacing repeated tree walks.

typesafe-computer-use moves the same idea to the macOS desktop. Each step OCRs a crop of the frontmost window, adds the accessibility tree’s labels for the icons OCR cannot see, computes the facts in code — date distances, focused field, actions already tried — and then spends one TypeSafe request on three Choice questions: which action, which item, which site. The writing model is invoked only when a text field genuinely needs free text. Its self-measured comparison (same screenshot, one decision each): $0.0002 per decision against $0.032 for Claude Opus 5 reading a bare screenshot, model latency 0.13–0.38 s against 5.2 s, end-to-end step of about 1.5 s against about 5.5 s, and a 12-step task for $0.003 against $0.40–$0.90. The README is honest about the price of that design: every piece of reasoning a frontier model does for free had to be rebuilt here as deterministic state.

The third project, agent-desktop, is counter-evidence: it never mentions Jev or TypeSafe. It is a single Rust binary that sees any app’s real UI structure through the operating system’s accessibility tree, hands out stable refs for elements, and runs an actionability preflight — visibility, stability, enabled state — before every action, without stealing focus or moving the real cursor by default. What it treats is a different expense: on dense apps such as Slack, a shallow three-level overview plus targeted drill-down shrinks a snapshot from 30,743 tokens to 383 (the project’s own comparison, claiming 78–96% reduction on dense apps). Read together, the three projects divide the labor cleanly: perception can be pure engineering, the token bill can be cut with structure, and the moment “which one” goes to a frontier model, cost jumps by orders of magnitude. That is the niche these decision models occupy.

Claude Code’s context bill

fast-jev-compaction treats a problem every long-session Claude Code user knows: /compact summarizes away the constraint you insisted on, the exact error, the command flags, and the model starts repeating mistakes. The plugin’s position is blunt — it never rewrites anything. It asks Jev two questions about each tool call and result (is this call still relevant, is this result worth keeping verbatim), then sorts them into three tiers: keep, truncate (defaults step down to 1,000, then 200, then 60 characters), or remove. User and assistant text stays byte-for-byte, the first message and the most recent six are pinned. State is fitted into 25,000 tokens by default and requests stay under 30,000 — Jev’s request limit is 32k.

Its dependencies and limits are on the label: function hooks are an early-access Claude Code feature (2.1.274+) behind an environment flag; token counts are character estimates, not a tokenizer; a probability is not proof that deleting is safe; the full state is resent with every request, so a history near the ceiling costs one request per handful of questions. When Jev fails or the key is missing, it throws and falls back to Claude Code’s built-in summary — and the toast tells you it happened.

Review, orchestration, and skills

jev-review decomposes a review into a chain of judgments: a Noul risk matrix first, then Choice plus Score for file profiles, then evidence selection, mechanism classification, a severity Score, and finally conditional routing to a reviewer. Thresholds and workflow policy live in code; Jev only makes bounded calls. Results land on a local dashboard bound to 127.0.0.1:4317. The author’s own framing is an experiment: findings are review prompts, not proof of a defect — it tells you where to look, it does not judge.

foreman has the lowest star count of the ten but the most interesting design: a TUI that supervises headless Claude Code agents through a gated delivery pipeline — plan, ADR/PRD, issues, TDD build, e2e. Design stages have human approvals (hash-sealed); build workers are boxed in by the orchestrator rather than trusted to behave. All state is readable files inside the target repository, and killing it mid-build is claimed to recover from disk. Phase 1 and 2 ship today, Phase 3 is planned, and Linux/WSL2 is the tested path. It does not touch Jev either — it assumes the coding agents it schedules are good enough, and that the problem is managing them.

typesafe-ai/skills is the official skill pack: one SKILL.md that teaches an agent how to build with Jev. Read the live docs first; work backward from the behavior you want to the judgments it needs; keep rules, calculations, and lookups in code; ask one narrow question per judgment and batch independent ones into the same request; drive behavior with probabilities and thresholds, remembering that confidence summarizes distribution concentration, not workflow correctness. Claude Code installs it as a plugin; other agents get it through npx skills add.

hermes-jev-skills spreads the same methodology across eleven skills: model routing (about 0.4 s per turn), search (about 1.9 s per round — rank, then sufficiency and the pick), memory (60 passages per request, up to 480 per call), skill selection (about 2.8 s to choose among 377 installed skills), and mailbox sorting (about 0.44 s and $0.00002 per message). Its two most interesting disclosures run in opposite directions: in web screening, Jev withheld 70 of 79 results carrying injected instructions while Hermes’ own pattern scan caught 11; yet the handoff skill measurably lost to the plain transcript — a handoff written from Jev’s keep/summarize/drop digest recalled less than one written from the full conversation, so the project ships the whole 1,200-word transcript by default. A project admitting its headline feature does not pay off, and changing the default accordingly, is worth more than any benchmark table.

Data and money

pg-jev is a Postgres extension that lets you write predicates like WHERE jev(people, 'the name is European'). Each row arrives as a composite value; the first call starts a read-ahead that streams the table in physical order; rows are packed into shared states of 20 by default, amortizing the roughly 270-token fixed cost per request — the project’s own comparison is about 435 tokens for one row alone against 175 per row in batches of 20. A 2,000-row table takes about 3.5 s, 100 requests, roughly 296k input tokens, and about $0.012 on a first full run (self-reported), about 50 ms on a cached rerun, and about 0.6 s for a new condition with LIMIT 3. Accuracy falls with batch size: 100% correct at 1–20 rows, 92–98% at 40, 77–94% at 80 — which is why 20 is the default. The costs are stated plainly: row contents leave your machine, the extension needs PostgreSQL 14–17 with plpython3u and a superuser, and managed hosts such as Supabase, Neon, and RDS cannot run it.

jev-trader is the project closest to real money: a market-making bot on Monad that asks Jev buy-or-sell once per block (about 300 ms) and posts a real post-only limit order one tick inside the touch, waiting for a taker to pay the spread. The 300 ms budget is dissected in the README: the hot loop makes exactly two RPC round trips, book reads at p50 18 ms and the whole loop at p50 100 ms; it deliberately skips gas estimation, avoids synchronous sends, and never waits for receipts — Monad charges the gas limit whether the order lands or not. Without a private key it dry-runs: real order book, real decisions, simulated fills. One caution worth repeating: the README publishes no track record (the small P&L in its example event stream is demo data) and no risk disclaimer, so treat it as an experiment, not a strategy.

The shared pattern

Line the ten projects up and three disciplines repeat. First, the model picks and code decides facts: dates, focus, occlusion, page freshness, and cost ceilings are computed deterministically before the model sees them — the reasoning a frontier model does for free is rebuilt here, item by item, as state. Second, probabilities become gates: a keepThreshold of 0.5, low-confidence stops, uncertain mutation results stopping instead of retrying — confidence turns from a feeling into a configurable threshold. Third, everything fails open: when Jev is down, the fallback is the built-in summary, routing stops, control returns to the user, and the worst cost is a 2.5-second time budget.

The counter-evidence belongs here too. Every number is self-reported, and TypeSafe’s refusal to publish benchmarks — “leaderboards are easy to game”, in the founder’s framing — means none of it can be independently checked. An early-access API can change under you. Row contents and transcripts leave the machine. Two of the ten projects never call Jev at all, and they are on this list too. One skill measured worse than the naive alternative and changed its default. Put together, the conclusion is a narrow one: when one judgment costs $0.0002 and takes a few hundred milliseconds, logic that used to be hardcoded because “asking a model is not worth it” can now move back, decision by decision. Whether it is worth it can only be measured in your own workflow.

Getting started

The shortest path is the use case closest to your own work: to add semantic judgment to an application, start from the typesafe-ai skill and the official docs; if Claude Code’s compaction is what hurts, install fast-jev-compaction; to see what a browser agent looks like now, run jev-ultrafast’s local demo; if your data sits in Postgres, try pg-jev’s Docker image. Keys come from the TypeSafe console; everything that offers a dry run should be dry-run first — the READMEs of jev-trader, typesafe-computer-use, and pg-jev all put the keyless or dry-run mode in the first step.