Perplexity Agent API adds ultra effort and cuts medium cost almost 90%

Perplexity has reworked every effort level of its Agent API, the managed research runtime that developers call with a single effort parameter instead of wiring together a model, a search tool and a step budget themselves. In a post dated November 5, 2026, the company says each level now costs less per query while research quality is higher or unchanged, and it introduces a sixth level, ultra, for the broadest research jobs. The headline figure belongs to medium: its accuracy on the public BrowseComp and DSQA research benchmarks rose from 55% to 77% while its cost per query fell by almost 90%, according to Perplexity.

The other levels moved in the same direction. Perplexity reports that high reached 88.0% accuracy at $0.073 per query on its evaluation, against 83.5% at $0.094 for the same level without the new page-extraction step, and that xhigh held its 76.5% score on WANDR, the company's in-house benchmark of long, multi-entity research tasks, while running at about 25% of the cost of its August 2026 configuration. The new ultra level, which runs three agents in parallel on the same task and a fourth to merge their work, scored 85.9% on WANDR at $21.71 per task.

Applications that request a level by name receive the new configurations automatically, without code changes. Teams that need stable behavior can pin a date-stamped version of a level, such as fast@2026-10-16.0, and the first ultra release carries the stamp ultra@2026-11-05.0 in the developer changelog. Perplexity attributes the savings to how each level spends steps, tokens and tool calls, and to cheaper search options such as Fast Search.

··········

PERPLEXITY AGENT API EFFORT LEVELS AFTER THE NOVEMBER 5 UPDATE.

The effort parameter selects a bundle of settings maintained by Perplexity: the backing model, the number of agent steps, the reasoning setting passed to that model, the output ceiling and the tools the agent may call. It is a separate control from reasoning.effort, which only sets how hard the selected model thinks inside each step. The current configurations, as published in the Agent API documentation on November 7, 2026, look as follows.

........

Effort	Backing model	Max steps	Model reasoning	Max output tokens	Tools
fast	openai/gpt-6-luna (fallback gpt-5.6-luna)	1	none	8,192	web_search (Fast Search, 10 results)
low	openai/gpt-6-luna	5	minimal	128,000	web_search, fetch_url
medium	openai/gpt-6-luna	15	medium	128,000	web_search, fetch_url
high	openai/gpt-6.1-terra	40	medium	128,000	web_search, fetch_url
xhigh	anthropic/claude-opus-5-5 (fallback gpt-6.1-sol)	300	high	512,000	web_search, finance_search, sandbox
ultra	anthropic/claude-opus-5-5	Not published	Not published	Not published	Not fully published

........

The fast level runs with parallel tool calls switched off and on a priority service tier, and Perplexity positions it for single-fact lookups. The three middle levels share a search depth of 4,000 tokens in total and 4,000 tokens per page, a 10,000-token budget across all pages fetched with fetch_url, and budget reminders that tell the agent how many steps it has left. The xhigh level starts compacting its context at 150,000 tokens, sets no system prompt of its own, and adds a load_skill tool with built-in skills whenever the sandbox tool is enabled.

··········

WHAT CHANGED IN THE HIGH AND XHIGH CONFIGURATIONS.

The developer changelog documents the specific configuration changes behind two of the levels. Both versions are stamped in late October and were described publicly in the November 5 post, which also covered the ultra release.

........

Level and version	Setting	Before	After
high@2026-10-28.0	Backing model	openai/gpt-6-sol	openai/gpt-6.1-terra
high@2026-10-28.0	Max steps	15	40
high@2026-10-28.0	web_search max tokens and per-page tokens	2,000	4,000
high@2026-10-28.0	fetch_url extraction model	None	openai/gpt-6-luna
xhigh@2026-10-29.0	Max steps	100	300
xhigh@2026-10-29.0	Context compaction	Not documented	Starts at 150,000 tokens
xhigh@2026-10-29.0	Frozen configuration instructions	Sent	Removed (no system prompt)
ultra@2026-11-05.0	New level	Not available	claude-opus-5-5, no frozen configuration

........

The high change is the most consequential for production traffic. Moving the level from gpt-6-sol to gpt-6.1-terra and raising the ceiling from 15 to 40 steps gives the agent far more room to search and read, and Perplexity pairs that with an extraction pass in which the small gpt-6-luna model condenses each fetched page before the main model reads it. In one evaluation example, the company says a 5,561-token page was reduced to 293 tokens, about 5% of its original size, and that extraction cut input tokens per query by roughly half across the evaluation.

The xhigh level kept its model, Claude Opus 5.5, with gpt-6.1-sol as fallback, but its step budget tripled to 300. Perplexity also noted in October that the old wide-research name now maps to xhigh and that the max_steps override accepts values up to 500.

