All articlesBrowser Use x Gumloop

Gumloop is a platform for building AI agents for work. When an agent needs a website that has no API, no MCP server and no Gumloop connector, it opens a browser and does the work itself. That browser is the Browser Use stealth browser. It runs on-prem, inside the same sandbox as the agent, rather than in Browser Use Cloud. Gumloop got the same stealth, CAPTCHA solving and residential proxies we run in our cloud, while sign-ins, downloads and recordings stay in its own infrastructure.

The long tail has no API

Gumloop already connects agents to the apps teams use every day through connectors. Its own docs say to prefer a connector when one exists, because connectors are faster and more reliable. But most of the web will never get one: the utility provider's portal, the state filing system, the supplier dashboard, the competitor's checkout flow, the internal tool somebody built in 2014. Even when a connector exists, it doesn't always support the task at hand.

That is the long tail of agent work. Each site is a small slice of usage, and together they make up most of what people actually ask an agent to do. Gumloop calls it "the last mile of automation". A connector per site doesn't scale. A browser does.

So on October 6, 2026, Gumloop launched Browser for every Gumloop agent. When an agent is asked to do something it has no connector for, it opens a real Chromium, navigates the site, clicks, types, fills forms and downloads files. When it reaches a step only a person should take (a 2FA code, an SSO approval, a purchase confirmation), it hands the browser to the user and waits (Gumloop docs).

The work this unlocks is exactly the long tail. In Gumloop's launch post:

  • Opendoor is building agents that handle utility turn-ons across hundreds of homes every week. The agents work provider portals, pull credentials from 1Password, and coordinate across browser, email and phone.
  • Competitive research: walk a competitor's free trial and screenshot every onboarding step, or check pricing pages and checkout flows every week and flag what changed.
  • Portals with no API: log into state, city and federal portals to track filing deadlines, permit renewals and trademark status. Pull statements and invoices from bank, utility, insurance and supplier portals and file them in Drive.
  • Office errands: restock snacks on Costco or Instacart, order team lunch on DoorDash, book a table on Resy or OpenTable.

On top of the browser itself, Gumloop shipped a credential vault, 1Password integration, a verified identity per agent, session replays, Skills that save a finished task as a reusable procedure, and model routing that lets a stronger model plan while a cheaper one drives the browser. A week later, on October 13, it added a mobile view and per-country proxies (changelog).

The catch with the long tail is that it is also where bot detection lives. Stock Chromium gets blocked at login pages, checkouts and anything behind Cloudflare, DataDome, PerimeterX or Akamai. An agent that gets stopped at the door is no use.

Why Gumloop wanted the browser inside its sandbox

Every Gumloop agent already runs in Gumloop's cloud sandboxes. Gumloop's docs put it plainly: "The browser runs inside the same Code Sandbox as the agent."

The usual way to give an agent a stealth browser is a hosted browser API. The agent runs in one place and drives a remote browser in someone else's cloud. For Gumloop that would have meant:

  • Paying for compute twice. The sandbox already has the CPU and memory. A remote browser adds a second machine for every agent.
  • Session data leaving their infrastructure. Cookies, sign-ins, downloads and recordings would live with a vendor instead of on the sandbox, next to the user's files.
  • An extra network hop on every action. Each click and screenshot crosses the internet twice.
  • A harder security review. Gumloop sells to enterprises, and enterprise security reviews look closely at where agent traffic and data go.

Gumloop's CTO, Rahul Behal, sent us the spec on day one, so we could work with it. Residential proxies with country selection were a must. Persistent profiles should live on the sandbox filesystem. Human takeover and session recordings should work too. The request was simple: run your browser inside our cloud sandboxes.

What an on-prem browser is

An on-prem browser (or self-hosted browser) is browser infrastructure that runs in the customer's environment instead of the vendor's cloud. The customer gets the vendor's browser, and the customer's machines run it.

For Browser Use, the on-prem browser is the same stealth browser that powers Browser Use Cloud. It is the same patched Chromium build, released on the same schedule, shipped as a single binary that runs anywhere the customer's agents already run.

Hosted browser (Browser Use Cloud)On-prem browser
Where Chromium runsBrowser Use's infrastructureYour VM, container or sandbox
How the agent connectsRemote CDP over the internetLocal CDP on 127.0.0.1:9222
Profiles, downloads, recordingsStored by Browser UseOn your filesystem
ComputeBilled per browserHardware you already run
Stealth and fingerprintsBuilt inBuilt in, same build
CAPTCHA solvingBuilt inBuilt in, with an optional solver service you can self-host
Residential proxiesBuilt inOptional, via Browser Use or your own
Best forStarting fast, burst scaleAgents that already run in your own sandboxes or VPC

