Does Perplexity just use other AI models?

The 'Wrapper' Question: Why It Matters

Search "is Perplexity just a wrapper" and you'll find no shortage of confident answers — usually some variation of "it's just GPT with a search box." The label sounds dismissive, and it matters more than it seems. If you're choosing AI tools for research and analysis work, whether a product owns its stack or merely resells someone else's API changes what you can expect from it on cost, reliability, and answer quality.

The honest answer is messier than the meme. Perplexity does lean on external frontier models — OpenAI's GPT series and Anthropic's Claude series are both in the mix, and Perplexity's own AWS case study confirms it serves Claude 3 models through Amazon Bedrock. But it pairs those with its own fine-tuned Sonar family and first-party embedding models, all coordinated by a routing layer that picks the right model for each query.

So the real question isn't "wrapper or not." It's: what does Perplexity actually own, and what does it borrow? The distinction matters because the two categories behave very differently:

• Borrowed components — frontier LLMs like GPT and Claude, plus the open-source base architectures (Mistral, Qwen3) underneath Perplexity's own models. Anyone can license these.
• Owned components — the Sonar fine-tunes, the pplx-embed models released in February 2025 to replace third-party embeddings from OpenAI and Cohere, and a proprietary search index tracking over 200 billion unique URLs.
• The glue — an orchestration system that routes a simple definition query to a small, fast in-house model and a complex multi-step query to a heavyweight like Claude Opus.

That third category is where the answer lives. As one technical deep-dive puts it, Perplexity's core competency is "not the development of a single, superior LLM but rather the orchestration of combining various LLMs with a high-performance search system." The company's history backs this up: it abandoned external search APIs — one leading provider charged $200 per thousand queries — and built its own crawling, indexing, and ranking infrastructure instead.

The nuance cuts both ways. Even Perplexity's "own" models are fine-tuned on external foundations, and independent benchmarks rate Sonar Pro at an estimated Intelligence Index of 8, just above the median of 7 for non-reasoning models. Owning the plumbing doesn't automatically mean owning the best model.

For anyone evaluating AI research tools, that's the useful lens: stop asking whether a tool is "just a wrapper" and start asking which layers it controls. The same logic applies when you equip AI agents — the agent framework is commoditized, but the skills and tools you attach to it determine the results. That's exactly the problem SkillzBench is building for: a free directory that discovers, verifies, and benchmarks agent skills, with a free MCP connector to wire the ones you choose into your agents.

Inside the Model Mix: GPT, Claude, and Sonar

Perplexity doesn't hide the fact that it borrows the biggest brains in AI — but the way it deploys them is the real story. Behind every answer sits a routing system that treats models like a toolbox, not a brand.

According to ByteByteGo's architectural analysis, Perplexity runs a heterogeneous mix of models: in-house fine-tuned models from the Sonar family, plus third-party frontier models from OpenAI's GPT series and Anthropic's Claude series. An AWS case study confirms Perplexity offers Claude 3 to users via Amazon Bedrock, with a 200,000-token context window — roughly 150,000 words of material per query.

Small classifier models decide who gets the job. A simple definition request routes to a small, fast in-house model; a complex multi-step reasoning task goes to a heavier hitter like GPT-5 or Claude Opus. The guiding principle, per ByteByteGo, is the smallest model that still delivers the best user experience — a deliberate hedge against vendor lock-in and pricing shifts.

Even Perplexity's "own" models stand on external shoulders. Its Sonar Small and Medium models are fine-tuned versions of open-source Mistral 7B and Mixtral 8x7B, trained on Perplexity's AWS infrastructure. Its pplx-embed embedding models build on the Qwen3 base architecture. Sonar Pro's size remains undisclosed, though Artificial Analysis gives it an estimated Intelligence Index score of 8 against a non-reasoning median of 7.

The combination happens through a multi-stage RAG pipeline:

