Jev: fast decisions, flight searches and paper classification

Browser Use’s public demo starts with one request: a one-way economy flight from Zürich to London on September 20 for one adult. Jev chooses the next action and control from a page-element list. Mercury 2.5 writes the city names when needed. The result shows matching flights without selecting or booking one.

The author records 7.073 seconds, timed after the initial homepage observation and including model calls, text entry and page loading. The video, measurements and code show how a decision becomes an on-screen action.

• Watch the author’s flight-search demo ↗Recorded at normal speed, ending at visible results.
• Open the project and running instructions ↗Model roles, source code and reproduction instructions.
• Browser Use license ↗MIT · Copyright 2026 Browser Use.

An incoming email needs to reach support, billing or partnerships before anyone writes a reply. Jev is built for repeated decisions like this. TypeSafe AI released it on September 15, 2026, calling this class of focused decision models System One.

Give it the material, the questions and the allowed answers. It can choose a category, score against defined levels or estimate whether a statement is true. Several questions can be evaluated together. Software uses those answers to continue the workflow; another model can write the reply.

A rule can check whether an attachment exceeds 20 MB. Recognizing a request for a progress update requires interpreting language. Writing a considerate reply requires generating text. These steps make Jev’s role easier to see. The table illustrates a possible division of work.

The vendor’s 193.6× speed and 444.6× cost claims come from its own workflow evaluations, using averaged Astra and Fable predictions as references. These measure particular decision workflows, not every kind of task.

Nexus compared agent checks on the same 469 cases. Jev handled 58%, handing the rest to rules. Including fallback, it made 90 mistakes against Sonnet 5’s 92; latency and cost differed more clearly in this experiment.

1kpapers is a browsable collection of 1,018 papers, organized by research topic, lab and date. On September 17, Hassan reported a Jev experiment using titles, DeepSeek V4 Flash summaries and 24 topic options: $0.08 for classification and 256 ms median latency per paper.

Summarizing and classifying are separate jobs: the existing 1,000-paper summary experiment cost $3.99 in DeepSeek inference. The public classification code read on September 20 still uses its earlier model pipeline. This pairs the existing atlas with a new experiment; it does not establish that its live labels have all switched to Jev.

• Explore the paper atlas ↗Choose a familiar topic and see how summaries support browsing.
• Read the author’s Jev classification report ↗Classification cost and latency are author-reported.

Pricing checked separately on October 4, 2026. Vercel’s promotion ended September 25. At that check, AI Gateway listed TypeSafe AI and DigitalOcean from $0.04 per million input tokens, neither eligible for Free AI Gateway Credit. No output rate was displayed; a blank is not a free-price claim. Gateway credentials, account availability and platform billing apply.

TypeSafe’s direct API is a separate route. The October 4 check listed Jev 1.13 at $0.042 per million input tokens, with output tokens free. Its account and playground are separate from Vercel’s billing terms. The new chapter below covers the October 16 version and context update.

Jev currently reads text, so images or audio need preprocessing. The documentation says English performs best; try representative samples for Chinese email or document classification. Model-call pricing does not include summarization, app operation or other models in the workflow.

• Open the TypeSafe console ↗Official account and playground access.
• Check current Vercel pricing ↗Rates and free-credit eligibility · checked October 4.

• October 9 follow-up: new price, shorter window and Omni →

Jev makes a decision for software to act on. On October 1, Cloudflare introduced Clef and Clef-flash for the same division of work: provide context, questions and allowed answers, then receive option probabilities. These are Cloudflare products; a bounded answer can still be wrong.

The official example reports checkout failing for every customer for an hour. Questions ask about urgency, the responsible team and severity. Software can use the probabilities to route, escalate or request human review. The model does not repair checkout or write the response; the application must connect those next steps.

Cloudflare reports an internal domain-classification workflow using Browser Run to fetch, render and classify a website: 2.2 seconds with Clef versus 4.7 with gpt-oss-120b. This vendor-reported task includes webpage handling. Its timing cannot be compared directly with Jev's flight search or agent checks, or treated as a fixed wait for every website.