How the Browser Use on-prem browser works

One install, one local DevTools port

The on-prem browser has two parts: the patched Chromium build, and a small manager that starts Chromium with the right fingerprint, profile, proxy and timezone settings. Install it on Debian 13 (amd64) with sudo, then activate it with a Browser Use API key and run it as your normal user:

curl -fsSL https://releases.browser-use.com/on-prem/install.sh | sudo sh
browser-use activate
browser-use run --config /etc/browser-use/config.yaml --profile default
# Browser ready: http://127.0.0.1:9222

Anything that speaks the Chrome DevTools Protocol can drive it from there: Playwright, Puppeteer, the Browser Use agent, or your own harness. A YAML config sets headless or headful mode, the proxy and named profiles. With no display attached, the browser falls back to headless on its own.

Gumloop runs it inside its cloud sandboxes. License material is installed at runtime, never baked into an image.

Stealth is a property of the build, not a plugin

A stealth browser doesn't just hide navigator.webdriver. Fingerprints have to stay consistent across every surface a site can probe: canvas, WebGL, fonts, screen, timezone, language and the network path. Browser Use patches this into Chromium itself:

  • A fingerprint per profile. Each profile gets a random, realistic fingerprint that stays sticky for that profile. A returning agent looks like the same returning user.
  • Headless and headful are both stealthy. The same build runs either way.
  • The timezone matches the exit IP. The manager looks up the proxy's exit location through Browser Use's own endpoint and sets the timezone to match.
  • The Chromium sandbox stays on. No --no-sandbox workaround is needed.
  • Settings that would leak are locked by default. Device-metric overrides are blocked unless you opt in, because a mobile user agent on a desktop fingerprint is an instant tell. When a Gumloop customer needed agents to QA the mobile layouts of its own storefronts, we added a manager switch that allows resizing. On October 13, Gumloop shipped a mobile view (Pixel 7 emulation) for every agent.

The on-prem browser follows Chrome majors along with our cloud. The Chrome 154 release improved stealth across our benchmark (Akamai-protected sites in particular), and it went to on-prem customers in the same week as production, built natively for Debian 13.

CAPTCHA solving, mostly inside the binary

Most CAPTCHAs are solved inside the binary, so nothing leaves the sandbox and the agent usually never sees the challenge. The harder ones go to a Browser Use solver service, which receives only anonymous data: a screenshot of the challenge or the challenge token. Nothing is stored except metadata and success rates. Customers who can't allow that egress can deploy the solver service in their own infrastructure. Whatever is left, Gumloop hands to the user like any other human-only step. Not every challenge type is covered; CAPTCHA handling lists what is supported.

Residential proxies without breaking TLS

Long-tail sites often block datacenter IP ranges or serve different content by country. The on-prem browser can route through Browser Use residential proxies in any supported country. The license authorizes the proxy, so there is no proxy password to hide in a config file.

The proxy runs with zero data retention, and TLS is never broken. Browser Use sees the destination domain, which it uses to block scam and phishing domains. Only the website sees the request, and only the customer sees the response. Customers who want their own proxies can bring them.

Licensing that is safe in a sandbox your users control

This was the hardest design problem, and Gumloop raised it before launch. In an agent sandbox the end user has full control of the machine. Anything the browser needs to verify, a user could copy out.

The answer has three parts:

  • Activation, not key files. browser-use activate exchanges a Browser Use API key for a short-lived license. A cron job renews it, and the installation key and profiles carry over, so the browser identity stays the same across renewals.
  • Short lifetimes. A license lasts seven days. A copied license expires, and old binaries fall behind the releases quickly.
  • No secrets in the browser's path. The proxy needs only a server and user name.

Releases you can audit

Every release ships with checksums, a signature, build provenance and an SBOM. The installer verifies them before installing anything, and the README shows how to check them by hand. Telemetry is off unless you turn it on. Password saving and sync are off.

The browser needs egress to four hosts: releases.browser-use.com, enterprise.browser-use.com, ip.browser-use.com, and proxy.browser-use.com if you use our proxies. That list fits on a short firewall allowlist.

How Gumloop's agent drives the browser

Gumloop didn't adopt a new agent framework. It added one tool to its existing agent harness, with raw CDP access to the local browser. The page, tab and CDP helpers were ported from our open-source browser-use-pi agent, following the approach in the bitter lesson of browser agents: give a strong model a real browser and a REPL, not a fixed list of actions.