··········

THE NEW ULTRA EFFORT LEVEL AND ITS $21.71 WANDR RUNS.

The ultra level is built for broad research and data-gathering jobs in which coverage is the priority, such as assembling a list of every company, person or document that meets a set of criteria. Three agents run the full task in parallel, and a fourth agent merges their findings, removes duplicates and writes the final answer. On WANDR, Perplexity reports a score of 85.9% at $21.71 per task, the highest result among the configurations it tested, against the 76.5% that xhigh holds on the same benchmark.

The documentation describes ultra as a level without a frozen configuration, because some of its settings are not part of the public request schema. Developers can call it by name or pin the returned version, but they cannot copy its settings into a request and run them unchanged later. Perplexity also warns that runs can take a long time and recommends background mode. An earlier ultra-preview name was added in October, when the company also removed an undocumented ultra name, so integrations that experimented with those identifiers should be checked against the current documentation.

The company illustrates the kind of work ultra targets with a WANDR task that required screening 188 engineers' profiles. According to the post, a first pass extracted 160 profiles and failed on 28; the agents then expanded 39 role terms into 117 search queries and merged the first-pass results into 43 unique profiles. The figures show the cost profile of the level: a single ultra task at $21.71 costs about 297 times the $0.073 that Perplexity reports for one high query.

··········

HOW PERPLEXITY CUT THE COST PER QUERY.

Perplexity attributes most of the savings to five factors that it now controls inside each level. The first is a fixed research budget with three parts: a step limit, a cap on total tool calls and budget reminders. The company gives an example in which an agent with a reminder found the correct answer using 13 of its 40 available steps, while the same agent without a reminder used all 40 steps and still failed. In another test with gpt-6-luna, raising the step limit from 1 to 15 lifted BrowseComp and DSQA accuracy from 41% to 80%, while the cost per query rose from $0.0017 to $0.0152, roughly nine times the cost for about twice the score.

The second factor is context compaction, which summarizes long runs once the context passes a threshold so that later steps do not pay to reread the whole history. The third is search itself. Each search now returns up to 4,000 tokens of results instead of 2,000, drawn from a new snippet engine, and Perplexity points to Fast Search at $1.00 per 1,000 requests as a cheaper and faster option for each search call.

The fourth factor concerns skills, the packaged instructions that agents can load. Perplexity now loads them progressively, only when a task needs one. When all skills were preloaded, cost on BrowseComp and DSQA rose by 13% and WANDR scores fell; with progressive loading, a people-search skill was loaded for only 6% of tasks, all of them questions that involved people. The fifth factor is model selection: an automated loop evaluates new models as they appear and swaps one into a level only if it improves quality at the same or lower cost. Under the same five-step budget, the company observed that gpt-6.1-terra makes more tool calls than gpt-6-luna, which is one reason each level pairs a model with its own budget.

··········

PERPLEXITY AGENT API PRICING FOR MODELS AND TOOLS.

The Agent API bills model tokens at each model's published rate on Perplexity's models page, plus a fee for every tool call or sandbox session. Perplexity states that its per-model rates may differ from the providers' own list prices. The tables below use the prices listed on the official Perplexity pricing and models pages on November 7, 2026, in USD.

........

Tool	Price
web_search, standard	$0.0025 per call ($2.50 per 1,000)
web_search, Fast Search	$0.001 per call ($1.00 per 1,000)
fetch_url	$0.0005 per call
finance_search	$0.005 per call ($5 per 1,000)
sandbox	$0.03 per session, plus $0.0025 per search inside it

........

The sandbox session fee covers up to 20 minutes of active use for billing purposes, which Perplexity describes as a billing window rather than a runtime limit. The flex service tier bills tokens at half the listed price and priority at twice the listed price, for models that offer those tiers; tool fees do not change with the tier.

........

Model on the Agent API	Input per 1M tokens	Output per 1M tokens	Cached input
openai/gpt-6-luna	$0.10 (up to 272K), $0.20 (above)	$0.50 (up to 272K), $0.75 (above)	90% off input
openai/gpt-5.6-luna	$0.20 (up to 272K), $0.40 (above)	$1.20 (up to 272K), $1.80 (above)	90% off input
openai/gpt-6.1-sol	$2.00 (up to 272K), $4.00 (above)	$10.00 (up to 272K), $15.00 (above)	95% off input
anthropic/claude-opus-5-5	$4.00	$20.00	$0.20
openai/gpt-6.1-terra	Not listed	Not listed	Not listed

........

