Writing-check use case (added 2026-11-09): raw/The_AI_chief_of_staff_that_this_Figma_PM_uses_all_day.md (How I AI, Claire Vo with Figma PM Ezra McCabe, https://www.youtube.com/watch?v=ztt8irafLMQ); see “A check that runs when you stop typing” below.

October 2026 news (added 2026-11-01): eight sources saved as ai-research/typesafe-news-*.md (TypeSafe blog ×2, Artificial Analysis, TechCrunch, UiPath, VentureBeat, arXiv 2610.06625, an independent Substack); see “October 2026 News” below.

Official docs (added 2026-11-01): 28 pages of docs.typesafe.ai saved as ai-research/typesafe-docs-*.md; the six cited in frontmatter carry the claims used below. Full docs breakdown: Jev API Reference.

Source: First-party: TypeSafe AI, “Introducing System One Models and Jev” (Diogo Almeida, typesafe.ai/blog, dated Sep 14, 2026), saved at ai-research/jev-typesafe-system-one-launch-2026-09.md. Commentary and hands-on reports (YouTube auto-captions, all fetched 2026-09-29):

  • Two Minute Papers, “Yes Jev Is Insane But There’s A Catch” (youtube.com/watch?v=qBBRRsH0rQc) — raw/Yes_Jev_Is_Insane_But_There_s_A_Catch.md
  • MattVidPro AI, “New Jev Model Acts in Real Time… Minecraft Broke It” (youtube.com/watch?v=DI3iRGUlczQ) — raw/New_Jev_Model_Acts_in_Real_Time..._Minecraft_Broke_It.md
  • Claire Vo, How I AI, “I’m using Jev more than Opus 5.5 or GPT-6” (youtube.com/watch?v=-KIBgpGA_XI) — raw/I_m_using_Jev_more_than_Opus_5.5_or_GPT-6._Here_s_why..md
  • NLW, The AI Daily Brief, “How People Are Actually Using Jev” (youtube.com/watch?v=uV6h3Uo4Nh8) — raw/How_People_Are_Actually_Using_Jev.md
  • NLW, The AI Daily Brief, “Why a New Class of AI Judgement Models Could Have Big Business Implications” (youtube.com/watch?v=sdR7FZ0SeqA) — raw/Why_a_New_Class_of_AI_Judgement_Models_Could_Have_Big_Business_Implications.md
  • Nate B Jones, “Why Developers Are Losing Their Minds Over AI That Can’t Write” (youtube.com/watch?v=tYugqJ9YytQ) — raw/Why_Developers_Are_Losing_Their_Minds_Over_AI_That_Can_t_Write.md
  • Greg Isenberg with Ryan Vogel (OpenCode founding team), “Jev is HERE. How to use it” (youtube.com/watch?v=4mTLpuQpB80) — raw/Jev_is_HERE._How_to_use_it.md
  • Matt Wolfe, “AI News - Opus 5.5, GPT-6 Sol, Jev, Muse and More” (youtube.com/watch?v=aDpIra7NFuE) — raw/AI_News_-_Opus_5.5_GPT-6_Sol_Jev_Muse_and_More.md
  • AI For Humans, “Instinct, Muse: AI Agents Can Run Your Life” (youtube.com/watch?v=-VL4VKHrnpU) — raw/Instinct_Muse_AI_Agents_Can_Run_Your_Life._We_Let_One_Try..md
  • Matthew Berman, “We need to talk about Jev…” (youtube.com/watch?v=2z-7pIj57f8) and “8 Jev Use Cases That Feel Like Cheating” (youtube.com/watch?v=jGD_UR4wMJc), both Zapier-sponsored — raw/We_need_to_talk_about_Jev....md, raw/8_Jev_Use_Cases_That_Feel_Like_Cheating.md
  • The Neuron Daily newsletter, 2026-09-25 and 2026-09-29 — raw/newsletter-theneurondaily-com-dceb623961.md, raw/newsletter-theneurondaily-com-094aff157e.md

Refreshed 2026-10-27 from:

  • “Using Jev In Your Agent Harness” (playlist video, creator not named in the raw file, youtube.com/watch?v=zaLQ0AnY9dI) — raw/Using_Jev_In_Your_Agent_Harness.md
  • Claire Vo with John Lindquist (caption “Linquist”), How I AI, “Jev - 8 real use cases this fast cheap model” (youtube.com/watch?v=dAIIaepNhQM) — raw/Jev_-_8_real_use_cases_this_fast_cheap_model.md
  • Claire Vo, How I AI, “OpenAI DevDay 2026 - Dots, Spaces and ULTRAFAST” (youtube.com/watch?v=pJNM1z9l5mU) — raw/OpenAI_DevDay_2026_-_Dots_Spaces_and_ULTRAFAST.md
  • Robo Nuggets (Jay), “Jev will 10x your Claude Code” (youtube.com/watch?v=tTnUcSj-QPA, 11:47, published 2026-09-21) — raw/Jev_will_10x_your_Claude_Code_Here_s_How.md
  • Robo Nuggets (Jay), “These 19 Jev-Claude use cases” (youtube.com/watch?v=3iDiWTt8lok, 14:06, published 2026-10-04) — raw/These_19_Jev-Claude_use_cases_are_blowing_people_s_minds_with_prompts.md

Refreshed 2026-10-28 from:

  • Ben AI, “Jev + Claude Will Change How You Work Forever (Real Use Cases)” (youtube.com/watch?v=L2K__oshGds, 10:37, uploaded 2026-09-23) — raw/Jev_+_Claude_Will_Change_How_You_Work_Forever_Real_Use_Cases.md

Refreshed 2026-10-30 from:

  • Sharbel (YouTube @sharbelxyz), “10 INSANE Jev Use Cases. It’s Not What They Told You.” (youtube.com/watch?v=IBONLMfA3Cw, 14:49, uploaded 2026-09-27) — raw/10_INSANE_Jev_Use_Cases._It_s_Not_What_They_Told_You..md
  • AI Master (youtube.com/@iamAImaster), “Ultimate Jev Tutorial - How to Set Up & Use Jev AI for Beginners” (youtube.com/watch?v=yM8hWPvot-A, fetched 2026-10-30; sponsored by Bitrix24, plus the creator’s own AI Master platform) — raw/Ultimate_Jev_Tutorial_-_How_to_Set_Up_Use_Jev_AI_for_Beginners.md. See the AI Master field-test section.

Jev is the first “System One Model” from TypeSafe AI: it reads text and returns a typed decision (a choice, a score, or a yes-probability) with calibrated probabilities, and it cannot write prose. That trade makes it far cheaper and faster than an LLM for the many small “which bucket / how urgent / is this true” calls inside software and agent workflows. Eleven creator videos, two newsletters and TypeSafe’s own launch post agree on what it is and what it costs; they differ on how big the speed and accuracy gains are in practice. The practical use is as a cheap judgment layer beside an LLM: Jev tags, routes, scores and filters, and the LLM handles only the items that need writing or reasoning.

Key Takeaways

  • What it is. “Unstructured state in, typed probabilistic decisions out” (TypeSafe post). Text only; no images (Claire Vo; TypeSafe’s own Doom demo runs on structured text state, “not on images (yet…)”). Update 2026-11-01: the official docs now document image input as a beta; see the contradiction note below.

  • Three output types. A choice from up to 255 options you list; a score on a 2–10 level scale you describe in words; and a yes/no probability from 0 to 1 (NLW, How People…; the 255 cap is also in the TypeSafe post). Update 2026-11-01: a fourth type, Box (where something is in an image), is in beta on Jev 1.14.

  • Price. 42 per billion”); output tokens free, “too cheap to meter” (TypeSafe post). Every creator who quotes a price gives the same figure (4 to 4.2 cents per million). TypeSafe says it “can’t prove it isn’t subsidized.”

  • Speed. 70–500 ms end to end per call (TypeSafe post). Ryan Vogel measured about 200 ms per query “no matter … the input output structure.”

  • Vendor multipliers vary by document ^[ambiguous]: the founder’s launch post on X said 20–200× faster and 40–400× cheaper (read aloud by Berman, NLW and MattVidPro); the blog table says 40–200× faster; the home-page figures of 193.6× faster and 444.6× cheaper come from TypeSafe’s own workflow evals, which it says are “on the higher end of real world gains.”

  • The recurring pattern across sources ^[inferred]: “LLM proposes options, Jev decides, code executes” (Nathan Flurry, quoted by NLW). Claire Vo: “Jev alone is okay. Jev with an LLM buddy is super powerful.”

  • Where it fails. Long-horizon goals (it loops in Minecraft on its own, per MattVidPro), multi-hop questions, maths and dates (NLW relaying TypeSafe), and anything needing reasoning or prose. It lost a chess game to Fable on material but won on the clock (Berman).

  • “Can’t hallucinate” is a claim about output shape. TypeSafe’s 0% figure “is not empirical. Schema matching is guaranteed” (TypeSafe post). In a test by Every it caught six of seven planted mistakes where Fable 5.1 caught all seven (NLW). ^[inferred] Treat it as always well-formed, not always right.

  • Adoption signal. Nate B Jones reports it was the fastest-adopted model in Vercel AI Gateway history within 24 hours. TypeSafe raised a 200M valuation and was reportedly in talks to raise up to 10B or more (NLW citing The Information; The Neuron, 2026-09-25). Update 2026-11-01: the round closed on 2026-10-09 as an 7.5B valuation, led by Andreessen Horowitz (TypeSafe blog). That is smaller than the reported talks of up to 10B+.

  • October 2026: wire it into the harness at four hooks (before the prompt, before the model call, before a tool runs, after a result), and reach it through OpenRouter without a TypeSafe invite. OpenAI’s Decisions API is now a competitor with vision. See the two October sections below.

  • In Claude Code specifically, start with a toggle. Jay (Robo Nuggets) wraps Jev model routing in a /jev on skill command and reports 70% savings on 12 prompts against all-Fable 5.1, plus skill lookups in about 5 s against about 30 s for Opus 5. His own tests; see the Robo Nuggets section.

