Jev Browser Use: Pick the Right Element in One Pass

A browser-use agent spends most of its budget on small decisions: which element on the page matches the task, whether to click, type, or scroll, and whether the last action actually worked. Jev browser use turns each of those decisions into one typed call instead of a paragraph of generated reasoning. You send the current page as a short list of elements plus the task, and Jev answers with the element to act on and the action to take, each with a probability and a confidence value. The demo below replays that loop on three built-in sample pages, with illustrative answers rather than live Jev calls.

This demo runs entirely in your browser against three built-in sample pages — a sign-in form, a product list, and a search results page. Nothing is scraped from the live web: each page is a self-contained HTML sample loaded into a sandboxed iframe with scripts disabled, so nothing on the page can execute code. Pick a scenario, run it, and the demo highlights the element the sample answer picked, directly on the page.

DOM Element Classification with Jev

Before Jev can act, the calling code turns the page into state: a task string plus a list of elements, each with an id, a role such as button, link, or textbox, and its visible text. Jev never sees a screenshot or the raw DOM tree — it answers from text input only, as TypeSafe documents for System One, which keeps requests small and easy to log. DOM element classification means asking Jev a Choice question over that element list — "which element should the agent act on next?" — with one criterion per element id. Jev returns a probability for every element plus a confidence value for the answer, so a low-confidence pick is a signal to fall back to something slower instead of clicking blindly. In the product-list sample, the state lists five buttons and links, three of which — the "Add to cart" actions — carry a price in their text, and the sample answer picks the one next to the cheapest cable rather than just the first button on the page.

A Fast Action Selector for Each Step

Picking the right element only answers half the step. Jev also needs to decide what to do with it, so the browser-use integration asks a second Choice question — a fast action selector — with three options: click, type, or scroll. In the sign-in sample, the illustrative answer picks the email field as the target and type as the action; on the product list, it picks the cheapest item's button and click. After the action runs, your loop can ask a Noul question to check whether the page changed the way the task expected — did a cart counter update, did a new page load — so it can retry or move on without asking an LLM to describe the difference in words; the demo on this page stops at the element and the action. Because both Choice questions are typed and travel in the same request, picking the element and the action takes one short request-response cycle instead of a chain of prose.

Where System One Jev Fits in a Browser Agent

System One Jev is built for exactly this kind of decision: fast, repeatable, and bounded to a fixed set of options. TypeSafe reports Jev decisions running end to end in 70–500ms, against 3–329 seconds for frontier models on its demo workflows — 40–200x faster, per its System One announcement. That gap is why a browser-use agent should hand routine steps to Jev instead of an LLM. System One Jev is not built for open-ended page understanding, though — summarizing an unfamiliar layout, reading a paragraph of terms, or deciding what a page is even for still needs a model that generates text. Pair Browser Agent with Claude so Jev keeps handling DOM element classification and the action selector on every routine step, while Claude only gets called in for the pages that actually need reading.

Cloud Browser Sessions (Coming with Early Access)

Everything on this page runs locally, in your browser, against built-in sample pages — there is no live browsing yet. A cloud headless session, where Jev drives a real hosted browser against a real URL instead of a sample page, is planned and will open through early access rather than being available today. There is no desktop app and no browser extension to install; a hosted session is the only planned form factor, and it will be called the same way as everything else on this page — over an API request, not a client you download.

Calling It from Code

Every browser-use call to the Jev API starts from the same shape: a state object with the task and the current elements, and a questions map naming a target Choice question, an action Choice question, and optionally a Noul question to confirm the step worked. The Jev Agent endpoint below, /api/v1/systemone, follows the shape of TypeSafe's published examples for its own POST /v1/systemone using the jev-latest model (docs.typesafe.ai/concepts/system-one); compatibility will be confirmed before the endpoint opens with early access.

curl https://jev-agent.org/api/v1/systemone \
  -H "Authorization: Bearer <your Jev Agent key>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": {
      "task": "Add the cheapest USB-C cable to the cart",
      "elements": [
        { "id": "e1", "role": "button", "text": "Add to cart - Braided cable, $12.99" },
        { "id": "e2", "role": "button", "text": "Add to cart - Basic cable, $8.49" }
      ]
    },
    "questions": {
      "target": {
        "type": "choice",
        "instructions": "Which element should the agent act on next?",
        "criteria": { "e1": "button: Braided cable", "e2": "button: Basic cable" }
      },
      "action": {
        "type": "choice",
        "instructions": "What should the agent do with it?",
        "criteria": { "click": "Click the element", "type": "Type into the element", "scroll": "Scroll the page" }
      }
    }
  }'

The response answers target and action the same way every Jev call does: a choice, a probability per option, and a confidence value. Wire this into whatever automation framework already drives your headless browser — Jev only has to answer the "which element, what action" question on each step. See the Browser Agent REST API reference for the full request and response format, or go back to All Jev AI Agent Tools to compare browser use against Jev's other agent integrations.