Perplexity Just Built What OpenClaw Users Have Been Running Themselves
On February 25, Perplexity launched Computer — a cloud AI that orchestrates 19 models, runs sub-agents in parallel, and executes tasks autonomously for $200/month. Here's what OpenClaw users already have, what they don't, and what this means for the agent platform race.
On February 25, Perplexity launched “Computer” — a cloud AI system that orchestrates 19 models, runs sub-agents in parallel, maintains a persistent filesystem and browser, and executes tasks autonomously for extended periods. Available to Perplexity Max subscribers at $200/month, which includes 10,000 credits.
Ars Technica’s summary of the product: “Then there is OpenClaw, which you could perceive as the immediate predecessor to this concept.”
This piece covers what Perplexity Computer actually is, where it converges with OpenClaw, where it doesn’t, and what the $200/month is actually buying.
Table of Contents
- What Perplexity Computer Actually Is
- The Core Idea Is the Same
- Where They Diverge
- What Perplexity Can’t Do
- What Perplexity Does Better
- Who Each Is Actually For
- What This Means for the Agent Platform Race
1. What Perplexity Computer Actually Is {#what-it-is}
The pitch: describe an outcome in plain language and Computer figures out how to get there. “Plan and execute a digital marketing campaign for my restaurant.” “Build me an Android app that helps me track my reading.” You’re not writing prompts or picking tools — you’re describing what you want to end up with.
Behind that interface, Computer breaks the request into structured subtasks, delegates each to whichever of its 19 available models is best-suited for that specific step, and runs them — some in parallel, some serially — until the work is done.
The model stack:
| Model | Role |
|---|---|
| Claude Opus 4.6 | Core reasoning and orchestration engine |
| ChatGPT 5.2 | Long-context recall, wide web search |
| Gemini | Deep research, sub-agent creation |
| Nano Banana | Image generation |
| Veo 3.1 | Video generation |
| Grok | Lightweight, speed-sensitive tasks |
19 models total — the table above shows the main named ones. Opus is the orchestration layer; it decides which model handles which subtask. You don’t configure any of this. It happens invisibly.
The environment: Each task runs in an isolated cloud compute environment with access to a real filesystem, a real browser, and prebuilt tool integrations. Nothing runs on your local machine. The integrations are curated by Perplexity — no third-party plugins, no custom MCP servers.
Pricing: $200/month for Perplexity Max, which includes 10,000 credits. Computer consumes credits as it runs — usage is not unlimited. You can set spending caps per sub-agent, which gives you actual dollar-level control over how much any individual task is allowed to spend.
One caveat on the marketing language: Perplexity says Computer is “capable of running for hours or even months.” The product launched February 25. Nobody has verified the multi-month claim against a real workflow yet. File it under aspiration until there are user reports to back it up.
2. The Core Idea Is the Same {#same-idea}
AgentPuter Blog #01 (February 4, 2026):
“AI Agents are remarkably capable — but they have no home, no persistent workspace, no computer of their own.”
Perplexity Computer is a commercial implementation of exactly that thesis.
This isn’t a case of Perplexity reading that post and building a product. Perplexity started internal experiments in January — before Blog #01 published. This is multiple teams independently arriving at the same conclusion. Which is itself a signal: the problem is real and obvious enough that different organizations are solving it without coordinating.
The structural parallel is hard to miss:
| Concept | Perplexity Computer | OpenClaw |
|---|---|---|
| Persistent workspace | Cloud filesystem per task | ~/.openclaw/data/ |
| Multi-model routing | 19 models, Opus-orchestrated | model.fallbacks + modelByChannel |
| Sub-agent coordination | Task decomposition → agent delegation | sessions_spawn fan-out |
| Long-running autonomy | Claimed: hours to months | Cron + runTimeoutSeconds |
| Real browser | Built-in | browser_snapshot, browser_navigate |
| Agent context files | Platform-managed, not user-visible | SOUL.md, USER.md, HEARTBEAT.md |
| Spending controls | Credit caps per sub-agent | runTimeoutSeconds (time-based proxy) |
The design decisions map almost one-to-one. Persistent storage, browser access, multi-model routing, sub-agent parallelism, long-running autonomy — these aren’t features Perplexity invented. They’re features the OpenClaw community has been using, in configurable form, since last year.
OpenClaw’s creator Peter Steinberger joined OpenAI in February. Altman described personal agents as something that “will quickly become core to our product offerings,” and said the future “is going to be extremely multi-agent.” Anthropic launched Claude Cowork in January. The entire industry is now productizing the infrastructure pattern that OpenClaw’s open-source community built first.
3. Where They Diverge {#diverge}
The ideas are identical. The execution philosophy is opposite.
Ars Technica put it well: “If OpenClaw were the open web of AI agent tools, then Computer is Apple’s App Store.”
That analogy is accurate and worth sitting with. The open web lets you build anything and access anything — at the cost of security, reliability, and requiring technical sophistication. The App Store limits what you can build and access — and in exchange gives you a curated, safer, more consistent experience.
Neither is wrong. They serve different users with different priorities.
| Dimension | Perplexity Computer | OpenClaw |
|---|---|---|
| Where it runs | Cloud only | Local machine, self-hosted VPS, or TinyClaw |
| Integration model | Curated platform integrations | Open Skills + MCP ecosystem |
| Configuration | Platform-managed, invisible to user | openclaw.json, full user control |
| Security model | Platform is responsible | User is responsible |
| Customization ceiling | Low — use what Perplexity provides | High — configure anything |
| Transparency | Black box | Full transcript via sessions_history |
| Data location | Perplexity’s cloud | Your machine or your server |
| Spending controls | Credit caps per sub-agent | runTimeoutSeconds (time proxy) |
The trade-off runs consistently in one direction: Perplexity gives up control in exchange for simplicity and safety; OpenClaw gives up simplicity in exchange for control and extensibility.
4. What Perplexity Can’t Do {#cant-do}
These aren’t edge cases — they’re capabilities that OpenClaw users treat as table stakes.
SOUL.md — persistent agent identity
On OpenClaw, SOUL.md is a file that shapes how the agent thinks and behaves across every session. You write it once: “you are a research assistant who always cites sources, prefers primary documents over summaries, and flags uncertainty explicitly.” Every session starts with that context already loaded.
Perplexity Computer has no equivalent. Every task starts from the platform’s defaults. You can’t write a persistent instruction set, you can’t define how the agent should handle ambiguity, you can’t give it a character that persists. The agent you work with today has no memory of any preference you’ve established.
Custom Cron scheduling
Perplexity Computer is reactive. You describe a task; it executes. You are always the one who starts it.
OpenClaw runs scheduled workflows autonomously. “Every weekday at 7:50 AM, pull yesterday’s GitHub activity, summarize the PRs that need review, and push a digest to Telegram.” Nobody presses a button. The agent fires on schedule, does the work, and delivers the output — whether you’re awake or not.
There’s no equivalent in Perplexity Computer. Long-running workflows that Perplexity supports still require a human to initiate them.
Webhook intake
OpenClaw exposes a /hooks/agent endpoint. A GitHub Webhook fires when a PR opens; the agent reads the diff, runs a review, and posts feedback to Slack — all without human involvement. The external event drives the workflow.
Perplexity Computer has no inbound Webhook surface. It can’t listen for events from external systems.
Local file access
If your workflow touches files on your machine — reading code from a local repo, processing documents in your filesystem, interacting with local applications — Perplexity Computer can’t reach them. Everything runs in Perplexity’s cloud environment. Your local machine is invisible to it.
Third-party Skills and MCP servers
OpenClaw’s ecosystem includes thousands of Skills on ClawHub and agentskills.io, plus support for custom MCP servers. You can install a skill that connects to your internal tools, write a custom skill that encodes your organization’s workflow, or connect an MCP server that gives the agent access to your proprietary data.
Perplexity Computer works with what Perplexity has built and maintains. That set is small and curated by design. You can’t extend it.
An audit trail you own
sessions_history in OpenClaw gives you a complete, inspectable transcript of everything the agent did: every tool call, every model response, every decision point. When something goes wrong, you can read exactly what happened.
Perplexity Computer shows you outputs. The reasoning — which model was used for which step, what each sub-agent decided and why — stays internal to the platform. You can see what you got; you can’t see how you got it.
5. What Perplexity Does Better {#does-better}
Being honest about what the $200/month is buying matters. Several of these are genuine advantages, not just marketing.
Zero setup
No server to provision. No openclaw.json to configure. No API keys to manage. No MCP connections to debug. Open a browser, describe what you want, and Computer starts working.
On OpenClaw, even with TinyClaw handling the infrastructure, there’s still a meaningful setup step: connecting channels, writing SOUL.md, configuring the model stack, deciding on Cron schedules. For a non-technical user, this gap is significant.
19-model routing you never think about
Opus decides which of 19 models handles each subtask. You don’t specify “use Gemini for research, use Nano Banana for images, use Grok for lightweight tasks.” That routing happens automatically based on what Perplexity’s system has determined works best.
On OpenClaw, building equivalent multi-model routing requires intentional configuration: setting subagents.model, using modelByChannel, writing model.fallbacks, potentially writing custom routing logic in AGENTS.md. It’s doable — but it’s work.
Per-sub-agent spending caps
This is the one area where Perplexity has something OpenClaw explicitly doesn’t. Credit-based spending caps let you say “this research sub-task should not spend more than X.” That’s direct dollar-level cost control at the task level.
OpenClaw’s cost control works through time limits (runTimeoutSeconds) — a proxy for spend, not a direct spend limit. There’s no field that says “stop when you’ve spent $0.50.” Perplexity Computer has that field.
Pre-built integrations that work
Browser, code execution, image generation, video generation — these work out of the box, without debugging, without credential management. On OpenClaw, each capability either requires a Skill installation, an MCP server configuration, or an API key. The result is more powerful once configured; the setup cost is real.
No attack surface from unverified plugins
The ClawHavoc incident is the clearest illustration of the risk. In February 2026, 341 malicious skills were discovered on ClawHub in a coordinated supply chain attack. The primary payload was Atomic Stealer (AMOS) — a macOS credential stealer targeting cryptocurrency wallets, API keys, and browser passwords. Around 300,000 active OpenClaw users were potentially exposed. ClawHub’s open upload model — requiring only a 7-day account age and a GitHub account — made it trivially easy for attackers to publish at scale.
Perplexity Computer’s closed model eliminates this attack surface entirely. You can’t install a malicious skill because you can’t install any skills.
Commercial accountability
$200/month buys a support contract, an SLA, and an organization that’s accountable if the product breaks in a way that costs you. OpenClaw is open-source. TinyClaw is a hosted service with its own support model. But neither carries the same accountability weight as a major company’s flagship paid product.
6. Who Each Is Actually For {#who-for}
These aren’t competing for the same user. This matters because framing them as competitors leads to the wrong conclusion about which one to use.
Perplexity Computer:
The user who benefits most from Perplexity Computer has cloud-based workflows, doesn’t need to touch local files or trigger on external events, is comfortable with a platform managing all the routing and infrastructure decisions, and values “it just works” over “I understand exactly what it’s doing.”
A marketing consultant automating competitive research. A writer using AI to assist with research and drafts. A small business owner who wants to automate client communication workflows that live entirely in cloud services. For these users, the OpenClaw configuration layer is friction — not value. Perplexity Computer removes that friction at $200/month.
OpenClaw:
The user who benefits most from OpenClaw has specific infrastructure requirements: local file access, Cron-triggered autonomous workflows, Webhook-driven event handling, custom Skills for proprietary tools, or data residency requirements that make “runs in Perplexity’s cloud” a non-starter.
An engineer who wants a PR review bot. A developer who needs agents that work with code in a local repo. An operations team that needs autonomous monitoring workflows running against internal infrastructure. A researcher who needs long-running agents that accumulate knowledge across sessions in a SOUL.md file. For these users, Perplexity Computer’s curated model isn’t a simplified version of what they need — it’s a fundamentally different product.
The clearest test: if your workflow needs to start without human input (Cron or Webhook), or needs to touch files not in Perplexity’s cloud, you’re an OpenClaw user. If your workflows are initiated by you and live entirely in cloud services, Perplexity Computer is worth evaluating.
Both groups exist. Both will grow. The agent infrastructure market is big enough for both approaches, and the two will likely continue diverging rather than converging.
7. What This Means for the Agent Platform Race {#platform-race}
The infrastructure thesis is settled.
In early 2025, “agents need their own persistent compute environment” was a claim you had to argue for. In February 2026, it’s a product Perplexity is charging $200/month for, OpenAI is building into its roadmap, and Anthropic is shipping as Claude Cowork. The debate over whether this is a real product category is over. It’s a real product category.
Competition is now over who owns the infrastructure layer — not over whether the infrastructure layer exists.
The open-source-to-commercial pipeline is running on schedule.
OpenAI hired OpenClaw’s creator. Perplexity built a product on the concept. Anthropic built Claude Cowork. The pattern matches what happened with Linux → Red Hat → AWS, with Android → Samsung, with Git → GitHub. Open-source defines the category and proves the concept; commercial players productize it for mainstream adoption.
The question worth asking for the OpenClaw ecosystem: does the open, configurable version retain its distinctive value as the closed, polished versions improve? The answer historically is yes — but the value proposition has to stay clear. “Full control, any infrastructure, extensible ecosystem” is a coherent position. “A slightly cheaper version of Perplexity Computer with more setup” is not.
$200/month with credit limits establishes what the market will bear.
That’s the current price for the most polished, zero-setup, 19-model-orchestrated version of this capability. It comes with 10,000 credits included — not unlimited usage.
TinyClaw deploys the same underlying multi-agent architecture in under a minute, at significantly lower cost, with access to Cron scheduling, Webhooks, local file access, and the full OpenClaw Skills ecosystem. The value proposition isn’t “cheaper Perplexity Computer.” It’s a different product for a user who needs capabilities Perplexity Computer deliberately excludes.
The market is real. The infrastructure race has started. OpenClaw was the open-source prototype that proved the concept. Perplexity Computer is one of the first major commercial bets on it. Expect more.
Quick Reference
| Perplexity Computer | OpenClaw + TinyClaw | |
|---|---|---|
| Price | $200/month (10k credits included) | Open-source + TinyClaw pricing |
| Setup time | Seconds | Minutes to hours |
| Model count | 19 (auto-routed by Opus) | Configurable (any provider) |
| Spending caps | Credit-based, per sub-agent | Time-based (runTimeoutSeconds) |
| Customization | Low | High |
| Local file access | No | Yes |
| Cron / scheduled tasks | No | Yes |
| Webhook intake | No | Yes |
| Custom Skills / plugins | No | Yes (ClawHub, agentskills.io) |
| Persistent agent identity | No | Yes (SOUL.md) |
| Data location | Perplexity’s cloud | Your choice |
| Full audit trail | No | Yes (sessions_history) |
Resources
- Perplexity Computer announcement
- Ars Technica: Perplexity announces “Computer”
- agentputer.com — 24/7 cloud hosting for OpenClaw
- tinyclaw.dev — one-click deploy
- docs.openclaw.ai — OpenClaw documentation
- github.com/openclaw/openclaw — OpenClaw repository
Sources: Perplexity blog · Ars Technica · TechCrunch · The Verge · gHacks · The Tech Outlook · Feb 2026