Gumloop then built its product on top of that. It added a live view the user can take over, step-by-step replays, credentials typed by Gumloop so the model never sees them, 1Password and Vault sign-ins, per-user browser profiles that keep people signed in, and handoffs that also work from Slack and SMS.

Built together, shipped fast

  • Sep 3: Gumloop shares its sandbox spec.
  • Sep 9: our browser binary runs outside our cloud for the first time.
  • Sep 15: the first on-prem build is delivered. Rahul's verdict the same day: "The core integration is working well."
  • Sep 24: API-key activation, signed releases, Chromium sandbox on, a passwordless proxy and telemetry off by default, shipped in response to Gumloop's launch-readiness review.
  • Sep 25: after the internal rollout, from Gumloop's Max: "Works so impressively well. bravo guys."
  • Oct 6: Gumloop launches Browser for every Gumloop agent.
  • Oct 8: Chrome 154 ships on-prem, with CPU improvements first proven in our cloud.
  • Oct 11: mobile emulation is unblocked for a Gumloop customer's storefront QA.
  • Oct 13: Gumloop ships mobile view and per-country proxies for the agent browser.

Most of these changes started as a precise bug report from Gumloop's engineers, who profile the browser under their own traffic. One report traced CPU cost in the CAPTCHA detector down to the DevTools traffic it generated. The fix shipped to every on-prem customer.

When to choose an on-prem browser

Choose on-prem browser infrastructure when:

  • your agents already run in your own sandboxes, VMs or VPC, and a second browser fleet would double the compute,
  • browser state (cookies, sign-ins, downloads, recordings) has to stay in your environment,
  • your customers restrict egress to a short allowlist, or
  • you need every action to stay local with no network hop.

Choose Browser Use Cloud when you want to start in minutes, scale bursts without capacity planning, or don't run your own sandboxes.

Same browser, same stealth, either way. To run it on-prem, write to sales@browser-use.com.

Frequently asked questions

What is an on-prem browser for AI agents? It is a browser that runs in your own infrastructure instead of a vendor's cloud. Your agents connect to it locally over the Chrome DevTools Protocol, and its profiles, downloads and recordings stay on your machines.

Is the on-prem browser the same as the Browser Use Cloud browser? Yes. It is the same patched, stealth Chromium build that runs in Browser Use Cloud, released on the same schedule.

What is a stealth browser? A stealth browser is a browser built so automated sessions look like real users. Its fingerprint (canvas, WebGL, fonts, screen, timezone and more) stays realistic and consistent, to help reduce detection and blocking. Browser Use patches this into Chromium itself rather than injecting scripts.

Does the on-prem browser solve CAPTCHAs? Yes. Most CAPTCHAs are solved inside the binary. The harder ones use an optional solver service that receives only anonymous challenge data, and you can host that service yourself. Supported challenge types are listed in the CAPTCHA handling docs.

Does Browser Use see my traffic when I use its residential proxies? No. TLS is never broken. Browser Use sees the destination domain and nothing else, and proxy traffic runs with zero data retention.

What do I need to run it? Debian 13 on amd64, sudo for the install, a Browser Use API key to activate the license, and egress to the Browser Use release, license and IP hosts, plus the proxy host if you use our proxies.

Which tools can drive it? Anything that speaks CDP: Playwright, Puppeteer, the Browser Use agent, or your own harness.

Who uses the Browser Use on-prem browser? Gumloop runs it inside its agent sandboxes to power Browser, the agent browser it launched on October 6, 2026.

Gumloop: gumloop.com. Browser Use Cloud: cloud.browser-use.com, docs: docs.browser-use.com.

Published November 17, 2026

Keep reading

All articles

Customers

/Nov 17, 2026

SAP Test Automation With AI Agents: How Glasslake Runs SAP Tests on Browser Use

How Glasslake automates Fiori testing with Browser Use AI agents: test steps run in a cloud browser, watched live, with screenshots as evidence.

Johannes Dittrich

Announcements

/Nov 16, 2026

Browser Use agents can now check out without ever seeing your card, with Evervault

Evervault Browser Tokens let a Browser Use agent fill checkout forms with stand-in card numbers. Evervault swaps in the real card only in the request to the payment host you allow.

Gregor Zunic

Tutorials

/Nov 15, 2026

Log In Once: Reuse Cookies and Profiles Across Browser Use Runs

Reuse a login across separate Browser Use runs with profiles. Save Playwright authentication state, handle expired cookies, and keep user accounts separate.

Nik Tomazic