Point your agents at the web,
get back clean data.
Describe a task and the agent does it live in a browser, or pick a tool to search, scrape, map, and crawl. Runs stream right here.
- OpenAI
- Anthropic
- LangChain
- AutoGen
- Claude
- Cursor
- Playwright
- MCP
- CrewAI
- Llama
The platform
One run, then near-zero forever.
Re-phrased requests still hit the compiled skill
The first run compiles a task into a skill. Every later request — worded differently, same intent — fuzzy-matches that skill through the semantic dispatch cache instead of re-planning from scratch. The match is the moment cost falls off a cliff.
How the cache matchesCompile once. Cache the rest. Replay for free.
Four stages take an agent from a free-form goal to a cached skill that gets cheaper every time it runs — so the bill falls with usage instead of climbing.
Compile once
The DOM → indexed-state compiler turns a live page into a compact numbered map of what an agent can act on. The planner discovers the goal once and minimizes it to the shortest reliable route — a skill.
[1] Button "Log in"
discover → 7 steps
minimize → 2 stepsSemantic cache
A re-phrased request is vector-matched to a skill you already compiled for that host and adapted to the new values — a cache hit, roughly 5× cheaper than a cold compile, instead of starting over.
dispatch → vector match
adapt → new values
cost → ~0.2×Deterministic replay
Compiled skills are descriptor-based and survive DOM rotation. Replay runs the minimal route by name with no model in the loop — the same flow, every time, with zero LLM calls.
run_skill → by name
llm calls → 0
result → deterministicMarginal cost ≈ 0
The more your agents repeat a task, the more runs hit replay — so cost per run trends toward zero. A cross-tenant skill corpus compounds it: a skill compiled once can be safely reused.
runs ↑
cost/run ↓
→ trends to $0Built for the run you do a thousand times.
LLM-per-run browser infra is flexible but bills up; generic RPA is cheap to license but brittle and siloed. Twin keeps the flexibility and bends the cost curve down.
| Re-run-the-LLM browser infra | Generic RPA | Twin Browser | |
|---|---|---|---|
| Cost as usage grows | No: Climbs — billed per browser-hour, step, or token | No: Flat licence, but breaks need paid rework | Yes: Falls — cache hits and replays trend to $0 |
| Handles a re-phrased request | Yes: Yes — but re-reasons from scratch each time | No: No — brittle recorded selectors only | Yes: Semantic cache matches it to a compiled skill |
| Survives DOM rotation | Yes: Yes, by re-paying the model every run | No: No — selectors rot, scripts shatter | Yes: Descriptor-based skills replay deterministically |
| Tokens per page | No: Raw HTML — 50k+ tokens of markup | N/A — no model in the loop | Yes: Indexed action map — a 50-step flow → ~3k tokens |
| Reuse across teams | No: Every run starts cold | No: Bots are bespoke and siloed | Yes: Cross-tenant skill corpus, safely sanitized |
| Distribution | Yes: Usually an SDK | No: Desktop studio, heavy setup | Yes: REST + MCP + LangChain / AutoGen adapters |
Fair caveat: re-running the LLM is the simplest thing to ship, and fine at low volume. Twin's edge shows up when the same flow runs again and again — which is exactly when an RPA-replacement product needs cost-per-1k-runs to fall, not rise.
Operators click. Builders call. Same engine.
Whether you never write a line of code or live in your IDE, every run hits the same compile-cache-replay engine — authenticated, isolated, and logged.
No code
The hosted dashboard
Describe a goal, give it a target URL, and watch it run in a real-time live view. Compile skills, replay them, store credentials in the vault, and review session video — no SDK, no agent to wire up.
- Real-time live view + session video
- Agent & skill library, one-click replay
- Credential vault, usage-based credits
Builders
The API + MCP
The same engine behind a small versioned REST API and an MCP server your agent drives natively. Bearer-key auth, per-tenant isolation, an audit log — drop it into Cursor, Claude, LangChain, or AutoGen in one line.
- REST under /api/v1/* with Bearer keys
- MCP tools: run · compile_skill · run_skill
- LangChain & AutoGen tool adapters
Built for the browser work you do at scale.
Twin automates the web where you're authorized — first-party sites, operator-approved automation, internal RPA, accessibility, and authorized testing.
AI agents at volume
Give your agent a browser that gets cheaper the more it runs — semantic cache plus deterministic replay, called from MCP or REST.
ExploreRPA replacement
Swap brittle recorded bots for descriptor-based skills that survive DOM rotation and drive cost-per-1k-runs down as you scale.
ExploreInternal & authorized testing
Automate first-party apps, operator-approved flows, and end-to-end checks — every run authenticated, scoped, and logged.
ExploreAccessibility & data ops
Token-efficient page state and human-in-the-loop handoff make repetitive, authorized web work reliable and auditable.
ExploreAutomates the web where you're authorized.
Twin is built for first-party sites, operator-approved automation, internal RPA, accessibility, and authorized testing. Auth, billing, and audit logging run on every call. It is not a CAPTCHA-bypass-for-hire or anti-bot evasion service.
Default-deny RLS
Tenancy is enforced in Postgres, not just the app. Every row is isolated by tenant with row-level security on by default.
Run URL = authorization
Each call is authenticated with your key and acts on exactly the target URL you provide — you hold the authorization, and it is stamped into the record.
Credential vault
Secrets are encrypted at rest, filled only at run time, and redacted from every log. Per-tenant keys, never shared.
Full audit log
Every run records its goal, path, success condition, and the target it acted on — a complete trail of what each agent did and where.
Usage credits. Cost that falls as you scale.
You pay for what your agent does, not per seat or per browser-hour. A read costs a credit; a solved semantic flow costs more — then every replay drops back to one. Discovery is the only premium you pay.
- Pay for actions, not seats
- Free to start — no credit card
- Compiled-skill replays cost a single credit
- LLM cost metered and passed through at 1×
- Pay-as-you-go auto top-up — no surprise stops
Transparent rate card at /api/v1/pricing.
Questions, answered.
What is Twin Browser?
Why does cost fall the more my agents run?
How do I call it?
What does it cost?
Is it a CAPTCHA-bypass or anti-bot evasion service?
What is the cross-tenant skill corpus?
Everything in one place
Dig into how Twin works, how to build on it, and where teams run it.
Product
The compile-cache-replay engine and everything it ships with.
Learn moreAPI
The versioned REST API under /api/v1/* — Bearer keys, OpenAPI.
Learn moreMCP
Drive Twin from Cursor, Claude, and Cline with run / compile_skill / run_skill.
Learn moreDocs
Quickstarts, references, and how the execution model fits together.
Learn moreUse cases
AI agents, RPA replacement, internal automation, and authorized testing.
Learn moreCompare
Twin vs re-run-the-LLM browser infra and generic RPA.
Learn moreGuides
Step-by-step walkthroughs for compiling and replaying skills.
Learn moreGlossary
Semantic cache, indexed DOM state, skill corpus — defined.
Learn moreGive your agent a browser that gets cheaper the more it runs.
Free to start. Compile your first skill in minutes and replay it for the cost of a single read — from MCP, REST, or the hosted dashboard.
Semantic dispatch cache · Deterministic replay · Cross-tenant corpus