What Is TypeSafe Jev? Typed Agent Decisions

Six GitHub projects published in the same 48 hours all import the same thing, and none of them explain it the same way. TypeSafe Jev is the common dependency: a browser agent from the browser-use team, a Super Mario player, a trading bot that fires once per Monad block, a Claude Code context plugin, and an open reproduction that runs on a home GPU. If you build agents, you're going to keep seeing the name, so it's worth knowing what it actually is before the marketing catches up.

The short version: TypeSafe Jev is a model, not a library, and the thing everyone is copying is the shape of the request rather than the model behind it.

What TypeSafe Jev is, in the vendor's own words

TypeSafe's documentation is unambiguous on this point. "Jev is TypeSafe's flagship model and the first System One model," the introduction page says, and it defines that category as models "built to make fast, structured decisions that software can use directly." Checked 18 September 2026.

The request shape is where it gets interesting. You send a state (whatever unstructured context you have) plus typed questions, and you get structured results back. TypeSafe documents three question types:

• choice returns a choice, the probabilities across options, and a confidence value
• score returns a score plus the same probability and confidence fields
• noul returns a single number between 0 and 1

All three can be mixed in one API call, and the docs note that adding questions "barely changes the response time." There's no answer sentence. Nothing to parse, nothing to repair when the model closes a brace in the wrong place. The docs also make a claim that matters for long-running agents: every question is evaluated in parallel and in isolation against the same state, so "adding more questions does not create context-rot."

Compare that to how most agents make decisions today. The model writes a paragraph or a JSON blob, your code parses it back into a boolean, and roughly a third of your error handling exists to cope with the cases where the parse fails. Jev removes the round trip through English.

Typed decisions versus an LLM writing text you then re-parse

TheoLeeCJ's openjev put numbers on the gap between a TypeSafe Jev-style typed readout and ordinary generation. Same frozen Qwen3.5-4B, same state, same 21 binary criteria, one RTX 3090:

Output path	Time	Output tokens
Direct typed logits (median of 3)	1.023 s	0
Autoregressive JSON array (median of 3)	5.332 s	111

That's 5.21× slower for the generated version, and the generated version was already the compact one: bare ordered "yes"/"no" values, no keys, no confidence objects, no explanations. All three JSON runs were valid and identical, which matters — this isn't a story about the model producing garbage. It's a story about spending five seconds writing tokens that software immediately throws away.

The author is careful about what the comparison proves. Direct argmax and the generated array agreed on 18 of 21 criteria, so openjev's README calls it "a systems comparison rather than a claim that the two readouts are semantically equivalent." That kind of caveat is rare enough in a two-day-old repository that it's worth pointing at.

There's a second measurement that matters more for real agents. On a 37-state by 21-criterion workload, fresh direct scoring managed 2.33 decisions per second; reusing the prefix serially got 10.75; running the suffixes in parallel hit 20.03. A native reranker, for reference, came in slowest at 1.86. When one long state gets branched across many criteria, the prefill is the cost, and you only pay it once.

jev-ultrafast: a browser agent built on the pattern

browser-use shipped jev-ultrafast on 16 September and it had 2,471 stars by the 18th. MIT, Python, and the clearest demonstration of why TypeSafe Jev suits agents at all. It's also worth keeping the scale in view: two commits, one contributor, no tagged release. This is a demo by browser-use's co-founder that a lot of people starred, not a product.

Every page observation produces a fresh element table, numbered. The available operations are fixed: CLICK, TYPE_TEXT, SELECT, SCROLL_UP, SCROLL_DOWN, WAIT, DONE, BLOCKED. One TypeSafe request returns the operation plus several speculative targets — a click target, a type-text target, a select target when one applies — and only the target matching the chosen operation ever executes. Two decisions, one network round trip. A small LLM gets involved only when the operation is TYPE_TEXT and something actually has to be written.

The README's headline claim is Zürich to London on Google Flights in 7.1 seconds, including text generation and loading waits. That's the vendor's own measurement, published by browser-use in its own repository, not an independent benchmark, and you should read it as such. What's more useful than the number is the design constraint behind it: the README states there are no site-specific action scripts or prepared field strings in the policy, and the flights example verifies the resulting route and date independently rather than trusting the agent's own claim of success.

Running it yourself needs two keys, TYPESAFE_API_KEY and TEXT_MODEL_API_KEY, and the demo configuration points the second at OpenRouter with inception/mercury-2.5, reasoning disabled. Chrome connects through browser-use's own Browser Harness. If you've been following the browser automation tooling that's accumulated this year, the interesting part isn't that someone built another browser agent; it's that the decision layer got pulled out of the language model entirely.