Official Docs Update (2026-11-01)

Source: ai-research/typesafe-docs-*.md (TypeSafe’s documentation, fetched 2026-11-01). Full reference: Jev API Reference.

Topic: does Jev accept images?

Existing claim: (from Claire Vo, raw/I_m_using_Jev_more_than_Opus_5.5_or_GPT-6._Here_s_why..md, and the TypeSafe launch post ai-research/jev-typesafe-system-one-launch-2026-09.md) — Jev is text only, with “no images”, and its Doom demo runs on structured text state, “not on images (yet…)”. New source says: (from ai-research/typesafe-docs-images.md and ai-research/typesafe-docs-primitives-box.md) — “An image can go anywhere text can go in a System One request… Jev 1.13 and Jev 1.14 both accept images”, behind a TypeSafe-Danger-Zone-Images: true header and labelled “Dreamer-ready” (not yet production quality). A Box question type returns an object’s location in an image, and needs Jev 1.14. Status: resolved (2026-11-01). TypeSafe’s Jev 1.14 release post (ai-research/typesafe-news-jev-1-14-release-2026-10-14.md, 2026-10-14) shipped image input, the Box type and long context as experimental “danger zone” headers (“not for production”). The text-only claim was correct at launch. Earlier wording of this note: TypeSafe’s own docs disagree: ai-research/typesafe-docs-concepts-system-one.md and ai-research/typesafe-docs-models.md still say “text input only… Images, audio, and video are not supported (yet)” and “Input: Text”. Those pages predate the 1.14 release and weren’t updated. Treat images as prototype-only.

  • New version: jev-1.14.0 has been available since October 14, 2026, at the same price ($0.042/Mtok input, output free). jev-latest now points to it. Pin the version ID once thresholds are tuned, because aliases move on release.
  • Context limits are two numbers: 64k tokens per request (state plus all questions) and 32k per question (state plus one question), with no cap on question count. An opt-in TypeSafe-Danger-Zone-Long-Context: true header raises both to 262k at the same price, “slower and less accurate”. This sharpens the “under 32K tokens” figure below.
  • Not a coding-agent model, officially: “There is no model: "jev-latest" setting that turns your coding agent into a Jev-powered agent.” Use Claude Code to write code that calls Jev, or install the TypeSafe plugin (claude plugin install typesafe@typesafe-ai).
  • TypeSafe’s own failure list for 1.13 (reviewed 2026-10-02) adds two items the creator tests below don’t mention. Injected or adversarial text in the state “can move the answer”. Choice answers lean toward the first option listed, so reorder options to check.
  • Confidence is a published formula (Choice: (p_max − 1/n)/(1 − 1/n); Score uses a distance-weighted spread; Noul has none). That lets you recompute or replace it from the returned probabilities.

October 2026 News

Sources: ai-research/typesafe-news-*.md, fetched 2026-11-01. Vendor-reported figures are labelled as such.

Funding and company

  • 7.5B valuation (2026-10-09), led by Andreessen Horowitz with Sequoia, existing investor DCVC and angels. Martin Casado joins the board. TypeSafe claims “a third of the Fortune 500” use Jev (vendor claim). TechCrunch names Diogo Almeida as CEO, and UiPath quotes Erik Gafni as CTO.

Jev 1.14 (2026-10-14)

  • Released first under jev-preview as “small, subtle improvements to everything”, with the biggest expected gain in multilingual. It is now the jev-latest target per the docs.
  • The same post added the three experimental headers (images, Box, long context) and an opt-in program that lets TypeSafe use your queries to find weak spots.
  • TypeSafe promises 60 days’ notice before deprecating 1.13 and 30 days for 1.14, with a written deprecation policy still to come.
  • It also published TypeSafe’s first internal benchmark chart, which the company itself calls “likely biased towards our models”.

Independent benchmarks

  • Artificial Analysis Decision Index v1.0 (2026-10-13). Jev 1.13 led decision models at 58, ahead of GLiDE and Microsoft-Decision-1 (54). Claude Haiku 5.5 (Low) scored 61 but was about 11× slower and 4.4× costlier. Jev’s cost per 1M tasks (17) and Microsoft-Decision-1 ($31). Artificial Analysis found all decision models overconfident on knowledge and reasoning tasks.
  • TechCrunch (2026-10-22). Newer models moved ahead: Liquid’s D1 Ultra and Baseten’s Elephant-1 lead the AIM System One Index and the Artificial Analysis index. The latest Jev is 7th and 3rd there, and OpenAI’s decision model 8th and 14th. TypeSafe is still “the most widely-queried on OpenRouter”, and Jev tops JevMan, Opper AI’s Pac-Man benchmark. Almeida “distrusts benchmarks” and urges trials on your own work.

