Guide · May 2026
Perplexity computer browser automation capabilities, the honest map as of May 2026
Perplexity ships browser automation through two surfaces: Comet, a Chromium-based browser, and Personal Computer, a native macOS agent that drives Comet for web work. The marketing pages list the tasks. This is the architectural map: what runs where, what the bundled-browser tradeoff actually costs, and where an extension flow on your existing Chrome sits differently.
Direct answer · Verified 2026-05-26
What can Perplexity automate in a browser? Through Comet (Perplexity’s Chromium browser), the agent fills forms, clicks, navigates multi-tab workflows, transfers structured data between tabs, and runs supervised tasks like comparison shopping, hotel and flight booking, scheduling, and drafting emails from page content. On macOS 14 or later, Personal Computer drives Comet for web tasks and reaches native Mac apps for everything else. The agent loop runs on Perplexity’s servers; the local app is the eyes and hands. The browser is Comet, not your existing Chrome.
Verified against the Perplexity Comet product page, the Comet help center use cases, and TechCrunch coverage of the May 7 Personal Computer release.
What Perplexity is actually automating
Browser automation at Perplexity is not a single product. It is two products that meet at one runtime. Comet is the browser, available standalone, and it carries the agent inside it. Personal Computer is the macOS app that wraps the agent in a system-level hotkey and adds reach into native Mac apps. Where the two overlap is the web tool: Personal Computer’s answer for “the agent needs to click on a webpage” is “open Comet and let it work there.”
That overlap is also where the bundled-Chromium tradeoff lives. Both products share the same fresh Comet profile by default, so anything that happens inside a browser tab happens outside the profile your daily-driver Chrome lives in. For most casual use this is invisible. For users who pile a real workflow into Chrome (saved logins, work Google profile, 1Password extension, Cloudflare Zero Trust cookies, a couple dozen tab-specific extensions) it is the single most consequential implementation detail Perplexity ships, and almost none of the reviews mention it.
The reach surface
On a Mac with both Comet and Personal Computer installed, the agent can act on the surfaces below. The hub is the hosted orchestrator that picks which tool to call next.
Where the Perplexity agent reaches
A frame for the comparison
Almost every public review of Comet describes the same demo: it adds items to a cart, finds the cheapest flight, books a restaurant, drafts an email from an article. The capability list is real. The thing the reviews skip is the runtime: the agent does all of this inside Comet’s own profile, not inside whatever Chrome the reader is already using. That choice has a name (bundled-browser approach), it has tradeoffs, and it is not the only approach a computer-use agent can take. The table below is what the choice looks like side by side, comparing Comet’s default with the Playwright extension flow Fazm ships.
| Feature | Perplexity Comet | Fazm extension mode |
|---|---|---|
| Browser used | Comet (bundled Chromium, separate install). | Your existing Chrome (or Arc, Brave, Edge), driven via a Playwright extension over CDP. |
| Profile and cookies | Fresh Comet profile by default. Logins must be redone or imported per site. | Whatever profile your real Chrome already has. No re-login. |
| Extension stack reuse | Comet ships its own; your real-Chrome extensions are not loaded. | 1Password, Vimium, work-account managers, all the extensions you already trust stay loaded. |
| Where the agent loop runs | Hosted orchestrator on Perplexity servers. | Local Node bridge wrapping Claude Code or Codex through ACP, model call routed wherever you choose. |
| Isolation if you want it | Always isolated. That is the design. | Optional. Set FAZM_BROWSER_MODE=managed and a bundled Chrome with profile at ~/.fazm/browser-harness/profile takes over, seeded by ai-browser-profile from a Chromium source of your choice. |
| Audit trail of agent actions | In-app narration. No public tool-call log. | Open source on GitHub. Every MCP tool call is in your local process tree. |
| Reach beyond the browser on Mac | Personal Computer adds native Mac app control through Perplexity's macOS layer. | macos-use MCP server drives native apps through public Accessibility APIs; whatsapp and google-workspace MCPs add platform-specific reach. |
Tradeoffs are real on both sides. A bundled browser ships a consistent automation surface for the vendor to support; a real-Chrome extension flow inherits whatever state your Chrome already carries, including the parts you might prefer the agent did not touch.
The anchor fact, with the file
The browser-mode switch is a single environment variable. In acp-bridge/src/index.ts around line 203 of the Fazm source, the runtime reads FAZM_BROWSER_MODE and routes between three states.
- extension (the default). Spawns the Playwright MCP server with
--extensionwhenPLAYWRIGHT_USE_EXTENSION=trueand lets the agent attach to your real Chrome through the Playwright extension over CDP. No profile migration, no extra Chrome install. - managed. Drops Playwright and spawns the bundled browser-harness MCP instead. That server holds a persistent Chrome profile at
~/.fazm/browser-harness/profileand can be seeded with cookies and localStorage exported from Chrome, Arc, Brave, or Edge through the bundledai-browser-profilePython lib. - off. No browser server is loaded at all. The agent keeps fazm-tools, macos-use, whatsapp, and google-workspace, but cannot click in a browser. Useful when the user only wants the assrt QA browser available or wants the agent restricted to non-web work.
The three branches are visible at the same place in the source on GitHub at github.com/mediar-ai/fazm. That is the runtime configuration of a shipping product, in the open. It is also the part where Perplexity ships a different choice on purpose: Comet is the only browser the agent talks to, and there is no --use-real-chrome flag.
What a single browser-automation step actually looks like
The diagram below traces one click. The shape is similar between Comet and any other CDP-driven agent, but the network hops change: Comet’s orchestrator and model live on Perplexity’s servers, while a local extension flow keeps the orchestrator inside your Mac and only the model call leaves the machine.
One supervised click in Comet
The questions a careful evaluator asks
Five practical questions worth answering before you wire Perplexity (or any other computer-use agent) into a real workflow.
1. What of my existing Chrome do I lose
Comet is a separate Chromium install. Your real-Chrome extensions, your sync profile, your live SSO cookies for the work apps you do not want to log into again, your saved card autofill, all of it stays outside Comet by default. Comet does support importing some of this through its onboarding, but it is an export-and-reimport flow rather than a shared profile. For a daily-driver browser the gap closes over time as you log in inside Comet; for an agent that flips through twelve tabs of internal tools, the gap is sharper.
2. Which steps run supervised vs unsupervised
Comet runs supervised by default, with the agent narrating and pausing on actions it classifies as sensitive. Perplexity’s help center is explicit that the user is expected to be present. That is correct for a 2026 computer-use agent of any vendor. The line worth checking is which categories of action auto-execute vs require confirmation, because the answer changes as the product updates. The agent that books a hotel today on tap-tap-confirm might book a hotel tomorrow on a single voice command.
3. Can the agent observe what is on screen, beyond the tab
Inside Comet, yes. The agent has direct DOM access on the active tab and can switch between tabs at will. Outside Comet, on macOS, Personal Computer reaches into native apps through Apple’s permission stack (Accessibility, Screen Recording, Automation are the three permissions the launch app requests). The exact API path is not documented publicly, which is fine for a marketing site and worth noticing for a regulated environment.
4. Is there an audit trail
Comet narrates steps in the chat panel and logs actions in the activity log Personal Computer ships. There is no public per-action JSON log of the tool calls the orchestrator made, the prompts that produced them, or the model output. If your operating model requires reproducible logs of every agent action (regulated industries, internal tool governance, customer-data-touching workflows), the closed-source path puts the burden of proof on Perplexity rather than on the binary. The open-source alternative is to run a local agent and instrument it at the MCP layer.
5. What happens to your workflow if the vendor changes the product
Perplexity is iterating fast. The connector list grew past 400 in the first half of 2026. That is good for capability and a real risk for any workflow that pins a behavior. If your business automation is built on “Comet will continue to handle this internal portal the way it does today,” you are accepting product-update risk. An open-source agent does not eliminate that risk, but it shifts it: you pin the version of the runtime and the MCP servers, and you decide when to upgrade.
Where Comet ends and Personal Computer takes over
Comet covers the browser. Personal Computer covers everything else on the Mac. The handoff between them is one of Perplexity’s clearest architectural choices: the browser is its own runtime, the Mac is its own runtime, and the orchestrator owns the rule for when to switch. If the task is “summarize this page,” the agent stays in Comet. If the task is “take the row totals from that spreadsheet and paste them into the Slack channel for the team,” the agent has to step out of Comet and into Excel and then into the Slack Mac app, which means Personal Computer is in the loop.
The architectural cost is the same as the cost on the browser side: those Mac apps are reached through whichever macOS APIs Perplexity uses, and the user grants three permissions at the OS level (Accessibility, Screen Recording, Automation) the first time. The bundle of permissions any computer-use agent on Mac asks for is roughly the same across vendors. The disclosure of which API the agent picks for each step is where vendors actually differ.
Which one should you use
The honest framing. If your workflow lives on public web pages, the connectors you care about already exist in Perplexity’s 400+ list, and you are happy adopting a new browser as your daily driver, Comet plus Personal Computer is a polished consumer product with one bill and a vendor on the hook for the kill switch working. The Pro tier at $20 per month is reasonable for what the agent does.
If your workflow leans on your existing Chrome (work logins, password vault, custom extensions, saved sessions you do not want to redo), or you need to read the code that touches your microphone, your file system, and your tabs, the open-source path is the more honest answer. The same agent loop runs locally, the model call is routable, and the browser-automation runtime is the one you already use every day. That is the design Fazm ships.
They are different products with different defaults, not the same product at different prices. Pick the one whose defaults match the part of your stack you want to keep.
Need an agent that drives your real Chrome
If your workflow lives in the browser profile you already use, we can show you how the extension flow attaches without rebuilding your sessions.
Frequently asked questions
What can Perplexity actually automate in a browser as of May 2026?
Two surfaces. Comet, Perplexity's Chromium-based browser, handles in-browser tasks directly: form fills, clicks, multi-tab data transfer, comparison shopping, hotel and flight booking, scheduling, drafting emails from the content of an open tab, and pulling structured data across pages. Personal Computer, the macOS agent that opened to Pro and Enterprise tiers on May 7, 2026, drives Comet for web work and reaches into native Mac apps for everything else. Both go through Perplexity's hosted orchestrator. The local layer is the eyes and hands; the model and the loop run on Perplexity's servers.
Does it run inside my existing Chrome or its own browser?
Its own. Comet is a separate Chromium build maintained by Perplexity. That means a fresh profile by default, no inherited cookies, no inherited extensions, no inherited password vault, and no shared cache with the Chrome (or Arc, Brave, Edge) you already use. Comet has its own profile importer for some sites, but if you rely on your existing Chrome session for a tool that does not survive an export and reimport, the agent will hit the login wall fresh. This is the architectural cost most reviews skip past.
Which kinds of tasks does Comet handle well today?
Anything that lives at the surface layer of a public webpage with a sane DOM. Comparison shopping, restaurant booking, summarizing a long article, drafting an email from the content of a page, filling out a form that exposes its inputs cleanly, transferring structured data between two tabs, and walking through a multi-step research workflow with intermediate tab state. Perplexity's own help center is explicit that the agent runs these under supervision and will pause for confirmation on actions it does not trust.
Where does Comet fall over?
Three places. First, login flows that involve out-of-band 2FA, a hardware key, or a passkey tied to your other browser. Second, sites with heavy client-side state, custom protocol handlers, or non-standard payment frames. Third, anything that lives behind your real-Chrome extension stack: a 1Password autofill that only works because the extension is loaded in your Chrome profile is not present in Comet's profile unless you also install and unlock it there. Perplexity acknowledges the first and third categories in its public help docs.
Does Personal Computer use Comet or does it have its own browser?
Personal Computer uses Comet as its web tool. The architecture, as Perplexity describes it, is that the agent runs on the Mac, Comet runs as the in-browser execution environment for web tasks, and native Mac apps are reached through whichever macOS API Perplexity uses (the public technical detail of which API is not disclosed). If you uninstall Comet, Personal Computer loses the cleanest path to web automation. The pairing is intentional and bundled.
Can the agent drive my real Chrome instead?
Not natively. Perplexity's product is built around the assumption that you adopt Comet as the runtime. If your reason for wanting browser automation is that your real Chrome already has 23 extensions, every password autofilled, your work Google account signed in, and your Cloudflare Zero Trust cookies live, the Perplexity stack is asking you to migrate to a new Chromium and rebuild that state. An open-source alternative like Fazm takes the opposite default: a Playwright extension flow that attaches to your existing Chrome over CDP, no profile migration required. There is also a managed mode for users who prefer an isolated Chrome with explicit cookie import from Chrome, Arc, Brave, or Edge.
How autonomous is the loop in practice?
Supervised by default. Comet runs in an interactive mode where the agent narrates, takes a step, and waits for review on actions it classifies as sensitive. Personal Computer ships three named safeguards in its launch material: a sandboxed working directory for files the agent creates, audit logs for actions, and a kill switch. Those are reasonable defaults. They are also vendor claims about a closed binary, and there is no public third-party audit of the sandbox boundary yet. If your threat model treats sandbox-escape-via-prompt as a real risk, you take Perplexity's word for the implementation.
What is the difference between Comet's agent and a headless browser automation framework?
Comet is a real Chromium window with a user-facing UI. Each action lands in a tab you can watch and stop. A headless framework (Selenium, Playwright in headless mode, Puppeteer) runs the browser without a window, optimized for CI rather than for sitting on someone's desk. Comet's agent is closer in spirit to a power user who can read pages, not closer to a CI script. The cost is throughput: a CI grid runs hundreds of parallel headless sessions, an agent like Comet runs one interactive one.
Which Mac and which subscription do I need to use Personal Computer with Comet?
macOS 14 Sonoma or later. Perplexity Pro at $20 per month unlocks Personal Computer access as of May 7, 2026, alongside the rebuilt native Mac app. Perplexity Max at $200 per month still leads on new capabilities and bundles a broader model rotation, but the Pro tier carries the same orchestrator, the same hotkey, and the same access to Comet for web tasks. Comet itself runs on Pro by default.
Where does the agent loop physically run?
Mostly on Perplexity's servers. The Mac app reads window state, sends tool calls, and executes whichever local actions come back from the orchestrator. The orchestrator picks tools, runs the model, and what Perplexity calls intense tasks are processed in their secure development environment. The line they draw is essentially that the local app is the hands; the brain is hosted. For comparison, an open-source agent like Fazm runs the same shape of loop but the wrapper, MCP servers, and orchestration glue are local; the model inference is wherever the user routes it (Anthropic, GitHub Copilot proxy, or a corporate gateway).
Is the in-browser automation observable enough to debug?
Comet shows the active tab and narrates steps in the chat, which is a step up from a CLI-only headless tool. It does not expose a public log of the tool calls the orchestrator made or the prompts that produced them. If a step fails for an unobvious reason, you typically rephrase the prompt and rerun, rather than reading a transcript. For users who want a reproducible event log of every tool call, an open-source agent that runs locally is the only honest answer to that requirement.
What is the difference between Comet's browser automation and Fazm's browser automation?
Both drive a Chromium window through real DOM interactions, not pixel-coordinate clicks. The difference is which Chromium and where the loop lives. Comet uses Perplexity's bundled browser with a hosted orchestrator. Fazm spawns the Playwright MCP server in extension mode by default (config in acp-bridge/src/index.ts at line 203 reading the FAZM_BROWSER_MODE environment variable) and attaches to the user's running Chrome through a Chrome extension over CDP. A managed mode is available for users who prefer an isolated browser, and the bundled ai-browser-profile Python lib seeds it with cookies and localStorage exported from Chrome, Arc, Brave, or Edge. The agent loop runs locally; the only thing that crosses the network is the model call.
Keep reading
Perplexity Personal Computer for Mac (May 2026) practical guide
The launch context, the Pro vs Max split, and the architectural detail no launch article surfaces.
Perplexity Personal Computer Mac alternative, the local one
If the hybrid-cloud architecture is the part you want to swap, the source layout of the local alternative.
Open source computer use agent for Mac
What an open computer-use agent actually does on macOS, the source layout, and where the model boundary sits.
Comments (••)
Leave a comment to see what others are saying.Public and anonymous. No signup.