Perplexity's Deep Research Rewrites Search in Python, Hits 83.8% on BrowseComp
Perplexity's Deep Research is now a native skill inside Computer, powered by a new Search as Code architecture that outperforms every major competitor on research benchmarks
Takeaways
- Deep Research is now a native skill inside Perplexity Computer, available to Pro ($20/mo) and Max ($200/mo) subscribers.
- Powered by Search as Code (SaC): the model generates Python to orchestrate thousands of parallel search operations instead of calling a fixed search endpoint.
- Benchmark gains are large: BrowseComp jumps from 40.7% to 83.8%; SaC outperforms OpenAI, Anthropic, Exa, and Parallel on 4 of 5 benchmarks.
- On WANDR (Perplexity's new professional research benchmark), SaC outperforms the next-best system by 2.5x; Perplexity plans to release WANDR publicly.
- Research now produces deliverables directly: reports, decks, spreadsheets, and dashboards without leaving Computer.
- Credit costs are opaque: no published per-task credit table; Max subscribers get 10,000 credits/month with no guaranteed task count.
Perplexity just made its most significant research upgrade yet. Deep Research is now a native skill inside Computer, Perplexity's multi-model agent platform, and it is built on a fundamentally new architecture called Search as Code (SaC). The result is a system that does not just search the web for you -- it writes code to orchestrate thousands of search operations in parallel, tailored to each specific question.
The old way was already broken
Traditional search was designed for humans: type a query, get back 10 blue links, and click through. That worked for decades. But in 2026, the primary consumers of search are no longer humans -- they are AI agents. And AI agents do not just need answers. They need to orchestrate complex retrieval workflows with thousands of operations, custom logic, and dynamic strategies tailored to each task.
Perplexity Computer unifies every current AI capability into one system, letting you research, design, code, deploy, and manage any project end-to-end from a single conversation. The problem was that its old Deep Research feature was still treating search as a monolith: fire a query, get a result, repeat. That architecture was becoming a bottleneck.
Search as Code: the model writes the pipeline
Search as Code (SaC) is a system that lets AI agents generate Python to call Perplexity's search stack directly, aiming to cut latency and reduce context pollution versus traditional tool-calling. Instead of the model calling a fixed search endpoint and getting back a blob of results, it now writes code that assembles the entire retrieval pipeline from scratch for each query.
SaC, now the default in the Perplexity Computer product and available via the Agent API, allows models to orchestrate search primitives such as async fan-out, deduplication, filtering, joining, and ranking before results hit model context. Think of it as the difference between ordering a pre-set meal versus cooking from raw ingredients -- the model now has access to every component of the kitchen.
The architecture has three tightly coupled layers:
- Models as the control plane: Models are well-suited to deciding what evidence is needed and how uncertainty should be resolved. Deterministic runtimes are well-suited to batching, parallelism, filtering, ranking, and aggregation.
- Compute sandboxes: Without sandboxes, models are forced into serial I/O and inefficient token-space processing. The sandbox is where generated Python actually executes, managing intermediate state across turns using a filesystem-based approach rather than keeping everything in memory.
- The Agentic Search SDK: Perplexity rearchitected their entire search stack into modular, atomic primitives. These are the building blocks the model composes into bespoke pipelines.
Here is a simplified illustration of what a SaC pipeline looks like in practice -- the model generates code like this to fan out across hundreds of sources in parallel:
# Model-generated code: fan out over vendor advisory sources
queries = [
{"vendor": vendor, "query": pattern.format(year=year)}
for year in [2023, 2024, 2025]
for vendor, pattern in templates
]
# Thousands of retrieval steps, running in parallel
seed_hits = sdk.search.web_many(queries, limit_per_query=8, concurrency=12)
# Filter to only authoritative sources
pages = [
{"vendor": q["vendor"], "url": h.url}
for q, hits in zip(queries, seed_hits)
for h in hits
if official_vendor_advisory(h.url, q["vendor"])
]The benchmarks are hard to ignore
Although SaC achieves state-of-the-art performance across the benchmark suite, its advantage is particularly pronounced on WANDR. Perplexity's SaC implementation outperforms the next-best system by a factor of 2.5x. WANDR is Perplexity's new internal benchmark designed to mirror real professional research workflows -- think competitive analysis, multi-source financial research, and legal mapping tasks.
Here is how Deep Research in Computer stacks up against legacy Deep Research on the benchmarks Perplexity published:
| Benchmark | Legacy Deep Research | Computer Deep Research |
|---|---|---|
| Humanity's Last Exam (HLE) | 36.4% | 50.5% |
| BrowseComp (OpenAI) | 40.7% | 83.8% |
| DeepSearchQA (Google DeepMind) | 81.9% | 85.0% |
Across the board, SaC provides a substantial boost in performance, with the largest absolute gain on DSQA (+19.77 pp, 29%) and the largest relative gain on WANDR (+12.00 pp, 45%). And critically, SaC does not just win on performance -- it dominates the cost-performance tradeoff across reasoning levels.
The comparison against other agent systems is equally striking. The benchmark suite comprises five benchmarks in total, designed to stress test search-dependent AI workflows across a range of domains, task formats, and complexity levels, using four preexisting benchmarks: DeepSearchQA, BrowseComp, Humanity's Last Exam, and WideSearch. Perplexity's SaC leads or ties on four of those five against OpenAI, Anthropic, Exa, and Parallel.
What this unlocks in practice
Deep Research in Computer is built on Perplexity's Agent Search SDK and Search as Code architecture, letting the model write code that assembles search itself, running thousands of retrieval steps, in parallel, tailored to each question. The practical implication is that research tasks that previously required serial, one-at-a-time searches can now be parallelized across hundreds of sources simultaneously.
The use cases that benefit most:
- Financial analysis: Finance answers in Computer and Deep Research all have a traceability layer, letting you audit information back to its original sources. Answers are powered by 40+ tools that pull from SEC filings, FactSet, S&P Global, Coinbase, CBOE, Nasdaq, NYSE, and other authoritative sources -- no setup required.
- Competitive intelligence: Multi-source breakdowns across earnings transcripts, news, and licensed data in a single run.
- Legal and compliance research: Mapping regulatory differences across jurisdictions, with every claim cited to primary sources.
- Deliverable generation: Deep Research now generates deliverables directly -- PowerPoint presentations, spreadsheets, dashboards, and websites from your research prompts. No more copy-pasting findings into other tools.
There are still limitations worth knowing. For intensive research workflows and structured document creation, results are impressive. For tasks requiring numerical precision or complex conditional logic, it is still uneven. The credit system also introduces unpredictability: Perplexity has not published a per-task credit conversion table. There is no page that says a research task costs X credits. Credit consumption varies, and the only way to see what a task cost is to check after it runs. This makes budgeting genuinely difficult.
How the SDK stays sharp over time
One of the more interesting engineering details is how Perplexity keeps the SDK itself from going stale. The SDK itself is optimized through autoresearch loops that test changes against latency, codegen quality, and task performance over weeks. The Agent Skills -- essentially the instructions that teach frontier models how to use the SDK -- are also continuously refined through a dedicated autoresearch loop, and are kept under 2,000 tokens to avoid bloating the model's context.
Perplexity also highlighted an internal benchmark, WANDR, built to mirror real professional research workflows, on which the firm claims a substantial performance lead. Management plans to release WANDR publicly, a move that could shape evaluation standards for AI research tasks and offer third parties a more transparent way to compare systems.
Who gets access and what it costs
Deep Research in Computer is available now to Pro and Max subscribers. Perplexity Pro is $20/month or $200/year. It includes unlimited Pro Search, 20 Deep Research queries per day, access to GPT-5.4, Claude Opus 4.6 and Gemini 3.1 Pro, plus $5/month of Sonar API credits. Perplexity Max sits at $200/month or $2,000/year, with unlimited Labs and Perplexity Computer (10,000 monthly credits).
The broader industry context matters here. In parallel, Perplexity continued expanding its enterprise reach through closer integration with Microsoft 365, bringing its Computer assistant into Excel, Word, PowerPoint, and Outlook. This side-panel deployment is backed by enterprise security features including SAML single sign-on, audit logs, and granular admin controls. The combination of a new search architecture, enterprise integrations, and a public benchmark release signals that Perplexity is positioning SaC as the infrastructure layer for serious agentic research -- not just a product feature, but a new standard for how AI systems should interact with information at scale.
The full technical paper on Search as Code is worth reading if you are building agents that rely on search. The core insight -- that models should orchestrate the search stack rather than merely consume its outputs -- is likely to influence how the broader field thinks about agentic retrieval going forward.