Competition

  • OpenAI’s Decisions API went generally available on 2026-10-22. It is “plain old Luna” reconfigured for speed (100–180 ms), with voice and visual input added for GA. Speak cut time between actions from 1.4 s to 0.13 s. OpenAI’s API lead says Luna “has been showing better calibrations” for image classification.

Integrations

  • UiPath has a TypeSafe connector in preview in Integration Service, using your own key. UiPath’s internal evals (not independent) found 94% agreement with an LLM judge, at 7.7× lower cost and 4–20× faster.
  • Data platforms (VentureBeat, 2026-10-19):
    • Databricks: an ai_decide SQL function in beta, which Databricks says is compatible with TypeSafe’s API, plus the open-weight community SemIf-OpenJev.
    • Snowflake Decision, in private preview.
    • MotherDuck: prompt_jev() on paid plans.
    • Community DuckDB and Postgres extensions with jev and jev_choice functions.

Criticism

  • arXiv 2610.06625 (political-science replications, about 2026-10-06). Jev 1.13 performs “on par” with GPT-6 Luna and Qwen3.8-27B against human coding. It has “little cost advantage” compared with Luna under batch processing, and its clear edge is speed.
  • Dylan Black, Substack (one independent blogger, about 2026-10-05). On 1,000 settings drawn from known physical distributions, Jev’s probabilities were “too peaky”: mean total variation 0.518, against 0.546 for a flat guess. They broke down on multi-step arithmetic, which matches TypeSafe’s own failure list. ^[inferred] Together with Artificial Analysis’s overconfidence finding, this is the main evidence against TypeSafe’s calibration claim, so validate thresholds on your own data.

