Why Twin
Your agent does the work. You keep the decisions.
Hand your agent the whole web: it reaches any site, pulls any data, and signs into the accounts you connect. You set the guardrails, approve what it cannot decide alone, and read the full trail afterwards. And because repeated work replays from cache, your cost per run falls as you scale instead of climbing with it.
Delegation
What you hand over — and what you keep
An agent that can act on the live web is only useful if you can still say what it may touch. Twin splits the two: the agent gets the browser, you keep the authority over credentials, decisions, and the record.
Credential vault
A write-only per-tenant vault: a stored secret is referenced in a goal as {{secret:NAME}}, resolved inside the browser at fill time, and redacted from every step, frame and log.
Human-in-the-loop handoff
A 2FA prompt, an approval push or a CAPTCHA the agent cannot clear returns status "paused" with a live session — resolve it automatically from a connected inbox, hand back a code, or drive the page yourself.
Live view & session video
POST /api/v1/live streams the browser back as Server-Sent Events while the agent works, and an opted-in run keeps a durable video you can fetch long afterwards.
The run’s target URL is the authorization signal, and auth, billing and audit logging run on every call. The full disclosure is on the security page.
The trade
The bill climbs with the work you repeat
Delegation has a catch. The unit changes — browser-hours, steps, gigabytes — but the economics rhyme: the LLM drives the page on every execution, so cost scales linearly with usage.
Run a 50-step authenticated workflow a thousand times and you’ve paid the model to re-read the same DOM and re-decide the same clicks a thousand times. Whether the bill says browser-hours (Browserbase, Steel), steps and tokens (Browser Use), or gigabytes (Bright Data), the curve points the same way: up and to the right, in lockstep with how much your agents actually work.
That’s backwards. The most valuable workflows are the repetitive, authenticated ones you run at volume — exactly the ones a per-run LLM bill punishes hardest. See the full breakdown on the comparison pages and the alternatives index.
The wedge
Compile once, replay free
Twin moves the LLM to the planning stage, where it belongs — not onto every execution. Four mechanisms bend the curve down, and the shape below is what they produce.
Compile once
A successful run compiles into a skill — a deterministic action plan over a token-efficient, numerically-indexed map of the page, not raw HTML. The expensive planning happens one time.
Match semantically
A re-phrased request (“book a demo” vs “schedule a call”) is matched to the compiled skill by a vector cache — not an exact selector key — so the next similar task hits the cache instead of cold-starting.
Replay free
On a cache hit, Twin replays the compiled skill deterministically with zero LLM calls. The cheapest model call is the one you never make.
Compound across tenants
A skill compiled once can be safely reused across tenants through a cross-tenant skill corpus, so the cache-hit rate climbs as the whole network runs — savings you didn’t have to earn alone.
Re-run the LLM every time
Cost per run is roughly constant — the model reads the page and decides the clicks again on every execution. A thousand runs cost about a thousand times one run. Volume is a liability.
- run #1
- ~$0.06
- run #100
- ~$0.06
- run #1,000
- ~$0.06
Compile once, then replay
Run #1 pays the cold compile. After that, semantic cache hits replay deterministically at ~$0 LLM, so the blended cost per run falls as usage grows — a cache hit is roughly 5× cheaper, and the marginal cost per run trends toward zero.
- run #1 · cold compile
- ~$0.06
- run #100 · cache hit
- ~$0.012
- run #1,000 · replay
- → ~$0
Figures are illustrative — they show the direction of the curve, not a benchmark or a guarantee. A run is billed the higher of its flat action price or its metered cost; the live rate card is on pricing, the deep dive is in Cutting LLM cost in browser automation, and the mechanism is on how it works.
Who it’s for
Built for teams that run the browser at volume
If you need an agent that does real web work you can hand off and still govern — accounts you authorize, steps you approve, a full audit trail — with a cost curve that falls as you scale, Twin is the layer.
- Teams building AI agents that need a browser they can trust to repeat.
- RPA-replacement products running authenticated, multi-step flows on a schedule.
- Anyone whose per-run model bill has become the line item that scales with success.