Sign in with Google — connect the accounts your agent may use — see the full stack
How it works
You send a goal. Everything between it and a finished run — the DOM compile, the cache check, the replay — happens automatically, and gets cheaper every time it repeats.
A plain-language goal comes in from the dashboard console, the REST API, or an MCP client.
The live page compiles into a compact numbered map of what an agent can act on — no selectors to maintain.
A re-phrased request is vector-matched against skills already compiled for this host.
A compiled skill runs by name, deterministically — the same flow, every time, with zero LLM calls.
No match yet — the planner discovers the goal once, then minimizes it to the shortest reliable route, so the next request is a hit.
Extracted data, confirmed clicks, or downloaded files land back with your agent — marginal cost trending toward zero as more runs hit the cache.
Cost per run
Nearly every repeat is a cache hit — so the second run of any task, and every one after it, costs a fraction of the first.
The wedge
Most browser infrastructure hands you a run button and a bill that scales with every execution. Twin ships the semantic cache, the cross-tenant corpus, and HITL guardrails as first-class infrastructure — the part that’s hard to run yourself, and the reason the second run of any task is cheaper than the first.
Most browser infrastructure re-runs the model on every execution, so cost climbs in a straight line with usage. Here a re-phrased request checks the cache before anything else happens.
How · A vector match against skills already compiled for that host, adapted to the new values — a cache hit, roughly a fifth the cost of a cold compile, instead of starting over.
One team compiling a flow shouldn’t mean every other team pays to compile it again — so a skill compiled once by anyone is available to everyone.
How · Compiled skills are sanitized and shared across the tenant corpus: the route is reused, your values and credentials never cross a tenant boundary.
An approval or an MFA prompt shouldn’t make an agent fail or improvise — so the run pauses at exactly that step instead of either.
How · HITL guardrails pause the run at the gate, you approve from the live console, and it resumes from precisely where it stopped.
Who it's for
The compile → cache → replay layer underneath is the same for everyone — what changes is the shape of the guardrails you set on top of it.
Give your AI agent a real browser it can drive — reach any site, act under your guardrails, and let repeated work replay at near-zero cost.
Learn moreReplace brittle, selector-keyed RPA bots with skills that adapt to the page — you authorize the run, the agent does the work.
Learn moreAuthor end-to-end tests as goals, run them deterministically, and replay every failure as session video.
Learn moreExtract from authenticated, multi-step pages you're authorized to reach — the agent signs in, does the work, and replays repeat pulls at near-zero cost.
Learn moreAutomate the internal tools and vendor portals that have no API — with audit logging and human approval built in.
Learn moreDrive web tasks on a user’s behalf and audit pages for accessibility — over a token-efficient view of the live DOM.
Learn moreHow it runs
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 service and it is not sold as anti-bot evasion.
Signals
Twin watches every run in the background so you only hear from it when something needs your attention.
Runs on
Runs on this infrastructure — not a partnership claim.
For developers
A versioned REST API under /api/v1/*, an MCP server (run_goal and 30 more tools) for Cursor, Claude Desktop, Claude Code, and Cline, and one-line LangChain/AutoGen adapters — or skip the code with the hosted dashboard console.
What it will and won't do
The guardrails aren't a policy page nobody reads — they're enforced in the same request path every run takes.
Every call is authenticated with your key and acts on exactly the target you gave it. You hold the authorization, and it is stamped into the record.
Tenancy is enforced in Postgres, not only in the application. Every row is isolated by tenant with row-level security on by default.
Secrets are encrypted at rest, filled only at run time, and redacted from every log. Per-tenant keys, never shared.
Every run records its goal, its path, its success condition, and the target it acted on — a complete trail of what each agent did and where.
Twin will
Twin won't
FAQ
The short, honest answers on how the delegation engine actually works.
Four ways in, pick whichever fits your stack:
Most browser infrastructure re-runs the LLM on every execution, so cost climbs with usage. Twin pays the model once at cold compile, serves re-phrased requests from the semantic cache at roughly a fifth of that, and replays compiled skills with no model in the loop — marginal cost per run trends toward zero.
Still have a question? Read the docs or email us.
Free to start. Connect an account, set the guardrails, and hand off the busywork — your agent runs it live in a real browser, from MCP, REST, or the hosted dashboard.
Any site · Any login you authorize · Guardrails you control