What Jev Is

  • Maker and founder. TypeSafe AI; founder Diogo Almeida. The captions spell him “Diego” and “Dooo”; the post’s byline settles it. He writes that at OpenAI he “helped build the methods that made language models useful at following instructions … That work ended up as the research behind ChatGPT.” In his X post he calls himself a ChatGPT co-inventor (read aloud by Berman and NLW). That is his own claim.
  • Release. Early access opened after “two years in stealth.” The post is dated Sep 14, 2026; Nate B Jones dates the launch to September 15 ^[ambiguous] (possibly a time-zone difference
  • Name. “System One” comes from Kahneman’s fast/slow thinking. “Jev” is named after William Stanley Jevons: cheaper intelligence should raise total demand for it, as cheaper steam power did for coal (TypeSafe post; Nate B Jones).
  • How it differs from an LLM, per TypeSafe:
    • a new model architecture;
    • a “parallel sampler” that produces every output in one pass rather than one token at a time;
    • a training method called RLCD (Reinforcement Learning for Calibrated Decisions), which optimises for “answers with epistemically honest probabilities” where RLHF optimises for human preference.
  • Why calibration matters (Two Minute Papers). If it says 80% confident, it should be right about 80 times in 100. You can then “look at the confidence value and decide when to trust it or fall back to a heavier, smarter model.”
  • Output is directly usable by code. Numbers come back as number objects, “not like text that is a number” (Ryan Vogel). Several questions about the same item run in parallel. Per NLW relaying TypeSafe’s tests, 13 questions in one call were 12.2× cheaper and 10× faster than 13 separate calls, with identical answers.
  • The yes/no type’s name is unclear ^[ambiguous]. The captions render it as “new”, “null” and “nule”; NLW says the name is short for “Bernoulli.”
  • Skeptic’s view (Two Minute Papers). “There is no official research paper,” only a high-level description. The core idea resembles a classifier “that dates back around 90 years,” and “similar ideas have been explored for years.” Is it hyped? “Yes. Is it new? Partly.” What is new is the combination of the three ingredients above.
  • Another framing (Matt Stockton, quoted by NLW). Jev is an LLM-style interface to classic machine-learning classification. You get the classifier without labelling data, training a model or hosting it.

Pricing, Speed and Access

ItemValueSource
Input price$0.042 / M tokensTypeSafe post; Berman (“4.2 cents”); Nate B Jones; Claire Vo (“4 cents”)
Output priceFreeTypeSafe post
Worked cost1,000 calls × 1,000 tokens = 4 cents; 10,000 calls = 42 cents; 1M calls = $42Nate B Jones
Latency70–500 ms per call (TypeSafe evals run from laptops on the US West Coast)TypeSafe post
Measured latency~200 ms per query; 173 ms for one 12-question ad callRyan Vogel; NLW (Berman’s ad test)
Starting credit$5. Ryan’s team ran heavy demos for two days without using it upBerman, 8 Use Cases; Ryan Vogel
Evidence sizeUnder 32,000 tokens of textNLW, How People…
Choice cardinalityUp to 255; above that TypeSafe scores the options first, then choosesTypeSafe post; NLW
  • Where to get it:
    • TypeSafe’s own early access and waitlist (TypeSafe post; “invite only” per Greg Isenberg).
    • Vercel AI Gateway for instant access. MattVidPro added credits, got a key and let Codex call it: “Hours of testing and I spent less than a dollar.” Claire Vo says Jev was “currently free on the AI gateway by Vercel” when she recorded.
    • OpenRouter (confirmed 2026-10-27). The harness-video creator calls Jev through OpenRouter, which has a Jev tutorial page: “if you haven’t been whitelisted for the actual TypeSafe API… anyone can just come and use the OpenRouter one” (raw/Using_Jev_In_Your_Agent_Harness.md). This settles MattVidPro’s earlier “it looks like.”
  • Access was throttled at one point. Matt Wolfe reported new sign-ups paused “because of the overwhelming demand.”
  • No-code route. Zapier added a “TypeSafe Jev” action (Berman; Zapier sponsored the video).
  • Agent route. Paste TypeSafe’s “setup prompt for agents” from its site into Claude Code, Codex or ChatGPT. The agent installs the TypeSafe skill; you create an account and an API key, and the agent connects it to your project (Nate B Jones). Claire Vo relies most on the docs’ “primitives” and “cookbooks” pages.

How People Use It: Four Patterns

These come from Nate B Jones. The mapping of NLW’s six categories onto them is this article’s

  1. A shim between messy input and routing code. Jev reads a ticket or email and picks a category, urgency and risk flag; ordinary code does the routing. NLW’s “triaging what comes in” and “instant response” categories fit here.
  2. Attention triage over a big corpus. Ask every item in a pile the same few questions, then count or rank the answers. This matches NLW’s “analyzing what you already have” and “searching by meaning.”
  3. The outer-loop chooser. Jev decides whether the next step is a tool, a cheap LLM, a frontier model or a human (Nate credits James Ward with “putting classifiers into the outer loop of a harness”). NLW’s “speeding up AI agents” belongs here.
  4. Live UI composition. Jev picks components from a fixed design system as the user types (Nate; Berman’s UI-assembly demo).
  • A fifth use: checking work against rules (NLW). Turn “please review this” into specific yes/no questions and run them on every paragraph or agent trace. Harrison Chase (LangChain) calls it “great for evals, especially online evals” (per NLW). Mike Taylor (Every) calls it a “linter for knowledge work” (per NLW).
  • Safety gate. Nate suggests having Jev review each proposed agent command (e.g. deleting a build folder, force-pushing) and return proceed / stop / ask a human.
  • Planner plus reflexes. MattVidPro’s conclusion from Minecraft: an LLM should direct “the instantaneous Jev body.” Paired with GPT-6 Astra as coordinator, Jev “plays Minecraft super well” (Woo Young Zoo’s demo, as MattVidPro describes it).

October 2026 update: Jev inside an agent harness

From raw/Using_Jev_In_Your_Agent_Harness.md. The creator’s framing: “most of the model calls in an agent harness aren’t actually writing anything. They’re making decisions.”

Six places a decision model belongs in a harness:

  1. Model routing. Send a request to a cheap fast model or an expensive reasoning model.
  2. Risk gating. Before a tool call runs (for example a bash tool), send its arguments to Jev and ask whether it is destructive or benign. “A safety check that can take milliseconds,” and with an open decision model it can run locally.
  3. Tool and skill selection. Load only the skills the task needs instead of the whole registry.
  4. Ranking and judging. Score retrieved chunks; grade answers against a rubric.
  5. Triage. Urgency for tickets and email, and when to go back to a human.
  6. Real-time filtering. Filter API or polling results before they enter the context window.

Rule of thumb (credited to TypeSafe): “If a panel of smart people could answer the question in just a few seconds,” use a decision model. If they would need to go away and write an answer, use an LLM.

Four hook points, in any framework (LangChain, ADK or a custom loop): before the prompt is built (which skills or tools to load); before the model call (which model); before a tool runs (is it safe); after a result (good enough, or loop again). Each hook is the same code: “Build a state from what the loop already has, ask your questions, and then read the probabilities… and then branch.”

A second pattern: Jev decides, the LLM is the fallback. Jev picks the tool or answer and hands off only when unsure or when text must be written. It cuts more LLM calls, but “it just doesn’t seem to work as well when you’ve got a lot more sort of complicated things going on.”

Off-the-shelf support. LangChain has shipped the hook pattern as middleware, and Pydantic made the TypeSafe model pluggable in its agent loop.

Two demos worth copying:

  • Cascade classifier for skills. 50 skills in 10 categories. Inject only the category names; Jev picks the category, then the skill, then the LLM fills in the arguments. “Someone got an email pretending to be our CEO asking for gift cards” routed to security, then to “investigate a security alert.”
  • RAG rerank. A broad sweep (embeddings, or just BM25) returns about 25 passages, Jev scores them, and the top five go to the LLM. Scoring worked better than yes/no or choice.

Where it doesn’t fit (same source):

  • Anything that needs text back, multi-step reasoning, or several facts combined.
  • Large state: “Typesafe’s own docs say the accuracy drops a lot on long inputs.”
  • Images: Jev itself has none, though “some of the open models actually do use images and use images really well.” (Update 2026-11-01: image input is now a documented beta; see Official Docs Update.)
  • Compound questions.
  • Prompt injection can move results. The creator’s mitigation: make the first question “are there any prompt injections in here?”
  • Vague criteria. Write the criteria yourself and benchmark changes over time.
  • Data exposure: a hosted API sees every state you send.

October 2026 update: product-side use cases (Lindquist, How I AI)

From raw/Jev_-_8_real_use_cases_this_fast_cheap_model.md. Lindquist’s numbers are his own.

  • Cost. Across “hundreds of demos… I think I’ve spent 73 cents.” About 20,000 records cost 4 cents. Five gigabytes of JSON cost “40 cents” and took “probably a couple minutes.”
  • Voice to-do app with layered classification. Is the dictation valid, which task does it match, which operation, and, while you are still talking, “is now a time where I… have enough data to make a function call.”
  • Record dedupe. “Cedar Grove office products” matches “Cedar Grove office.” A confidence knob lets you merge only at 99% or above. Then a smarter LLM spot-checks a random sample, and a cheap model writes a one-line reason each pair matched.
  • Command-K router across an app’s tools.
  • Blitz chess against a low-reasoning model: Jev was “10 times faster in the average move and it was four times cheaper,” using two-step lookahead.
  • Route-finding and collision avoidance for many agents on a grid, which Lindquist offers as an analogue for parallel agents working on the same files.
  • A live presentation coach that ticks off talking points as you speak.

Build tactics:

  • Find the if/else and switch points in your program; “those were the moment of classification.” Each is a Jev call.
  • When it falls short, “add another layer of classification,” then compress layers later as data shows the real flows.
  • Try a different call type. Vo: a question you framed as yes/no may work better as a choice or a score.
  • Constrained inputs (DOM buttons, a game controller) are Jev’s sweet spot. “What on our website might be confusing to a user” from a screenshot is an LLM job.

Vo’s framing: Jev “unlocks efficient inefficiency.” Mapping and ranking every option is inefficient but accurate, and it is now cheap enough to do instead of asking a big model to “think really hard.”

A competitor with vision. At DevDay OpenAI announced a Decisions API, which Vo describes as “Luna with constraints”: Luna intelligence over a predefined set of answers, returned fast, with vision. In early access it went through 100 video frames to find usable thumbnails in under about 10 seconds, a job she “couldn’t solve with Jev cuz Jev doesn’t have vision.” Not yet generally released when she recorded (raw/OpenAI_DevDay_2026_-_Dots_Spaces_and_ULTRAFAST.md).

Robo Nuggets field notes (2026-09 to 2026-10): Jev inside Claude Code

From Jay’s two videos (raw/Jev_will_10x_your_Claude_Code_Here_s_How.md, 2026-09-21; raw/These_19_Jev-Claude_use_cases_are_blowing_people_s_minds_with_prompts.md, 2026-10-04). The timings and savings are his own tests or tests he relays; none was reproduced here. Both videos pitch his paid community and a PDF guide, which are left out.

Access and price, as of late September.

  • Jay connected through OpenRouter. On the day he recorded, TypeSafe had announced that Jev was “now actually available to everyone”: the waitlist had been removed “just hours ago.”
  • He reads the rate card as “around 24 times cheaper than Haiku and around 230 times cheaper than Fable 5.1.” That is his arithmetic on input price; Haiku 5.5 is now tiered-priced, so check the ratio against Claude Haiku 5.5 before quoting it.

Level 1: inside your agent setup.

  • Make it a toggle. Jay built a skill command, /jev on (captioned “/jv”), that turns Jev routing on for the rest of a session. He advises starting with an on/off switch so you can compare.
  • Model routing. Across 12 prompts, Jev-routed runs against Fable 5.1 on every prompt saved 70%, because “nine out of those 12 tasks never needed the top” model. One example: a file-path lookup went to a Haiku helper instead of Opus 5, the session default. His caveat: check the output is still good enough for your work.
  • Skill selection. With about 145 skills in his workspace, 14 lookups took Jev about 5 seconds in total and Opus 5 about 30. He relays a TypeSafe test with 182 skills where Jev “cut the wrong picks by more than half.”

Level 2: business automations at volume. His side-by-side demo classifies 100 emails as warm lead, cold lead or not a lead with Jev, Haiku and Fable; Jev finishes in under a second. His examples of the same shape: invoice fraud, spam, community moderation, refund requests and churn classification. His test question: “What are the things that you are receiving in volume that you need to classify?”

Level 3: apps that were not worth building before. Meaning-based image search over his generated-media library, and Kitsy’s Unclutter (already listed below).

Use cases from the 19-item video that add to the list below:

  • Spreadsheet column. Type a column name such as “category” and Jev fills every row. Because it picks only from your list, “it never invents a category that you didn’t ask for.”
  • Inquiry triage with a confidence rule. Tag each customer message (billing, bug, question) and send anything under, for example, 60% confidence to a person; adjust the threshold as you learn. He cites “one independent test” of 217 call transcripts sorted in 13 seconds for 7 cents.
  • Competitor ad tagging. A plugin or Chrome extension saves Meta Ad Library ads and Jev tags format, call to action and funnel stage into a database. Jay: 54 ads from three brands in about 1.5 seconds for under a cent.
  • Clip finder. 411 candidate clips from a 70-minute interview scored in 6.5 seconds, with the top 10 picked.
  • Customer health groups for a SaaS database: healthy, needs attention, at risk of churn.
  • Internal links for a website or a second-brain folder of notes: 60 test blog posts linked in 2.5 seconds.
  • Buyers in comments. Scrape TikTok comments with Apify (captioned “Appify”) and tag each as ready to buy, question or complaint.
  • Validation set first. Run Jev on a few dozen to a few hundred items whose answers you already know, without showing it the answers, count matches and study the misses.
  • Image search needs words. Jay logs the generation prompt for every image as its metadata. Without that, caption images with a small cheap model; he names Gemini Flash Lite. The per-1,000-image cost is garbled in the captions.
  • Live sentence sorting. Classify each sentence of a meeting or sales call as decision, action item, risk or question as it is spoken. Someone built a debate “Jev meter” on the same idea.
  • A narrow chatbot with no LLM calls. Jev picks which of his pre-transcribed lessons answers a viewer’s question. Works for a fixed set of documents.
  • Icon and component picking. A habit tracker picks the water icon for “drink more water”; a demo assembles a page per visitor from ready-made forms, buttons and fonts at normal page-load speed.
  • Find your own Jev steps. shipwithjev.com (captioned “shipwithjv.com”) lists use cases by category; give it to Claude with a file about your business and ask which fit. Or ask Claude to review your past sessions for steps where “a quick Jev call would have done the job.”

OpenAI’s answer. Jay describes OpenAI’s Decisions API as picking from a list of allowed answers “in about 150 milliseconds” (see the DevDay note above).

Ben AI field notes (2026-09): five business classifications from Claude

Creator: Ben AI · URL: https://www.youtube.com/watch?v=L2K__oshGds · Duration: 10:37 · Platform: YouTube · Uploaded: 2026-09-23. Every figure below is from Ben’s own runs; none was reproduced here. The captions spell the model “Jeff” and the site “typeset.ai”; both are normalised to Jev and typesafe.ai. The video pitches his paid AI Accelerator, which is left out.

His setup, for non-developers. Sign in free at typesafe.ai, create an API key (new accounts get $5 of credit, matching Berman above), and give Claude both the key and the link to Jev’s documentation page so it knows how to call it. Then describe the task and say which buckets to use. His standing instruction: “Do not use a normal LLM for sorting. Use Jev only.” Claude picks the output type for you.

JobVolumeTimeCostOutput
YouTube comments into 5 buckets (positive, negative, constructive feedback, unanswered question, answered question)A year of commentsNot given in the captionsNot given in the captionsCSV and dashboard
Same comment job on Opus 5, for comparison1,400 comments (it skipped some)34 min$23Same
Lead scoring: is this person a decision-maker, and are they US-based?250 leads4 s1 centScored Excel sheet
Churn risk 1 to 10 from activity data (days since joining, posts, last login, comments, meetings joined)203 new members from the last month25 s1 centColour-coded Google Sheet
Community posts into buckets (community feedback, technical question, sales question, business question, intro or win) for routing to a person1,300+ posts from a year106 s4 centsDashboard
Customer-support calls into 6 buckets227 call transcripts13 s7 centsDashboard
  • Package the repeatable ones as skills. After the lead run he asked Claude to “create a skill out of this process including the Jev classification step”, which produced a “score leads with Jev” skill. For churn he had Claude build a skill plus a scheduled task that reruns it every two weeks. See Claude Code Scheduled Tasks.
  • Jev first, Claude on the survivors. Score a large lead list with Jev, then have Claude research or write outreach only for the leads Jev marked qualified. This is the “LLM plus Jev” pairing the sources above describe.
  • Browser agent. In the Claude Code tab he had Claude build a YouTube-feed scanner on an open-source browser-use repo with Jev built in (captioned “Jeff ultra fast”; it is free on GitHub and, he says, needs Claude Code). It scrolled his feed for 5 minutes, judged 443 videos as “about Claude or not”, saved 99 with title, channel, link and probability to a Google Sheet, for 1 cent. The lowest-probability entry (a score of 55) was a false positive, which he takes as evidence that the probability is meaningful. The 7-second Zurich-to-London flight booking he shows is the same demo listed under Browser use below.
  • Reliability claim. Ben says Jev is “almost similar to Opus” and “better than Sonnet” on these classification jobs. He shows no labelled comparison, so treat it like the other unverified accuracy claims in Vendor Claims vs Evidence.
  • Likely the “independent test” Jay cites. Jay’s 19-use-case video (2026-10-04) cites “one independent test” of 217 call transcripts in 13 seconds for 7 cents. Ben’s run (227 transcripts, 13 s, 7 cents, published 11 days earlier) is probably that test, with one of the two counts misheard in captions.

Simon Scrapes walkthroughs (2026-09 to 2026-10)

Full write-up: Pairing Jev with Claude Code (Simon Scrapes), from raw/Jev_+_Claude_=_INSANE_Results_Every_Concept_Explained.md (2026-09-23) and raw/You_Should_Be_Using_Jev_s_Browser_Agent_Here_s_Why.md (2026-10-08).

  • Question design first. His five-step checklist: list the actions, write each trigger as a sentence (it becomes the question and fixes the type), name the state, add edge cases that change routing, and set each threshold by the cost of a wrong answer.
  • Support triage. 50 emails, five questions each in one request, routed to Claude drafts, engineering, a feature log or a person, plus a second Jev pass on Claude’s drafts: 4.2 seconds and $0.0026 by his run.
  • Browser agent mechanics. Numbered page elements and two choice questions per step (action and element) behind a 0.7 confidence gate, with Claude handling low confidence, “blocked”, text entry and an independent “done” check. Four traps: cookie banners, iframes and uploads, false “done”, and a five-action memory.

Use cases people reported

Numbers are as the named users reported them, relayed by the creators listed. None was independently reproduced here. Several names are caption spellings.

Bulk analysis of what you already have

  • Engineering-effort split (Claire Vo).
    • Method: pairwise “are these two PRs related?” calls cluster the PRs, then Gemini Flash Lite names the clusters.
    • Marketing site: 112 PRs for 1.1 cents.
    • ChatPRD: 1,700 PRs and 17,000 pairs for 9 cents in about 2 minutes. “Almost 30%” of PRs were platform, security and infrastructure.
  • Her local Claude Code and Codex session logs (Claire Vo). In January almost all her tasks were engineering; by September it was under 40%.
  • Product-insights graph (Claire Vo). About 1,100 signals (PRs, support tickets, Granola notes, Linear tickets) went through “over like 200,000 classification and pair-wise groupings” for about $4 of Jev. Astra did the analysis and Sol/Luna the generation.
  • Ad archive (Matthew Berman, per NLW). 724 live ads from 37 brands × 12 questions (hook, format, offer, CTA…) took 40 seconds and 9 cents.
    • He then ran 723 ads past 30 buyer archetypes: 21,690 stop-or-scroll decisions for 22 cents.
    • NLW’s caution: “this is not data” — treat it as a hypothesis generator before paying for real tests.
  • Post archive (Ian Nuttall, per NLW). Eight questions (topic, hook, tone…) about roughly 3,300 past X posts, to compare with engagement. The cost is garbled in the captions.
  • Inbox and messages.
    • Ryan Vogel: 1,700 emails scored on category, priority, spam and reply-worthiness. 4.2M input and 500K output tokens cost 18 cents in total, which matches free output
    • “Zach” (per Nate B Jones): 20,000 emails, Slack messages and transcripts in 7 minutes for about $1.
  • Tax documents (Nakshatra Saxena, per Nate B Jones). Swapping an LLM pipeline to Jev cost 34× less and ran 6× faster.
  • Research triage (Derya Unutmaz, per Nate B Jones). Picked the top 100 of 10,000 literature-grounded immunology questions.

Search and filter by meaning

  • SEO internal-link map (Boura, per NLW).
    • Jev read all 586 site pages (8,790 yes/no calls) in 45.1 seconds; its cost is garbled in the captions.
    • Claude Opus 5 got through 21 pages for $1.43.
    • Boura’s framing: internal linking “is a classification problem and we’ve been paying frontier prices to do it one page at a time.”
  • Brand news filter (Elvis, per NLW). Checked 384 morning news stories against 15 brands in 24.9 seconds; Opus 5 got through four stories in the same time.
  • Property search (Justine Moore, a16z, per NLW). Classified Zillow listings by things you can’t normally filter on: architectural style, renovation state, closeness to freeways.
  • Video clipping.
    • Clips from a 90-plus-minute video in under 2 seconds (Clipfast, per Berman; Burhan, per NLW, “under two cents”).
    • Ryan Vogel’s clip finder scored 17 moments in about 3 seconds.
  • Audience comments (Claire Vo).
    • About 4,500 YouTube comments via YouTube Data API v3, scored for sentiment and “contains an episode idea” (58 did), with a dashboard and live search.
    • She notes the speed needed architecture: “you have to like batch the results and then score them and then push the high scores up.”
  • Slop and ad blocking.
    • Kitsy’s Unclutter ad-and-slop blocker; bring your own key; open source per Berman.
    • A slop detector on madewithjev.com rated anthropic.com “26% AI slop” (Berman).
    • Robin Billgill’s real-time X slop filter (NLW).
  • Fuzzy find-in-page (Berman). A Google product manager’s open-source tool finds what you mean rather than the exact keyword.

Triage and routing

  • Email priority (Jonathan Unikowski, per NLW and Matt Wolfe). 100 emails rated in 453 ms for about a tenth of a cent; he reports Jev’s ratings matched his own on every one.
  • Downloads folder (Marcel Pio, CTO of Beyond Code, per NLW). Detects invoices, renames them and moves them, “no other LLM calls involved.”
  • Malicious links (Steven Tey, Dub, per NLW). Fed Jev 10,000 known-bad domains to flag links on the free shortener. “With Jev, we solved it in 2 hours.”
  • Moderation and routing.
    • Dev Ed moderates live chat (NLW; Matt Wolfe).
    • Box has tried incident triage for customer impact, severity and escalation route (NLW).
    • A CRM vendor proposed scoring every new lead on priority, buying readiness and spam (NLW).
  • Gmail cleanup (Claire Vo). Scored each email’s deletability from subject line and snippet, then handed the kept clusters to an agent.
  • Inbound leads for a small agency. Ryan Vogel’s girlfriend scores contact-form enquiries “is good lead” from 0 to 1.
  • No-code (Berman). A Zapier Zap where Jev accepts or declines calendar invites against your criteria.

Checking work against rules

  • Every’s planted-mistake test (per NLW).
    • Mistakes were planted in 12 passages. Jev caught six of seven in 0.35 s; Fable 5.1 caught all seven in 8.83 s.
    • Jev was “about 580 times cheaper,” and roughly 25× faster by those timings
  • Mike Taylor’s AI-tell check (Every, per NLW). 37 documents × 21 questions returned 777 judgments in under 0.7 s for “an estimated quarter of a cent.”

Speeding up agents and cutting tokens

  • Model and effort routing.
    • Riley Brown’s prompt-to-model router (Berman).
    • Vchen (per NLW) had Jev change GPT-6’s reasoning effort inside Codex mid-task, reporting “50% lower Astra costs” and faster runs.
  • Skill selection (Daniel Son, per NLW). Jev picks the one Claude Code skill that matches each request and injects only that skill: an “88% decrease in tokens and cost.”
  • A harness that learns (AJ Aspher, per NLW). Repetitive steps move from LLM calls to code as the harness runs. Cost per compliance alert fell from about $2.95 at the start (the end figure is garbled in the captions), and they claim the harness “cuts the cost of repetitive work by 90%.”
  • A cheaper tagger (AI For Humans). Gavin swapped Claude Haiku for Jev to tag link-blog posts on the AI For Humans site; his Claude did the swap. Result: “faster, better, and cheaper.”

Real-time and interface

  • Games (TypeSafe post; Berman; MattVidPro).
    • Doom at 10 queries a second, which TypeSafe prices at about $7 an hour.
    • Wikiracing: five hops in half a second, where the other models took 4–5 s.
    • Also “Melee” in real time (Alex from Berman’s team) and a simulated self-driving car (Justin Schroeder).
  • Crowd simulation (Berman). 50 town NPCs each chose a reaction in 0.6 s.
  • Browser use (Ryan Vogel; Nate B Jones). In Browser Use’s agent, Jev picks an operation and an element. It picked a Zurich→London flight in 7.1 s.
  • Voice computer use (Jack Chang, per MattVidPro). “Put that there” shape editing at conversational speed.
  • Voice mood app (Claire Vo). OpenAI Realtime voice feeds Jev, which scores a list of hex colours for the speaker’s mood and filters a quotes API.
  • Spreadsheet column (per Nate B Jones). Type “urgency” as a column header and Jev classifies every row.
  • Smart forms and paste. Copy a résumé and the application fields fill themselves (Marcus Low and Norman, per NLW). Match a service request to the best local provider for an instant quote (Ryan Vogel’s startup idea).

AI Master field test (October 2026): playground, a 10-ticket check and a confidence gate

Source: raw/Ultimate_Jev_Tutorial_-_How_to_Set_Up_Use_Jev_AI_for_Beginners.md. Small hand-run tests in TypeSafe’s playground; the creator says himself that 10 tickets “is nowhere near a benchmark.” Sponsors: Bitrix24 (a clinic front-office workflow segment unrelated to Jev) and the creator’s AI Master platform.

The playground. The left field is state (whatever Jev should look at). Each question gets one of three primitives:

  • noul (“spelled n o u l”): one number from 0 to 1, how likely a statement is true. This spelling fits NLW’s “Bernoulli” reading. It returns no separate confidence.
  • score: a scale you define (he used 0 to 3, “it can wait” to “answer right now”). It returns the level, a probability per level and a confidence.
  • choice: up to 255 options, with a probability per option and a confidence.

The playground has an automation threshold (default left at 90%) and flags answers for human review.

One review, three questions, 426 ms. On “My order arrived 5 days late, but support refunded me quickly”:

  • satisfied: 54%;
  • urgency: 0.13 of 3, “can wait” at 82% confidence;
  • topic: delivery 75%, support 25%, with a topic confidence of 67.

Confidence is separate from probability: the delivery/support split “makes the whole answer less certain.”

10 tickets against ChatGPT with structured output. The tickets: 3 obvious, 4 everyday and 3 ambiguous, hand-labelled for department, urgency (0 to 3) and refund (yes/no).

  • Jev: about 420 ms per request.
  • ChatGPT: about 10 s per answer. It matched his labels on all 10 and never broke the format.
  • That works out to roughly 24x faster: above the independent median and far below TypeSafe’s top figure. He cites Open Chamber’s roundup of launch posts for a median speed-up of about 7x, and notes TypeSafe itself calls its 193x the upper end of what it measured, not a typical result. Its homepage demo shows 0.114 s against 8.566 s.
  • He admits his department card was set up as yes/no rather than a four-way choice on the first ticket.

Confidence gate (5 tickets, 0.9 on both questions).

  • Three clear tickets got the department at 100% confidence (billing, technical, sales), but urgency confidence was only 73%, 61% and 39%, so none cleared the gate.
  • A mixed login-plus-unknown-charge ticket: technical 29%, billing 32%, other 21%, flagged for review; urgency “very urgent” at 98%.
  • A sarcastic complaint: technical at 80% with a confidence of 73.
  • Result: 0 of 5 cleared. His fix: set thresholds per question, or gate only on department.

TypeSafe’s stated weak spots, tested. TypeSafe says Jev 1.13 is shaky on counting, arithmetic and dates.

  • Which of two emails arrived first: correct, 100%, 559 ms.
  • Count of “refund” in a ticket: correct (four) but at 58% with a confidence of 47, so it was flagged.
  • Receipt total from four options: correct ($79.24), 100%.
  • A sarcastic “absolutely thrilled” complaint: satisfied at 4%, so the sarcasm was read correctly.
  • His rule: dates, counts and totals go to regular code; Jev gets only the questions about meaning. “A valid answer still isn’t the same as a correct one.”

Dispatcher and writer. Jev answers two questions per ticket: a choice (department, which picks the template) and a noul (does this need a custom reply?). Only “complex” tickets go to the LLM.

  • On three test tickets, the messy one scored 88. The two simple ones scored 55 and 46, close to a coin flip, so under his rule all three went to the LLM and the gate saved nothing.
  • His fix is literal wording, which TypeSafe recommends: “this ticket can be answered with a standard template” instead of “needs a custom written reply from a person.”
  • Being wrong toward the LLM costs one extra call; being wrong the other way sends a template to an angry customer.
  • The same shape works elsewhere: a cheap model drafts, Jev checks the rules, and only doubtful items go to a bigger model or a person.

Access, as of this video.

  • Early access opened September 15 behind a waitlist, and TypeSafe dropped the waitlist “within a week”. Anyone can sign up at typesafe.ai. The console has the playground, API keys and docs.
  • Also available through Vercel AI Gateway, Cloudflare Workers AI and Netlify’s AI Gateway. OpenRouter listed it in beta on September 18.
  • In code it is one POST request with the model, the state and your questions. SDKs exist for JavaScript and Python.
  • Pin the version. The jev-latest alias moves whenever a new version ships, so pin the exact version for reproducible results.
  • Suggested fits: support routing, résumé screening, moderation (low confidence sends a post to a person instead of deleting it), email sorting, and replacing label-only LLM steps in n8n or Make via HTTP.

Sharbel field notes (2026-09-27): ten uses and a bouncer test

Source: raw/10_INSANE_Jev_Use_Cases._It_s_Not_What_They_Told_You..md (Sharbel, YouTube @sharbelxyz, https://www.youtube.com/watch?v=IBONLMfA3Cw, 14:49, uploaded 2026-09-27). No sponsor named. Captions alternate “Jeff” and “Jev”. His numbers come from his own demos and are unverified.

  • His framing: a “smart if statement” that returns yes/no, a pick from a list, or a score, each with a confidence number. “It can’t write, it can’t code, it can’t hold a conversation”; he beat it at checkers.
  • Inbox sort: receipt, brand deal or scam across his inbox in 4 seconds, about 69 emails a second, for $0.007.
  • Feed filter: an open-source browser plugin tags posts on X, Reddit and LinkedIn as they load (“likely human”, AI slop) and can hide or show only one class.
  • Lead scoring with template routing: score fit 0-3 and lead type, then pick reply template A to D, or no reply for spam, in about 300 ms.
  • Also shown: a flight booker that picks each click (about 7 seconds; the same Browser Use demo recorded above), a text box that morphs into a date picker or colour swatch as you type, search-bar reranking without a vector database, competitor ad breakdowns (offer, angle, hook, funnel stage), applicant scoring that cites the points behind each score, and a front-door router (cheap jobs to automation, questions to a thinking model, important items to him).
  • Bouncer test. In a daily AI-news research automation, Jev screened 173 sources and passed 33 to Claude. Claude alone used 29,000 tokens; with Jev in front, 6,000 (he calls it 78% fewer).
  • What not to do. He calls the most-liked Jev demo online, using Jev to compact Claude’s memory, “one of the worst things you can do with Jev” because it lacks the reasoning and context. Same for judging another AI’s answers or writing text a letter at a time.

A check that runs when you stop typing (How I AI, November 2026)

Source: raw/The_AI_chief_of_staff_that_this_Figma_PM_uses_all_day.md. A prototype by Ezra McCabe, a growth PM at Figma, shown live but blocked partway because the API now sits behind Figma’s firewall. Full episode: Figma’s PM OS and Auto XP.

  • Why Jev. Frontier models on a design canvas feel too slow to act like a co-worker; Jev is cheap and fast enough to call on every pause.
  • What it does. Each time he stops typing, the editor calls Jev to look for blanks (“TK”, brackets) and claims that need support, then searches his library of interviews and offers matching quotes. Typing “we spoke with X writers and they said” pulled interview quotes from the library; a “TK” with nothing relevant in the library came back as an unfinished thought it could not fill.
  • What he found surprising: that Jev also handles retrieval, linking a block of text to a related section “in real time”.
  • His worry: candidates in product-sense interviews running the same kind of helper against notes on their own career.

Where It Falls Down

  • Long-horizon goals. In Minecraft on its own it “would consistently predict the same actions over and over again, getting itself in loops.” It is “not so good at long-term goal keeping” (MattVidPro).
  • Open-ended judgment. A Bitcoin buy/hold/sell signal “does not seem to be doing well”: “I would not put this model in front of like your stock portfolio” (Ryan Vogel).
  • Deep reasoning. Fable outplayed it at chess (+16 material by move 29) but ran out of time at 6–15 s per move against Jev’s 2.6 s (Berman).
  • TypeSafe’s own list (per NLW). Accuracy drops with each hop in multi-step questions. It is weak at counting, maths and dates, so extract the facts with Jev and calculate elsewhere. It has consistency and intent-reading issues.
  • High-stakes calls. NLW advises caution on hiring, money and security: Jev “is going to return with a number that doesn’t have any reasoning attached.”
  • No reasoning trace. Nothing comes back but the typed answer (Ryan Vogel).
  • Input limits. Text only, and under 32K tokens of evidence (NLW). Matt Wolfe describes game-playing Jev as looking “at the screen” ^[ambiguous]. That conflicts with TypeSafe’s note that its game demo uses structured text state, and with Claire Vo and MattVidPro saying it can’t take images. Update 2026-11-01: the docs give 64k per request / 32k per question (262k with the long-context header), and image input in beta; see Official Docs Update.
  • The headline speed needs engineering. Real-time search over thousands of items needed batching and ranking (Claire Vo). The TypeSafe post concedes its side-by-side demo used a short, dense input that “paints our model in an advantageous light.”

Vendor Claims vs Evidence

  • Benchmark.
    • TypeSafe’s “workflow evals” score each model against the average answer of GPT-6 Astra and Fable 5.1. The four workflows were built by its own capability team, and the LLMs ran through TypeSafe’s System One LLM wrapper (TypeSafe post).
    • Berman, reading a vendor chart, puts Jev about level with Luna, Terra and Sonnet 5 and above Opus 5 and Sol. That is vendor-run.
  • Hallucination. Berman frames Jev as suitable where “any hallucination is catastrophic” (healthcare, military targeting). TypeSafe’s actual guarantee is about schema matching. The Every test shows wrong answers still happen.
  • Price sustainability. TypeSafe: “We can’t prove it isn’t subsidized,” though it expects prices to fall. Claire Vo’s heavy use ran partly on Vercel’s free period.
  • Accuracy against labelled data. No source publishes it. The closest are Claire Vo (“it is accurate”), Unikowski’s 100 emails matching his own ratings, and Every’s six of seven.

Try It

  1. Find a Jev-shaped step. The Neuron’s test: “if you can write every valid answer on a sticky note, you probably don’t need a giant model composing prose to pick one.” NLW’s four fit criteria:
    • the answers can be written in advance;
    • there is volume (a pile or a stream);
    • a wrong answer is cheap or easy to catch;
    • the evidence fits in under 32K tokens of text.
  2. Get a key. Add credit on Vercel AI Gateway and create an API key (MattVidPro spent under $1 in hours of testing), or join TypeSafe’s early access. Without code, use the Zapier “TypeSafe Jev” action.
  3. Let your agent wire it up. Paste TypeSafe’s setup prompt for agents into Claude Code or Codex, then give it Nate B Jones’s prompt: “use the type safe skill to find a place in the project we’re working on together where asking an LLM to choose among defined outcomes is suboptimal. Build a Jev version instead.” Have it compare results, speed and cost and report back.
  4. Write the questions well (NLW).
    • Ask one judgment per question. “Is this a good lead?” is several: industry fit, company size, intent.
    • Describe every score level in words.
    • Ask many questions per item in one call; parallel questions add tokens, not time.
  5. Test before you trust it. Label 50 items yourself and compare (NLW). Then set a confidence threshold: act automatically above it, and send lower-confidence items to a frontier model or a person (Two Minute Papers; TypeSafe post on calibration).
  6. Marketing starters:
    • Turn each style-guide rule or banned phrase into a yes/no question and run it on every paragraph of a draft (NLW).
    • Score an ad or post archive on hook, format and offer, then join the results to performance data (Berman and Nuttall, per NLW).
    • Cluster your last few hundred PRs or support tickets pairwise and have a cheap generator name the clusters (Claire Vo).

Implementation

Tool/Service: Jev, TypeSafe AI’s first System One Model. Setup:

  • API key via Vercel AI Gateway, or TypeSafe early access plus its agent setup prompt, which installs a TypeSafe skill.
  • Docs: “primitives” and “cookbooks” pages. There is also a playground (Matt Wolfe).
  • Zapier action for no-code flows.

Cost: 5 of credit (Berman). Integration notes:

  • Define the question and every allowed answer up front; the response is typed (choice key, score, probability) and needs no parsing (Ryan Vogel).
  • Text in only.
  • More than 255 options needs two stages: score, then choose (TypeSafe post).
  • Batch items and questions for throughput (Claire Vo; NLW).
  • Pair it with a generative model for anything that must be written or reasoned.

Open Questions

  • No paper and no independent accuracy study. Are RLCD’s calibration claims reproducible on your own labelled data?
  • Data retention and terms. None of the sources saved here covers them; check before sending customer data.
  • Price after the free and subsidised period. Rate limits, and whether the sign-up pause Matt Wolfe reported has ended. (Jay reported on 2026-09-21 that TypeSafe had removed the waitlist that day; AI Master (2026-10-30) also says the waitlist was dropped within a week of the September 15 opening. Two creators agree; still not confirmed against a TypeSafe post.)
  • Launch date. Sep 14 (post dateline) or Sep 15 (Nate B Jones; AI Master also gives September 15 for early access). ^[inferred: the post may be dated the day before access opened]
  • The yes/no type’s exact name. Captions give “new” and “null”; NLW ties it to “Bernoulli.” AI Master spells it aloud as “n o u l” (2026-10-30), which fits “Bernoulli.” Still to confirm in TypeSafe’s primitives docs.
  • OpenRouter availability. Resolved 2026-10-27: Jev is on OpenRouter (see Pricing, Speed and Access).
  • Jev against OpenAI’s Decisions API. Vo plans a head-to-head; no result yet. The Decisions API has vision, which Jev lacked at the time. As of 2026-11-01 Jev has image input and Box questions in beta (see Official Docs Update).
  • The reported 10B or more. Relayed from The Information via NLW and The Neuron; not confirmed by TypeSafe.
  • The founder’s co-invention claim. It rests on his own statements. Ben AI repeats it (“one of the co-inventors of ChatGPT”) without a source.
  • Ben AI’s Jev-powered browser repo. The captions give “Jeff ultra fast”; the repo’s real name, owner and licence were not checked. Ben’s Jev time and cost for the 1,400-comment job were shown on screen, not spoken.