GitHub - browser-use/jev-ultrafast · GitHub

Skip to content

Navigation MenuSign inAppearance settingsPlatformAI CODE CREATIONGitHub CopilotWrite better code with AIGitHub Copilot appDirect agents from issue to mergeMCP RegistryIntegrate external toolsDEVELOPER WORKFLOWSActionsAutomate any workflowCodespacesInstant dev environmentsIssuesPlan and track workCode ReviewManage code changesCode QualityEnforce quality at mergeAPPLICATION SECURITYGitHub Advanced SecurityFind and fix vulnerabilitiesCode securitySecure your code as you buildSecret protectionStop leaks before they startEXPLOREWhy GitHubDocumentationBlogChangelogMarketplaceView all featuresSolutionsBY COMPANY SIZEEnterprisesSmall and medium teamsStartupsNonprofitsBY USE CASEApp ModernizationDevSecOpsDevOpsCI/CDView all use casesBY INDUSTRYHealthcareFinancial servicesManufacturingGovernmentView all industriesView all solutionsResourcesEXPLORE BY TOPICAISoftware DevelopmentDevOpsSecurityView all topicsEXPLORE BY TYPECustomer storiesEvents & webinarsEbooks & reportsBusiness insightsGitHub SkillsSUPPORT & SERVICESDocumentationCustomer supportCommunity forumTrust centerPartnersView all resourcesOpen SourceCOMMUNITYGitHub SponsorsFund open source developersPROGRAMSSecurity LabMaintainer CommunityGitHub StarsArchive ProgramREPOSITORIESTopicsTrendingCollectionsEnterpriseENTERPRISE SOLUTIONSEnterprise platformAI-powered developer platformAVAILABLE ADD-ONSGitHub Advanced SecurityEnterprise-grade security featuresCopilot for BusinessEnterprise-grade AI featuresPremium SupportEnterprise-grade 24/7 supportPricingSearch/Sign inSign upAppearance settings

You signed in with another tab or window. Reload to refresh your session.
You signed out in another tab or window. Reload to refresh your session.
You switched accounts on another tab or window. Reload to refresh your session.

Dismiss alert

Uh oh!

There was an error while loading. Please reload this page.

browser-use

/

jev-ultrafast

Public

Notifications
You must be signed in to change notification settings

Fork
11

Star
260

Code

Issues
1

Pull requests
1

Actions

Projects

Security and quality
0

Insights

Additional navigation options

Code

Issues

Pull requests

Actions

Projects

Security and quality

Insights

mainBranchesTagsGo to fileCodeOpen more actions menuLatest commit History2 Commits2 CommitsFolders and filesNameNameLast commit messageLast commit datedocsdocs  examplesexamples  jev_ultrafastjev_ultrafast  scriptsscripts  teststests  .env.example.env.example  .gitignore.gitignore  AGENTS.mdAGENTS.md  LICENSELICENSE  README.mdREADME.md  pyproject.tomlpyproject.toml  uv.lockuv.lock  View all filesRepository files navigationREADMEMIT licenseMore items
Jev Ultrafast ⚡
A browser agent with a dynamic, indexed action space.
Give it one goal. TypeSafe's Jev picks an operation and an element. A small LLM writes text only when the operation is TYPE_TEXT.
Zürich → London on Google Flights in 7.1 seconds. One natural-language goal, actual text generation, and loading waits included.

Watch the MP4 · Measurements · Read the loop
The action space
Every observation produces a new element table:
[1] button Change ticket type · Round trip
[2] combobox Where from? · San Francisco
[3] combobox Where to? · empty
[4] textbox Departure · empty
...

The operations are CLICK, TYPE_TEXT, SELECT, SCROLL_UP, SCROLL_DOWN, WAIT, DONE, and BLOCKED. Only supported operations and targets are offered.
one TypeSafe request
┌───────────────────────────┐
page → element table → operation │
│ click_target │
│ type_text_target │
│ select_target, if present │
└─────────────┬─────────────┘
use the matching target
│
CLICK [7] ─────┤──→ browser
TYPE_TEXT [3] ─────┘
↓
small LLM → text → browser

