Back to Explore
NewsVibeFix editorialUpdated Nov 20, 2026

One API for 45 Models, and It Switches Providers When One Fails: Perplexity's Orchestrator Wants to Be the Switchboard

On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.

Against a black background, a conductor seen from behind raises a baton, with swirling trails of light circling beneath him like an orchestra being conducted

In short: more models, more scattered bills — Perplexity wants to collect them all

On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching frontier models from OpenAI, Anthropic, Google and xAI, plus open-weight models such as GLM, Kimi and DeepSeek. Swap in a Perplexity API key and base URL, and your existing OpenAI or Anthropic SDK keeps working. Each request is billed at the answering model's published per-token rate, with no additional platform fee from Perplexity.

The background is simple: this year alone, Anthropic and OpenAI have released more than a dozen new models, and over 100 open-weight models have shipped. More models mean more choice, but also more scattered bills — one account, one key, one contract and one invoice per provider, and every change to your model mix means renegotiating. Perplexity's bet is that picking a model is no longer the hard part; the hard part is making every request fast, reliable and affordable without a separate contract for each model. Orchestrator takes the "model layer" Perplexity has run internally for years and sells access to it.

This piece answers four questions: what Orchestrator actually is, how it differs from gateways like OpenRouter, whether its routing is genuinely useful or just decoration, and whether builders should adopt it now.

What Orchestrator is: the in-house model layer, now for sale

Perplexity describes itself as multi-model at its core: every day, its model layer routes hundreds of millions of requests across more than 85 models and over a dozen providers. Simple, high-volume work goes to cheaper models; demanding work is reserved for stronger ones, and the company has lowered its own serving costs the same way. Orchestrator opens that infrastructure to outside developers.

The public catalog lists more than 45 models from seven sources: 15 from Anthropic, 18 from OpenAI, 5 from Google, 3 from xAI, 2 GLM models from Z.AI, 1 from DeepSeek and 1 Kimi model from Moonshot AI. Open-weight models are served by Perplexity or through inference partners. Model IDs carry a provider prefix, such as anthropic/claude-fable-5-2 or perplexity/glm-5.3, the usual convention for gateway products.

