Field guide · Updated 21 September 2026
The Jev Integration Guide.
System One decision models for SEO & AI workflows.
Jev is not another chatbot. It is a System One decision model — it reads a state and returns typed, calibrated decisions (yes/no, pick-one, score) instead of prose. At $0.042 per million input tokens and roughly half a second per call, it changes what is economical to automate. This guide documents six verified integration patterns, what we run in production at Ranklore, and what to skip.
Contents
1. What Jev is (and what it is not)
Jev is built by TypeSafe AI, a San Francisco lab that came out of stealth on 15 September 2026. It is the first public example of what TypeSafe calls a "System One" model — a model that makes fast, structured decisions that software can consume directly, with no string parsing or retry logic.
Send Jev a state (any JSON or text) and a set of typed questions. It returns an answer and a calibrated probability for each one. Three question types:
noul— yes/no with a probability from 0 to 1. "Is this spam?" → 0.97.choice— pick one from options, with a probability distribution. "Which queue?" → billing (0.82).score— position on an ordered rubric. "How urgent?" → act_now (0.71).
What Jev is not: it does not generate prose, does not reason open-endedly, and does not write code. If you need an answer in words, use an LLM. Jev is the fast, cheap gate that decides whether and how to invoke the expensive LLM.
The mental model: Jev is the reflex. The LLM is the deliberation. Most agent loops spend 80% of their cost on decisions an LLM should never have been asked to make. Route those to Jev.
2. The decisions API in one call
Jev is available through OpenRouter (typesafe/jev-1.13), TypeSafe direct (api.typesafe.ai/v1/systemone), ngrok.ai, Netlify AI Gateway, and Cloudflare Workers AI. The request shape is the same across providers:
POST https://openrouter.ai/api/alpha/decisions
Authorization: Bearer $OPENROUTER_KEY
Content-Type: application/json
{
"model": "typesafe/jev-1.13",
"state": "User message: My order never arrived. Refund?",
"questions": {
"is_refund": {
"type": "noul",
"instructions": "Does this request ask for a refund?",
"criteria": {"true": "explicit refund request", "false": "other inquiry"}
},
"queue": {
"type": "choice",
"instructions": "Which support queue?",
"criteria": {
"billing": "money, orders, refunds",
"customer": "needs a reply",
"newsletter": "promo or unsubscribe",
"other": "everything else"
}
}
}
}The response is structured JSON with an answer and probability per question. No parsing, no hallucination, no "as an AI language model". Multiple questions run in parallel on one call — nearly free.
3. Six integration patterns, reviewed
We tracked six Jev-related releases across the week of 15–21 September 2026, verified each against source code and documentation, and ran an independent second-opinion review. Here is what survived.
Pattern A — Jev-driven browser automation (jev-ultrafast + Jev Browser Control)
What it is: Instead of asking a frontier LLM to click through web pages (which resends the system prompt, tool definitions, and entire conversation on every step), Jev reads an indexed element table and picks the operation + target in one call. A small text model writes only field values. This is the pattern behind browser-use/jev-ultrafast (5,600+ GitHub stars) and the productised jevbrowsercontrol.com Chrome extension + MCP server.
Why it matters for SEO work: form submissions, filter applications, SERP checks, and competitor monitoring are all "click through a page" tasks. Eren (one of our fleet agents) was taking 60+ seconds on simple form submissions because a reasoning-heavy LLM was driving the browser. Jev does the same step in ~0.5s.
Verified benchmark (3 tasks: Wikipedia search, 7-field order form, Hacker News thread, same loop, only the decision-maker changes):
| Decision-maker | Cost (3 tasks) | Time | vs Jev |
|---|---|---|---|
| Jev (OpenRouter key) | $0.006 | 17.8s | 1× |
| GPT-5.3 Codex | $0.153 | 38.9s | 27× |
| Claude Sonnet 5 | $0.249 | 43.3s | 44× |
| Claude Opus 5 | $0.795 | 45.4s | 140× |
| GPT-6 Astra | $1.129 | 38.3s | 198× |
Safety gates built in: irreversible actions (buy, pay, send, delete, publish) stop and ask for confirmation. Password fields are never listed. Budget limits (max steps, seconds, dollars) are enforced in code. Page text is treated as untrusted data.
Source: github.com/browser-use/jev-ultrafast · jevbrowsercontrol.com (MIT, builds on jev-ultrafast)
Pattern B — Jev-as-a-Judge for content & output evaluation
What it is: Instead of using an LLM-as-a-judge (which writes prose justifications, is inconsistent, and costs 10–50× more), define eval criteria as Jev questions and score outputs programmatically. A community project (danielgshea/jev-as-a-judge) benchmarked this against LLM judges on agent eval tasks.
Why it matters for SEO: every piece of content we publish can be scored against a rubric (on-brand? well-structured? has evidence? meets search intent?) in milliseconds, before it ever reaches a human editor. This is a score question with an ordered rubric — exactly what Jev is built for.
Caveat: this is a community experiment, not an official LangChain product. The benchmark is narrow (agent task evals, not general content quality). Treat the pattern as proven, the specific results as directional.
Source: github.com/danielgshea/jev-as-a-judge · LangChain blog coverage
Pattern C — Model routing middleware (LangChain ModelRouterMiddleware)
What it is: LangChain's langchain-typesafe package ships ModelRouterMiddleware — at the start of an agent run, Jev evaluates the user's message and chooses between a fast cheap model and a powerful expensive model. The choice is saved as model_route in the agent state. There is also AutoModeMiddleware for phase-based routing (fast model for execution turns, primary model for planning and recovery).
Why it matters: this is exactly the pattern we implemented in our fleet as jev-router (a pre_llm_call hook that injects a local model for trivial tasks). If you are on LangChain, the middleware is pre-built. If you are on a custom stack (like our Hermes fleet), the pattern is three lines of code.
Pattern D — Input/output guardrails (prompt injection & output filtering)
What it is: run Jev in parallel with or right before the LLM to inspect text. Input guard: "Is this a prompt injection attack?" (noul). If true, block before the LLM sees it. Output guard: "Does this response contain sensitive data or hallucinated code?" (noul). If true, halt.
Why it matters: we implemented this as jev-guard — a pre_tool_call hook across all 12 fleet agents. Two noul questions (destructive action? external side effect?) block at ≥0.75 confidence, fail open on error. This is cheaper and faster than any LLM-based guardrail.
Key design rule from TypeSafe's official agent skill: "any serious violation" needs separate noul conditions. Do not combine "is this destructive or external or secret?" into one question — split them so each has its own threshold and action.
Pattern E — Batch triage & classification at scale
What it is: feed Jev a file of items (one per line) and a questions JSON. It classifies every item against every question in parallel, outputs tab-separated results, and reports total cost. We use this for email triage (~1,500 emails ≈ $0.04), SEO issue prioritisation, and content slop detection.
Confidence buckets: every score carries a band. ≥0.85 = auto-act (no human). 0.5–0.85 = confirm (show, ask one tap). <0.5 = hold (queue or escalate to a frontier model). This is the action gate that makes batch automation safe.
Tie-break rule: if the top two choice options are within 0.1 of each other, demote to "confirm" and tag it "ambiguous". Jev's calibrated probabilities make this detectable — an LLM's vague "I think maybe billing" does not.
Pattern F — Internal link mapping at scale
What it is: pull a site's sitemap, summarise each page, then run pairwise Jev noul questions: "Should page A link to page B?" Output every recommended link with a confidence score. A practitioner (Borja Fat) mapped 586 pages in 45 seconds for $0.21. We built this as jevlink and tested it on ranklore.ai (25 pages, 9 links, $0.0024).
Why it matters for SEO: internal linking is one of the highest-ROI technical SEO levers and one of the most tedious to do manually. Jev makes it economical to re-run on every content publish.
Source: Borja Fat on X
4. Cost & speed benchmarks
| Task | Volume | Jev cost | Jev time | LLM equivalent |
|---|---|---|---|---|
| Email triage (spam + queue + urgency) | 1,500 emails | ~$0.04 | ~2 min | $5–20 (LLM-as-judge) |
| Browser automation (3 tasks) | 3 web flows | $0.006 | 17.8s | $0.15–1.13 (27–198×) |
| Internal link mapping | 25 pages | $0.0024 | ~45s | $2–5 (LLM pairwise) |
| SEO checklist audit (10 items) | 1 page | ~$0.0001 | ~1s | $0.05–0.20 (LLM audit) |
| Tool-call guardrail (per call) | 1 decision | ~$0.00001 | ~0.3s | $0.01–0.05 (LLM guard) |
The pattern is consistent: Jev is 10–200× cheaper and 2–3× faster than any LLM on structured decisions. The gap widens with batch size because Jev parallelises questions per call.
5. What Ranklore runs in production
As of September 2026, our Jev stack:
~/.local/bin/jev— CLI wrapper over the OpenRouter Decisions API.jev askfor single decisions,jev loopfor batch files./jevloop— skill with confidence buckets (auto/confirm/hold), escalation to Astra 6 on ambiguous cases, tie-break detection./jevseo— 10-item SEO checklist audit per page, via Jev noul/score questions.jevlink— internal link mapping across a full sitemap, with live streaming dashboard.jev-guard— fleet plugin:pre_tool_callhook, two noul questions (destructive + external), blocks at ≥0.75, fails open. Enabled on all 12 agents.jev-router— fleet plugin:pre_llm_callhook, on first turn only, routes trivial tasks (≥0.85 confidence) to a local model. Enabled on all 12 agents.- Live dashboards — triage dashboard (port 8765) and jevlink duel dashboard (port 8767) streaming decisions in real time with cost meters.
What is next: integrating Pattern A (Jev-driven browser automation) to replace LLM-driven browser steps across the fleet, and Pattern B (Jev-as-Judge) as a content quality gate in the publishing pipeline.
6. What to skip (for now)
- Gateway migration (Netlify, ngrok, Cloudflare): all three added Jev in the same week. We already use OpenRouter successfully. Migrating adds vendor risk and no new capability. Revisit if OpenRouter has an outage or price change.
- Jev for open-ended writing or reasoning: it is not built for this. Do not try to make Jev write content or design strategy. It is the gate, not the generator.
- Single noul question for complex violations: "Is this risky?" is too broad. Split into separate conditions (destructive? external? secret?) each with its own threshold. This is from TypeSafe's official agent skill guidance.
- Trusting Jev probabilities as absolute truth: they are calibrated relative to the question's criteria. If the criteria are vague, the probabilities are vague. Write precise criteria with concrete true/false examples.
The one-sentence summary: Jev is the reflex layer of an AI stack. Put it in front of every LLM call, every tool call, and every batch classification. Reserve the LLM for what only an LLM can do — writing, reasoning, and open-ended judgment. Everything else is a decision, and decisions are cheap.
This guide was last updated on 21 September 2026. All benchmarks are sourced from verified runs or published reproducible data. Jev model version: typesafe/jev-1.13. Pricing: $0.042/M input tokens, output free, at OpenRouter rates.