The browser automation studio that runs in your real Chrome, not a fresh Chromium sandbox
Selenium IDE, Playwright Codegen, Cypress Studio, BrowserStack Low Code, UiPath Studio Web, Bardeen, BAS, Browserbase, Firecrawl. The 2026 SERP for "browser automation studio" is dense, and almost every tool on it shares one structural choice: drive a fresh Chromium with no cookies, no fingerprint, and no logged-in sessions. Fazm flips that choice. Its studio is a chat surface that attaches to the Chrome window you already have open, through a Chrome Web Store extension whose ID is pinned in the Swift source. The result is a studio that walks past Cloudflare and Google's "this browser may not be secure" gates because the fingerprint already lives on the machine, and that pivots from `browser_click` to `mcp__macos-use__open_application` in the same session.
“The Chrome Web Store extension that lets Fazm attach to your real Chrome has the ID mmlmfjhmonkocbjadbfplnigmagldckm. That ID is hard-coded in Desktop/Sources/BrowserExtensionSetup.swift line 220. The on-page overlay text that proves Fazm is in your Chrome (and not a hidden Chromium) is hard-coded in acp-bridge/browser-overlay-init.js line 58: 'Browser controlled by Fazm · Feel free to switch tabs or use other apps'. Both are verifiable from the source and from any installed copy of Fazm.”
BrowserExtensionSetup.swift L220 + browser-overlay-init.js L58
What the SERP currently calls a "browser automation studio"
Read the top ten results in April 2026 and you get a tidy bucket list. Recorder/replay IDEs aimed at developers writing test specs (Selenium IDE, Playwright Codegen, Cypress Studio, BrowserStack Low Code). Visual canvas RPA tools (UiPath Studio Web, Power Automate Desktop, Bardeen, Workato). Botting and scraping platforms (BAS, Browserbase, Firecrawl, Multion). One thing every single one of them shares: when the studio runs the workflow, it spins up a fresh Chromium instance with no prior state.
Fresh-Chromium is a defensible default. It is reproducible, it is isolated, it is what every CI pipeline wants. It is also the single biggest reason these studios bog down in real consumer workflows: the moment a Cloudflare Turnstile shows up, or Google decides the browser looks suspicious, the script falls over and you spend the next two hours wiring up stealth-plugin or residential-proxy duct tape.
The anchor fact: how Fazm's studio attaches to your real Chrome
Two lines of code do the work. One Swift line in the desktop app sets a single env var. One TypeScript line in the bridge appends a single Playwright flag. Together they flip the underlying Playwright MCP CLI from "launch a fresh Chromium" to "connect to the running Chrome over CDP using the Chrome extension I just installed".
That is the entire bridge wiring. After this code runs, every `mcp__playwright__browser_*` tool call routes through the Chrome extension into your live Chrome process. Cookies, fingerprint, 2FA tokens, password manager state, all there. No stealth plugin, no proxy, no fresh-fingerprint problem.
Sandboxed Chromium vs your real Chrome, side by side
Both models have legitimate use cases. CI test suites and isolation-critical scraping want sandbox. Consumer workflows that already require you to be logged in, signed up, and trusted by the site want real-Chrome. Most browser automation studio articles never actually frame this as a tradeoff, so here it is.
Sandboxed studio vs real-Chrome studio
The studio launches a fresh Chromium with a clean profile every run. No cookies, no logged-in sessions, no extensions, no Chrome history, no saved passwords, no fingerprint that any anti-bot system has seen before. To pass a logged-in flow you script the login. To pass Cloudflare you bolt on a stealth plugin and a residential proxy. To pass 2FA you wire in a TOTP secret or a SMS gateway.
- Fresh Chromium fingerprint every run
- Login flow must be scripted from scratch
- Cloudflare/Turnstile gates require stealth + proxy
- Reproducible, isolated, CI-friendly
How a single "automate this" chat flows through the studio
The diagram is literal. Four local sources converge on the ACP bridge (the Node subprocess Fazm spawns). The bridge fans out tool calls to the Playwright MCP server (which is connected to your real Chrome over CDP), or to mcp-server-macos-use for any non-browser action. A single chat turn can use both.
Browser automation studio: chat input to live Chrome and Mac actions
Six dimensions where the Fazm studio differs from the SERP
Not a feature checklist. Six axes where the structural choice of attaching to your real Chrome (and reaching beyond the browser) leads to a visibly different daily experience than every other "browser automation studio" on the SERP.
Runs in your real Chrome
Attaches to the Chrome window you already have open via the Playwright MCP Bridge extension (ID `mmlmfjhmonkocbjadbfplnigmagldckm`). Cookies, sessions, extensions, fingerprint — all already there. No stealth plugins. No proxy. No 2FA detours.
Goes beyond the browser
Same studio session can pivot from `browser_click` to `mcp__macos-use__macos-use_type_and_traverse` and drive Numbers, Mail, Slack, Figma, or Xcode. The native binary `mcp-server-macos-use` is wired at `acp-bridge/src/index.ts` line 1057.
Studio surface is chat
Instead of a node graph or a script editor, the studio canvas is a natural-language chat. Each turn translates into a sequence of MCP tool calls. Faster than dragging boxes; the saved chat is the workflow document.
Visible 'controlled' overlay
Every controlled tab gets a glowing wing border and a centered pill: 'Browser controlled by Fazm · Feel free to switch tabs or use other apps' (`browser-overlay-init.js` line 58). You can never lose track of what is being driven.
Snapshots dumped to disk
`--output-mode file --image-responses omit --output-dir /tmp/playwright-mcp` (acp-bridge/src/index.ts line 1033). Snapshots and screenshots write to `/tmp/playwright-mcp/` instead of inflating the chat context. Inspectable later, never lost.
Token stays on your Mac
The extension auth token (base64url, 20+ chars) is saved to UserDefaults key `playwrightExtensionToken` and only piped into the Node subprocess at runtime. It never crosses the network.
Real-Chrome studio vs sandbox studio, on workflows users actually run
Not "Fazm beats UiPath". Concrete tasks a Mac user does, scored against the two structural models. Sandbox studios win anywhere isolation matters. Real-Chrome studios win anywhere session age and fingerprint trust matter, which is most consumer and prosumer flows.
| Feature | Sandbox studio (Selenium IDE, Playwright Codegen, UiPath Studio Web, BAS, Browserbase) | Real-Chrome studio (Fazm) |
|---|---|---|
| Pull a report from your logged-in Stripe dashboard | Requires scripted login + 2FA bypass + stealth | Yes, you are already logged in |
| Pass Cloudflare Turnstile on a logged-in admin panel | Often blocked, needs residential proxy + stealth plugin | Yes, fingerprint already trusted by the gate |
| Reproducible CI test of a public marketing page | Yes, this is exactly what sandbox is for | Possible but not the design center |
| Drive a Mac app like Numbers or Mail in the same session | No, sandbox studios are browser-only | Yes, via mcp-server-macos-use (any AX-compliant app) |
| User can see which tab is being driven | Sandbox runs in a separate window, easy to ignore | Yes, on-page overlay 'Browser controlled by Fazm' |
| Run the same workflow against a fresh Chromium in CI | Yes, this is the default | Possible (set playwrightUseExtension=false) |
| Survive a Google 'this browser may not be secure' interstitial | Often blocked | Yes, your Chrome profile age clears it |
| Studio surface is chat, not a node graph or script editor | Visual canvas (UiPath, BAS) or code editor (Playwright) | Yes, natural-language chat translates to MCP tool calls |
| Cookies and 2FA tokens never leave your machine | Varies; cloud platforms often store credentials remotely | Yes, the extension is local-only, token in UserDefaults |
| Snapshots saved to disk for later inspection | Varies; many keep snapshots only in-memory | Yes, /tmp/playwright-mcp/ via --output-mode file |
What happens, step by step, the first time you set up the studio
Seven steps from clicking "Set up browser access" in Fazm onboarding to the studio attached to your real Chrome and ready to drive any tab. Every step is a real call in the source.
1. You install the Playwright MCP Bridge extension into Chrome
Fazm opens `chromewebstore.google.com/detail/playwright-mcp-bridge/mmlmfjhmonkocbjadbfplnigmagldckm` via AppleScript so it lands in your existing Chrome profile, then polls `~/Library/Application Support/Google/Chrome/<profile>/Extensions/<id>` every 2 seconds (BrowserExtensionSetup.swift line 707) until it appears.
2. Click the extension icon, copy the auth token
The extension's status page renders a token. Fazm's onboarding accepts either the bare token or a full `PLAYWRIGHT_MCP_EXTENSION_TOKEN=...` line; `parseToken` (line 564) strips the prefix automatically, then `validateToken` (line 574) checks for base64url, 20+ chars.
3. Token saved to UserDefaults, ACP bridge restarts
`UserDefaults.standard.set(token, forKey: "playwrightExtensionToken")` (BrowserExtensionSetup.swift line 785). The bridge restarts so the new env vars take effect; `ChatProvider.swift` line 780 has a UserDefaults publisher that watches for changes and triggers the restart.
4. Bridge spawns Playwright MCP with --extension and CDP token
`acp-bridge/src/index.ts` line 1029: `if (process.env.PLAYWRIGHT_USE_EXTENSION === 'true') playwrightArgs.push('--extension')`. The CLI then constructs a CDP connection authenticated with the token, attaches to the running Chrome, and exposes `browser_navigate`, `browser_click`, `browser_type`, `browser_snapshot`, `browser_evaluate` as MCP tools.
5. First navigation injects the on-page overlay
Playwright's `--init-page` flag points at `acp-bridge/browser-overlay-init-page.js`, which calls `page.context().addInitScript(overlayScript)`. The overlay's HTML and pill text live in `browser-overlay-init.js` line 58: 'Browser controlled by Fazm · Feel free to switch tabs or use other apps'. Re-injected on every navigation by the patched `extensionContextFactory.js` (npm postinstall hook in `scripts/patch-playwright-overlay.cjs`).
6. The same chat thread can pivot to non-browser tools
When the model calls `mcp__macos-use__macos-use_open_application_and_traverse`, that routes to `Contents/MacOS/mcp-server-macos-use`, the bundled Rust binary registered at `acp-bridge/src/index.ts` line 1057. So the 'studio' that just scraped a logged-in page can immediately open Numbers, paste the data, and save the sheet, all in the same session.
7. Connection is verifiable end-to-end
`ACPBridge.swift` line 1503 exposes `testPlaywrightConnection()`, which sends a one-shot prompt: 'Call browser_snapshot to verify the extension is connected'. If the response contains 'CONNECTED', the studio is wired. The verify phase of onboarding runs this exact test before declaring the setup complete.
The studio wiring, in numbers
Three line numbers. One Chrome Web Store extension. One env var. That is the entire "real Chrome" wiring.
Verify the real-Chrome story with three commands
Three commands against a fresh clone of the Fazm desktop repo, or against an installed copy at `/Applications/Fazm.app`. The output below is the actual output as of April 2026.
Three consequences of running the studio in your real Chrome
Picking the real-Chrome model changes the daily experience of a browser automation studio more than the script syntax does. The three places it shows up most often.
Anti-bot gates stop being the bottleneck
Cloudflare Turnstile and Google's security interstitial are tuned to spot fresh Chromium with no profile age. Your year-old Chrome profile is exactly what those gates trust. The studio inherits that trust for free.
You stop scripting the login
Every sandbox studio guide opens with "here is how to store credentials and script the login." In a real-Chrome studio you are already logged in everywhere. The first MCP tool call lands on the page you actually want.
The studio extends to your whole Mac
Once the studio is a chat surface that fans out to MCP tools, there is no architectural reason to stop at the browser. The same chat call can drive Numbers, Mail, Slack, or Figma via mcp-server-macos-use, in the same turn.
Try the real-Chrome browser automation studio
Fazm is free to download for macOS. Onboarding installs the Playwright MCP Bridge extension into your existing Chrome and walks you through the four-step token paste. The same chat surface drives any AX-compliant native Mac app via the bundled mcp-server-macos-use binary.
Download Fazm for Mac →Browser automation studio FAQ
Frequently asked questions
What is a browser automation studio?
In April 2026, the term covers two non-overlapping things. One: a developer IDE for recording and replaying browser scripts (Selenium IDE, Playwright Codegen, Cypress Studio, BrowserStack Low Code Automation, the Russian-language Browser Automation Studio bot framework). Two: an RPA visual canvas for browser-centric workflows (UiPath Studio Web, Power Automate Desktop, Bardeen, Workato). All of them, with one structural exception, drive a fresh sandboxed Chromium that has no cookies, no extensions, and no fingerprint. Fazm is the structural exception. It is a consumer Mac app whose 'studio' is a chat surface, and the browser it drives is the Chrome window you already have open.
Why does the 'real Chrome vs sandboxed Chromium' distinction matter?
Because almost everything that breaks a browser automation flow in 2026 breaks at the gate, not in the script. Cloudflare Turnstile, Google's 'this browser may not be secure' interstitial, hCaptcha, Akamai Bot Manager, and Datadome all fingerprint Chromium signatures, look at session age, and treat clean Chromium profiles with hostility. A studio running in a fresh Chromium instance has to fight that battle every run with stealth plugins and residential proxies. A studio running inside your real Chrome session inherits a fingerprint that gates already trust because it has been on the machine for a year, signed into Google, with extensions and bookmarks and a real Chrome profile directory.
How does Fazm attach to a real Chrome instead of launching its own?
Through the Chrome Web Store extension named 'Playwright MCP Bridge' with extension ID `mmlmfjhmonkocbjadbfplnigmagldckm`. The exact URL is hard-coded in `Desktop/Sources/BrowserExtensionSetup.swift` line 220: `chromewebstore.google.com/detail/playwright-mcp-bridge/mmlmfjhmonkocbjadbfplnigmagldckm`. When the Fazm onboarding asks you to set up browser access, it opens that URL inside Chrome via AppleScript (so it lands in your active Chrome profile, not a fresh one), waits for you to install the extension, and verifies installation by scanning `~/Library/Application Support/Google/Chrome/<profile>/Extensions/<id>` until it appears. After that the bridge passes `--extension` to the bundled Playwright MCP CLI and Playwright connects to your live Chrome over the Chrome DevTools Protocol.
Where is the bridge that sets `PLAYWRIGHT_USE_EXTENSION=true`?
`Desktop/Sources/Chat/ACPBridge.swift` lines 369-377. The Swift bridge reads the user's preference (default on), exports `PLAYWRIGHT_USE_EXTENSION=true` and `PLAYWRIGHT_MCP_EXTENSION_TOKEN=<token>` into the spawned Node subprocess, and the Node subprocess at `acp-bridge/src/index.ts` line 1028 then constructs the Playwright args with `--extension` appended. That single flag flips Playwright MCP from 'launch a fresh Chromium' to 'connect to the running Chrome over CDP using this auth token'.
What proves Fazm is actually using my Chrome and not a hidden Chromium?
An on-page overlay. Every page Fazm controls gets a glowing border and a status pill rendered into the DOM with the exact text 'Browser controlled by Fazm · Feel free to switch tabs or use other apps'. The overlay code is at `acp-bridge/browser-overlay-init.js`, the pill text is on line 58 of that file. It is injected by Playwright's --init-page mechanism (registered in `acp-bridge/src/index.ts` line 1037) and re-injected on every navigation by a patched `extensionContextFactory.js`. You can install Fazm, ask it to open google.com, and watch the overlay appear inside the Chrome tab you already had open. That is not a thing a sandboxed Chromium can do, because a sandboxed Chromium does not share a process tree with your existing Chrome.
Why does Fazm count as a 'studio' when there is no visual node graph?
Because the underlying capability set matches the RPA studio category, the surface is just a chat box instead of a drag-and-drop canvas. UiPath Studio Web exposes activities like 'open browser', 'click selector', 'type into', 'extract table', and you wire them with a mouse. Fazm exposes the same primitives via a Playwright MCP tool surface (`browser_navigate`, `browser_click`, `browser_type`, `browser_snapshot`, plus accessibility tools `mcp__macos-use__*` for the parts that are not in a browser), and the studio surface is a natural-language chat that the model translates into a tool call sequence. For a non-developer building an automation, the chat box is faster than the canvas; for a developer who wants reproducibility, the tool call log is the artifact you save.
Does the studio go beyond the browser?
Yes, and that is the second thing every other studio on the SERP misses. The same Fazm session that runs `browser_navigate` to load a Cloudflare-gated page can also run `mcp__macos-use__macos-use_open_application_and_traverse` to open Numbers, paste the scraped table into a sheet, and save the file. The Mac side is wired in `acp-bridge/src/index.ts` line 1057 with `mcp-server-macos-use`, a Rust binary inside `/Applications/Fazm.app/Contents/MacOS/`. So a single chat command can scrape a logged-in dashboard, transform the data in Numbers, and post the summary into Telegram, with no glue script and no separate tool.
Is the Playwright MCP Bridge extension safe?
It is the official `@playwright/mcp` Chrome extension (Microsoft, MIT-licensed). Fazm bundles a pinned version of `@playwright/mcp` as a Node module (path: `acp-bridge/node_modules/@playwright/mcp/cli.js`), and the Chrome side is the matching extension from the Chrome Web Store at the ID above. The auth token is a base64url string at least 20 characters long; `BrowserExtensionSetup.swift` lines 574-587 implement a parser that strips a `PLAYWRIGHT_MCP_EXTENSION_TOKEN=` prefix if you accidentally paste the env var line, and validates the character set. The token is stored only in macOS UserDefaults under the key `playwrightExtensionToken` and never leaves your machine.
What about Cypress Studio, Playwright Codegen, BrowserStack Low Code, BAS, UiPath Studio Web, Bardeen?
All real and useful, all built around a fresh-browser model, all aimed at a different user. Cypress Studio and Playwright Codegen are recorder/replay tools for developers writing test specs. BrowserStack Low Code Automation is a cloud test platform. BAS (Browser Automation Studio, Russian-language) is a Windows app for compiling botting scripts that emulate browser fingerprints. UiPath Studio Web is enterprise RPA. Bardeen is a Chrome extension that runs simple recipes inside your browser but is not capable of cross-app actions outside the browser. Fazm is the only one of the group that runs as a consumer Mac app, attaches to your real Chrome through a CDP extension, AND drives any other native Mac app through accessibility APIs in the same session.
Can I see exactly what the studio is doing in my browser?
Three places. One: the on-page overlay is a literal visible signal. Two: every Playwright tool call ID is logged to the chat thread and the log is queryable. Three: snapshots are written to `/tmp/playwright-mcp/` (set in `acp-bridge/src/index.ts` line 712, `PLAYWRIGHT_OUTPUT_DIR`). The studio uses `--output-mode file --image-responses omit --output-dir /tmp/playwright-mcp` (line 1033), which keeps the chat context small and dumps the full snapshots to disk where you can inspect them. The post-tool log line in the bridge prints the relative path so you can `open /tmp/playwright-mcp/<file>.yml`.
Does running in my real Chrome create privacy risk?
It is the same risk model as any Chrome extension you choose to install: the extension can interact with tabs you have open. Fazm reduces blast radius by injecting the visible 'Browser controlled by Fazm' overlay so you always know the session is being driven, by writing every action into the chat history, and by routing every tool call through Claude's permission model so destructive actions are auditable. The opposite trade is also real: a sandboxed-Chromium studio cannot accidentally touch your logged-in Gmail because it does not have access to it, but it also cannot DO anything useful in your logged-in Gmail without you also logging it in fresh, which most users find more annoying than the audit trail.
Is Fazm open source so I can verify the file paths in this guide?
Yes. Every file path here is a real path in the public repo. The relevant files: `Desktop/Sources/BrowserExtensionSetup.swift` (extension ID, install flow, token validation), `Desktop/Sources/Chat/ACPBridge.swift` (env var wiring), `acp-bridge/src/index.ts` (Playwright + macos-use MCP server registration), `acp-bridge/browser-overlay-init.js` (the visible 'Browser controlled by Fazm' overlay). Run `rg -n mmlmfjhmonkocbjadbfplnigmagldckm Desktop/Sources` and `rg -n PLAYWRIGHT_USE_EXTENSION` against a fresh clone and the lines line up with this page.
Comments (••)
Leave a comment to see what others are saying.Public and anonymous. No signup.