THE PRACTICAL DATABASE & DIRECTORY

Jev for Agents: How Jev Powers Real AI Agents

Browser agents, coding agents, routers, tool selection, evaluation and guardrails — with real builds, demos and implementation patterns.

405Curated Builds

198Visual Demos

9Core Patterns

100%Evidence Sourced

Explore All 405 Builds Watch Real Demos

Independent curation. Sources and evidence on every example.

38,000,000+ VIEWS ON 𝕏

Diogo Almeida@CompleteSkeptic · Sep 15

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

20–200× faster than conventional generative models
40–400× cheaper (with output tokens free)
Composable intelligence optimized for agent decisions

💬 3.9K🔁 8.2K❤️ 74.5K📊 38.4M Views

WHAT THIS REPRESENTSJev makes the bounded decision. Code, tools, and agents execute.

Showing 58 builds matching criteria

Jetwani Avinash@jetwaniavinash · 2026-09-24

Case summary

Jetwani Avinash demonstrates a memory gate for Claude Code: Jev decides whether a message is worth remembering, and jevmem saves useful project memory in JEVMEM.md. Its public README describes retaining decisions, rules, bugs, to-dos and failed approaches, then bringing relevant lines into later sessions. The repository was inspected, not independently installed or tested.

GitHub Repo

🤖 Jev AgentProject memory gate

Claude Code Project Memory with jevmem

WHAT JEV DECIDES

Decides whether a message is worth retaining as project memory.

Raph Guilhem@raph_guilhem · 2026-09-23

Case summary

Raph Guilhem demonstrates a marketing pipeline combining Opus 5.5, Jev and Pletor. The author reports scoring 120 ads from 12 competitors on seven criteria, then having code select 10 to adapt. Opus builds the pipeline, Jev makes ad judgments, and Pletor MCP creates variants. These counts and results are author-reported.

🤖 Jev AgentAd evaluator

Competitor Ad Scoring with Opus and Jev

WHAT JEV DECIDES

Makes judgments on seven ad criteria, including health-claim risk.

a16z@a16z · 2026-09-28

Case summary

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.

🤖 Jev AgentFounder interview

Jev in Software: A TypeSafe Founder Interview

WHAT JEV DECIDES

Explains typed choices and confidence as decision inputs for application code.

Mr. Buzzoni@polydao · 2026-09-28

Case summary

Mr. Buzzoni previews a 14-page PDF describing a proposed Jev-and-Claude workflow. Jev handles typed judgments for triage, context selection, command screening and evaluation; Claude handles work that needs generation, while code owns the branches. The original post includes a PDF flip-through video and links a related article.

🤖 Jev AgentCommunity PDF overview

Jev and Claude: Workflow Architecture PDF Overview

WHAT JEV DECIDES

Proposed decision layer for triage, context selection, command checks and run evaluation.

elune@elune0x · 2026-09-24

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 ↓

🤖 Jev AgentCODING AGENTS

Elune Coding Agent Switch

WHAT JEV DECIDES

Select Claude Code or Codex and review tool calls before execution.

Brad Wardell@draginol · 2026-09-21

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

🤖 Jev AgentCODING AGENTS

Clairvoyance Jev Integration for Mac

WHAT JEV DECIDES

Make file-related decisions within Clairvoyance; exact outputs are undisclosed.

Lomesh Dutta@lomeshdutta · 2026-09-18

Just hacked a fun little project - Skill Router (Open source) using Claude and Jev @typesafeai Why? I have ~ 90 Claude Code skills installed and use maybe five. The rest are fine, I just forgot they existed, and Claude won't reach for a skill on its own unless you call it. So I built myself a little personal skill-router: https://t.co/A8HdsngGXf https://t.co/yEmWwAMO1q

GitHub Repo

⚡ Jev Skills🤖 Jev AgentMCP / SKILLS

Lomesh Dutta Skill Router

WHAT JEV DECIDES

Recommend an installed skill, a search for one, or no skill.