SemIf, formerly openjev: reproducing the interface on hardware you own

One housekeeping note before the substance, because it will send you to a 404 otherwise. The project renamed itself to SemIf on 18 September and now lives at TheoLeeCJ/SemIf (1,995 stars, MIT); the old openjev path redirects, but searches for the old name inside GitHub no longer find it. The browser demo still answers on openjev.com. Everything below describes the same codebase under its new name, and the README now leads with "SemIf (formerly OpenJev)".

Here's the distinction everyone keeps blurring. openjev's README puts it plainly: "Jev is TypeSafe's closed service for runtime-defined semantic decisions. This project reproduces that interface pattern with open models; it does not reproduce Jev's undisclosed model or training."

So openjev is not an open-source Jev. It's an open-source answer to the question "does reading option logits directly actually beat generating text, or is that just TypeSafe's marketing?" The benchmarks above are the answer, and they're committed to the repository along with the fixtures, runners, model revisions, prompt hashes, and a list of known failures.

The project also ships something you can poke at without a GPU. openjev.com loads a model into your browser and runs both paths locally, no backend, no account. Desktop defaults to MiniCPM5 2B at about 1.56 GB; phones get Qwen3 0.6B; there's a Qwen3.5 4B option for machines with memory to spare. The site's banner reads "There is no waitlist! Just try it out," which is a small dig at how this category usually launches. It loads, it detects your device and preselects a model size, and the weights come from Hugging Face and stay in your browser cache; whether it finishes a run depends on your machine having a usable WebGPU adapter, which a headless browser does not.

The honesty about limits is consistent. openjev's fast reuse paths are marked experimental because BF16 execution changed 5 or 6 argmaxes out of 777 relative to fresh scoring. Small, but stated.

Where the pattern is showing up: trading, compaction, games

The four smaller projects tell you more about adoption than the two big ones do, because nobody at browser-use or TypeSafe asked for them.

jarrodwatts/jev-trader (543 stars, created 16 September, MIT) makes one trade decision per Monad block against Kuru's MON-USDC pair. Whatever you think of autonomous trading, a blockchain block time is a hard deadline, and the whole reason to want a typed decision is that it arrives before the deadline does.

tamaratran/fast-jev-compaction (635 stars, created 17 September, MIT) is the one I'd actually reach for. It's a Claude Code plugin that replaces compaction summaries with Jev decisions: every tool call and result gets scored, stale ones get dropped or truncated, and everything kept stays verbatim. Summaries lose file paths and exact error strings; this doesn't rewrite anything, it only deletes. It uses noul questions, two per non-pinned call, and its default request budget of 30k tokens sits deliberately under what its README describes as Jev's 32k request limit.

fhshaik/typesafe-mario (221 stars) plays Super Mario Bros. from structured emulator state, which is a demo and knows it. Note that it ships with no license file at all, so treat it as read-only reference rather than something to build on. thruwire/foreman (203 stars, MIT) is one day old and describes itself as a software-factory coordinator built on Jev.

None of these will still be interesting in six months as products. What they establish is that TypeSafe Jev picked up four independent integrations in 48 hours, which is not a thing that happens to bad ideas.

Two days later: local runners, a router, and a tax classifier

Everything above was written on 18 September. By Sunday morning the list was already out of date, so here is the wave that landed between then and 20 September. Star counts come from the GitHub API that morning and will be wrong by the time you read them.

Three projects went after the same thing the openjev work did, which is running the pattern without a TYPESAFE_API_KEY. githubnext/localjev (454 stars, MIT) is a Jev-compatible POST /v1/systemone endpoint written in TypeScript for Bun, backed by DiffusionGemma through an ordinary OpenAI-compatible chat endpoint. Its README explains why a bridge has to exist at all: openjev gets its probabilities through unmerged vLLM request extensions like diffusion_seed_canvas and diffusion_read_only, and a normal oMLX server exposes none of them. featherless-ai/simple-jev (302 stars) does the same job from the Hugging Face side, reading next-token logits from compatible open models so the server assembles the JSON rather than asking the model to write it. It has no LICENSE file.