• An LLM parses query intent and complexity
• Live web retrieval pulls 60+ sources per query, with an L3 reranker applying a ~0.7 quality threshold — only the top ~30% survive
• Citations are structurally assigned during context assembly, before generation begins
• The LLM synthesizes an answer constrained to retrieved material, with inline citations

That last constraint is the grounding philosophy in one line: "you are not supposed to say anything that you didn't retrieve." Because citations are embedded pre-generation rather than retrofitted, answers stay tethered to sources — though a Columbia Journalism Review review found a 37% error rate, so grounding reduces rather than eliminates mistakes.

The takeaway: Perplexity's moat is orchestration, not any single model. It's the same logic driving modern agent design — route each task to the right capability. SkillzBench is building a free directory and MCP connector for exactly that reason: to help builders discover, security-scan, and benchmark the agent skills that extend what any single model can do, since published research found ~26% of skills carry at least one vulnerability.

The Insourcing Journey: From Renting to Building

The most revealing part of Perplexity's story isn't which models it rents — it's what it decided to stop renting. The company's engineering blog is unusually candid about this: "The very first version of Perplexity's answer engine actually incorporated some of these offerings," referring to third-party search APIs. That arrangement didn't last.

The breaking point was economics. According to Perplexity's own engineering blog, one leading external search API provider quoted $200 per thousand queries — an "exorbitant" price, compounded by design limitations that prevented Perplexity from tuning retrieval the way its answer quality demanded. So the team built its own crawling, indexing, retrieval, and ranking stack.

The scale of what replaced the rented APIs is striking. Perplexity now describes an exabyte-scale index tracking 200 billion+ unique URLs, with capacity for "many hundreds of billions more." Its crawler and indexing fleets run on tens of thousands of CPUs and hundreds of terabytes of RAM, executing tens of thousands of indexing operations per second.

Embeddings followed the same pattern. In February 2025, Perplexity released pplx-embed-v1 and pplx-embed-context-v1, replacing reliance on third-party embedding providers like OpenAI and Cohere. The pplx-embed models were trained on roughly 250 billion tokens across 30 languages — and notably, pplx-embed-context-v1-4B scores 81.96% on the ConTEB benchmark, edging out Voyage's voyage-context-3 at 79.45%.

The insourcing journey, in short:

• Search: from the Bing Web Search API (its 2022 approach) to proprietary search infrastructure
• Embeddings: from OpenAI and Cohere providers to first-party pplx-embed models
• Models: from pure reliance on frontier LLMs to fine-tuned Sonar models — themselves built on Mistral and Qwen3 bases

Even here, the nuance matters: Perplexity's "own" models still rest on external foundations, as its AWS case study confirms for Sonar Small and Medium.

Why insource selectively? Because the strategic logic is explicit: orchestration, not any single model, is the moat. ByteByteGo's analysis frames model-agnostic design as a deliberate defense against vendor lock-in and pricing changes — the very risk that the $200-per-thousand-queries episode made concrete. Perplexity internalizes the components where control drives quality (retrieval, embeddings, routing) and rents where frontier capability justifies the cost.

That same logic — equip your agent with the right tools per task rather than betting on one — is what SkillzBench is building toward with its free skills directory and MCP connector, letting you discover, verify, and benchmark agent skills before you depend on them.

What the Evidence Doesn't Settle

For every confident claim about Perplexity's architecture, there's a conflicting number or an unresolved question sitting right next to it. That's worth pausing on before you accept any tidy narrative about how the product works.

Start with scale. ByteByteGo reports Perplexity's index is supported by "over 400 petabytes in hot storage," while Perplexity's own engineering blog describes an "exabyte-scale index" — a gap of roughly 2.5x that neither source reconciles. User counts diverge too: the AWS case study cites "more than 10 million monthly users," while Ziptie's analysis puts active users at roughly 22 million. These figures likely reflect different dates, but no source says so explicitly.

