What developers are actually building with Jev
A week after launch there are dozens of public projects. The patterns inside them say more than the vendor benchmark.
This translation was produced automatically using AI. The German version is the editorially reviewed original.
Between a model launch and a reliable picture of what the model is good for there are usually months. With Jev it took a week, because the interface is narrow enough that a working project fits into one evening.
This piece walks the public projects built since 15 September and names the recurring pattern behind them. The collections are open, among them awesome-jev and awesome-jev-by-typesafe.
01. Triage is the first reflex
The obvious application is an inbox that has to be sorted. TypeSafe shows this itself with a triage dashboard for GitHub repositories: every issue gets the same fixed question set, meaning kind, severity, urgency, duplicate and next step. Uncertain items and points where humans disagreed get separate attention, and every human correction is kept and shown back to the model on later runs.
The same pattern carries a support inbox. Code assembles the case and the business rules, the model answers category, urgency and frustration, and queue assignment stays ordinary code. The order matters: improve the queues first, automate second.
02. Retrieval, search and checking claims
The second large group sits in front of or behind a search. jev-reranker is a Rust command line that reorders, filters and compresses results with yes/no questions. nlgrep searches files against a condition written in natural language and returns ranked files with line hits. jevql pushes the same questions into a Postgres query as filters and sorts.
More telling than the tools is the question list that has settled in. A retrieved passage is checked not only for relevance, but for whether it supports the answer, whether it contradicts it, and whether it carries an injected instruction. Four independent judgments on the same state, in one call.
03. Code, commits and CI as a decision problem
A surprisingly dense group sits inside the development chain itself. jev-git screens staged diffs before commit for secrets and destructive commands. is-malicious scores source, config and CI files, with thresholds and severity owned by code. jev-pref reads project conventions from an AGENTS.md and checks diffs against them, which is semantic linting rather than format checking.
The common thread: rules that used to live as a regular expression or as a comment in a pull request become yes/no questions that can run on every commit, because they cost nothing.
04. Agents that grade their own steps
The most interesting group steers other AI systems. JevRouter picks from a capability set while availability, permissions and fallback stay in code. jev-guard scores planned tool calls by risk and allows, asks or denies. wakegate decides, before resuming a sleeping agent, whether an event belongs to it at all.
Observability belongs in the same group. jevlogs annotates OpenTelemetry records and skips expensive analysis for traces with nothing in them. A finished agent run can be reviewed afterwards for permission breaches, task completion and satisfaction without a person reading it.
05. Numbers that come from real runs
A few projects publish their own measurements, and those hold up better than any vendor benchmark. jev-skip, a browser extension that detects sponsor segments in YouTube videos from the captions, reports catching 77 percent of sponsor seconds across 23 videos at 0.0008 US dollars per video. An audit study over 1,204 crawled pages came to 4,816 typed judgments per run and 0.0048 US dollars per twelve-question triage batch.
The number that matters day to day is not the multiple against a language model, it is the absolute cost per decision. At that order of magnitude the question of whether a check is worth running disappears.
06. The pattern behind all of them
Nearly every one of these projects splits the same way. The model answers a narrow question about a supplied state. The code owns the option set, the threshold, the permissions, the ordering and the fallback. Where a project drops that split and lets the model decide what it is allowed to do, an exception handler shows up in the repository shortly afterwards.
The second recurrence is batching. Instead of five sequential calls, every plausibly needed question is asked in one call, including the ones whose answer may never be used. With output tokens free, that is cheaper than the second network round trip. What this means for designing a pipeline is in Where a decision model actually goes.