Jared Palmer's kev (565 stars, Apache 2.0) is the most carefully documented of the three, and the part worth copying is its restraint. It publishes four checkpoints at 0.5B, 0.6B, 4B and 8B, and only kev-0.5b carries a version tag. The other three sit as previews because the project declared a release bar in advance and has not cleared it: both siblings of a held-out policy pair correct at least 70% on every seed, where the best recipe currently lands between 0.62 and 0.73, with day-precision date arithmetic deciding the outcome. On the frozen out-of-domain suite, kev-4b scores 0.79 and kev-8b 0.80 against the hosted Jev at 0.86. kev-0.5b trains in about an hour and three quarters on an Apple M5; the larger recipes take 40 to 70 minutes on a single H100 and then serve on a 32 GB Mac in bf16.

The plumbing arrived at the same time. gargpratyush/jev-router (211 stars, MIT) puts a routing decision in front of both Claude Code and OpenAI Codex, not just Claude Code, sending easy turns to a fast model and hard ones to a strong one while leaving each CLI's own login, sessions and permissions alone. realZachi/pg-jev (218 stars) is a Postgres extension under the PostgreSQL licence, already on PGXN, that lets a WHERE clause carry a plain-language condition and judges each row with Jev. superagents-lab/jev-search (238 stars, MIT), built by Search1API and explicitly not an official TypeSafe product, uses typed questions to pick sources, time ranges and query terms, then ranks what comes back and shows the scores instead of writing an answer. droidrun/mobile-jev (230 stars, MIT) drives a real Android phone through the Mobilerun API with no ADB connection; its Uber demo covers nine actions in roughly 21 seconds and reaches payment selection, and the README says outright that a completed booking is not demonstrated.

The one with real numbers behind it is kyotofin/tax-doc-classifier (265 stars, Apache 2.0), from a firm that already ran an LLM classification pipeline and replaced it. No model is trained and nothing is hosted: the classifier is a JSON file of form descriptions generated from the IRS's own PDFs, and Jev returns a probability over 261 forms and 7 page kinds per page.

Read the scoring rule before the score. A page counts as an error if the answer is wrong or its confidence sits below 0.95, which is stricter than most published accuracy. On 314 filled forms it recorded zero errors; on 753 blank IRS forms it recorded 38 strict errors, 5.05%, and none of the 38 was actually wrong, they were instruction pages and deep schedules hedging against their parent form. Against the Sonnet-based classifier it replaced, measured on the same pages in the same hour: $0.00115 versus $0.039 per page, about 0.5 seconds versus 3.3 warm, and 261 nameable forms versus 30.

Two competing awesome lists appeared as well, which is how you know a category has arrived. cobanov/awesome-jev (211 stars, CC0) finished a review on 19 September that brought its community section to 102 entries. yibie/awesome-jev (386 stars) builds its README from category files and carries the more useful warning of the two: when one author ships several repositories on the same day, they usually share a scaffold, land in one or two commits each, and can contain more prose than code. Legitimate, possibly, but unproven, and the list tells you to treat them as leads rather than validated tools. Apply that to this whole section.

I have not run any of them. Everything above comes from READMEs, licence files and the GitHub API, checked on 20 September 2026.

The replicas caught up: NanoJev, a reviewer, and a list

The projects above mostly answer one question, which is whether you can run this without a TypeSafe key. A second group landed on 17 September answering something else: what the pattern looks like once people stop benchmarking it and start building on top of it.

TianyuCodings/NanoJev (1,025 stars, MIT) is the smallest honest reproduction so far. It trains a 0.6B parallel decision model on Qwen3-0.6B and publishes both the weights and the training data, which is more than most of this wave bothers with. The name nods at nanoGPT and the framing matches: small enough to read end to end, complete enough to retrain yourself.

The reason to open it is the side-by-side demo, which runs Jev, NanoJev and an untuned Qwen3-0.6B through the same 50x50 maze and the same game of Snake on identical controller code, advancing every panel by the same environment step. Look at the untuned baseline rather than the winner: 4,726 attempts and 2,044 collisions before it reached the goal. That gap is the argument for this entire category, and checking it costs nothing, because the recorded runs and the replay manifest both sit in the repository.

devagrawal09/jev-review (358 stars, MIT) is the first of these I would call an application rather than an experiment. It reviews a git diff or scans a whole codebase, and the interesting decision is where the judgment lives: a Noul risk matrix feeds file profiles, which feed evidence selection, then mechanism classification, then a severity score, and only after all that does it route to a reviewer. Thresholds and workflow policy stay in ordinary code. That is close to the opposite of pasting a diff into a chat model and asking what it thinks, and it happens to be the shape this model type is good at. It wants Node 24 and a TypeSafe key, binds its dashboard to 127.0.0.1, and refuses to serve environment files.

