Jev in the Wild: Early Architecture Patterns for System One Models
Jev has been out for less than a week, but we’re already starting to see patterns in how people are building with it. And they are all over the place.
There are browser agents and coding agent supervisors. People are putting Jev into databases, model routers, security layers, context systems, games, and computer-use loops.
Unlike Jev’s LLM counterparts, which have been at the center of the agentic loop, the common pattern with Jev isn’t giving it control. It’s inserting Jev at a specific decision point in otherwise conventional software.
The result is a much more granular line between deterministic software and probabilistic decisions. Instead of moving the entire workflow into the model, Jev can make a decision and hand control right back to the software.
Here are some of the early architecture patterns showing up across Jev projects.
All Sorts of Routing
Model routing was one of the most obvious Jev use cases from the start. If you give Jev the request and a set of models, it can decide which model should handle the work.
Projects are already taking this even further. JevRouter puts models, subagents, skills, MCP tools, and CLIs into the same candidate set. agent-router chooses between coding agents as well as the model and effort level. jev-codex-router makes that decision for individual Codex turns.
The overall pattern is bigger than model routing, though. Jev can sit in front of a set of agent capabilities and decide which one should handle the work, based on semantics that would otherwise be difficult to encode in rules.
This is already showing up outside AI infrastructure too. hono-jev-router routes HTTP requests by meaning instead of just URL patterns. The same decision primitive works whether the things behind it are models, tools, agents, or ordinary software.
Context Filtering
Another group of projects uses Jev to decide what information should make it through to the next stage.
Winnow judges tool results before they enter a coding agent’s context. jev-sift scores files, URLs, and snippets so an agent only opens the ones that matter. fast-jev-compaction uses Jev to decide what survives Claude Code context compaction while keeping the selected content verbatim.
There are similar experiments around search and RAG. reranker gives each candidate document a relevance probability, while blink applies the same idea to code search.
This is a different approach to context than generating another summary or relying entirely on embeddings. Jev decides what matters for the agentic decision being made right now.
That makes context selection a read-time decision. The system doesn’t have to completely decide what a piece of information means when it stores it.
Tool Gating
Some of the clearest Jev use cases are showing up at the point where an agent is about to take an action or call a tool.
jev-guard evaluates tool calls from coding agents and turns the result into allow, ask, or deny decisions. It can also inspect tool results for prompt injection before they return to the agent. pi-warden puts a similar decision layer directly into the Pi coding agent, checking actions against project rules and feeding the resulting guidance back into the worker.
Jev Shield pushes the pattern down to MCP. Tool calls, results, and descriptions can all pass through semantic checks before the system acts on them.
None of these systems need Jev to enforce the policy. That’s done in deterministic code. Conventional software can still own permissions and execution. Jev just provides the semantic judgment that the policy uses.
That gives the policy a way to act on fuzzy conditions without giving the model control over the action itself.
Worker Supervision
Another place Jev is showing up is above the worker itself. This could give System One models a pretty important role in software factories.
I built Foreman around this pattern. A Codex worker does the software engineering while Foreman independently watches the work. Jev continuously assesses the evidence coming off the factory floor, including worker output, Git changes, tests, previous assessments, and the original job.
It looks at questions such as whether the worker is stuck or drifting from its instructions.
Jev doesn’t do the coding and it doesn’t control the coding-agent loop. It makes assessments of the work while deterministic policy decides whether Foreman should continue, steer the active worker, stop it, retry, start verification, finish, or escalate.
This creates a clean separation between doing the work and judging the work. We normally ask the same frontier model to do both. A fast decision model makes it practical to move some of those judgments outside the worker.
Fast Control Loops
Browser and computer use push Jev into a new type of role. It’s less agent-like and more gamer-like. Its job is to observe the current state, make a fast decision, then do it again.
Browser Use’s Jev Ultrafast constructs a set of possible browser operations and DOM targets, then has Jev pick one. A small language model is only needed when the browser actually has to generate text. jev-browser uses a similar architecture and uses Jev to choose an action on each step.
The same architecture is showing up in computer use. typesafe-computer-use reads the screen, constructs possible actions, and uses Jev to decide what to do, such as where to move the mouse or what to click on.
Game applications of Jev are the easiest way to see this pattern. Projects have Jev playing Pokémon, driving cars, and controlling other simulations. The surrounding program defines what the model is allowed to do. Jev repeatedly chooses among those bounded actions.
This is one of the places where Jev does sit directly inside a loop, but it still doesn’t own all that much of the system around it. Code controls the environment and execution, and the model only makes the fuzzy decisions at key times.
Fuzzy Data Queries
Jev is also starting to show up directly in the data layer, where a lot of decisions have traditionally been limited to what we can express in queries and rules. And it’s very cool!
pg-jev puts Jev directly inside Postgres. A SQL query can filter rows based on whether a customer sounds angry, rank products by how luxurious they seem, or classify a ticket by which team should handle it.
The rest of the query stays ordinary SQL. Instead of only writing deterministic predicates like country = 'US' or revenue > 100000, you can add conditions whose answers depend on the meaning of the data.
And Postgres isn’t the only experiment. There are already Jev extensions for DuckDB, while neo4jev brings the same idea to graphs by using Jev to decide which relationship to follow through Neo4j.
This opens up a pretty large category of data use cases. Warehouses are full of classifications, rankings, filters, and business rules that are easy to describe in English but hard to turn into SQL. Jev lets those decisions happen at query time, directly against the data that’s already there.
And Then There’s Everything Else
Some of the most fun Jev projects are people finding completely new places to put a probabilistic decision.
There’s a Magic Jev Ball that looks at a GitHub PR and decides whether you should approve it. There’s an ad blocker that asks Jev whether something actually looks like an ad, Unclutter deciding what parts of a webpage are unnecessary, and Every asking a semantic question against every function in a codebase.
People are also using Jev for autonomous cars, mobile phone control, semantic code search, sponsor detection in YouTube videos, and even scoring every sentence in a video to flag when someone dodges a question.
And then there are experiments like Stefan’s, which are mostly about seeing what happens when you put Jev somewhere nobody would have thought to put a model before.
Even the TypeSafe's own Jev playgrounds lean into this. One example asks whether putting Luke Skywalker between two pieces of toast makes a “Jedi sandwich” a sandwich.
A lot of these aren’t serious applications, and that’s kind of the point. People are playing with a new primitive and figuring out where it works. We’re less than a week in, and I expect the weird stuff to keep getting weirder.
Where Does Jev Go?
After looking through all these projects, the answer to where Jev fits seems to be almost everywhere.
And I think that’s basically TypeSafe’s bet. Jev is cheap and fast enough that we start rewriting applications to send thousands of tiny decisions to a model.
If that happens, and I think it will, applications start to look very different. The line between what’s decided in code and what’s decided by a model gets harder to draw because Jev calls are just mixed into the normal application logic.
Judging by what people are building, that’s already starting to happen.