Jev Browser Agent

01 / LIVE DEMO

One browser decision cycle

This is a decision-layer demonstration, not a live browser. The page state below is a simulated observation. One click sends one shared state and three typed questions to the real typesafe-ai/jev model.

02 / THE LOOP

Decisions sit inside a deterministic loop

Jev is one step in a cycle. The browser harness owns everything around it — observing the page, building the action space, and performing the side effect.

1. 01
   Goal

   A natural-language instruction.

2. 02
   Observe

   Browser code reads the current page.

3. 03
   Index actions

   Controls become a bounded action space.

4. 04
   Jev decides

   One request returns operation, target, sensitivity.

5. 05
   Validate

   Code checks freshness and policy.

6. 06
   Execute

   Deterministic code performs one action.

7. 07
   Observe again

   The loop repeats from the new page.

03 / WHAT JEV DECIDES

Three bounded judgments in one request

Each answer is a typed decision with probabilities, never free text. The operation and the possible target are asked together so the application can consume only the answer that applies.

04 / WHAT JEV DOES NOT DO

Jev is the decision, not the execution

• Jev does not launch or drive a browser.
• Jev does not emit CSS selectors or coordinates.
• Jev does not generate JavaScript or tool calls.
• Jev does not type free-form text.
• Jev does not prove an action is safe to run.
• Jev does not prove a task has completed.

All of those belong to the browser harness and your application code. Jev narrows the decision to a bounded, validated answer your software can act on.

05 / REAL OPEN-SOURCE PATTERN

The architecture this demo reflects

The Browser Use project ships a browser agent called Jev Ultrafast ↗ (opens in a new tab). It is an independent, open-source project — not created by Jev Playground.

Its loop turns page controls into an indexed action space, has Jev choose an operation and an operation-specific target in one request, uses a separate text model only when text must be generated, and never lets model output become selectors or executable JavaScript. It also treats DONE as a hypothesis that still needs independent outcome verification.

Those engineering choices are specific to that project, not mandatory Jev behavior. Its published Google Flights timing is a small measured demo — a few repeats of one task on one browser profile — not a general browser-agent benchmark.

06 / IMPLEMENTATION

One state, three questions, application owns execution

The example below matches the AI SDK integration used across this site: one structured browser state plus operation, click_target, and sensitive questions in a single experimental_evaluate call.

import { createGateway, experimental_evaluate as evaluate } from "ai";

const gateway = createGateway({ apiKey: process.env.AI_GATEWAY_API_KEY });

const state = [
  "USER GOAL",
  "Open the Browser Use Jev Ultrafast GitHub repository.",
  "",
  "CURRENT PAGE",
  "URL: https://www.example-search.test/search?q=jev+browser+agent",
  'Title: Search results for "jev browser agent"',
  "",
  "OBSERVED ELEMENTS",
  'e1 · textbox · Search = "jev browser agent"',
  "e2 · link · Introducing System One Models and Jev — TypeSafe AI",
  "e3 · link · browser-use/jev-ultrafast — GitHub",
  "e4 · link · Jev on Vercel AI Gateway",
  "e5 · button · Sign in",
].join("\n");

const { answers } = await evaluate({
  model: gateway.evaluationModel("typesafe-ai/jev"),
  state,
  questions: {
    operation: {
      type: "choice",
      instructions: "What operation should the browser agent take next?",
      criteria: {
        CLICK: "Activate an observed link, button, or control.",
        TYPE_TEXT: "Enter or replace text in an editable field.",
        SCROLL_DOWN: "Scroll down to reveal more of the page.",
        SCROLL_UP: "Scroll up toward earlier content.",
        WAIT: "Wait for the page to load or update.",
        DONE: "The user's goal is already satisfied on this page.",
        BLOCKED: "No supported operation can advance the goal.",
      },
    },
    click_target: {
      type: "choice",
      instructions: "If the next operation is CLICK, which element is the best target?",
      criteria: {
        e1: "textbox — Search",
        e2: "link — Introducing System One Models and Jev — TypeSafe AI",
        e3: "link — browser-use/jev-ultrafast — GitHub",
        e4: "link — Jev on Vercel AI Gateway",
        e5: "button — Sign in",
      },
    },
    sensitive: {
      type: "boolean",
      instructions:
        "Does the requested action involve a destructive or sensitive side effect?",
    },
  },
});

// Application code consumes the decision — Jev never executes anything.
const operation = answers.operation.choice;

if (operation === "CLICK") {
  const target = answers.click_target.choice;
  // Re-check page freshness, resolve the observed element, apply policy,
  // then perform the click with your own browser executor.
} else {
  // Handle TYPE_TEXT / SCROLL / WAIT / DONE / BLOCKED in your own code.
}

The application consumes click_target only when operation is CLICK. Every other operation ignores the target head, avoiding an extra round trip while keeping execution logic deterministic.

07 / PRODUCTION GUARDS

What real deployments still need

• Stale page and DOM checksRe-verify freshness before acting; a dynamic page can invalidate a prior observation.
• Only execute offered actionsResolve every target from the observed action space, never from free model text.
• Consume the target for the chosen operationIgnore target heads whose operation was not selected.
• Separate confirmation policyDestructive or sensitive actions get their own deterministic gate, outside the model.
• Deterministic permissionsIrreversible actions use allowlists, not model confidence.
• Independent completion verificationDONE and BLOCKED still need evidence before the run stops.

08 / LIMITATIONS

Be honest about the boundaries

• This page is a decision-layer demo, not a live browser executor.
• The demo uses a simulated, structured page observation.
• Semantic decisions can still be wrong; probabilities are not guarantees.
• A real agent needs browser observation and execution infrastructure.
• Dynamic pages can invalidate prior observations between decisions.
• Free-text typing requires a separate text model or mechanism.