Exa Agent Collapses Web Research Into One API Call at Half the Cost

Web research has always been one of the messiest parts of building AI pipelines. You either pay top-dollar to run a frontier model with browsing tools, or you stitch together a fragile chain of search calls and hope the context doesn't explode. Exa Agent is a new API endpoint that tries to collapse that entire workflow into a single async call, and it does it at a price point that undercuts the obvious alternatives by more than half.

One endpoint, any research task

Exa Agent combines top language models with Exa's state-of-the-art web search tools to achieve exhaustive and accurate results, now used in a variety of agentic products. The endpoint is called /agent, and it is available in the API today.

Exa Agent is highly effective on deep research, list-building, and entity enrichment tasks. The practical range is wide: from enriching a CRM list of 500 companies to running a multi-hop literature review that requires chaining dozens of searches together.

The architecture behind the cost savings

The cost story is the headline, but the more interesting part is how Exa gets there. Two mechanisms do most of the work.

• Model fusion: When working with large datasets, Exa Agent divides the task into many subtasks and assigns subagents to research various domains at once. When researching, it uses a fusion of frontier and cost-effective models to find the most cost-effective methodology for the given research task.
• Token-efficient highlights: Highlights are snippets from a page that now offer higher quality results for ~94% fewer tokens on some evals, significantly reducing costs and leading to latency benefits. In practice, on benchmarks like SimpleQA, 500 characters of Exa's highlights match the accuracy of the first 8,000 characters of the page, and use 16x fewer tokens.

This is especially important in agentic search use cases, where doing multiple rounds of search is the norm and reducing context bloat is critical. The highlights model runs per-request (not cached) and completes in under 100ms.

Benchmark results that matter

Exa tested the agent across several public benchmarks designed specifically for agentic web research. These are not the standard knowledge-recall tests. BrowseComp tests whether an AI model can find answers on the web, not just recall them from training. A model must plan a search, inspect sources, filter noise, and synthesize a correct answer.

The other key benchmark is WideSearch, which measures a different skill. WideSearch was introduced to evaluate agents' abilities to aggregate and structure atomic information about entities from across the web. The expected output is always a table, structured as a list of enriched entities. This maps directly to real-world GTM and finance workflows where you need structured data on dozens of companies, not a prose summary.

The goal was to produce the best web research agent using methodologies like model fusion and Exa's token-efficient highlights model, which have shown up to 94% reductions in token usage. The result is significantly lower cost and latency for frontier performance.

What it costs

Pricing is effort-based, with a fixed cap per run so you always know your worst-case spend. The auto mode dynamically scales compute to the task complexity.

To put that in context: a high effort run at $0.50 competes with models like GPT-5.5 and Claude Opus that cost several dollars per equivalent research session at token rates alone. The async agent tier is priced at $0.025 to $2.00 per run, making the ceiling predictable for budget-sensitive pipelines.

How to plug it in

The API is async. You create a run, save the ID, then poll for completion or stream server-sent events. Here is the minimal Python pattern for a structured list-building task:

from exa_py import Exa
import json
exa = Exa(api_key="YOUR_EXA_API_KEY")
run = exa.beta.agent.runs.create(
    betas=["agent-2026-05-07"],
    query="Find engineering leaders at AI infra companies that raised Series A or B in the last 6 months.",
    output_schema={
        "type": "object",
        "properties": {
            "people": {
                "type": "array",
                "maxItems": 10,
                "items": {
                    "type": "object",
                    "properties": {
                        "name": {"type": "string"},
                        "job_title": {"type": "string"},
                        "linkedin_url": {"type": "string", "format": "uri"},
                    },
                    "required": ["name", "job_title", "linkedin_url"],
                },
            }
        },
        "required": ["people"],
    },
    effort="auto",
)
# Poll until done
run = exa.beta.agent.runs.poll_until_finished(run.id, betas=["agent-2026-05-07"])
print(json.dumps(run.output.structured, indent=2))

The three fields that matter in production are query (what to do), input.data (rows to enrich), and outputSchema (the JSON shape you want back). The agent handles everything in between: spawning subagents, running searches, and validating the output against your schema.

What it is good at, and where it falls short

The clearest wins are tasks that require breadth across many entities at once:

• Building lists of companies, people, or products matching open-ended criteria
• Enriching CRM or prospect data with web-sourced fields at scale
• Financial research that aggregates public signals across many sources
• Literature reviews and competitive landscapes that need structured, cited output

The weaker spots are tasks that depend on freshness-sensitive or paywalled data. Exa is genuinely fast and developer-friendly for web search tasks, but is not equipped for freshness-dependent queries that require real-time structured datasets like BLS tables or FRED time series. If your research task lives behind a login or in a proprietary database, the agent cannot reach it.

The bigger picture

The release lands in a market where web research is becoming a core primitive for AI products, not a nice-to-have. Deep research features are now standard in consumer AI assistants, and the pressure has shifted to the API layer: how do you offer that capability to developers building their own agents without forcing them to pay frontier-model prices for every search call?

Exa's answer is to own the retrieval layer and make it radically more efficient before the request ever reaches an expensive model. Up to 25 trillion tokens passed to models each week are concise excerpts powered by highlights, which gives a sense of the scale at which this efficiency layer already operates. The agent product is essentially packaging that infrastructure into a task-oriented API that any developer can call without building the orchestration themselves.

The endpoint is currently in beta, requiring the Exa-Beta: agent-2026-05-07 header on every request. You can try it now in the Exa API Playground or read the full API docs to integrate it into your own pipeline.