Lahfir@mdlahfir · 2026-09-16

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

🤖 Jev AgentAGENT ROUTING

Lahfir Local Harness Router

WHAT JEV DECIDES

Select a local coding harness or model tier before delegation.

Ranjan@manofsteel3129 · 2026-09-20

built askjev on typesafe jev for all-site navigation with claude you talk to claude in plain english and askjev runs your real browser on any site. jev decides every next click — open pages, switch tabs, scroll feeds, fill forms, run multi-step goals without you babysitting the DOM. mcp server + chrome/brave extension. auto-connect once, then stay in chat while the browser moves. claude handles the conversation. jev handles the decision on each step. askjev is the hands on the web. install: load the extension → paste your typesafe key → auto-connect → restart claude → talk example: use askjev, open http://x.com and scroll my feed and find the best posts http://github.com/ranjan2829/AskJev npx -y askjev-mcp

GitHub Repo

🤖 Jev Agent⚡ Jev SkillsMCP & Skills

AskJev (MCP Agent)

WHAT JEV DECIDES

Separates Claude high-level dialogue from Jev DOM click navigation.

Sawyer Hood@sawyerhood · 2026-09-18

thanks to @typesafeai jev I no longer have fill out all of those fields on prompt boxes. It picks the agent / model / computer / folder for me. - For a major rewrite it uses Fable + Claude Code. - Changes to an ios app run on one of my macs

🤖 Jev AgentAgent Routing

Prompt Box Router

WHAT JEV DECIDES

Picks agent, model tier, computer target and folder from raw prompt.

jonathanavis96@jonathanavis96 · 2026-09-23

I've been using TypeSafe's Jev with Claude Code for a couple of days and kept adding more use cases/ideas. So I've cleaned it up and put it in one repo. For anyone who doesn't know Jev; Jev is a small fast model that answers pick-one and yes/no questions (and more) in about 0.3s, which makes it cheap so you can put it inside your agents loop and make calls Claude would otherwise spend a turn on (eating away our already limited weekly usage). What's in it: * A PreToolUse guard. Plain code checks let about 93% of tool calls straight through in ~33ms, the grey ones get one question to Jev. Catches stuff like cat on an env file or a find across the whole disk * Sub-agent right-sizing. It asks Jev what kind of job a dispatch really is and flags or blocks when you send Opus to do a grep. On one day 20 of my 27 dispatches were a tier higher than they needed to be * A check that sends an agent back when it says done without having verified anything * File search pointed at plocate on Linux and Everything on Windows instead of find (like 500 times faster search) * A browse tool for Claude Code where Jev does the clicking * Installer, doctor, a warm daemon so calls stay fast, runs on Linux, WSL and native Windows The browser part is what I spent the last chunk of tokens on. Since Jev only picks one thing on screen at a time and doesn't plan, it's good when you literally spell out the clicks and useless when you don't. I put Sonnet on low effort with thinking off in front of it as a planner, and it's kept warm between calls. 6 Wikipedia tasks run 3 times for cleaner data where every link is pre-planned: |Model|Score|Time per task|Cost| |:-|:-|:-|:-| |Jev alone| 15/18|7s|$0.00001 ?| |Sonnet low + Jev|16/18|16s|$0.05| |Sonnet + Playwright |17/18|26s|$0.1| Tasks where Jev has to find its own way: |Model|Score|Time per task|Cost| |:-|:-|:-|:-| |Jev alone|0/6|DNF|$0.00001 ?| |Sonnet low + Jev|6/6|33s|$0.11| |Sonnet + Playwright |6/6|47s|$0.18| First version of that planner was a full Claude Code session and it sat thinking for nearly a minute per task, so warm + thinking-off matters a lot. About the guard: I ran 30 sessions with and without it and it blocked nothing. Agents mostly behave and it costs almost nothing when nothing's wrong and if Jev is down or times out the call just goes through, so I keep it on as a backstop. Hopefully it helps some of those skill issue posts from happening. MIT license, and needs a TypeSafe key. Browser agent is browser-use's jev-ultrafast vendored in with my changes on top.