Target questions are speculative. If the operation is CLICK, only click_target can execute. Two decisions, one network round trip. Each target head contains only compatible elements. Native dropdown choices carry an observed element/option index.
There are no site-specific action scripts or prepared field strings in the policy. The Flights example supplies a goal and independently verifies the outcome. The screenshot renderer adds labels afterward; it does not drive the browser.
Try it
git clone https://github.com/browser-use/jev-ultrafast.git
cd jev-ultrafast
uv sync
cp .env.example .env
# Add TYPESAFE_API_KEY and TEXT_MODEL_API_KEY.
uv run jev
Open http://127.0.0.1:8766 and click Start demo → Run automatically. The inspector shows numbered elements, operation probabilities, target probabilities, and executed actions. Choose next pauses before execution.
Chrome connects through Browser Harness, installed by uv sync. Run uv run browser-harness --doctor if it needs connecting. Allow remote debugging in Chrome when prompted.
TEXT_MODEL_API_KEY is an OpenRouter key in the example configuration. The current demo uses inception/mercury-2.5 with reasoning disabled. Gemini, GLM, and DeepSeek can also use the OpenAI-compatible text helper; configure the appropriate model, endpoint, and reasoning setting.
Use the library
from jev_ultrafast import Agent

with Agent(
"https://www.google.com/travel/flights?hl=en",
"Find one-way flights from Zurich to London on September 20, 2026, "
"for one adult in economy. Stop when matching flight options are visible.",
) as agent:
for state in agent.run():
print(state["elapsed_ms"], state["status"])
Run with uv run --env-file .env python your_script.py. The same policy can run a different task:
uv run --env-file .env python examples/run.py \
--url https://en.wikipedia.org/wiki/Main_Page \
--goal 'Find and open the Wikipedia article about Gödel’s incompleteness theorems.'
uv run --env-file .env python examples/flights.py --keep-open performs the flight search, checks the actual route/date/results, and saves its trace. It does not select or book a flight.
Why it moves

One request per decision cycle. Operation and target heads share the same observed state.
No screenshots in the default agent loop. Jev consumes structured state. The inspector opts into screenshots; the video uses a separate continuous screencast.
One browser call per snapshot. Read visible controls, their names, values, and text atomically. Keep references to the actual DOM nodes.
Validate the selected target. Clicks check the document, form values, target, and nearby context. Animation alone does not force another prediction. Resolve current geometry and reject covered controls before input.
Wait for useful state. After typing into a combobox, wait for visible suggestions, capped at 200 ms. Other interactions get at most two animation frames or 50 ms. These reads happen after execution is logged.
Keep hidden tabs rendering. Focus emulation prevents background animation throttling without switching Chrome's visible tab.
Send visible text. Offscreen article bodies and footers do not fill the model context.
Reuse an interrupted text request. A generated value survives a stale-page retry only if the entire text-helper input is unchanged.

Every executed target is resolved from an observed node. The executor rechecks page freshness and click occlusion. Model output never becomes selectors, coordinates, shell commands, or executable JavaScript. Text-helper output must parse as a small JSON object before typing.
Small enough to read

File
Job

agent.py
The complete loop and text-helper handoff

snapshot.js
Atomic DOM snapshot, indexed controls, freshness guards

browser.py
Browser connection, current geometry, execution

model.py
Dynamic operation/target heads and text generation

questions.py
Model instructions

demo.py
Local inspector

