Perplexity’s Computer is a serious bet on AI routers

Perplexity has launched Computer, a cloud-based agent that can orchestrate 19 AI models, spawn subagents, browse the web through Perplexity’s own search stack, and assemble finished outputs like reports, charts, and websites. Access starts at the $200/month Perplexity Max tier, which tells you exactly who this targets: researchers, analysts, and teams making expensive decisions.

That matters because Computer points to a specific view of AI product design. Perplexity thinks model specialization is real, durable, and worth building around. Instead of asking one frontier model to handle every job, it routes work across many models and tries to pick the right one for each step.

The bet makes sense. Trusting the product is a separate question.

Why Perplexity built this

Perplexity’s pitch is simple: users don’t want to spend their day choosing models or stitching together fragile prompt workflows. They want to hand over a research task and get back something usable.

Computer is meant to do that as a computer-use agent running in the cloud. A planner breaks the request apart. Subagents take on specific tasks. A router chooses which model to call for each step. The system can also run a Model Council mode, where multiple models answer the same prompt and the system compares or aggregates the results.

If you’ve worked with agent frameworks, the architecture is familiar. What’s new is the packaging. Perplexity is turning a standard agent stack into a paid product for people who care about reliability, traceability, and output quality across mixed tasks.

The company says its own usage data backs the multi-model argument. In December 2025, visual work skewed toward Gemini Flash, software engineering toward Claude Sonnet 4.5, and medical research toward GPT-5.1. That matches what plenty of teams already see. Models have different strengths, and those differences are annoying enough that people still switch by hand.

Computer is supposed to absorb that mess.

The architecture holds up

Under the hood, this looks like a standard but competent agent stack:

• a planner that turns a broad request into a task graph
• subagents with narrower instructions and tool access
• a router that chooses models based on cost, latency, past performance, and content type
• a memory or scratchpad layer to hold intermediate results
• a policy layer for safety and boundaries
• tool access for browsing, code execution, extraction, and visualization
• a reporting layer that assembles the final deliverable

That architecture exists for a reason. A single prompt is a bad fit for serious multi-step work. If the task is “research competitors, extract pricing, compare positioning, build a chart, then draft a brief,” the failure modes stack up fast. One model call can miss a source, garble a table, or write a polished summary from bad retrieval. Breaking the task apart usually works better.

The router is the part that matters most. If Perplexity gets that right, it can beat a stronger single model on both cost and accuracy. There’s nothing mystical about it. It’s query allocation. Don’t spend premium model tokens on trivial extraction. Don’t use a cheap fast model where you need precision or source-heavy reasoning. Use ensembles when disagreement is actually useful.

It can also go wrong in ways that are hard to see from the outside. Once routing logic becomes part of the product’s intelligence, evaluation gets murky. If the results are good, was the planner effective, was retrieval strong, or did one expensive model quietly carry the whole run? If the results are bad, did the failure come from tool use, decomposition, source ranking, or model choice? Multi-model systems are good at hiding their own mistakes behind extra layers.

Cloud-only changes the risk profile

Perplexity runs Computer entirely in the cloud, not on the user’s device. For a product aimed at enterprises and research teams, that makes sense. Centralized execution gives Perplexity tighter control over logging, policy enforcement, model routing, and tool access. It also avoids some ugly local-agent risks like file exfiltration, rogue app control, or uncontrolled OS-level actions.

But cloud-only just moves the questions around.

Enterprise buyers will want clear answers on:

• where uploaded files are stored
• how long prompts and outputs are retained
• who inside Perplexity can access run data
• whether workspaces are isolated
• whether audit logs are exportable
• what model providers see when a task gets routed externally

Those are product questions, not legal footnotes. If Computer is meant for “GDP-moving decisions,” as Perplexity executives have suggested, reproducibility and governance matter as much as model quality.

A useful system here needs run traces, model identifiers, timestamps, tool-call history, token counts, and enough metadata to explain why an answer looks the way it does. Without that, you’re back to opaque AI with cleaner packaging.

Perplexity’s search stack matters

Computer uses Perplexity’s AI-optimized search API rather than third-party web search. That’s a bigger detail than it sounds.

Search is one of the most expensive and differentiated parts of any research agent. If your system depends on someone else’s search API, you inherit their indexing quality, ranking choices, reliability problems, and pricing. You also give up a lot of control.

By using its own search infrastructure, Perplexity can tune retrieval for agent workflows instead of generic search traffic. It can optimize around citation quality, document chunking, extraction, and query reformulation. That’s a better base for deep research than grafting search onto a chat product later.

It also shows Perplexity wants to own more of the stack than the interface layer. That’s expensive. It may also be necessary if the company wants to keep model vendors from flattening the category.

The canceled demo says a lot

One rollout detail deserves attention: Perplexity reportedly canceled a planned press demo just hours before it was set to happen because flaws were found in the product.

That’s embarrassing. It’s also one of the more credible things in the launch.

Live agent demos are where products fall apart. Agents loop, click the wrong thing, cite garbage, break on odd page layouts, or finish 90 percent of the task and quietly ruin the part that matters. Canceling the demo suggests Perplexity found something serious enough that it didn’t want to bluff stability in public.

It also underlines the obvious problem. A compelling architecture is easier than a dependable product. Multi-step agents are still fragile, and the failure surface gets large fast when you add 19 models, multiple tools, and parallel subagents.

The benchmark pitch is thinner

Perplexity is also promoting a new research benchmark called Draco, which it says better reflects deep research workloads. Fine. Benchmarks help, and standard chatbot evals do miss the messiness of real research tasks.

Vendor-built benchmarks still deserve skepticism. For a product like Computer, the useful test is whether it produces consistent, source-grounded work on ugly real tasks: internal strategy memos, regulatory research, competitive analysis with conflicting information, literature reviews that survive citation checks.

If Draco is any good, independent teams will put pressure on it. Until then, it’s support for a product claim, not proof.

What technical buyers should watch

If you’re evaluating Computer or building something similar, a few practical issues stand out.

First, observability. If the system chooses among 19 models, you need visibility into routing decisions. Otherwise cost control, debugging, and compliance get murky fast.

Second, determinism. Multi-model orchestration can drift badly across runs if model versions change, temperatures vary, or retrieval snapshots move underneath you. Teams doing regulated or high-stakes work need outputs that are at least directionally stable.

Third, unit economics. A flat $200/month plan sounds clean, but the cost profile underneath probably isn’t. Ensemble calls and premium models get expensive quickly. Any vendor selling this kind of product needs aggressive caching, pruning, early exits, and hard limits. Users will notice if “deep research” starts meaning “you hit your cap.”

Fourth, failure recovery. More providers and more subagents mean more points of failure. Good systems need retries, fallback models, provider health checks, and sane degradation when a dependency gets flaky.

And then there’s procurement reality. A lot of teams won’t buy an agent on narrative alone. They’ll want logs, admin controls, data retention settings, workspace boundaries, and predictable performance before they hand over real internal work.

Perplexity seems to understand that. The company has said it cares more about depth of usage than raw MAU counts. Fair enough. Enterprise AI gets judged on whether people trust it with expensive work.

Perplexity’s Comet browser is also headed to iOS next month, and the company has an Ask developer conference scheduled for March 11 in San Francisco. Those are useful signals. Perplexity is building around agentic search and research, not just adding another premium chat tier.

Whether Computer holds up is still open. The idea is credible. The timing makes sense. The execution burden is huge.

The next fight in AI products probably won’t be settled by one model. It’ll be settled by whoever can route messy work across imperfect models, tools, and retrieval systems without forcing the user to babysit the stack.