Workers AI documentation checked on October 2 lists Clef at 27B and Clef-flash at 9B, priced at $0.24 and $0.09 per million input tokens. Developer-account access and open weights are available. In a real workflow, assess errors, human handoffs and the costs of webpage handling and subsequent models together.

• See the checkout-failure decision example ↗

If you use GPT, Opus, Grok or another assistant for writing, coding or organizing material, start with the two builds above: writing a city name and choosing a control are separate steps, as are summarizing a paper and assigning a topic. Jev suggests another way to divide a workflow; a new model need not mean a new chat subscription.

The Blender work in our Astra topic shows descriptions becoming editable scenes. Jev adds a useful question: which steps create something new, and which choose among existing options? This is our interpretation of the examples; an actual combination depends on the application’s integrations.

• Continue to Astra’s editable 3D work →Explore model roles from the creation side.
• See the official smart-home example ↗Identify devices and actions, then let software execute.

• Watch the default recorded Pac-Man game ↗Original external work; the default is recorded. Live watching or Play modes have separate account and shared-credit conditions.

At a maze junction, the page shows direction probabilities and Pac-Man continues along the selected route. Opper's Jevman makes repeated small decisions visible. The default view is a recorded Jev 1.13 game, with an expandable decision log. Our visit watched that recording reach 3870. Its source is dated October 6 and matches the previous evening's file when checked October 11. Watching a route before examining repeated-game results connects probabilities to actions.

Software supplies JSON containing the maze grid, character positions and directions, ghost states, pellets and fruit. It also computes legal routes, distances and danger clues, then presents allowed options. The model chooses a direction; software acts, updates the state and asks again at the next junction. It can also ask whether to turn back mid-corridor. The display makes the process visible, while the decisions use structured state.

The loop must handle waiting and a changing environment. In the benchmark, a request without a usable answer within two seconds of sending, a failed call or an invalid answer hands the move to a simple rule. Changes such as a moved fruit can also invalidate old decisions. Backup rates count decisions, not games. Scores reflect model choices, latency and fallback rules together. A fast answer reduces waiting; the chosen route still shapes pellets eaten and ghosts avoided.

The author's published results retain eight models, each playing 100 games with the same classic maze, scripted ghosts, three lives and a five-minute cap; community submissions are separate. They share an input format, but choices and waiting change later states. No paired random-seed procedure is documented. The table selects three models. The ± values are about twice the mean's standard error. Within those eight author-run results, the combined-error rule places these three in the joint leading group. Mean scores alone do not establish a winner.

Timing and cost have separate scopes. Mean latency covers successful replies, including the upstream network and response read; warm-up, timeouts and full-game duration are not folded into it. Per-game cost is recorded call spending, not a complete application bill or today's provider token rate. These are Opper's tests. BitShovel did not run the eight 100-game groups; the original board retains all models and methodology.

This continues the flight-search and bounded-choice examples: software organizes the environment, the model selects a next step and software executes it. The game repeats that division more densely and shows feedback after decisions. Luna uses the Decisions API, which currently supports only gpt-6-luna; Opper adapts it to the System One shape. Its moves and costs here have a separate scope from regular Luna chat, coding or the text Intelligence Index.

• Inspect the complete author results and scope ↗
• Read the project, inputs and running method ↗
• Revisit model roles in the flight search →
• Continue with Clef's hosted window and pricing →

The previous chapter used a checkout-failure message to explain urgency, team and severity decisions. Clef-flash was $0.09 per million input tokens when checked October 2. On October 9, Cloudflare cut it to $0.038 while reducing the hosted window from the previously advertised 64k to 24k. Short-message classification gains a cheaper option; longer material needs another fit check. The table quotes Cloudflare-hosted Workers AI rates, with no separate regional price table. Other gateways have their own billing conditions.

The window includes the material, questions and media. Documentation checked October 10 gives Flash 24,576 tokens. Images become input tokens; Omni also converts audio and video by duration. All use the model's input rate, with no output-token charge. A request fails if media and questions alone exceed the window; otherwise text state may be truncated. For a batch of emails, compare the rate alongside which material actually reaches the decision.

