Source: raw/Jev_+_Claude_=_INSANE_Results_Every_Concept_Explained.md (https://www.youtube.com/watch?v=D-Z5HnLW_ho, 37:22, uploaded 2026-09-23) · raw/You_Should_Be_Using_Jev_s_Browser_Agent_Here_s_Why.md (https://www.youtube.com/watch?v=zac3kEUwIlg, 12:03, uploaded 2026-10-08)
Creator: Simon Scrapes (YouTube) · Platform: YouTube
Two Simon Scrapes walkthroughs of TypeSafe’s Jev decision model used from Claude Code. The first explains the three question types, installs the TypeSafe skill, and builds a 50-email support triage with a second Jev pass that checks Claude’s drafts. The second shows how a Jev browser agent works (numbered page elements, two choice questions per step, a confidence gate) and the four traps he hit building one. The entity page, with pricing and other creators’ reports, is Jev (TypeSafe AI). Both videos promote his Agentic Academy community; the build plan and question checklist are offered free.
Key Takeaways
- Jev turns fuzzy inputs into numbers an
ifstatement can use. You send a state (the text to judge) and questions with defined options; it returns probabilities and, for multi-option questions, a confidence. It never writes text. Your script, written by Claude, takes the action. - Three question types, picked by what the code does next. Act or don’t act: a yes/no question (captioned “null”). Route somewhere: a choice. Sort or rank: a score on an ordered scale described in words (calm, annoyed, furious), which can land between levels (2.4 of 3). Choice and score return a confidence; yes/no does not.
- Always give an out. Add “none of those” to every choice, or Jev picks the nearest option.
- Ask everything in one request (“speculative fan-out”). All questions in a request run in parallel and you pay to read the state once, so include questions that may not apply (bug severity on a billing email) and ignore the answers you do not need.
- One threshold per action, set by the cost of being wrong. TypeSafe’s voice-banking example: about 0.6 is enough for “check my balance”; a transfer needs 0.85 to 0.95 or a confirmation.
- Break big judgments into weighted parts. Instead of “is this a good candidate, 1 to 10”, score Python depth, leadership, system design and learning speed separately and weight them per role in code.
- Route each request to the cheapest correct handler (intent routing). A database lookup for “where’s my order”, Claude with product docs for a product question, a person for messy cases, and a person for anything under threshold.
- Claude does the reasoning, writing and verification. He relays TypeSafe’s founder on the Latent Space podcast: Claude is the conversation and Jev is the plumbing. Two pairings: Jev around Claude (guardrails before and after, citation checks on Claude’s output) and Jev instead of Claude for bulk deterministic work.
- The hard part is the questions, not the code. His five-step checklist: list the actions first; write each action’s trigger as a sentence (that sentence is the question and fixes its type); write down what a person would look at (the state); add what else could be true that changes routing (edge cases); decide what a wrong answer costs (the threshold).
The support-triage build
He ran the build on a CSV of 50 overnight support emails (received time, ID, customer since, plan, last invoice, subject, body).
- Install and test. TypeSafe ships an agent skill (two terminal commands from
docs.typesafe.ai/agent-skill, or the console’s agent prompt). Put the key in.envas the TypeSafe API key. Name the skill in every prompt (“Use the TypeSafe skill”). His key test, “We’ve been charged twice. Please fix this ASAP” against “the customer is reporting a billing problem”, returned 0.99 with 324 input and 24 output tokens. He puts Jev’s share of the time at about 0.3 seconds and the cost at $0.0000136, or about 73,000 such calls per dollar. - Brief Claude with the actions, not the questions. Four piles: Claude drafts a reply, engineering queue, feature log, send to a person. Each pile sorted angriest first. Rules: anything about money goes to a person, never Claude; low category confidence or an unusual case goes to a person; “cannot use the product” goes to engineering; feature requests are logged; everything else Claude drafts from a reply guide. Priority is mostly anger, partly severity. “Show me the plan before you run anything.”
- Read the plan. Claude wrote
questions.pywith three parts: the state (one structured object per email with named fields, leaving out thread history), five questions per email in one request (topic choice with “none”, refund yes/no, breakage score 1 to 4 with defined levels, anger score, judgment-needed choice), and routing rules with a threshold per rule. The routing is plainifstatements, no model. - Second pass on Claude’s drafts. A separate Jev request asks whether the draft answers the customer’s question and whether it promises a refund or discount; only drafts that pass both are kept.
- Result. All 50 ran in 4.2 seconds with eight concurrent workers (31 seconds sequentially) for $0.0026, which he works out as about 19,000 emails per dollar, or about a dollar a year at 50 a day. Priority weighting came out 70% anger, 30% severity. 19 went to a person and 19 to Claude drafts; the rest went to engineering and the feature log.
A request is capped at 64,000 tokens, but he says structured requests should be nowhere near that.
How a Jev browser agent works
- Pages become data, not screenshots. Playwright, or an open-source library captioned “Jev ultraast” from the Browser Use team, lists every interactive element on the page and numbers it (1: pricing link, 2: free-trial button, 3: email input; up to about 100).
- Two choice questions per step, in one call. What to do (click, type, select, scroll down, scroll up, wait, done, blocked) and which numbered element (with a “none” option). If both confidences clear the threshold (his example: 0.7), code performs the action, waits for the page to settle, re-reads the elements and asks again.
- Claude steps in on four occasions: confidence below threshold, “blocked”, typing (Jev picks the box but cannot write the text), and “done”, which the runner does not trust. He notes Browser Use’s own readme says “done” needs an independent check.
- Reported speed. Browser Use rebuilt its agent on Jev and ran a Google Flights search in about 7 seconds; he relays their figure that browser calls on that run fell from 1,092 to 101.
- His build. A “grab any flow” tool with a UI that researches sites for a goal (“pricing pages with annual toggles for SaaS tools”), opens parallel browsers and screenshots each flow. He based it on a demo by Omar on X, had Claude Code (Opus 5.5) build it from a plan that included screenshots of that demo, and says it took about 20 minutes.
Four traps he hit
- Cookie and consent banners. Add a yes/no question (“is this a cookie banner / manage-preferences banner?”) and have the script accept it.
- iframes and file uploads. Playwright cannot see inside embedded frames, so payment and embedded sign-up forms are invisible; upload buttons too. Browser Use lists these as out of scope.
- False “done”. A run asked to screenshot the last 10 blog posts on four competitor sites reported 10 pages done in 77 seconds; one or two were real blog pages. Send the result back to Claude to check against the goal.
- Short memory. The agent sees only its last five actions, so keep goals short and chain them: one goal per page or form.
Try It
- Pick one bulk judgment you now do with Claude row by row (lead scoring, ticket tagging, review sorting).
- Write the actions first, then one trigger sentence per action, then the threshold each action needs.
- Install the TypeSafe skill in Claude Code, add the key to
.env, and ask Claude for the plan file (state, questions, routing) before any run. - Run 20 rows, read the per-row answers, and adjust question wording and thresholds before scaling up.
- For browser work, start with a single-page goal and add the cookie-banner question from the start.
Implementation
Tool/Service: TypeSafe Jev via the TypeSafe agent skill in Claude Code; Playwright or the Browser Use library for browser state.
Setup: Two install commands from docs.typesafe.ai/agent-skill; /plugins should list the TypeSafe plugin as installed; API key in .env. For Claude desktop he suggests uploading the skill’s SKILL.md under Customize → Skills (he had not tested this). OpenRouter also serves the model, but then you write the question schema yourself.
Cost: About 4 cents per million input tokens, output effectively free (his figures, matching the entity page).
Integration notes: The skill runs nothing itself. It is a rule book that tells Claude which question type to use, how to word criteria, when to batch, and where to set thresholds.
Open Questions
- The “Jev ultraast” library name is a caption; the Jev entity page records a similar caption (“Jeff ultra fast”) for a Browser Use repo. Real name and licence not checked.
- The 1,092-to-101 call reduction and the 7-second flight search are Browser Use’s figures as relayed, not checked against their post.
- His cost and timing numbers come from Claude’s own report of the run.
Related
- Jev (TypeSafe AI) — the entity page: pricing, speed, other creators’ builds, limits.
- Orchestrator and Cheap-Worker Routing — the general routing pattern Jev fits into.
- Claude in Chrome — the slower screenshot-based browser route he contrasts it with.
- Browser Harness — another approach to agent browsing.
- Claude Code Advice Reset (Simon Scrapes) — the same creator’s verification-first framing.