Perplexity opens its Mac agent app to everyone, and the interesting part is what still isn’t local

Perplexity has made Personal Computer available to all Mac users through its desktop app.

The pitch is straightforward: give an AI agent access to local files, native Mac apps, web tools, and a large set of connectors so it can handle multi-step work on your machine. Perplexity is going after the same desktop-agent category that picked up attention with projects like OpenClaw, but with a commercial product and heavier emphasis on safety.

That safety angle matters, because Perplexity’s version of “local” is only partly local.

What Perplexity is shipping

Personal Computer is now generally available on macOS as a direct download from Perplexity. It’s not in the Mac App Store. That makes sense. An app that can inspect local files, interact with native apps, and control workflows across services was always going to fit badly with Apple’s sandbox and review rules.

Perplexity says the older Mac app will be deprecated in the coming weeks so it can focus on the new Personal Computer app. This is becoming the Mac client, not a side project.

The app sits alongside Perplexity’s broader “Computer” push, which the company describes as a general-purpose, multi-model digital worker. The naming is still clumsy. “Perplexity Computer” and “Personal Computer” are easy to mix up, especially when one is mostly cloud-based and the other is supposed to work on your own device. Still, the direction is pretty clear: Perplexity wants an agent layer that can move from browser tasks into desktop work.

At launch, the Mac app can:

• work with local files
• interact with native Mac apps
• operate on the web
• orchestrate tools and files
• use 400+ connectors
• pull in personal context
• pair with Perplexity’s Comet browser to drive web tools without dedicated connectors

Perplexity is also pitching it for always-on setups such as a Mac Mini, with remote access from iPhone so you can start tasks or approve actions from your phone.

That part stands out. A lot of agent products still assume someone is sitting at the keyboard. Perplexity is pushing toward a semi-autonomous model where a machine stays online as the execution environment and the user steps in for approvals.

The biggest caveat: it’s not fully on-device

Perplexity says Personal Computer brings its agent system “onto the device where most of your real work already takes place.” Fine. But the company also says the app operates “within a secure development environment on Perplexity’s servers.”

So this is not a fully local agent in the way some developers will read the branding.

The desktop app looks like the access layer into your Mac, while some meaningful part of orchestration, reasoning, or execution context still runs in Perplexity-managed infrastructure. That may be the right product call. It gives Perplexity tighter control over runtime reliability, model routing, and tool execution, and it avoids dumping all compute onto the user’s machine. But it changes the privacy and threat model.

That distinction matters for developers, security leads, and IT admins. There’s a real difference between:

1. a local app using local models and local tool access
2. a local app brokering actions for an agent stack that runs partly in the vendor’s cloud

Perplexity is much closer to the second bucket.

That isn’t automatically worse. For plenty of teams, it may be preferable. Fully local agents with broad system permissions have already shown how ugly this can get. OpenClaw got attention quickly, and security researchers were just as quick to flag the risks. Elevated permissions, wide access to local resources, and autonomous decision-making are a bad mix when the implementation is loose. It doesn’t take many mistakes before “desktop automation” starts looking like credential theft or data exposure.

Perplexity’s server-side control plane may reduce some of that chaos. It also creates a different risk. Your desktop workflows now depend on a hosted intermediary with access to sensitive context and the ability to act across apps and services.

That’s the trade-off. Better guardrails, less actual locality.

Why this category is getting attention

The core idea is attractive because real work is still scattered across too many tools.

A developer might have specs in Notion, logs in the terminal, tickets in Linear, docs in Google Drive, rollout data in a spreadsheet, and a browser full of vendor consoles. Data scientists deal with the same mess across notebooks, CSVs, dashboards, cloud storage, and internal docs. The drag isn’t just opening windows. It’s carrying context from one system to another.

Personal Computer has value if it can hold that context across boundaries. Compare files from different apps. Pull notes from one tool and draft something in another. Use connectors where APIs exist, then fall back to the browser where they don’t.

That’s more useful than another chat sidebar dressed up as productivity software.

The technical appeal is the mixed execution model. Connectors are structured and usually more reliable. Browser automation is messy but flexible. Native app access fills the gaps where web APIs or connectors don’t exist. Together, that covers a wider range of tasks than any one approach by itself.

It also introduces a lot of failure points.

Where it breaks down

Agent demos tend to look good when the workflow is narrow and the environment is controlled. Real desktops are neither.

Native Mac apps don’t expose a uniform interface. UI automation breaks when windows move, menus change, permissions pop up unexpectedly, or apps update. Browser automation has the same problem, especially with dynamic front ends, bot detection, or multi-step authentication. Connectors are cleaner, but only for the services Perplexity supports well and only while those APIs stay stable.

So when Perplexity says the app can work across local files, apps, web tools, and hundreds of connectors, the practical reading is broad surface area with uneven reliability.

That’s normal for this category. It’s also why these tools are still a bad fit for workflows where failures have to be deterministic. If you’re dealing with regulated data, financial approvals, or production operations, an agent getting most of the way there is not good enough.

The remote approval flow from iPhone is a useful guardrail. It doesn’t solve the deeper problem. Human approval can catch risky actions, but it doesn’t prove the steps leading up to them were correct.

What technical teams should care about

For engineering and data teams, the obvious question is whether this can fit into existing work without turning into another security exception nobody wants to own.

A few things matter.

It’s a desktop agent, not a browser helper

That distinction matters. Browser-based AI tools are limited by what they can see and which services they can reach. Personal Computer reaches into local files and native apps. That makes it more useful for actual work, especially on macOS, where plenty of developer and analyst workflows still live outside the browser.

The connector count is less important than connector depth

Perplexity says it supports 400+ connectors. Fine. The useful question is whether the important ones are deep enough to do real work reliably. A connector that reads metadata but can’t perform the action you actually need is brochureware. Teams will need to test real workflows, not headline numbers.

Mac-only is a real constraint

Perplexity is starting with Mac users, which is a sensible place to find early adopters. Plenty of developers, founders, and data workers are on macOS. But if you run mixed environments or Windows-heavy fleets, this is not becoming a standard workflow layer anytime soon.

Outside the App Store means more freedom and more scrutiny

Direct download gives Perplexity more room on permissions and runtime design. It also means many orgs will treat this as privileged endpoint software, because that’s effectively what it is. If you manage enterprise devices, expect questions about MDM policies, logging, data flow, and exactly what leaves the machine.

Comet matters here

One important detail is the tie-in with Comet, Perplexity’s browser. If Personal Computer can drive web apps through Comet when no direct connector exists, Perplexity gets tighter control over one of the hardest parts of agent execution: the browser.

That’s a smart move. Browser automation gets easier when you control the browser stack. It also gives Perplexity a path to capture richer context from tabs, sessions, and page state.

The downside is obvious enough. This works best if you go deeper into Perplexity’s own ecosystem. That may be fine for individuals. Technical teams should look closely at that kind of platform coupling.

Promising product, overstated locality

Perplexity has a credible product here. A Mac-resident agent that can bridge local files, apps, connectors, and browser workflows is a better answer to day-to-day work than another chatbot pane. The always-on Mac Mini setup is also more practical than it sounds. Cheap dedicated hardware with remote approvals is a sensible way to run this sort of software.

But the branding pushes the local angle harder than the architecture seems to justify. “Personal” and “local” do a lot of work for a system that still depends on vendor infrastructure. That doesn’t make the product bad. It does mean buyers should read the architecture literally.

If you want a fully on-device agent, this isn’t it. If you want a managed desktop agent with broader reach than a browser extension and fewer obvious hazards than the early open-source crowd, Perplexity has something worth testing. Just don’t confuse convenience with containment.