Twin Browser
Platform
OverviewHow it worksREST APIMCP serverIntegrationsDocs
Capabilities
OverviewSemantic dispatch cacheDeterministic replayCross-tenant skill corpusToken-efficient DOMHuman-in-the-loopLive view & videoCredential vault
Solutions
All use casesAI agentsRPA replacementQA & test automationData extraction
Resources
GuidesGlossaryBlogCompareFAQStatus
Pricing
Log inGet an API key
Use case

RPA replacement

Replace brittle, selector-keyed RPA bots with skills that adapt to the page — you authorize the run, the agent does the work.

Start freeHow it works

The problem

Classic RPA records exact coordinates and CSS selectors. The moment a vendor ships a redesign, the bot breaks, and a developer rebuilds the recording by hand. Maintenance is the real cost — and the per-run price never falls, because every run replays a rigid script that can’t generalize.

See how Twin works
app.example.com
  1. Open the vendor portaldone
  2. Resolve login from the vaultrunning
  3. Adapt cached skill to new layoutqueued
  4. Pause for approval (handoff)queued
  5. Resume and finish the runqueued

A Twin run for rpa replacement — compile once, then replay on a cache hit.

The wedge

How Twin solves it

Twin replaces the brittle recording with a compiled skill driven by intent, not coordinates. The DOM-to-indexed-state compiler gives the planner a stable, numerically-indexed view of interactive elements, so a layout change degrades gracefully — the semantic cache adapts the cached skill instead of failing open. When a step genuinely needs a human (an approval, an MFA prompt on an authorized flow), Twin pauses for handoff and resumes.

  1. 1Describe the workflow as a goal once; Twin compiles it into a skill instead of a coordinate recording.
  2. 2Re-phrased or re-parameterized runs match the skill semantically — no recompile for every variant.
  3. 3A page redesign shifts the indexed DOM map, not your script; the cached skill adapts rather than snapping.
  4. 4Credentials live in the per-tenant credential vault; authenticated logins are handled without hard-coding secrets.
  5. 5Human-in-the-loop handoff covers approvals and MFA on authorized flows, then the run continues automatically.
In practice

One call, and the agent does the work

Describe the workflow once. Twin compiles a skill that adapts to layout changes instead of snapping on selectors — and pauses for a human at approval gates.

run.tsts
import Twin from '@twin-browser/sdk';

const twin = new Twin({ apiKey: process.env.TWIN_API_KEY });

const run = await twin.agents.run({
  goal: 'Submit the weekly expense report and capture the confirmation',
  url: 'https://portal.vendor.example.com',
  credentials: 'vendor-portal',   // resolved from the per-tenant vault
  onBlocked: 'handoff',           // pause for approval / MFA, then resume
});

console.log(run.status);       // 'completed' (or 'awaiting_handoff')
console.log(run.adapted);      // true when a redesign was absorbed
console.log(run.creditsUsed);  // falls toward ~1 as the skill is reused

What happens on this call

  • Twin compiles the goal into a deterministic, replayable skill.
  • The next re-phrased request matches it in the semantic dispatch cache.
  • Matched runs replay with zero LLM calls — credits drop back toward ~1.
  • Every call is authenticated, billed, and written to the audit log.
Read the API docs
Under the hood

The machinery under every run

Every use case runs on the same primitives — a token-efficient view of the page, deterministic replay, and a human-in-the-loop checkpoint, so the agent does the work under your guardrails.

Semantic dispatch cache

Re-phrased requests fuzzy-match a skill you already compiled, so they skip the planner LLM entirely.

Learn more

Deterministic replay

Matched skills replay the same way every time — a pass is a pass, and the marginal cost trends toward zero.

Learn more

Token-efficient DOM state

A live page becomes a compact, numerically-indexed map of interactive elements instead of raw HTML.

Learn more

Human-in-the-loop handoff

Blocked steps — approvals, MFA on an authorized flow — pause for a person, then resume cleanly.

Learn more

The outcome

Teams moving off coordinate-keyed RPA trade a maintenance backlog for skills that self-adapt, and watch cost per 1,000 runs fall — illustratively trending toward zero LLM cost on cache hits — instead of staying flat forever.

Go deeper

Glossary: RPA vs agentic automationTwin vs. SkyvernGuide: Compile a reusable browser skill
FAQ

RPA replacement on Twin — common questions

Why is Twin more durable than traditional RPA?
Traditional RPA keys on exact selectors and coordinates, so a redesign breaks it. Twin plans over a numerically-indexed map of interactive elements and matches intent semantically, so a layout change adapts the cached skill instead of breaking the run.
How does Twin compare to AI-RPA tools like Skyvern?
AI-RPA caches keyed on a parameter hash only help when the same workflow repeats with known parameters. Twin matches semantically across re-worded tasks and pools skills across tenants, so the hit rate climbs and cost falls as usage grows. See our Skyvern comparison for the full breakdown.
Can a human approve sensitive steps?
Yes. Twin pauses on blocked steps — approvals or MFA on an authorized flow — for human-in-the-loop handoff, then resumes the run from where it left off, with full audit logging.
Related

More ways teams use Twin

Internal workflow automation

Automate the internal tools and vendor portals that have no API — with audit logging and human approval built in.

AI agents

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.

QA & test automation

Author end-to-end tests as goals, run them deterministically, and replay every failure as session video.

Put rpa replacement on autopilot.

Start free, hand your agent the work under your guardrails, and let repeated runs replay at near-zero cost.

Start freeRead the guides