Playwriter vs agent-browser

agent-browser is a Rust CLI with 50+ commands, one per action: open, click @e2, fill @e3 "text", screenshot, close. By default it drives a new browser (Chrome for Testing, or a detected system Chrome/Brave) with a fixed command set.

Playwriter has one tool: execute. It runs any Playwright code in your already running Chrome with your logins and extensions. The agent writes real JavaScript with loops, conditions, and variables. It already knows Playwright, so there is nothing new to learn.

Comparison

	Playwriter	agent-browser
Browser	Your running Chrome (extension)	New browser by default
Login state	Already logged in	Fresh (or a read-only profile snapshot)
Extensions	Your existing ones	None by default (`--extension <path>` for unpacked)
API surface	1 `execute` tool + full Playwright	50+ CLI commands, one per action
Multiple actions per turn	Real JS: loops, conditions, variables	`batch` of quoted command strings
Reusable logic	Import a `.js` module with the live `page`	Shell scripts or `batch` command lists
LLM knowledge	Already knows Playwright	Must learn 50+ custom commands
Bot handling	Real Chrome; disconnect for manual challenges	Automated browser by default; stealth via plugin
Video recording	Native tab capture, no base64	CDP screencast piped to ffmpeg
Skill recorder	Record your workflow → reusable skill	Bundled reference skills only
Cloud browsers	Built-in stealth + proxy + CAPTCHA	Provider plugin
Remote tab sharing	Built-in one-click secret tunnel	No built-in tab-sharing tunnel
Raw CDP / debugger / live edit	Full, first-class	Via `eval` / CDP url

One tool vs fifty commands

agent-browser makes the agent learn a large surface: find role button click, get attr, storage local set, network route, and dozens more. Its optional MCP mode loads tool schemas into client context (mitigated with tool profiles and paginated discovery). When you need something the command set does not cover, you fall back to eval or raw CDP.

Playwriter exposes one execute tool. The agent writes Playwright, which it already knows from training. There is no command vocabulary to memorize and no per-tool schema tax.

1234567# agent-browser: separate commands, each a fixed shape
agent-browser open example.com
agent-browser snapshot
agent-browser click @e2

# Playwriter: one call, real Playwright the model already knows
playwriter -s 1 -e 'await page.goto("https://example.com"); await page.getByRole("button", { name: "Submit" }).click()'

Real scripts, not brittle bash

This is the core difference. agent-browser is one action per command. To do many things you either fire many commands or hand-write a batch array of quoted command strings. batch --bail stops on the first error and returns structured results, but there is still no real control flow, no variables, and no branching between steps.

Playwriter runs a whole JavaScript program in one call. Loop over rows, branch on page state, collect results, retry. It is a language, not a command list.

12345678910111213# Playwriter: loop, branch, and collect in a single execute
playwriter -s 1 -e '
  const rows = await page.locator("table tr").all();
  state.results = [];
  for (const row of rows) {
    const name = await row.locator("td.name").textContent();
    if (name?.startsWith("A")) {
      await row.locator("button.expand").click();
      state.results.push(name.trim());
    }
  }
  console.log(state.results);
'

agent-browser has an eval command, but it runs in-page JavaScript (document, window), not the Playwright driver. You cannot mix locator actions, auto-waiting, and Node-side state in one program the way you can with Playwriter.

Save a `.js` file, replay forever

Repeatable work should be a function you call again, not a fragile string of shell commands you paste each time. Playwriter runs from your session working directory, so the agent writes a helper once and replays it with different parameters.

12345678// submit.js
export async function submitProduct({ page, name, url }) {
  await page.goto('https://directory.example.com/submit')
  await page.getByRole('textbox', { name: 'Product name' }).fill(name)
  await page.getByRole('textbox', { name: 'Website URL' }).fill(url)
  await page.getByRole('button', { name: 'Submit' }).click()
  await page.waitForResponse(r => r.url().includes('/api/products'))
}

12# Replay any time, from any session
playwriter -s 1 -e 'const { submitProduct } = await import("./submit.js"); await submitProduct({ page, name: "Acme", url: "https://acme.com" })'

You can of course wrap agent-browser calls in your own shell or JS script. The precise advantage of Playwriter is different: it imports a module that receives the live Playwright page object and runs driver-side control flow (locators, auto-waiting, waitForResponse) in the same program.

Your Chrome, not a fresh one

By default agent-browser launches a new browser (Chrome for Testing, or a detected system Chrome or Brave). That instance starts logged out with default fingerprints, so a fresh automated browser is what sites see. It can copy your profile as a read-only snapshot with --profile <name>, use a persistent writable profile path, load unpacked extensions with --extension, or attach to a Chrome you launched with --remote-debugging-port (which shows Chrome's permission dialog an agent cannot dismiss).

Playwriter connects to the Chrome you are already using, through an extension. Your cookies, logins, and extensions are all there with zero setup. The site sees a real user browser because it is one. No dialog, no flags, no relaunch. See vs Chrome Direct CDP.

Video recording without base64 waste

agent-browser records video by driving CDP screencast frames into ffmpeg. That is the same per-frame base64 pipeline Playwright uses: frames are encoded to base64, shipped over CDP, then decoded before ffmpeg muxes them.

Playwriter records with chrome.tabCapture inside the extension. The MediaRecorder lives in the browser, so recording is native 30-60fps, survives page navigation, and never ships base64 frames over the wire.

123playwriter -s 1 -e "await recording.start({ page, outputPath: './demo.mp4', frameRate: 60 })"
playwriter -s 1 -e "await page.click('a'); await page.waitForLoadState('domcontentloaded')"
playwriter -s 1 -e "await recording.stop({ page })"

See Recording.

Skill Recorder

agent-browser ships bundled reference skills (skills get <name>) that always match the installed CLI version. Playwriter has a Skill Recorder for your own flows: perform a workflow once by hand in your real browser, and the agent turns the recording into a reusable skill with verified locators, expected network outcomes, and an importable replay script. Show a flow instead of describing it. See Skill Recorder.

Cloud browsers, built in

agent-browser reaches cloud browsers through a third-party provider plugin. Playwriter has cloud browsers built in: stealth Chromium instances with residential proxies (195+ countries) and automatic CAPTCHA solving (Turnstile, reCAPTCHA v2/v3, hCaptcha). They appear right next to your local Chrome in playwriter session new, so your scripts work unchanged. See Cloud Browsers.

Remote control for cloud agents

Playwriter lets a remote agent (Devin, a Grok bot, a friend's CLI) drive one tab of your own logged-in Chrome over a secret tunnel. You click the cloud button, paste the URL to the agent, and revoke anytime. The agent needs no install, only you have the extension. agent-browser can connect to a CDP url or a provider plugin, but has no built-in one-click tunnel for sharing a single tab from your existing Chrome. See Remote Access.

And more

Everything below comes free because you get the full Playwright API plus raw CDP, not a fixed command list:

Persistent session state across calls (state): build up context, reuse pages and handles.
Debugger and breakpoints: set breakpoints, step, inspect variables via createDebugger.
Live code editing: patch a page's running JavaScript with createEditor.
Full network interception: page.route, request/response listeners, mocking, HAR.
Performance profiling: CPU profiles and metrics over raw CDP.
Accessibility snapshots with aria-ref locators, plus Vimium-style visual labels.
Shared tabs across sessions: many agents work in the same browser without colliding.
Any MCP client or plain CLI: Claude, Cursor, OpenCode, Windsurf, scripts, cron.