Jev Ultrafast: TypeSafe Browser Agents That Fly at 7.1 Seconds — browser-use 2026

Introduction

Seven seconds. That’s how long it takes Jev Ultrafast to search flights on Google Flights, fill in departure and destination cities, select dates, and return results. Not a mocked response. Not a recorded script. A real browser, real page interactions, real text generation.

The previous record for autonomous browser agents was measured in minutes. Jev Ultrafast, built by the browser-use team using TypeSafe’s decision engine, shatters that barrier.

This isn’t about speed for its own sake. It’s about proving that structured decision-making—picking an operation, then picking an element—creates exponentially better results than free-form text generation. Every character typed by a browser agent is a token cost. Every unnecessary click is a latency penalty. Jev Ultrafast minimizes both.

Let’s explore how it works, why the TypeSafe approach differs from conventional agents, and whether 7.1 seconds scales to real-world workflows.

What Is Jev Ultrafast?

Jev Ultrafast is a browser automation agent that combines two key innovations:

1. TypeSafe’s Jev decision engine — A structured decision model that separates operation selection from target selection
2. Dynamic indexed action spaces — Element tables generated from each observation, with operations restricted to compatible targets

The architecture follows a simple loop: observe the page, generate an element table, select an operation and target, execute, repeat until the goal is complete.

┌─────────────────────────────────────────────────────────────┐
│                    Jev Ultrafast Loop                       │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Page State ──→ Element Table ──→ Operation Selection       │
│      ↑                                       │             │
│      │                              Target Selection         │
│      │                                       │             │
│      └─────────────── Execution ──────────────┘             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Key insight: The agent doesn’t generate HTML or CSS selectors. It operates on observed elements with indices. This eliminates a whole class of failures where agents construct invalid selectors from partial page state.

# The element table after observing Google Flights
element_table = [
    {"index": 1, "tag": "button", "text": "Round trip"},
    {"index": 2, "tag": "combobox", "text": "From:", "value": "San Francisco"},
    {"index": 3, "tag": "combobox", "text": "To:", "value": ""},
    {"index": 4, "tag": "textbox", "text": "Departure", "value": ""},
    {"index": 5, "tag": "textbox", "text": "Return", "value": ""},
    {"index": 6, "tag": "button", "text": "Search"},
]

# Jev selects: (operation=TYPE_TEXT, target_index=3)
# Followed by: (operation=TYPE_TEXT, target_index=4) with value="London"

The operation set is fixed and minimal:

Only TYPE_TEXT requires a small LLM call. All other operations are deterministic based on the element table. This design reduces token costs by approximately 70% compared to free-form browser agents.

How Jev Ultrafast Works

Step 1: Page Observation

The agent captures the current page state and generates an element table. Each element receives a stable index that persists across operations.

from jev_ultrafast import BrowserAgent

agent = BrowserAgent(model="inception/mercury-2.5")
page = agent.observe("https://flights.google.com")

# Returns:
# {
#   "url": "https://flights.google.com",
#   "elements": [...],
#   "title": "Google Flights"
# }

The element table includes:

• Index (stable identifier)
• Tag type (button, textbox, combobox, etc.)
• Visible text
• Current value (for input elements)
• Position on page

Step 2: Operation Selection

TypeSafe’s Jev evaluates the element table and selects an operation-target pair. This is a single API call with structured output.

decision = agent.decide(
    goal="Find cheapest one-way flight from Zurich to London on Sept 20, 2026",
    element_table=page.elements
)

# Output:
# {
#   "operation": "TYPE_TEXT",
#   "target_index": 2,
#   "value": "Zurich"
# }

Step 3: Execution & Feedback

The agent executes the operation, updates the page state, and loops.

result = agent.execute(decision)

if result.status == "complete":
    print(f"Task completed in {result.elapsed_seconds}s")
elif result.status == "blocked":
    print(f"Blocked: {result.reason}")
    # Agent can recover by trying alternative operations

Why 7.1 Seconds?

Three factors combine to achieve sub-10-second task completion:

1. Single network round-trip per decision — Operation and target selection happen in one TypeSafe API call
2. Minimal text generation — Only TYPE_TEXT operations invoke the LLM; all others are rule-based
3. Optimized browser emulation — Focus emulation prevents background tab throttling; visible text only excludes offscreen content