GitHub Repo

🤖 Jev AgentCODING AGENTS

jev-kit for Claude Code

WHAT JEV DECIDES

Guards ambiguous tool calls and sizes sub-agents before Claude Code spends a full turn.

Jev decision latency: ~0.3 s
Code-only pass-through: 93% / ~33 ms
Over-tiered dispatches: 20/27
Named-hop Jev score/time: 15/18 in 7 s
Named-hop Sonnet + Jev score/time: 16/18 in 16 s
Named-hop Sonnet + Playwright score/time: 17/18 in 26 s
Guard sessions / blocks: 30 / 0

Jason Lu@jasonlu_ai · 2026-09-18

JEV is changes the world of E2E testing! Same eBay test flow, completed-run medians: Jev: 47s / $0.0067 GPT-5.6 Luna: 62s / $0.0277 Claude Sonnet 5: 79s / $0.4062 Try jev-e2e. https://t.co/fyOdrNi3jF

GitHub Repo

🤖 Jev AgentAgent Evaluation

jev-e2e

WHAT JEV DECIDES

End-to-end latency and accuracy benchmarking of Jev vs Claude.

Jev: 47 s / $0.0067
Sonnet 5: 79 s / $0.4062

Showing 12 of 58

SECTION 03 / SYSTEM ARCHITECTURE

What is Jev AI?

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.

Jev is TypeSafe AI's first System One Model

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→continue

The 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.

Explore:Browser Agents·Agent Routing·Tool Selection·Agent Evaluation·Guardrails·MCP & Skills

Is Jev an LLM?

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:

LLM“What should I do and how should I do it?”→reason / plan / generate

Jev“Which of these allowed actions should happen now?”→choose / score / verify

Jev vs LLM comparison for AI agents showing generation tasks versus bounded decision tasks — LLMs handle open-ended reasoning and generation; Jev is designed for bounded decisions such as choosing, scoring, routing, verifying, and classifying.

This does not mean Jev replaces an LLM everywhere. Many of the most interesting Jev agent architectures combine both.

The LLM: Handles open-ended intelligence & high-level synthesis.
Jev: Handles bounded, repeated decision points.
Code: Executes the result deterministically.

See real examples → Jev + Claude Code·Jev + Codex·Browser Agents

How Jev works: state in, typed decisions out

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 → TYPED DECISION

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.02

The browser automation framework performs the action. Then the next state is sent back into the loop.

Jev decides. Code and tools act.

Where Jev fits inside an AI agent

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.

AI agent architecture showing an LLM for planning, Jev for decisions and verification, and tools for execution — A common pattern: the LLM handles open-ended work, Jev handles bounded decisions, and deterministic software executes actions.

SECTION 04 / THE COMPANY

What is TypeSafe AI?

Why TypeSafe built Jev

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.

RLCD: Reinforcement Learning for Calibrated Decisions

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.

SECTION 05 / AGENT PATTERNS

What can you use Jev for?

Jev is most useful where decisions are repeated, bounded, and machine-readable.

AI agents and browser agents

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 →

Model routing and tool selection

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 →

Evaluation, verification and guardrails

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 →

Coding agents, Codex and Claude Code

Developers are experimenting with Jev alongside Codex, Claude Code, Cline and MCP-based coding workflows for context filtering, code review, and next-action selection.

Explore Codex →Explore Claude Code →

MCP and agent skills

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 →

SOURCED IMPLEMENTATIONS

Real Builds in Action: How Developers Implement These Patterns

View all 405 builds →

TypeSafe AI@typesafeai

Agent Evaluation

WATCH DEMO

Wikiracing Fast Navigation

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.

Hop Latency: <50ms / stepBenchmark: Wikiracing

Inspect Build & Demo →

Gregor Zunic@gregpr07

Browser Agents

WATCH DEMO

Flight Search with Browser Use

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.

Run time: ~7 sCost: ~$0.004