The deeper question is whether the search index is truly proprietary. ByteByteGo states Perplexity "outsources search infrastructure to Vespa AI rather than building its own web-scale index," while Perplexity's blog and Ziptie describe fully in-house crawling, indexing, and ranking. These may describe different layers of the stack or different timeframes — but the contradiction is unresolved, and it matters for anyone evaluating the "orchestration is the moat" story.

• Conflicting scale figures — 400PB vs. exabyte-scale index; 10M vs. 22M users; 200M daily vs. ~780M monthly queries.
• Unresolved index question — Vespa AI outsourcing vs. proprietary infrastructure, with no source reconciling the two.
• Vendor bias
— the AWS case study and Perplexity's blog are promotional first-party sources; independent benchmarks like Artificial Analysis should carry more weight for performance claims.

Then there's the accuracy question. The grounding philosophy sounds airtight — "you are not supposed to say anything that you didn't retrieve" — and the RAG design is often described as less hallucination-prone. But the Columbia Journalism Review found a 37% error rate in Perplexity answers, which complicates that claim considerably. Grounding reduces hallucination risk; it doesn't eliminate it.

The takeaway for readers is simple: treat AI tool claims like any vendor claim. Attribute every figure, check who published it, and prefer independent verification over first-party marketing. That's the same discipline SkillzBench applies to agent skills — the platform being built at skillzbench.com will pin every skill to a commit SHA, security-scan it, and benchmark it with and without the skill before publishing results, because published research found ~26% of skills carry at least one vulnerability. Whether you're evaluating a search engine or a skill package, the principle holds: verify before you trust.

The Orchestration Lesson for Your AI Stack

If there's one lesson to steal from Perplexity's architecture, it's this: the winning move isn't owning the single best model — it's matching the right model to the right task. Analysts at ByteByteGo put it plainly: the company's moat is not any single LLM, but the proprietary orchestration system that combines many models with high-performance search.

That orchestration is remarkably deliberate. Small classifier models read each query's intent and complexity, then route it — a simple definition goes to a fast, small in-house model, while a multi-step reasoning task gets routed to something more powerful like GPT-5 or Claude Opus. The guiding principle is to use "the smallest model that will still give the best possible user experience." Even Perplexity's own Sonar models are fine-tunes of external bases like Mistral 7B and Mixtral 8x7B, built on its AWS infrastructure.

The same logic applies directly to AI agents. An agent's value doesn't come from the model underneath — it comes from what capabilities it's equipped with for each job. And here's where the parallel gets a warning label: agent skills are everywhere, but quality control isn't. Published research found that roughly 26% of agent skills carry at least one vulnerability, which means grabbing skills blindly is a bit like routing every query to an unverified model.

That's the problem SkillzBench is being built to solve. It's a free, independent directory of agent skills — the SKILL.md instruction packages used by Claude Code, Codex, Cursor, Gemini CLI, and chat-app agents — with a free MCP connector in development that lets you attach only the skills you choose to any agent. The approach mirrors Perplexity's playbook:

• Discover and verify — continuously crawl skills from GitHub, pin every version to a commit SHA, and run security, license, and quality scans before you ever install one.
• Benchmark honestly — test each skill in a sandbox with the same model, with and without the skill, and publish the measured Lift in percentage points.
• Equip precisely — toggle skills and tools per agent via one free MCP server, so each agent only sees what you assigned it, just as Perplexity routes each query to one chosen model.
• Stay current — track upstream changes, re-scan, re-benchmark, and notify you when something shifts.

Perplexity learned the hard way that outsourced components have costs — it abandoned third-party search APIs after being quoted $200 per thousand queries and built its own index. For agent builders, the equivalent lesson is cheaper: know exactly what you're plugging in, measure whether it actually helps, and keep control of the routing. Trust scores from 0–100 and separately published Lift numbers mean money and marketing never touch the results — everything on the platform stays free, supported only by ads around blog content.

If you want your agents to route to the right skills the way Perplexity routes to the right models, join the SkillzBench waitlist to get early access to the directory, benchmarks, and MCP connector as they roll out.