# Configuration for maximum speed
config = {
    "model": "inception/mercury-2.5",
    "reasoning": False,  # Disable for speed
    "focus_emulation": True,  # Prevent tab throttling
    "visible_text_only": True,  # Reduce context size
}

Installation & Setup

Jev Ultrafast requires Python 3.11+ and a TypeSafe API key.

Quick Start

# Install via uv (recommended)
uv add jev-ultrafast

# Or pip
pip install jev-ultrafast

Configuration

import os
from jev_ultrafast import BrowserAgent

# Set your TypeSafe API key
os.environ["TYPEsafe_API_KEY"] = "your-key-here"

# Initialize agent
agent = BrowserAgent(
    model="inception/mercury-2.5",  # Fast model, no reasoning
    max_steps=20,
    timeout=30
)

Example: Flight Search

goal = "Find one-way flights from Zurich to London on September 20, 2026"

result = agent.run(goal)

print(f"Completed in {result.elapsed_seconds:.1f}s")
print(f"Steps taken: {result.steps}")
print(f"Final URL: {result.final_url}")

# Access results
for item in result.data.get("flights", []):
    print(f"{item['airline']}: ${item['price']}")

Running the Demo

# Clone the repository
git clone https://github.com/browser-use/jev-ultrafast.git
cd jev-ultrafast

# Install dependencies
uv sync

# Run the Google Flights demo
uv run python examples/google_flights.py

The demo shows a real Zurich-to-London search completing in approximately 7.1 seconds, including page loads and text generation.

Integration with Development Workflows

Python Projects

from jev_ultrafast import BrowserAgent

class FlightScraper:
    def __init__(self):
        self.agent = BrowserAgent(model="inception/mercury-2.5")
    
    def search(self, origin: str, destination: str, date: str) -> list:
        goal = f"Find one-way flights from {origin} to {destination} on {date}"
        result = self.agent.run(goal)
        return result.data.get("flights", [])

# Usage
scraper = FlightScraper()
flights = scraper.search("Zurich", "London", "2026-09-20")
for flight in flights[:5]:
    print(f"{flight['price']}: {flight['airline']}")

CI/CD Testing

Jev Ultrafast integrates with test suites for UI automation.

import pytest
from jev_ultrafast import BrowserAgent

@pytest.fixture
def agent():
    return BrowserAgent(model="inception/mercury-2.5")

def test_login_flow(agent):
    result = agent.run("Log in to example.com with user [email protected]")
    assert result.status == "complete"
    assert "dashboard" in result.final_url

MCP Server Integration

For AI agent ecosystems, expose Jev Ultrafast as an MCP tool.

# mcp_server.py
from mcp.server import Server
from jev_ultrafast import BrowserAgent

server = Server("jev-ultrafast")
agent = BrowserAgent()

@server.tool()
async def browser_search(goal: str) -> dict:
    result = await agent.run(goal)
    return {
        "status": result.status,
        "elapsed": result.elapsed_seconds,
        "data": result.data
    }

Benchmarks & Performance

Speed Comparison

Benchmarks measured on equivalent hardware with identical network conditions. All agents completed the same tasks with equal accuracy.

Token Efficiency

The structured action space eliminates the need to regenerate selectors or re-parse page state, dramatically reducing token consumption.

Reliability

The element indexing system prevents selector drift—a common failure mode where agents generate invalid selectors after page updates.

Advanced Usage

Custom Model Configuration

Jev Ultrafast supports multiple backend models through the OpenAI-compatible API.

# Use Gemini for better reasoning (slower)
agent = BrowserAgent(
    model="gemini-2.0-flash",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai"
)

# Use DeepSeek for cost efficiency
agent = BrowserAgent(
    model="deepseek-chat",
    base_url="https://api.deepseek.com/v1"
)

Handling Dynamic Pages

For SPAs with frequent updates, configure observation timing.

agent = BrowserAgent(
    observe_interval=0.5,  # Seconds between observations
    stale_threshold=3,     # Retries before giving up
    retry_strategy="exponential"
)

Parallel Execution

Run multiple agents concurrently for batch tasks.

import asyncio
from jev_ultrafast import BrowserAgent

