Browser agents, coding agents, routers, tool selection, evaluation and guardrails — with real builds, demos and implementation patterns.
Independent curation. Sources and evidence on every example.
After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI?
I spent the last 2 years building a new way to train models (RLCD) and a new type of frontier AI model we are releasing today: Jev
In an a16z interview, TypeSafe AI’s Diogo Almeida joins Ben Horowitz and Martin Casado to discuss Jev, automation and reliability. The central idea is to give software typed choices with confidence signals so code can handle intent and uncertainty. This is a product and architecture discussion, not a runnable project.
Explains typed choices and confidence as decision inputs for application code.
Jev just made the Claude Code vs Codex debate obsolete I connected both to Jev - now the best coding agent is selected for every task, and neither can cross a risky tool boundary without a typed decision in one run it scanned 247 files, routed the security audit to Claude Code, routed the patch to Codex, passed 18/18 tests and stopped npm publish before execution here’s how to set it up in 10 min: task → Jev decision → Claude Code / Codex → tool execution → fresh verification step 1 → open @typesafeai and create your Jev API key (never paste it into chat) step 2 → clone and verify the complete agent switch step 3 → export the key before starting either agent: export TYPESAFE_API_KEY="YOUR_KEY" step 4 → test the full decision layer before connecting a live agent: npm run doctor && npm run check:claude && npm run check:codex step 5 → connect Claude Code directly from the repository: claude --plugin-dir . Claude discovers the plugin and turns Jev review decisions into real confirmation requests step 6 → for Codex, install the same folder through your local plugin marketplace, open /hooks and trust the exact PreToolUse hook Codex uses the same policy and safely stops calls that need human review step 7 → keep agent: auto and the plugin detects Claude Code or Codex automatically - or set agent: claude / codex when you want to lock one runtime step 8 → start in shadow mode for 20–50 real decisions: export JEV_AGENT_SWITCH_MODE="shadow" && export JEV_AGENT_SWITCH_LOGGING="true" your agent keeps working normally while Jev records the route, confidence and outcome without blocking anything step 9 → switch to enforce only after the decisions look reliable: export JEV_AGENT_SWITCH_MODE="enforce" safe calls pass, uncertain calls stop for review, dangerous calls are denied the default boundary is 0.62 minimum confidence and 0.86 harmful-action probability step 10 → use it normally - ask Claude Code or Codex to inspect, patch, test or prepare a release; the same Jev layer stays in front of both the result: Claude Code handles deep repository context, Codex handles fast patches and verification, and Jev decides which worker gets the task - while keeping publishing, production and irreversible actions behind a human boundary unfortunately, most people are still comparing coding models as if one model needs to win forever the actual 2030 setup makes the model replaceable: one task enters, Jev selects the best worker, code enforces the decision and every action leaves a receipt Steal the agent setup everyone will use by 2028, copy the repo below - then read the full Jev Engineering playbook ↓
Select Claude Code or Codex and review tool calls before execution.
I turned hermes into my iMessage router and bridge to codex. I have multiple codex projects going on, each with multiple tasks, so jev providing quick cheap context finding when I text Hermes something random is amazing
Find relevant context; the precise bounded output is not disclosed.
Mac Version of Clairvoyance now has Jev support if you have Plus or higher. If you have Claude Code, Codex, OpenRouter, Grok Build, or Cursor you can save literally millions of tokens. When enabled, Clairvoyance will automatically try to use Jev when decision making on files. Also integrated into Deep Search and Code Search. Does require Plus or higher but here's an invite for you for the Mac version. https://t.co/Ck6RjplYOf
Make file-related decisions within Clairvoyance; exact outputs are undisclosed.
I cannot use codex the same anymore after installing a jev-based autorouter https://t.co/7ABawReZMJ the model and effort change based on the complexity of the task and its near instant and almost free https://t.co/vLIfHdR4vN
Choose the Codex model and reasoning effort for a task.
I talk. Codex clicks. Watch the browser go⚡ This video is 1× !!! speed. Built Jev Browser: an open-source adapter for your existing Codex browser tools. Say the task naturally; Codex plans, Jev selects, the browser moves. @sama @OpenAI make this native? @DarioAmodei @hackgoofer https://t.co/xzvUPFBbGa
Choose the next browser action; the exact input schema is not disclosed.
Jev solved local harness/model routing I use a combination of Claude Code, Codex and Opencode as my local agentic stack and routing to other harnesses was always enforced in the system prompt/rules With a deterministic hook that Claude Code can decide before delegation, Jev helps to route to the right harness/model based on the task, and it's pretty accurate based on the intensity/intelligence of the task > Mechanical tasks get routed to Haiku > Intelligent ones to Opus sub-agents > Long-running implementation work to external harness
Select a local coding harness or model tier before delegation.
Experimental. I currently recommend against adopting this routing workflow. I built Switchloom to see whether mixing models could get me the same quality for less money. My benchmarks did not deliver that result. In the second Pokédex run, the team with Jev cost almost as much as Astra alone and hit the time limit before final acceptance. Astra finished and passed all 14 independent functional checks.
Optional Jev route to model/capability slot; Codex executes the tasks.
Jev-powered MCP tool routing for Codex. Instead of exposing hundreds of external MCP tool schemas directly to the agent, Jev Tool Router exposes a small routing surface and resolves external tool discovery on demand.
Picks the specific MCP tool for Codex to prevent tool context overflow.
Combined Jev with Playwright-controlled Chrome to build jev-browser, a general browser automation skill. Works across agents. Two demos in Antigravity CLI and Codex: finding related articles, then job openings on a site. Both ran fast. This could handle many more browser tasks.
Choose the next in-page browser action for a bounded task.
Jev has been blowing up lately. If you've got the Jev API but don't know how to play around with it yet, you can just copy this checklist. 1. jev-ultrafast A high-speed browser Agent built with Browser Use. Jev only judges "what to do, which element to click" at each step, and only calls the small model when typing is needed. Searching for a flight on Google Flights takes about 7 seconds. https://github.com/browser-use/jev-ultrafast 2. fast-jev-compaction Context compression for Claude Code. Before each tool call, have Jev judge if there's anything still useful; delete the useless stuff, and keep the original text without rewriting it. https://github.com/tamaratran/fast-jev-compaction 3. json-render Vercel Labs' generative UI framework. In experiments, Jev doesn't write JSON token by token; it just handles selecting components, properties, and layouts. https://github.com/vercel-labs/json-render 4. typesafe-mcp Best for people who just got the API. Plug Jev into Claude Code, Claude Desktop, Codex, and Pi, and do Choice / Score / Noul anytime. https://github.com/itsmostafa/typesafe-mcp 5. jev-mcp Ready-made Agent judgment toolkit: fact-checking, content screening, semantic ranking, classification, and information extraction. https://github.com/jkudish/jev-mcp 6. SemDecide Turn Jev into a command-line tool. Directly classify, score, and filter in the Shell—great for hooking up to crawlers, CI, and data pipelines. https://github.com/sharziki/semdecide 7. jev-codex-router First have Jev judge how hard this round of programming tasks is, then decide the model tier, reasoning depth, and speed mode. https://github.com/0xNatoshi/jev-codex-router 8. Winnow Context garbage collection for Claude Code. When Read / Bash / Grep spits out a ton of stuff, Jev first judges which parts are really relevant to the current task. https://github.com/GhalebDweikat/winnow 9. jev-review Before code review, run it through Jev first to pick out high-risk changes, then hand them off to a pricier big model or a human. Comes with a local dashboard. https://github.com/devagrawal09/jev-review 10. Blink Use Jev as a code repository navigator. At each directory level, judge which files are most relevant to the current issue, then keep digging down. https://github.com/ellipsis-dev/blink Copy these complete Jev blueprints - then read full Jev setup below ↓ ↓
DOM Action Selection
10 Jev Repos Blowing Up Right Now (and What They Actually Do) 1. jev-ultrafast 15k stars Browser Use agent. Jev picks the next click. A small model only types when needed. https://github.com/browser-use/jev-ultrafast 2. fast-jev-compaction 5.8k stars Claude Code context trim. Jev scores tool calls, drops junk, keeps useful text verbatim. https://github.com/tamaratran/fast-jev-compaction 3. jev-trader 1.7k stars Monad market maker. One Jev buy/sell decision every block. About 81ms latency. https://github.com/jarrodwatts/jev-trader 4. skills (TypeSafe) 1.5k stars Official agent skill for Claude Code and Codex. Choice, Score, Noul patterns included. https://github.com/typesafe-ai/skills 5. agent-desktop 1.4k stars Desktop automation on the accessibility tree. Jev picks the next button or input. https://github.com/lahfir/agent-desktop 6. typesafe-computer-use 719 stars macOS computer use for about $0.0002 a step. OCR the screen, Jev chooses the action, click. https://github.com/awlevin/typesafe-computer-use 7. jev-review 457 stars Staged code review with a local dashboard. Jev flags risk before you burn a frontier model. https://github.com/devagrawal09/jev-review 8. foreman 454 stars Agent supervisor. Jev decisions keep coding agents on task inside a software factory loop. https://github.com/thruwire/foreman 9. hermes-jev-skills 360 stars Jev routing, memory, compaction, skill pick, and computer use for Hermes, Claude Code, and Codex. https://github.com/kerpopule/hermes-jev-skills 10. pg-jev 272 stars Postgres extension. Ask your tables questions in plain English with WHERE jev(...). https://github.com/realZachi/pg-jev
Dynamic Skill Selection & Tool Routing
Jev is an AI model built by TypeSafe AI for fast, structured decisions inside software and AI agents. Unlike a conventional large language model that generates text token by token, Jev takes application state as input and returns typed decisions, probabilities and confidence that code can use directly.
TypeSafe describes Jev as its first public System One Model: a model optimized for automation tasks such as classification, routing, scoring, verification and choosing between a predefined set of actions. (TypeSafe AI)
That makes Jev especially interesting for AI agents. An LLM can handle planning, reasoning and generation, while Jev handles the repeated decisions inside the loop:
observe→decide→act→verify→continueThe builds above show this pattern in practice across browser agents, coding agents, model routers, tool selection, computer use and agent guardrails.
For a closer look at a proposed coding-agent harness, read the Jev Engineering for Coding Agents PDF guide. It separates the independent PDF's design ideas from official Jev documentation and measured results.
Not in the conventional sense.
Traditional LLMs are optimized to generate strings: explanations, code, chat responses and other sequences of tokens. Jev gives up general string generation and instead produces type-safe structured values with probabilities and confidence scores.
TypeSafe summarizes the distinction as unstructured state going in and typed probabilistic decisions coming out. (TypeSafe AI)
A simple way to think about the difference is:
This does not mean Jev replaces an LLM everywhere. Many of the most interesting Jev agent architectures combine both.
A Jev call starts with state.
That state might be: the current DOM of a browser, a coding task, a list of available MCP tools, an email, a pull request, a proposed agent action, or the current state of a workflow.
The developer also defines the decisions Jev is allowed to make.
For example:
State: The user asked to find a flight to London.
Available actions:
- search
- click
- type
- go_back
- finish
Jev:
search → 0.91
click → 0.04
type → 0.02
go_back → 0.01
finish → 0.02The browser automation framework performs the action. Then the next state is sent back into the loop.
Jev decides. Code and tools act.
A common pattern in production systems: the LLM handles open-ended planning and synthesis, Jev handles repeated bounded decisions and verification, and deterministic software executes actions.
TypeSafe AI is the company behind Jev.
TypeSafe introduced Jev publicly on September 15, 2026 as its first System One Model. The company says it built a new model architecture, parallel sampling system and training approach called Reinforcement Learning for Calibrated Decisions (RLCD), with the goal of making AI intelligence easier to compose directly into software. (TypeSafe AI)
The idea is different from simply asking a chatbot to return JSON.
With Jev, the possible output types are defined in advance, and the model returns probabilities that software can use when deciding whether to act automatically, retry, route elsewhere or ask for human review. TypeSafe describes this as “machine-native intelligence” designed for automation. (TypeSafe AI)
JevForAgents is independent from TypeSafe AI. We collect real implementations, demos, GitHub projects and developer reports to understand how Jev is actually being used inside agent systems.
Jev is most useful where decisions are repeated, bounded, and machine-readable.
Browser agents frequently need to choose one action from a bounded action space: click, type, scroll, open a page, switch a tab or declare the task complete. Real projects combine Jev with Browser Use, Stagehand, and Cline.
Explore Browser Agents →An agent does not always need its most expensive model. Jev can classify the current task and route it to a model, sub-agent, machine or workflow based on predefined choices.
Explore Agent Routing →Agents need fast answers to questions: Did the task succeed? Is this PR safe to merge? Should this action require human approval? Does output satisfy policy? Is the agent stuck?
Explore Evaluation & Guardrails →Developers are experimenting with Jev alongside Codex, Claude Code, Cline and MCP-based coding workflows for context filtering, code review, and next-action selection.
Tool-heavy agents carry dozens of tool definitions. Jev evaluates current task state and selects the appropriate tool before invoking the main agent.
Explore Tool Selection →
@typesafeai
In the classic Wikiracing challenge (navigating between two unrelated Wikipedia articles using only internal links), Jev acts as the real-time choice model, evaluating candidate links and advancing hops in tens of milliseconds rather than waiting seconds per generative step.
@gregpr07
Demonstrates an open-source browser agent navigating flight booking flows. Rather than prompting a heavy vision model for every click, the agent feeds DOM candidate states to Jev to select the next action in tens of milliseconds.
@syntaxfm
wtf is jev? CJ from Syntax explains how the System One model works, then demos browser use, classification, code review, a dynamic model router and building an autonomous agent loop with zero LLM prompt waste.
Jev is available through TypeSafe's API. The current API exposes System One requests that can ask yes/no questions, select choices, evaluate scores and return structured results. (Typesafe API)
A typical agent integration follows four steps:
Gather the DOM, log output, user prompt, or active context.
Enumerate valid action choices, boolean checks, or scoring scales.
Obtain deterministic typed results and calibrated probabilities in 70–250ms.
Execute tools, trigger fallback logic, route requests, or ask for human review.
JSON Payloadcurl -X POST https://api.typesafe.ai/v1/systemone \
-H "Authorization: Bearer $TYPESAFE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "jev-latest",
"state": "DOM: <button id=\"book-ticket\">Book Now</button> | User: \"reserve 2 seats\"",
"questions": {
"next_action": {
"type": "choice",
"instructions": "Which browser action fulfills the user intent?",
"options": ["CLICK_BOOK", "SCROLL_DOWN", "ASK_CLARIFICATION"]
}
}
}'Sub-100ms{
"answers": {
"next_action": {
"selected": "CLICK_BOOK",
"probabilities": {
"CLICK_BOOK": 0.942,
"SCROLL_DOWN": 0.041,
"ASK_CLARIFICATION": 0.017
},
"confidence": 0.942
}
},
"latency_ms": 84,
"type_error": false
}The important design question is not simply:
“Can Jev do this?”
It is:
“Is this a repeated, bounded decision that does not require a full generative model?”
If yes, it is a strong candidate for experimentation.
TypeSafe structures Jev as a high-frequency micro-decision layer. Rather than billing for sequential token generation, input states are evaluated in parallel at ultra-low cost with zero output-token generation fees.
Source: TypeSafe AI Launch Announcement. Metrics reported in community builds above remain author reports rather than independent guarantees.
Jev and LLMs solve different parts of an AI system.
| Better suited to an LLM | Better candidate for Jev |
|---|---|
| Open-ended writing | Classification |
| Complex reasoning | Routing |
| Planning | Tool selection |
| Code generation | Scoring |
| Conversation | Verification |
| Long-form synthesis | Guardrail decisions |
| Novel problem solving | Repeated bounded choices |
In many real agent systems the most useful architecture is not Jev vs LLM:
Jev + LLM + deterministic software.
Each component does the kind of work it is best suited for.
Jev is TypeSafe AI's first public System One Model, designed to return fast, typed probabilistic decisions for use inside software and automation. (TypeSafe AI)
TypeSafe uses the term System One Model for a class of AI models optimized for rapid structured decisions rather than general-purpose string generation. (TypeSafe AI)
Jev is not designed like a conventional generative LLM. It returns predefined structured decisions and probabilities instead of freely generating text.
Jev was developed by TypeSafe AI, founded by Diogo Almeida. TypeSafe publicly introduced Jev on September 15, 2026. (TypeSafe AI)
Current developer projects use Jev for browser action selection, agent routing, tool selection, classification, evaluation, verification, guardrails, coding-agent workflows and computer use.
Yes. TypeSafe publishes an API for System One requests and model discovery. (Typesafe API)
TypeSafe currently lists Jev at $42 per billion input tokens. Check the official TypeSafe site for the latest pricing before relying on it in production. (TypeSafe AI)
Developers are already experimenting with Jev in Codex, Claude Code and MCP-based coding-agent workflows. JevForAgents tracks these projects separately so reported results can be distinguished from official TypeSafe claims.
Typed choices, scores, confidence, guardrails, and the evidence behind the current claims—all in one focused guide.