Two details affect budgeting. The gpt-6.1-terra model that now backs high does not appear in the models page price table, so developers cannot compute its token cost from Perplexity's documentation and have to rely on the usage reported in responses. Requests that target anthropic/* models directly must also include max_output_tokens, or the API returns an HTTP 400 error. Claude Opus 5.5, which runs xhigh and ultra, costs 40 times as much per input token and 40 times as much per output token as gpt-6-luna, a gap consistent with the choice to build the three lower levels on the smaller model.

··········

WHAT THE CHANGES COST IN A TYPICAL WORKLOAD.

For a high-volume research feature, the per-query figures translate into large monthly differences. Take an application that sends 10,000 high queries a day, or 300,000 a month. At the $0.094 per query that Perplexity measured for high without extraction, the bill would be about $28,200 a month; at the $0.073 it reports with extraction, it falls to about $21,900, a saving of roughly $6,300, or 22%, with a higher accuracy score on the company's evaluation. These are Perplexity's averages on its own benchmark mix, and real costs will vary with the length of the questions and of the pages the agent reads.

The choice of search mode has its largest effect at the bottom of the range. Consider a single-fact lookup on the fast level with one search call, about 5,000 input tokens (the 4,000-token search result plus roughly 1,000 tokens of prompt and instructions) and 400 output tokens on gpt-6-luna. Token costs come to $0.0007 per query. With Fast Search at $0.001 per call, the total is about $0.0017 per query, or $1,700 per million lookups; with a standard search call at $0.0025, the same lookup would cost about $0.0032, or $3,200 per million. These are illustrative estimates built only from the official list prices and the stated assumptions.

At the top of the range, ultra is priced for occasional, high-value jobs. A team that runs 200 broad research tasks a month at Perplexity's reported $21.71 per WANDR task would spend about $4,342 a month. The changes therefore favor two kinds of users: products that run very large numbers of short searches, which gain most from Fast Search and the cheaper medium level, and analysts who need exhaustive lists, for whom ultra buys a nine-point gain over xhigh on WANDR at a much higher price per task.

··········

WHAT CHANGES FOR DEVELOPERS USING THE AGENT API.

Code that passes an effort name such as effort="medium" already runs on the new configuration, because a bare name and the @latest suffix both resolve to the active version of the level. Teams with evaluation suites, regulated workflows or cost forecasts tied to the old behavior should pin a version. Each response returns an effort field with the level and version that handled the request, and that value can be sent back to keep later requests on the same configuration. The Agent API documentation gives this example in Python:

from perplexity import Perplexity

client = Perplexity()

first = client.responses.create(
    effort="fast",
    input="What is the capital of France?",
)
pinned = first.effort  # e.g. "fast@2026-10-16.0"

second = client.responses.create(
    effort=pinned,
    input="What is the capital of Japan?",
)
print(second.output_text)

An unknown level name, an unknown version or a malformed value returns HTTP 400, and a request cannot set both effort and profile. Streams resumed with starting_after omit the effort field, so applications that resume streams should record the version from the first response. Developers who want full control can copy a level's current values into the request and omit effort, which freezes the configuration, with two limits: frozen setups receive no future improvements, and some settings, including all of ultra, cannot be reproduced that way. Individual fields can also be overridden on top of a level, for example a higher max_steps or a different search token budget, while the level's other tools stay attached.

For an overview of how the Agent API relates to Sonar, the Search API and API keys, see our guide to the Perplexity API. Perplexity's always-on agents for consumer subscribers are covered in our report on Perplexity Teammates for Max users, and the models Perplexity offers in its apps are listed in our overview of the models Perplexity uses.

··········

PERPLEXITY AGENT API EFFORT UPDATE: CONFIRMED FACTS AND OPEN QUESTIONS.

The documented facts are specific. Six effort levels now exist, the high level runs on gpt-6.1-terra with 40 steps, xhigh runs on Claude Opus 5.5 with 300 steps, ultra arrived with version ultra@2026-11-05.0, and all tool fees, from $0.001 for a Fast Search call to $0.03 for a sandbox session, are published. Version pinning lets developers decide when to adopt each configuration.

The performance and savings figures are Perplexity's own measurements. BrowseComp and DSQA are public benchmarks, but WANDR is an internal test, and the company does not publish absolute before-and-after costs per query for every level, so the "almost 90%" reduction for medium and the 75% reduction for xhigh cannot be checked against a published baseline. The token price of gpt-6.1-terra is also missing from the models page, and the full ultra configuration, including its step and output limits, is not documented. Developers moving traffic to the new levels should run their own question sets on pinned versions and compare the usage reported in responses before relying on the published averages.

··········

FOLLOW US FOR MORE.

·····

DATA STUDIOS

·····

datastudios.org