The onboarding is its most ingratiating feature: it accepts OpenAI Chat Completions, OpenAI Responses and Anthropic Messages request formats. Most teams do not need to rewrite their calling code — change the API key and base URL (https://api.perplexity.ai/orchestrator/v1 for OpenAI-format requests; Anthropic SDK users drop the trailing /v1), pick a model, and the first request takes minutes, according to the company.

One pair of numbers is easy to confuse: the blog mentions both "85+ models" and "45+ models". The first is the scale of Perplexity's internal model layer, routed every day; the second is the number of models in the public catalog you can call right now. They describe two different things, so do not mix them up.

The key difference: switch the deployment, not the model

Every gateway promises automatic switching, but what gets switched matters, and this is Orchestrator's most interesting point: it switches the deployment, not the model. Pick Claude and it stays Claude. If Anthropic returns an error, hits a rate limit or times out, Orchestrator retries the same request on another deployment of the same model — AWS Bedrock, for example. Each retry attempt is bounded by limits on time to first token and total duration, so it does not wait forever.

This targets a specific pain: the model is chosen, but the provider is not always reliable. The same model behaves differently at different providers, and the ranking changes daily — one provider has an outage, throttles, or slows down, and your requests suffer with it. In its technical blog, Perplexity published measurements from 30 days of its own production traffic, 4 October to 2 November 2026: Claude and GPT requests routed through Perplexity succeeded more often than requests to any individual provider measured, and daily success rates varied less during provider incidents. Client errors such as invalid requests and client-side rate-limit violations were excluded; only server-side failures counted.

The launch blog also offers an arithmetic example: for a team running millions of requests a day, the gap between 99.0% and 99.99% success means thousands of responses. At one million requests a day, 99.0% means 10,000 failures and 99.99% means 100 — a simple calculation from the two percentages the blog gives. The intuition is plain: the larger the volume, the more the second decimal place of reliability is worth. It is also worth stating plainly that these measurements come from Perplexity's own traffic under its own methodology, not from an independent third-party test.

Speed is a variable too: which provider is fastest depends on the day

Beyond success rates, Perplexity published output-speed comparisons for the same models over the same 30 days, and the conclusion is the same: do not bet on one provider. For Claude Opus 5.5, Anthropic was fastest on 15 of the 30 days and AWS Bedrock on the other 15 — neither won consistently. For GPT-5.6 Sol, Azure's median output speed after the first token was 27% higher than OpenAI's. In other words, "which provider is fastest" is not a fixed answer but a ranking that changes daily.

Perplexity says it is building speed-aware adaptive routing so provider selection can follow live performance, but that is still in development and not live yet. So what Orchestrator guarantees today is: when a provider fails, it retries elsewhere. What it does not yet guarantee is always picking the fastest provider at that moment. That distinction is worth keeping in mind, so the product is not credited with more intelligence than it has.

Routes and Auto effort: tell it in one sentence which job goes to whom

On top of same-model failover, Orchestrator adds a model-switching layer, currently in preview, called Routes. You describe each kind of task in plain language and assign it a model, forming a routing profile; requests set the model to perplexity/auto, and a decision model reads the conversation, matches it against your route descriptions, and falls back to your default model when nothing matches. The decision model never sees the model names, only the task descriptions, and it also falls back to the default if the decision model itself fails or times out.

There are three built-in profiles — Lower cost, Balanced and Higher quality — or you can write your own. The technical blog gives three worked examples. Customer support: GLM-5.3 Flash by default, billing disputes to Claude Opus 5.5, technical issues to GPT-6.1 Sol. Coding: GLM-5.3 Flash by default, hard debugging to Opus 5.5, cross-module design changes to GPT-6.1 Sol. Research: factual questions to GLM Flash, calculations to Sol, memo writing to Opus 5.5. Routing also follows a conversation across turns: as one chat moves from an account question to a billing dispute and then a broken integration, the route changes with the task, and returns to the cheap default for a closing thank-you.

The other preview feature is Auto effort: it adjusts how much reasoning a supported model spends on its next turn according to a policy the developer defines. An agent can spend more effort recovering from a tool error without switching models. Both features are in preview, which means their behavior and pricing can change — keep an exit path ready before wiring them into a production-critical chain.

To show routing is useful, Perplexity ran an experiment: on a 63-task subset of Terminal-Bench 4.1, Claude Code with Claude Fable 5.2 alone solved 38 tasks; with routing profiles that sent security, biology and after-refusal work to GPT-6.1 Sol while keeping Fable as the default, it solved 41 — at a higher estimated cost per task. That is 41 versus 38, or 65.1% against 60.3% pass rates. Read it with its caveats: only 63 tasks, a small sample, and the chart notes that one Astra run includes an assumed pass and that costs are estimated. The fair conclusion is "routing helped on these specific tasks", not "routing is better across the board".

Terminal-Bench 4.1, 63-task subset: Claude Fable 5.2 alone solved 38 tasks; with routing it solved 41, at a higher estimated cost per task

How the money works: no platform fee, but the best models sit behind an upgrade

Pricing is Orchestrator's second selling point: each request is billed only at the answering model's published per-token rate, whichever provider serves it, so failover does not change the price. Usage draws from the same prepaid credits as the rest of your Perplexity API project, and the console breaks spending down by model, project and API key, with model allowlists and spend caps. There is no per-request fee and no additional platform fee.

But "no platform fee" does not mean "every model is open to everyone". Access is tiered by cumulative credit purchases: Tier 0 needs nothing and covers Google, xAI and open-weight models; Tier 1, after $50 in cumulative purchases, unlocks OpenAI and most Anthropic models; Tier 2, after $250, unlocks Claude Opus 5, Opus 5.5 and the Fable models. The strongest models are not on the default menu — you have to spend enough first. These tiers come from the official documentation's pricing table, with figures consistent across several reports.

For teams, the real convenience may not be the unit price but having all the spending controls in one console: costs break down by model, project and API key, so who burned what is visible at a glance; admins can set model allowlists restricting which models a project may use, and spend caps that stop one runaway loop from eating the month's budget. Those features sound unremarkable, but for teams handing agents to many people, they often matter more than a few percent off the price — an out-of-control bill is scarier than a slightly expensive one.

Two more limits matter: Orchestrator does not support bring-your-own-key, so you cannot plug in your own Anthropic or OpenAI keys; and you cannot manually pick a deployment — you choose the model, it chooses the provider. That is the biggest control trade-off against OpenRouter: the price of cheap and convenient is handing the choice over.

How it compares with OpenRouter: the next round of the gateway war

Judged only by "one API, many models", Orchestrator and OpenRouter do the same thing. But they play it differently. OpenRouter charges a 5.5% standard fee on credit purchases; Orchestrator charges none. OpenRouter's Auto Router picks the model for you; Orchestrator's default behavior keeps the model fixed and swaps the deployment, with model selection as a separate preview feature. This site covered OpenRouter's Auto Router and Auto Code on 6 November, with "no more picking models yourself" as the anchor; this piece's anchor is "you pick the model, it swaps the provider" — a different feature, not the same story retold.

There is another angle: Perplexity is not building a gateway from scratch. It is opening the internal model layer that already serves its own search product. Large internal traffic means its failover and speed data come from real requests paid for with real money — but it also means Orchestrator will always rank behind Perplexity's own product in priority. The internal layer keeps Perplexity Search up first and serves outside developers second. The company never wrote that sentence, but anyone who has run a platform business understands it.

For independent developers, the real difference may not be on the price sheet but in the billing structure: if you already pay Claude, GPT and Gemini separately, Orchestrator folds them into one bill and one vendor to negotiate with; if you only use one model, it saves you almost nothing and mainly buys you failover. Count how your monthly spend is split across providers before deciding whether moving is worth it.

Not just Orchestrator: three APIs in three days

Orchestrator did not launch alone. On 16 November Perplexity shipped the Monitor API, which runs web searches or page checks on a schedule and alerts you when something new appears; on 17 November Orchestrator arrived alongside the Context API, which fetches the content of pages you already have URLs for and returns it in a form ready for models and agents. Three APIs in three days is clearly the build-out of a whole developer platform, not one more endpoint.

On 19 November, Perplexity CEO Aravind Srinivas posted on X that the company's API business grew 4.3 times in a year to a nine-figure annual run rate. That is the vendor's own claim in a public post, without independent financial statements behind it, but it explains why Perplexity is opening its internal model layer now: the API has gone from a side business to its fastest-growing line.

For builders: when to adopt it, and when to wait

Three situations favor adopting it now. First, your app already calls two or three providers, and the bills and keys are scattered everywhere — folding them into one bill saves real management cost. Second, your volume is large enough that one provider outage puts errors in front of thousands of users, so failover is worth more than the platform fee you save. Third, you want to try routing work to models by task but do not want to write the routing logic yourself — the built-in profiles are enough to start.

Three situations favor waiting. First, you use a single model at low volume — Orchestrator saves you close to nothing. Second, compliance requires bring-your-own-key or a specific provider deployment — neither is supported today. Third, you want to put Routes and Auto effort on the critical path in production — both are in preview, and their behavior and pricing can still change. Wait until they stabilize.

One practical reminder: the Tier 2 threshold of $250 means Claude Opus 5.5 and the Fable models require that much cumulative spending on Perplexity first. If you already have usage there, that is no barrier; if not, it is an entry fee for switching providers, and it belongs in your cost calculation before you move.

What it takes to plug in: two lines of config and one key

Going by the official documentation, adopting Orchestrator is a small change. Create a key in Perplexity's API Console — it uses your existing Perplexity API project key, no second credential to manage — then point your SDK at the Orchestrator base URL, write the model name with its provider prefix, such as openai/gpt-6.1-sol or perplexity/glm-5.3, and you can send the first request. The console also breaks spending down by model, project and API key, supports model allowlists and spend caps, and credits can be bought through AWS Marketplace.

Two implementation details are worth knowing in advance. First, Orchestrator is stateless: the server keeps no conversation state, so every request must carry the full message history, and fields that depend on server-side state return an error. When a multi-turn conversation switches models back and forth, the docs recommend a stable prompt_cache_key so related requests stay on the same deployment where possible, letting each model reuse its own prompt cache — when a conversation returns to GLM Flash in turn 4, it can reuse the matching prefix from turn 1 and treat the intervening Opus and Sol replies as new input. Second, failover and routing need no retry logic from you — but that also means there is little for you to intervene in when something goes wrong: how many retries happen and how long each waits are decided inside Orchestrator, which only says each attempt is bounded by time-to-first-token and total-duration limits, without publishing the numbers.

For an independent developer, the adoption cost is low: no new SDK to learn, no calling layer to rewrite, and a first request running within half an hour. The flip side of that low cost is that your model calls are then tied to a single vendor. But moving back out costs the same two lines of config — easy in, easy out, which is the healthiest property a gateway can have: what keeps you should be reliability, not migration cost.

How this relates to what this site has already published

Perplexity has appeared on this site before, so the boundaries matter. The October Decider piece covered Perplexity's open-weight 27B decision model: a model you call directly to answer judgment questions such as which option to pick. Orchestrator is a gateway: it also uses a decision model for routing, but what it sells is "one API reaching every model", not any single model. A model and a gateway are two different layers.

The 6 November OpenRouter piece covered Auto Router and Auto Code, anchored on automatic model selection. This piece is anchored on keeping the model fixed while the provider switches automatically, plus preview task routing. The 12 November OpenRouter hands-on piece was about guardrails against agent loops — a different subject from gateway failover. Read together, the three pieces trace the gateway category's November in three steps: first automatic model selection, then hands-on proof that guardrails work, and now Perplexity entering with "same model, different deployment" — do not mix up which feature belongs to which piece.

Views 0Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

A developer with glasses types on a laptop at a wooden desk, an external monitor to the left showing C code on a dark background, a small plant on the desk
News
Microsoft's Coding Model Stops Playing Second Fiddle: MAI Code 2 Scores 96% of Opus 5.5 for 5% of the Cost — Read the Three Caveats First

On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.

Developer WorkflowProduct LaunchModel Updates
A developer types at a dual-monitor workstation; the left screen shows a dark code editor, the right a testing dashboard with green checkmarks and bar charts
News
Did Your Agent Get Better or Worse? AWS Open-Sources UAEF to Measure Agents from Every Framework with One Ruler

On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.

Developer WorkflowProduct LaunchTesting & Quality
Screenshot of Amp's new thread composer: the run-location picker lists Boxes, and the acme/workbench workspace shows the bug-tracker, tiny-crm, team-wiki and incident-database apps
News
An $18-a-Month Home for Agent-Built Software: Amp's Boxes Fill In the Last Missing Piece

On 10 November 2026, Amp launched Boxes: always-on mini-computers from $18 a month for deploying software you built with an agent. Each box runs its own runner, so the agent can edit live production data right there; the same month Amp also shipped Spaces, retired the Dial, and arrived on Windows — the agent's workplace is moving off the laptop into the cloud.

Developer WorkflowProduct LaunchDeployment