Inspect Build & Demo →

CJ (Syntax.fm)@syntaxfm

Browser Agents

WATCH DEMO

wtf is jev? Demos: Browser Use, Classifier, Router

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.

Format: YouTube 4KDemos: 5 live setups

Inspect Build & Demo →

SECTION 06 / DEVELOPER IMPLEMENTATION

How to use Jev

Jev API

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)

Jev with existing agents

A typical agent integration follows four steps:

1. Collect application state
Gather the DOM, log output, user prompt, or active context.
2. Define the allowed decision
Enumerate valid action choices, boolean checks, or scoring scales.
3. Send both to Jev
Obtain deterministic typed results and calibrated probabilities in 70–250ms.
4. Let software act on the returned probabilities
Execute tools, trigger fallback logic, route requests, or ask for human review.

POST /v1/systemoneTypeScript SDKPython SDK

84ms INFERENCE · ZERO HALLUCINATION

1. RAW STATE + BOUNDED QUESTION INJSON Payload

curl -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"]
      }
    }
  }'

2. CALIBRATED TYPE-SAFE PROBABILITIES OUTSub-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.

Start with Jev →Browse implementation patterns →

SECTION 07 / ECONOMICS & PERFORMANCE

Jev pricing, speed and cost

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.

Input Tokens$42 / 1B

Output TokensFREE

Decision Latency70ms–500ms

Architectural Rule: Reserve frontier LLMs for top-level reasoning and synthesis, while delegating high-frequency loop steps (routing, tool selection, scoring, and policy guardrails) to Jev to cut overall inference cost.

Source: TypeSafe AI Launch Announcement. Metrics reported in community builds above remain author reports rather than independent guarantees.

TypeSafe AI official launch announcement comparing Frontier LLMs with System One (Jev): Input tokens $0.042/MTok, Output tokens FREE, 70ms-500ms response time — Official comparison table: LLM token generation vs. Jev calibrated decisions.

SECTION 08 / PARADIGM COMPARISON

Jev vs LLMs: when should you use each?

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.

SECTION 09 / FREQUENTLY ASKED QUESTIONS

Frequently asked questions about Jev

What is Jev AI?+

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)

What is a System One Model?+

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)

Is Jev an LLM?+

Jev is not designed like a conventional generative LLM. It returns predefined structured decisions and probabilities instead of freely generating text.

Who made Jev?+

Jev was developed by TypeSafe AI, founded by Diogo Almeida. TypeSafe publicly introduced Jev on September 15, 2026. (TypeSafe AI)

What is Jev used for?+

Current developer projects use Jev for browser action selection, agent routing, tool selection, classification, evaluation, verification, guardrails, coding-agent workflows and computer use.

Does Jev have an API?+

Yes. TypeSafe publishes an API for System One requests and model discovery. (Typesafe API)

How much does Jev cost?+

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)

Can Jev work with Codex or Claude Code?+

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.

JEV ARCHITECTURE GUIDE

Understand the decision layer before you add it to an agent.

Typed choices, scores, confidence, guardrails, and the evidence behind the current claims—all in one focused guide.

Read the builder’s guide →Explore Jev Assistant cases →

Jev for Agents: How Jev Powers Real AI Agents

Real Jev AI agent builds and demos

Jev is TypeSafe AI's first System One Model

Is Jev an LLM?

How Jev works: state in, typed decisions out

Where Jev fits inside an AI agent

Why TypeSafe built Jev

RLCD: Reinforcement Learning for Calibrated Decisions

AI agents and browser agents

Model routing and tool selection

Evaluation, verification and guardrails

Coding agents, Codex and Claude Code

MCP and agent skills

Real Builds in Action: How Developers Implement These Patterns

Wikiracing Fast Navigation

Flight Search with Browser Use

wtf is jev? Demos: Browser Use, Classifier, Router

Jev API

Jev with existing agents

Explore 405 Curated Agent Builds, Code & Visual Demos

Understand the decision layer before you add it to an agent.