Then the ecosystem grew the thing ecosystems grow at about three weeks old. AbdelStark/awesome-typesafe (349 stars, MIT) is a curated index with a live site and, more usefully, a "last reviewed" date on it, currently 17 September. One detail is easy to misread: the list catalogues official TypeSafe resources, but the list itself is independent and says so in its own README. Nobody at TypeSafe signed off on it.

dabit3/jev-experiments (308 stars) is the loosest of the four, a pile of latency-focused demos that each carry their own README, tests and screenshots. Two things there get conflated, so they are worth separating. The repository sits under Nader Dabit's account, while the apps inside carry a "Built by Devin" badge, meaning the Devin agent wrote them rather than he did. It also ships no LICENSE file, which makes it reading material rather than something to lift code out of.

Four repositories in roughly thirty hours, not one of them from TypeSafe. Star counts here came from the GitHub API on 20 September 2026 and will have drifted by the time you read this.

Is Jev a model or an interface? Both, and the distinction matters

You'll see Jev described as "a new kind of interface" in a lot of writing about it, and that's half right in a way that will confuse you later.

Jev is a model. TypeSafe says so. The model weights and training are undisclosed, and you reach it through a hosted API; that's the closed part, and openjev's README names it directly.

What's reproducible is the interface: send a state and typed questions, read option probabilities without decoding tokens. Any model that exposes logits can do that, which is exactly what openjev demonstrated on a 3090. So when someone says "we're using the Jev pattern," they might mean calling TypeSafe Jev over the wire or they might mean the technique. Ask which.

The practical consequence: building on TYPESAFE_API_KEY is a vendor dependency, with the availability and pricing exposure that implies. TypeSafe's introduction page doesn't publish pricing, rate limits, or a free tier as of 18 September 2026, and the only request limit I found documented anywhere was that 32k figure in a third-party plugin's README. Building on the interface pattern is portable. Those are different bets.

What this changes for people shipping agents

Faster decisions don't fix the part that usually breaks. An agent that picks the right operation in 40 milliseconds and then leaves the result in a terminal buffer has still handed you homework. This is the gap Zentor was built around: the run finishes and the output goes back into Notion, Airtable, Canva, Slack or the inbox where the task started, instead of becoming an artifact you have to relocate yourself.

The memory question is the other half. Typed decisions are stateless by construction, since you ship the state with every request, which is why openjev's prefix-reuse trick exists at all. Across a week of related tasks, something has to hold what was already decided. Zentor keeps that history at the account level and lets you export it, so the accumulated context belongs to you rather than to whichever decision endpoint you were calling in September.

And there's a trust dimension that typed outputs genuinely improve. A constrained option set is much harder to poison than free-form text, which connects to the fake tool output problem in coding agents. If the model can only return one of eight operations, an injected instruction has a much narrower channel. It doesn't close the channel, since the state you send is still attacker-influenced, but it narrows it. Worth reading alongside how agent sandboxes handle the same class of problem from the execution side.

FAQ

Is TypeSafe Jev open source?

No. TypeSafe Jev is the company's own model, served through a hosted API, and the docs don't disclose the model or its training. openjev reproduces the interface pattern with open models and is MIT licensed, but its README explicitly states it does not reproduce Jev itself.

What models does TypeSafe Jev use?

TypeSafe hasn't said. The introduction page describes what Jev does and what it returns, without naming an architecture, a parameter count, or training data. Undisclosed as of 18 September 2026.

How is TypeSafe Jev different from structured output or function calling?

Structured output still generates tokens and then validates them against a schema; you pay the decoding cost and you can still get a malformed result. Jev reads probabilities over options you declared at request time, so there's nothing to decode. The 1.023 s versus 5.332 s measurement in openjev is that difference, on one 4B model.

Can I try the pattern without an API key?

Yes. openjev.com runs a small model in the browser with no backend and no waitlist. On a desktop it defaults to MiniCPM5 2B, around 1.56 GB to download.

Is the 7.1-second Google Flights result independently verified?

No. It's browser-use's own measurement, published in the jev-ultrafast repository. Treat it as a vendor claim until someone reproduces it.

Where this lands

A concept becomes real when four people who don't know each other build on it in the same week. That happened to TypeSafe Jev between 16 and 17 September 2026, and the repositories referencing it are small, young, and mostly experiments.

What I'd take from it: the expensive part of an agent decision was never the thinking, it was the writing and re-reading. Whether TypeSafe specifically wins is an open question and a commercial one. The technique openjev demonstrated on a consumer GPU doesn't depend on that outcome.