unbrowseA confession, before a reply guy finds it for me.
Unbrowse runs about $1,200 a month of cloud infrastructure, by our own estimate. Running 20 browsers that learn sites at the same time costs roughly $600 a month on its own. Revenue so far: $0, because the service is free during the beta.
I'm Lewis Tham, founder of Unbrowse and first author of "Internal APIs Are All You Need". The paper argues agents should stop browsing. And here I am, paying for browsers.
There's a reason, and it's the whole subject of this piece: the first call.
Every route starts as a browser session
The trick behind Unbrowse is simple. An agent does a task in a browser once. We record the request the page sends to its own backend:
GET /api/search?q=hotels+in+lisbon
Next time, the agent calls that request directly over HTTP. No rendering, no clicking, no waiting for the cookie banner to animate.
The replay is cheap. The learning is a browser agent.
To learn a route, something has to open Chrome, load the site, let a model find the search box, type, wait, retry when a popup eats the click, and watch the network tab. In our April 2026 paper we modelled that at $0.10–0.53 per task: browser time, LLM tokens, retries.
That's about what a browser agent costs to do the task in the first place. Because it is a browser agent doing the task.
So here's the uncomfortable sentence:
If Unbrowse learns every route on its own browsers, Unbrowse is browser automation with extra steps.
The savings start at call two
Same task, first call and hundredth call:
RECEIPT time cost
---------------------------------------------------
call 1 browse + learn 36.7 s $0.10–0.53
call 100 replay the route 1.97 s ~$0.00003
---------------------------------------------------
1 call a browser agent, plus a recording
100 calls, averaged $0.001–0.005 per call
The times are medians from our own demo booking site, in a September evaluation. The first-call cost is modelled in the paper. The replay cost is what a direct HTTP read costs us per page on our Apify actors, a different workload, so treat the bottom line as arithmetic on two rows, not a bill.
The paper's wider test points the same way with a smaller gap. Across 94 domains, a cached route ran the same tasks as Playwright in 950 ms against 3,404 ms: 3.6x faster on average, 5.4x at the median. The benchmark deep dive has the method.
Use a route once and you saved nothing. Use it a hundred times and the first call dissolves into the average.
The whole business is reuse. Learning is the cost. Replay is the payoff.
So who pays for the first call?
Three candidates.
We do. That's the $1,200. It grows with the number of first calls, which means with every site and task nobody has learned yet, which is most of the web. With $0 coming in, that's a hobby with a cloud bill.
The developer does, by renting our browsers. Fair, and sometimes the right answer. But it puts a toll at the exact moment someone is deciding whether the tool works at all.
The user's own browser does. It's already open. It's on a home connection. It's already signed in to the sites its owner cares about. If it learns a route for its owner's task, the browser time costs us $0, and the owner was going to do that task anyway.
That's where we want to land. It is a plan, not how the service works today. Here is the order we're building towards when an agent needs a route that doesn't exist yet:
route missing?
1. your private cache live: you learned it before
2. public registry live: someone else learned it
3. another node learns it plan, not built
4. your own browser plan: in testing
5. our cloud browser live: today's default for a new site
---------------------------------------------------
every path ends in a learned route
Your browser for your tasks. Ours as the fallback, for the hours yours isn't around. I make that case in The Best Browser for Your Agent Is Already Open.
Your free call should become everyone's cheap call
Today, when an agent learns a public, read-only route in our cloud browser, a scrubbed copy can go to the public registry: no cookies, no tokens, no personal values. It publishes only after a clean replay with a query it has never seen, and it gets re-checked over time. The next agent that needs it starts at call 100.
A route learned on your own machine is different. In the version we're testing, it stays private to your workspace and never goes to the public registry, because your machine is not a recorder we can trust on its own. The plan is to let those routes in only after someone else's replay confirms them. Until that exists, your browser's first call helps you and nobody else.
That changes which number matters. It isn't the price of a browser minute. It's hit rate: the share of real requests that find a working route on the first try.
Demand is concentrated, so the routes people actually call get learned first. And a miss heals itself: browse once, learn, replay. Every first call paid once is one nobody pays again.
Where the honest gaps are
Not every site replays. In our 100-site eval in September, 42 of 100 sites replayed a new query without a browser. On the other 58, the browser stays, and so does its cost.
As of 12 October 2026, the free first call is mostly not shipped:
testing local browse: a cloud agent drives a browser
on your machine through the CLI (the service
side exists; the released CLI doesn't have it)
built browser extension relay: agent calls run
through your own Chrome (off in production)
merged an outbound link from a program on your machine
to Unbrowse (not in production)
plan delegated learning on other people's nodes
So today, the first call on a new site lands on our cloud browser. That's the $1,200, and that's what this plan is for.
Where this actually is
As of 12 October 2026, the replay, the public registry and the cloud browser are live, and the service is free during the beta: 500 verified calls a month. Using your own browser for the first call is in testing. The extension is built and not yet switched on in production. The rest is a plan.
It's one MCP server: unbrowse.ai/mcp. Point your agent at the site it visits every day. If nobody has learned it yet, that's the first call worth paying exactly once. Setup is in the docs.
The first call is the expensive one. The goal is to make it once, on the browser that's already open.