Cursor taught you Playwright MCP in an IDE. Fazm runs the same server without one.
Every guide on this topic walks you through pointing Cursor at Microsoft's @playwright/mcp server so the code agent can drive a browser while you edit files. Fazm spawns that exact same server with the same --extension flag and the same Chrome Web Store bridge, from a consumer Mac app you talk to by voice. Then it bolts on three sibling MCP servers for Finder, Mail, and WhatsApp so one turn can cross apps.
WHERE THIS TOPIC SPLITS
Two honest answers hide inside the same phrase
When someone types this into Google, one of two things is true. Either they are a developer with Cursor open wanting to add Playwright MCP to their editor, or they want an AI to drive their browser and do not actually care that Cursor is involved. Most of the existing playbooks only answer the first version and quietly assume the second one is a subset of the first. It is not.
| Feature | Cursor + @playwright/mcp | Fazm (consumer Mac app) |
|---|---|---|
| Needs a code project open | Expects a workspace folder | No project, no IDE |
| Attaches to your real Chrome | Yes, same extension | Yes, same extension ID |
| Can drive Finder, Mail, or WhatsApp | No, browser tool only | Yes, via macos-use, whatsapp, google-workspace |
| Voice input | No | Push to talk, whisper or cloud STT |
| Requires paid subscription to the host | Cursor Pro or equivalent | Free to start, bring your own Claude key |
| Best used while you code | Inside the editor | When the task outgrows the IDE |
THE ANCHOR FACT
The five-name list that defines the surface area
This is the one line most guides on this topic cannot write, because they are building around an IDE that only has one browser tool. Inside Fazm's bridge, the set of built-in MCP server names is hard-coded in a single place. The browser is one of four automation targets, sitting next to a native macOS accessibility driver, a native WhatsApp driver, and a Google Workspace API driver. All four are MCP servers. The agent treats them identically.
The Playwright entry is spawned like this. Same CLI Cursor users point to. Same --extension flag. Same env var for the auth token. The only thing unique to Fazm is the init-page overlay script, which is a visual marker for the human in front of the screen, not a behavior change for the agent.
“Built-in MCP servers the agent can route a single turn to: playwright, macos-use, whatsapp, google-workspace. Cursor's Browser tool is one of them.”
acp-bridge/src/index.ts (BUILTIN_MCP_NAMES)
THE EXTENSION MODE
What --extension actually changes
Without the flag, Microsoft's Playwright MCP launches a fresh Chromium on each session. With the flag, it connects to a Chrome Web Store extension running inside the Chrome you use every day. Both modes expose the same tool list (browser_snapshot, browser_click, browser_type, browser_navigate, and so on) so a prompt written for one works for the other. What changes is the browser identity on the other side.
From a prompt to a click in your real Chrome
Five things Cursor's Browser tool cannot reach, that Fazm does
Not a shot at Cursor. It is a scope observation. The IDE's browser tool is exactly that: a browser tool. Cross the boundary and the IDE does not have an answer. Fazm does, because there are three more MCP servers on the same bus.
Read a Google Calendar invite
google-workspace MCP hits the Calendar API directly and returns the event as JSON. No browser involved. The agent decides whether to then open Chrome for the meeting link.
Open a file in Finder
macos-use drives Finder through the accessibility tree. The agent can navigate a path, reveal a file, and hand its absolute path back to the browser step.
Send a WhatsApp message
The whatsapp-mcp binary controls the WhatsApp Catalyst app natively. No web.whatsapp.com, no QR dance.
Read a Gmail thread
Gmail API via google-workspace MCP. Full thread text, attachments resolvable, no scraping.
Control Settings or Mail
Any AX-compliant Mac app. macos-use walks the accessibility tree, finds elements by role and label, and clicks or types on them the same way VoiceOver does.
Chain across all of the above
The agent routes each step to whichever MCP fits. One prompt, multiple servers, same conversation.
PROOF IN THE PROCESS LIST
What you actually see if you ps on Fazm
The easiest way to confirm the Playwright MCP server under Fazm is the same one a Cursor user would configure is to look at the running processes. The bridge launches Node against the bundled @playwright/mcp entry point, with the same argv you would write into Cursor's mcp.json.
When to stay in Cursor and when to leave
The honest recommendation is not a winner-take-all. Cursor is an editor with an agent bolted on. Fazm is an agent with a voice UI bolted on. The right answer depends on where your task actually lives.
STAY IN CURSOR
The task is code, the browser is the test harness
When to stay in Cursor
- Reproducing a bug in your own app during development
- Checking layout against a Figma reference while editing CSS
- Running Playwright assertions against a localhost dev server
- Iterating on a page while the AI drives the browser and you drive the code
MOVE TO FAZM
The task crosses apps or is not a code task at all
When to move to Fazm
- Find every invoice in Gmail this quarter, archive the paid ones, file the rest
- Read today's calendar events, open the Notion for each, paste prep notes
- Export a CSV from a web dashboard, rename it in Finder, send it over WhatsApp
- Reply to a thread in Gmail based on what is on screen in three other apps
Numbers you can verify in the source
Every number here is a count of files, flags, or exact binaries in the repo, not a benchmark.
Source: acp-bridge/src/index.ts around line 1027 for the Playwright spawn and the BUILTIN_MCP_NAMES constant; Desktop/Sources/BrowserExtensionSetup.swift line 220 and line 675 for the Chrome Web Store URL and the raw ID mmlmfjhmonkocbjadbfplnigmagldckm.
HOW THE SWITCH HAPPENS
The one environment variable that flips Playwright into your real Chrome
In Cursor, you turn extension mode on by editing mcp.json. In Fazm, the Swift app writes two UserDefaults keys when you complete the onboarding. The ACP bridge reads them, sets PLAYWRIGHT_USE_EXTENSION=true and PLAYWRIGHT_MCP_EXTENSION_TOKEN, and the server the agent talks to is now the attached-to-real-Chrome variant.
Honest caveats before you make the swap
There are things Cursor gives you that Fazm will not. Going in knowing this saves you a wrong-fit afternoon.
What stays in Cursor's lane
- Editing source files. Fazm has no code editor. If the end state is a diff, use Cursor.
- Local dev server context. Cursor knows your repo and running processes; Fazm treats every app as an MCP target, not a project.
- Typing into your editor as the AI works. Fazm does not sit inside your editor view.
What you gain the moment you step outside the IDE
- Voice input. Push to talk, transcribe with on-device or cloud STT, keep your hands off the keyboard.
- Native apps. Everything with an accessibility tree is reachable via macos-use.
- Cross-app chaining in a single turn. No copy-paste between tools.
- A free-to-start consumer Mac app that you can hand to a non-developer on your team.
Want the IDE workflow and the cross-app workflow in the same day?
We run a 20-minute walkthrough that sets up the Playwright MCP Bridge extension once and wires it into both Cursor and Fazm, so the same Chrome session works for both.
Book a call →Questions we keep getting about this exact topic
Is Fazm a replacement for Cursor's browser tool?
No, they solve overlapping problems from different angles. Cursor's Browser tool sits inside the IDE and is best when the AI is editing code and needs to verify changes in a live browser. Fazm is a standalone Mac app. The underlying browser automation server is the same in both cases: Microsoft's @playwright/mcp. Fazm just runs it outside any code editor and pairs it with three other MCP servers for native Mac apps.
What exactly do Cursor and Fazm share under the hood?
Both paths converge on Microsoft's @playwright/mcp server. In Cursor, you add it as an MCP server in the IDE settings and point it at an installed Chrome extension. In Fazm, the exact same server is spawned by the bundled ACP bridge with the args --extension --output-mode file --image-responses omit --output-dir /tmp/playwright-mcp --init-page browser-overlay-init-page.js. The Chrome Web Store extension the server attaches to, Playwright MCP Bridge with ID mmlmfjhmonkocbjadbfplnigmagldckm, is also identical. You can confirm this at acp-bridge/src/index.ts around line 1027 and Desktop/Sources/BrowserExtensionSetup.swift around line 220.
Does Fazm require me to install Cursor first?
No. Fazm has zero dependency on Cursor, VS Code, or any code editor. It is a signed, notarized Mac app. You do need Google Chrome installed at /Applications/Google Chrome.app, because the extension mode attaches to the Chrome window you are already signed into. If Chrome is not installed, Fazm shows a Download Chrome button and polls every two seconds for it to appear.
Why would I use Fazm instead of Cursor's Browser tool if I am a developer?
If your task genuinely lives in code, use Cursor. If the task crosses into apps that are not the browser, Cursor's Browser tool cannot help. Fazm ships four MCP servers in the same bridge: playwright for Chrome, macos-use for any accessibility-compliant Mac app, whatsapp for the WhatsApp Catalyst app, and google-workspace for Gmail, Drive, and Calendar. One voice turn can route to any of them. The built-in list is hard-coded in acp-bridge/src/index.ts: BUILTIN_MCP_NAMES = new Set(['fazm_tools', 'playwright', 'macos-use', 'whatsapp', 'google-workspace']).
Does Fazm's browser automation use screenshots or the DOM?
Both, because it is Microsoft's Playwright MCP. The default path is an accessibility-tree plus DOM snapshot from the browser_snapshot tool, which is text and cheap to reason about. Playwright also exposes a screenshot tool for the cases where the AI needs pixel confirmation. What Fazm does not rely on is pure screenshot-based robotic control. For Mac apps outside the browser, it uses the real macOS accessibility API via the bundled mcp-server-macos-use binary, not screen scraping.
Is the Playwright MCP attach mode really the same as what Cursor users configure?
Yes. The Chrome extension is the same Web Store listing, Playwright MCP Bridge, extension ID mmlmfjhmonkocbjadbfplnigmagldckm. The env var is the same, PLAYWRIGHT_MCP_EXTENSION_TOKEN. The CLI flag is the same, --extension. The only difference is who launches the server. In Cursor, the IDE launches it from mcp.json. In Fazm, the ACP bridge launches it from a TypeScript file at acp-bridge/src/index.ts.
Can Fazm drive Cursor itself?
Yes, because Cursor is a regular Mac app and the mcp-server-macos-use binary drives any app that exposes an accessibility tree. You can ask Fazm to open Cursor, navigate to a file, and run a command from the command palette, though it is usually a weird thing to ask for since Cursor has its own agent. Where this becomes genuinely useful is chaining: ask Fazm to read a calendar event, copy a repo URL out of the description, open Cursor on that repo, and then keep going in the browser.
How does the visual overlay work when Fazm drives Chrome?
Playwright MCP supports an --init-page flag. Fazm passes browser-overlay-init-page.js to it. That script runs once per navigation and mounts a small indicator so the human in front of the Mac can see the tab is being driven by the agent. The overlay does not alter the page content the AI perceives or submits, it only sits on top of it as a visual signal.
Does Fazm work if I already have @playwright/mcp configured in Cursor?
Yes. Each process spawns its own server. Fazm's bridge launches Node with its bundled @playwright/mcp CLI path at a specific node_modules resolution, and Cursor does the same from its own configuration. They do not fight over ports because Playwright's MCP transport is stdio, not TCP. The one shared resource is the Chrome extension token, which authorizes any caller that presents it to attach to your browser. Fazm stores its token in UserDefaults under the key playwrightExtensionToken.
Is Fazm open source?
Yes. The Mac app source is at github.com/fazm/fazm under an MIT license. The ACP bridge at acp-bridge/, the Desktop Swift package at Desktop/, and the bundled skill markdown files are all in the same repo. The third-party MCP servers Fazm bundles (playwright, macos-use, whatsapp, google-workspace) are each open source in their own repositories; Fazm just ships pre-built binaries inside the Mac app's Contents/MacOS so you do not have to install them.
What happens when I run a prompt that needs both the browser and Gmail?
The agent picks whichever tool fits each step. A prompt like 'find the most recent invoice from Anthropic in Gmail, open its billing portal in Chrome, and screenshot the current balance' routes the first step to the google-workspace MCP (Gmail API), the second step to the playwright MCP in extension mode (your real Chrome), and the third step stays in playwright. The agent does not need to switch between the browser and the desktop mode because both are just MCP tools on the same bus.