Evidence and limits
The current video is a 7,073 ms Google Flights run. Timing starts after initial page observation and includes model calls, generated text, browser work, stale decisions, and loading waits. A fresh independent check verifies the one-way setting, Zürich, London, September 20, 2026, and visible flight options. The video plays at 1×, with no opening hold and a 0.5-second final hold.
In six alternating runs with identical models and settings, both versions passed 3/3. Median task time went from 9.450 s → 7.092 s, a 25% reduction; median browser protocol calls went from 1,092 → 101. This is three repeats of one task on one browser profile, not a general reliability benchmark.
The same policy opened the requested Wikipedia article in 2.798 s and passed a local hotel search/filter task in 1.896 s. Runs, failures, source hashes, and measurement boundaries are in performance.md.
A DONE choice still requires independent outcome verification. The DOM reader handles common HTML and ARIA controls, not the full accessible-name specification. Shadow roots, frames, canvas, uploads, pop-up tabs, nested scrolling, and arbitrary keyboard widgets remain outside this MVP. Owned tabs share the existing Chrome profile.
Development
uv run ruff check .
uv run pytest
node --check jev_ultrafast/static/app.js
node --check jev_ultrafast/snapshot.js
uv build
Tests are offline. uv run python scripts/check_guards.py checks real controls in a local browser without model calls. Live examples and recording scripts make paid API calls. scripts/record_flights.py <new-folder> captures original browser timestamps; scripts/render_demo.py <recording-folder> renders that verified run at 1× and crops out the Google account strip. Credentials and raw traces stay ignored.

Browser Use · Browser Harness · TypeSafe speculative fan-out
AboutNo description, website, or topics provided.ResourcesReadmeMIT licenseActivityCustom propertiesStars260 starsWatchers0 watchingForks11 forksReport repositoryReleasesPackagesUsed byContributorsLanguages

Footer

© 2026 GitHub, Inc.

Footer navigation

Terms

Privacy

Security

Status

Community

Docs

Contact

Manage cookies

Do not share my personal information

You can’t perform that action at this time.

The Jev Ultrafast project introduces a browser agent designed with a dynamic, indexed action space to execute complex tasks efficiently using natural language goals. The fundamental mechanism involves a small language model that generates text only when the prescribed operation is TYPE_TEXT, allowing the agent to orchestrate interactions with a browser environment in tasks such as searching for flight options. The system processes a request by observing the page state to produce an element table, which then dictates the possible operations and targets available to the agent. Supported operations include CLICK, TYPE_TEXT, SELECT, SCROLL_UP, SCROLL_DOWN, WAIT, DONE, and BLOCKED, each linked to specific targets derived from the observed elements.

The process prioritizes efficiency through strict constraints on decision-making and execution. The agent operates on a principle of one request per decision cycle, ensuring that the operation and target heads share the same observed state. The design eschews screenshots in the default agent loop in favor of consuming structured state, making it a state-driven system rather than a purely visual one. Interactions are managed by a single browser call per snapshot, allowing atomic reading of visible controls, their names, values, and text while retaining references to the actual Document Object Model nodes. Crucially, the system validates selected targets, ensuring that clicks check the document, form values, and surrounding context, preventing execution based on mere animation.

The agent is engineered to move state progressively while mitigating latency. For instance, after inputting text into a combobox, the system waits for visible suggestions, capped at 200 milliseconds, ensuring that reads occur only after execution has been logged. The system maintains hidden tabs to prevent background animation throttling without altering the view of the currently visible Chrome tab. The text generation is also constrained, as offscreen article bodies and footers do not fill the model context, which helps keep the generated output small enough to be manageable.

The execution pipeline is managed across several modules, including agent.py, snapshot.js, browser.py, model.py, and questions.py, interfacing with components like Browser Harness. The core objective is to ensure that every executed target is resolved from an observed node, and that the model output never devolves into executable JavaScript or coordinates. The system is designed to consume structured state rather than relying on external or speculative information, requiring independent outcome verification following actions like selecting DONE.

Empirical evidence demonstrates the efficiency of this approach. Performance measurements from running tasks, such as a Google Flights search, showed significant reductions in time and protocol calls. In alternating runs with identical models and settings, the median task time decreased by approximately twenty-five percent, and the median number of browser protocol calls was reduced by over ninety percent. These results suggest that the method of consuming structured state and carefully managing browser interactions yields substantial speed and reliability improvements for agent-based automation. The system is further developed through testing protocols that check real controls against the model's predictions, ensuring that the inferred actions correspond to actual DOM elements.