This changes hosted service conditions. Cloudflare says Flash's published weights are unchanged and support a 256k window when self-hosted. That does not preserve the hosted allowance or establish that every device can carry it. Current hosted limits are 65,536 for Clef and 64,000 for Omni. Match material length, deployment resources and price separately rather than turning weights capability, service limits and device performance into one promise.

Clef-omni adds sound to bounded decisions. Its documentation accepts text, JSON, images, audio or video and still returns probabilities over allowed options. Cloudflare reports scoring one 21-second video with sound in about 1.5 seconds. That is a vendor-reported timing example, not our reproduction or a verified continuous-video agent. It suggests another division of work: answer a defined question about an existing recording or clip, then let software act. Correctness and human handoffs still need representative samples.

• Revisit bounded decisions for a checkout message →
• Check Flash's current window and billing ↗
• Read Omni input and media billing conditions ↗

TypeSafe dates Jev 1.14’s availability to October 14, but the stable jev-latest alias still points to 1.13; jev-preview selects 1.14. An existing program has not necessarily switched. Responses identify the actual version. If classification thresholds were tuned for an earlier release, pin that version and compare the same material before changing.

Both versions have two default limits: the state plus all questions must fit 64k tokens per request, while the state plus any one question must fit 32k. There is no separate question-count limit. For an email and handling rules, questions about a refund request and the responsible team share that material; 64k is not a separate allowance for every question.

Both versions offer an optional Long Context header that raises both limits to 262k, at the same input-token rate. TypeSafe warns that this longer mode is slower and less accurate than staying within the defaults. That describes a mode trade-off, not a regression from 1.13 to 1.14; the capacity alone does not establish correct understanding of a long document.

Jev still reads text or structured text and returns constrained choices, scores or probabilities. English is its primary training language; Chinese needs its own evaluation. Both versions cost $0.042 per million input tokens through the direct API, with free output. An editorial starting point is a checkable set of messages: compare choices and uncertainty before deciding what software may handle and what needs a person. Calibration does not guarantee an individual answer.

• Open the official console for available access ↗
• Start with material and predefined questions ↗

“The same order was charged twice. Please refund it.” A program might ask whether a refund is requested, which team should receive the message, and how serious the problem is. OpenAI’s documentation checked October 23 marks Decisions generally available, still using gpt-6-luna. It accepts text, images and structured evidence. This fictional email illustrates the work; no API result is claimed.

A predicate estimates whether a condition holds; choice selects a supplied category; score averages ordered level indices using their probabilities. With levels 0, 1 and 2, the score may fall between levels. It is neither an accuracy rate nor permission to refund a payment. The application still executes any action.

The formal reference permits one question to return a refusal while others receive answers. A refusal should not become “no” or zero. Choice and score also have confidence and option probabilities, separate from the level score. For this email, recognizing a refund request neither verifies duplicate charges nor establishes refund eligibility.

Thresholds need evidence from the actual workload. Our suggested comparison starts with labeled Chinese messages, including wrong routes, missed urgent cases and human handoffs. Count coverage and errors; an improper refund and an extra review have different costs. Jev’s current docs still favor English, with latest on 1.13 and preview on 1.14. Fix versions, input, questions and handoff rules before comparing it with Luna.

Current Decisions pricing is $0.10 per million uncached input tokens, with no output charge; cache reads are discounted and writes charged. The beta’s no-cache-charge description is outdated. Jev’s direct API remains $0.042 per million input tokens, with free output. Whole-task cost also depends on input length, retries, refusals and handoffs.

The earlier 100-game Jevman run remains the author’s experiment with its original interface and adapter. GA does not turn it into a new-version test. OpenAI’s roughly 10× speed statement is a vendor claim; no timed comparison or paid call was run here. Another formal decision interface is available, while its practical value still depends on the workload and handoffs.

• Read the formal Decisions guide ↗
• Revisit the original 100-game comparison and conditions →
• Check Jev versions and context limits →