From a goal to deterministic action.
Agents reason brilliantly but break the moment they touch the live web. Twin Browser is the engine they call to act — token-efficient, authenticated and audited, and built so repeated work gets cheaper instead of more expensive.
- Open billing.acme.comdone
- Read DOM → indexed state (42 elements, ~3k tokens)done
- Plan: log in → open invoices → pick latestdone
- Act: fill #user · fill #pass · click “Sign in”running
- Compile run into a deterministic skillqueued
One run: open the page, read it as indexed state, plan, act, and compile the path into a skill the next run can replay for free.
Marginal cost trends toward zero
Most browser infra re-runs the LLM on every execution, so cost climbs with usage. Twin compiles a task once, matches re-phrased requests with a semantic cache, and replays deterministically — so the curve bends the other way.
The first time a goal is seen, the planner discovers a path and minimizes it into a deterministic skill. You pay the model once.
A re-phrased request is vector-matched to a compiled skill for that host and adapted — far cheaper than recompiling.
Call a skill by name and it blind-replays with no model in the loop. The most-repeated workflows trend toward zero marginal LLM cost.
A cross-tenant skill corpus compounds the savings: a skill compiled once can be safely reused across tenants. See how the cache and corpus fit together on the why-Twin page and the skills page.
Observe, plan, compile, replay
The loop that turns an unpredictable LLM-driven browse into a repeatable, low-cost skill.
- 01
DOM → indexed state
A compiler turns the live page into a compact, numerically-indexed map of interactive elements under a token budget — not raw HTML. The model spends tokens on the decision, not the markup (a 50-step flow → ~3k tokens, illustratively).
- 02
Plan → act
The planner picks actions against the indexed state — click element 14, type into element 7, submit — and drives the browser until your structured success condition is met. This is the only stage that needs an LLM.
- 03
Compile → skill
A successful run is minimized into a reusable, deterministic skill: the essential steps, no exploration noise, keyed to the page’s structure and stored in your skill library.
- 04
Dispatch → replay
Re-runs hit the semantic dispatch cache and replay deterministically with zero LLM calls — or compile fresh and cache for next time. Blocked steps hand off to a human, then resume.
Want the full eight-stage mechanism, end to end? Read how it works →
Everything an authenticated task needs
Not a screenshot tool — a full execution engine, with the security, control, and observability real workflows demand. Every capability below is shipped; open one for the deep dive.
Semantic dispatch cache
Re-phrased requests fuzzy-match to a skill you already compiled for that host — variants hit the cache instead of cold-starting at full LLM cost.
Deterministic replay
Compiled skills blind-replay with no model in the loop. Same input, same path, every time — and effectively no LLM spend.
Cross-tenant skill corpus
A skill compiled once can be safely reused across tenants. Only the sanitized navigation skeleton is shared — never your values, credentials, or exact paths.
Token-efficient DOM state
Pages become indexed element snapshots, a fraction of the tokens of raw HTML, and stable enough to replay.
Human-in-the-loop handoff
Connect an inbox or phone number and Twin auto-fills an emailed/texted 2FA code itself; anything it can't resolve — an approval, an authenticator code — pauses for a human, then resumes where it left off.
Live view + session video
Watch any run as a real-time screencast, or replay it from durable storage afterwards — for debugging, audit, and trust.
Agent & skill library
Every compiled skill is versioned, named, and callable by id — a growing library your agents and teammates can reuse.
Credential vault
Secrets are encrypted at rest, filled at run time as named references, and redacted from every log and response.
Proxy support
Route egress through managed residential or datacenter proxies when an authorized workflow needs a specific network path.
Compile once, replay for free
The first call discovers a path and compiles a skill. The next similar call — even re-worded — replays it deterministically with near-zero LLM tokens. Same key, same audit log, same vault.
# 1 — cold run: the planner compiles a reusable skill
curl -X POST https://twin-browser.com/api/v1/run \
-H "Authorization: Bearer $TWIN_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"goal": "Log in and download this month'\''s invoice",
"url": "https://billing.acme.com"
}'
# -> { "result": {...}, "skill_id": "sk_9f2c", "llm_tokens": 3120 }
# 2 — dispatch a re-phrased request: semantic cache HIT -> replay
curl -X POST https://twin-browser.com/api/v1/dispatch \
-H "Authorization: Bearer $TWIN_API_KEY" \
-H "Content-Type: application/json" \
-d '{ "goal": "Grab the latest invoice PDF", "url": "https://billing.acme.com" }'
# -> { "result": {...}, "replayed": true, "llm_tokens": 0 }Full reference on the API page, or drive the same engine from your editor over the MCP server and one-line LangChain / AutoGen adapters.
A plain headless browser vs. Twin
Same browser underneath — but Twin adds the skill layer that makes the second run nearly free, observable, and safe to run at volume.
| Aspect | Plain headless browser | Twin Browser |
|---|---|---|
| Cost of the next identical run | Full LLM cost again | ~0 LLM — deterministic replay |
| Page representation | Raw HTML / pixels | Indexed-state map under a token budget |
| Re-phrased request | Cold start | Semantic cache hit, adapted |
| Reuse across teams | None | Cross-tenant skill corpus (sanitized) |
| 2FA / blocked step | Run fails | Auto-fill code, else HITL handoff |
| Observability | Logs, if any | Live view + durable session video + audit log |
| Billing | Opaque | Usage credits; LLM metered, passed through at 1× |
Illustrative engine behavior. See the line-by-line breakdown on the compare pages.
Call it from MCP, the API, or your framework
The same engine behind a versioned REST API, an MCP server for Claude and Cursor, and one-line LangChain and AutoGen adapters.
REST API
Bearer-authenticated endpoints under /api/v1/* — run a goal, dispatch to the cache, or replay a compiled skill.
MCP server
Tools run, compile_skill, run_skill for Cursor, Claude Desktop, Claude Code, and Cline.
LangChain & AutoGen
One-line tool adapters drop the same engine into your existing agent framework — no replay logic to reimplement.
Adapters in the docsAutomate the web where you’re authorized
Twin runs first-party sites, operator-approved automation, internal RPA, accessibility, and authorized testing. The run’s target URL is the authorization signal — and auth, billing, and audit logging run on every call.
- Per-tenant API keys, stored only as a hash.
- Default-deny RLS on a multi-tenant Supabase backend.
- An audit log and credential vault on every run.
It is not a CAPTCHA-bypass-for-hire or anti-bot evasion service. Read the full disclosure on the security page.
The product, answered
What is Twin Browser?
How is this different from a headless-browser API?
What does the indexed-DOM compiler actually do?
Where is Twin authorized to automate?
How do I call it?
What does it cost?
Give your agent a browser it can trust.
Free to start. Usage-based credits from $29/mo, with LLM cost passed through at 1×.