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

Internal workflow automation

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

Start freeHow it works

The problem

Most internal operations run on tools that never shipped an API: legacy admin panels, vendor portals, insurance and procurement systems. Teams automate them with fragile scripts or armies of contractors, and either way there’s no clean audit trail and no safe place to pause for a human approval.

See how Twin works
app.example.com
  1. Open the internal admin paneldone
  2. Resolve service credentialsrunning
  3. Run the compiled workflow skillqueued
  4. Human approves the gated stepqueued
  5. Write the run to the audit logqueued

A Twin run for internal workflow automation — compile once, then replay on a cache hit.

The wedge

How Twin solves it

Twin automates first-party and operator-approved internal workflows where you’re authorized, treating the run’s target URL as the authorization signal and logging every call. It compiles each workflow into a replayable skill, holds credentials in the vault, and pauses for human-in-the-loop handoff on approvals or MFA — then resumes. Because it’s a multi-tenant backend with default-deny RLS, per-tenant API keys, and an audit log, it fits internal-ops governance rather than fighting it.

  1. 1Compile each internal workflow into a skill from a plain-language goal — no API required on the target system.
  2. 2Store service credentials in the per-tenant credential vault instead of in scripts.
  3. 3Insert human-in-the-loop handoff at approval and MFA gates; the run pauses and resumes cleanly.
  4. 4Every call is authenticated, billed, and written to the audit log for governance.
  5. 5Repeated runs hit the semantic cache and replay deterministically, so recurring back-office work gets cheaper over time.
In practice

One call, then it gets cheaper

Automate internal tools and vendor portals that never shipped an API — with credentials in the vault, a human checkpoint at gates, and an audit log on every call.

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: 'Approve the pending purchase order and record the reference number',
  url: 'https://admin.internal.example.com',
  credentials: 'internal-admin',  // never hard-coded in scripts
  onBlocked: 'handoff',           // approvals / MFA pause for a person
});

console.log(run.status);       // 'completed'
console.log(run.auditId);      // every call is written to the audit log
console.log(run.creditsUsed);  // recurring back-office work gets cheaper

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 that bends the cost curve

Every use case runs on the same primitives — the wedge that makes browser work cheaper the more your agents run.

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

Back-office work that once needed brittle scripts or manual labor becomes a set of governed, replayable skills — illustratively cutting per-run cost as the same workflows recur, with a full audit trail and clean human checkpoints.

Go deeper

Glossary: Credential vaultGlossary: Human-in-the-loop handoffGuide: Compile a reusable browser skill
FAQ

Internal workflow automation on Twin — common questions

What about tools that have no API?
That’s the core case. Twin drives the browser the same way a person would — over the live UI — so internal admin panels and vendor portals with no API become automatable through a compiled skill.
Is this authorized to run on our internal systems?
Twin automates the web where you’re authorized — first-party sites, operator-approved automation, and internal RPA. The run’s target URL is the authorization signal, and auth, billing, and audit logging run on every call.
How are approvals handled?
Blocked steps — approvals or MFA on an authorized flow — trigger human-in-the-loop handoff. The run pauses for a person to act, then resumes automatically, with the handoff recorded in the audit log.
Related

More ways teams use Twin

RPA replacement

Replace brittle, selector-keyed RPA bots with skills that adapt to the page and get cheaper the more they run.

AI agents

Give your LLM agent a real browser it can drive — and stop paying the model on every single run.

Accessibility automation

Drive web tasks on a user’s behalf and audit pages for accessibility — over a token-efficient view of the live DOM.

Put internal workflow automation on autopilot.

Start free, compile your first skill, and watch the marginal cost per run trend toward zero.

Start freeRead the guides