async def batch_search(tasks: list) -> list:
    agents = [BrowserAgent() for _ in tasks]
    results = await asyncio.gather(
        *[a.run(goal) for a, goal in zip(agents, tasks)]
    )
    return results

# Usage
tasks = [
    "Search flights ZRH to LHR on 2026-09-20",
    "Search flights JFK to LAX on 2026-10-01",
    "Search flights ORD to MIA on 2026-11-15"
]
results = await batch_search(tasks)

Debugging & Observability

# Enable detailed logging
import logging
logging.basicConfig(level=logging.DEBUG)

# Monitor element tables
agent.trace_element_changes = True

# Export session data
agent.export_session("session_20260924.json")

Comparison with Alternatives

Limitations & Honest Assessment

What Jev Ultrafast Doesn’t Do

• It’s not general-purpose automation. The structured action space works best for form-filling, navigation, and data extraction. Complex multi-step workflows may require manual intervention.
• It requires TypeSafe infrastructure. The decision engine depends on TypeSafe’s API. Without it, the agent falls back to slower LLM-based operation selection.
• Cloud availability is limited. The Browser Use Cloud waitlist is open but not yet public. Self-hosting requires your own TypeSafe setup.

Known Limitations

1. Model dependency: Performance varies significantly by backend model. Mercury-2.5 is optimized for speed; Gemini offers better reasoning at higher latency.

2. Page compatibility: Some sites implement anti-bot measures that interfere with element indexing. CAPTCHA challenges are not handled automatically.

3. Single-threaded execution: Each agent instance handles one task at a time. Parallel execution requires multiple instances.

When to Skip Jev Ultrafast

If you need to interact with sites that heavily rely on JavaScript frameworks with dynamic routing (React SPA with hash-based navigation), consider traditional Playwright/Selenium approaches with more robust waiting strategies. Jev Ultrafast excels at structured, goal-oriented tasks—not exploratory browsing.

Frequently Asked Questions

Q1: Is Jev Ultrafast free to use?

The library is MIT-licensed and free. However, it requires a TypeSafe API key for the decision engine. Free tier limits apply; check pricing at typesafe.ai.

Q2: Can I use Jev Ultrafast without TypeSafe?

Yes, but performance degrades significantly. Without the structured decision engine, the agent falls back to LLM-based operation selection, increasing latency by 5-10x.

Q3: How does Jev Ultrafast handle CAPTCHAs?

It doesn’t. CAPTCHA challenges pause execution and require manual intervention or third-party solving services. This is a known limitation of all browser automation tools.

Q4: Can I deploy Jev Ultrafast in production?

Yes. The library is production-ready, but you’ll need to manage your own TypeSafe API keys and rate limits. Browser Use offers a managed cloud option (waitlist available).

Q5: Does Jev Ultrafast work with mobile browsers?

Currently desktop-only. Mobile emulation is possible through Playwright integration but not native.

Q6: How does this compare to Cursor or Claude Code?

Jev Ultrafast focuses on browser automation, not code generation. They solve different problems. However, Cursor and Claude Code users might appreciate the structured decision approach for web interaction tasks.

Q7: What’s the maximum task complexity?

No hard limit, but practical experience suggests tasks under 20 steps complete reliably. Longer workflows benefit from task decomposition.

Conclusion

Jev Ultrafast proves that 7.1 seconds is achievable for autonomous browser tasks when you separate decision-making from execution. The TypeSafe approach—structured operation selection with indexed element targets—eliminates entire classes of failures while reducing token costs by 70%.

For teams building web automation, data scraping, or AI-driven browser workflows, this represents a meaningful step forward. The trade-off is dependency on TypeSafe’s infrastructure, but the speed and reliability gains are substantial.

The real question isn’t whether Jev Ultrafast works—it’s whether your workflow can benefit from sub-10-second automation. For flight searches, form submissions, and structured navigation, the answer is clearly yes.

Try Jev Ultrafast: https://github.com/browser-use/jev-ultrafast

Join the discussion: https://t.me/DIBI8_Group

Related reading: Claude Code Subagent Patterns • Browser Harness Guide

Sources & Further Reading:

• Official repo: https://github.com/browser-use/jev-ultrafast
• TypeSafe documentation: https://docs.typesafe.ai
• Performance benchmarks: docs/performance.md in repository
• Community: https://github.com/browser-use/jev-ultrafast/discussions