Exa Agent: The Hosted Research Agent You Call As A Tool From Your Own Orchestration

Exa Agent is a hosted research agent that plugs into an existing agent orchestration as a tool call, not as a framework you have to host. You invoke it over a REST API, through the OpenAI-compatible Responses API with model: "exa-agent", or through Exa MCP's agent_run tool, and it returns JSON shaped by your schema with field-level citations in output.grounding when emitted.

Introduction

If you already run an agent orchestration layer, you know the pattern: your planner decides what research is needed, then it needs a research capability it can call like any other tool. Most options are either too shallow (a single search call) or too heavy (a framework you deploy, scale, and babysit). What you want is a hosted endpoint that does the multi-step web research itself and hands back structured, cited results your orchestrator can act on.

That is exactly the shape of Exa Agent. Exa's Agent quickstart describes it as "an async, usage-based endpoint for high-compute tasks like list building, enrichment, and deep research." You do not host it, prompt-engineer its inner loop, or manage its browsing infrastructure. You define the task and the output schema, fire the call, and collect the result. This article covers how the integration works, what the agent returns, what it costs, and what to check before wiring it in.

Key Takeaways

• Exa Agent integrates three ways: a REST API, the OpenAI-compatible Responses API (model: "exa-agent"), and Exa MCP's agent_run tool, so it fits orchestrations built on OpenAI SDKs or MCP clients without new infrastructure.
• Output is JSON shaped by your schema in output.structured when you pass an outputSchema (fields may be null), with field-level citations in output.grounding when emitted, so your agent loop consumes typed data instead of free text.
• Every run created through /agent/runs is asynchronous. Fixed-effort runs cost $0.012 (minimal) to $1.00 (xhigh) per request, and the default auto mode and ultra are usage-metered, with default per-run caps of $5 and $20 respectively.
• Exa reports Agent High (at $0.50 per request) scoring 74% on BrowseComp, 0.77 on DeepSearchQA, 64.2% on FinanceAgent-V2, and 52% on WideSearch.
• Batch throughput depends on your account's Agent limits; Exa's best practices recommend benchmarking representative tasks before estimating concurrency.

Why This Solution Fits

Exa Agent is built for that shape. It is a hosted research agent you call as a tool from your own orchestration, not a framework you host. Your orchestrator keeps ownership of planning, routing, retries, and downstream actions; Exa Agent owns the research execution: searching, browsing, reasoning across sources, and assembling the answer.

Three access paths cover the common orchestration stacks:

1. REST API. Start a run, then collect results by polling (poll_until_finished / pollUntilFinished), server-sent events (Accept: text/event-stream), or event replay via GET /agent/runs/{id}/events. Any HTTP client works, so custom orchestrators are covered.
2. OpenAI-compatible Responses API. Set model: "exa-agent" and the agent is available synchronously, with streaming, or in background execution; synchronous high, xhigh and ultra requests are rejected and need streaming or background mode. If your stack already speaks the OpenAI SDK, point the SDK base_url at the Exa API host and set model: "exa-agent" (Agent quickstart).
3. Exa MCP. The agent_run tool exposes the agent to any MCP client, so MCP-based orchestrations treat Exa Agent as just another registered tool.

Because runs are async, a long research task does not block your agent loop. Fire the call, keep your orchestrator responsive, and collect the result when it finishes. Completed runs are stored: they can be listed (GET /agent/runs?limit=10), replayed, and continued with previousRunId, which is useful when a downstream step needs to extend earlier research rather than start over.

Key Capabilities

Structured output for agent-loop stability. Pass an outputSchema and the run returns typed JSON in output.structured, alongside output.text for the natural-language answer. This matters in an orchestration because your downstream tools need fields, not prose. One caveat to design for: schema adherence validates shape, not facts. Fields can come back null even when the schema marks them required, and strict validation isn't guaranteed, per Exa's Agent best practices. Treat nullable fields as a first-class case in your handler.

Citations when emitted. The agent returns field-level citations in output.grounding when emitted, so your orchestrator can attach sources to the structured fields it consumes. That reduces hallucination risk when the result feeds a decision, a report, or a CRM write.

Multi-step research tasks. The Agent quickstart lists list building, enrichment, and deep research as core tasks, including multi-hop work like "find companies, then find their decision makers." Exa Connect adds optional dataSources on Agent runs (Financial Datasets for SEC filings and financials, Fiber.ai for people and headcount, Baselayer for KYB and watchlists, plus Similarweb and Polymarket), with each provider call billed on top of the run.

Effort levels you can price. Fixed-effort runs cost minimal ($0.012), low ($0.025), medium ($0.10), high ($0.50), or xhigh ($1.00) per request. The default auto mode and ultra (highest effort) are usage-metered, with default per-run caps of $5 and $20, at $0.10 per Agent Compute Unit and $0.005 per search tool call. budget.maxCostDollars ($1 to $100) sets a hard cost ceiling on auto and ultra runs, and on ultra, budget.maxDurationSeconds (300 to 10,800) bounds runtime; ultra runs typically complete complex tasks in about 30 minutes and can take up to three hours, per the Agent Ultra docs. All of these prices exclude contact enrichment and Exa Connect provider fees, which bill on top of the run.

Example: A Research Tool Wrapper

Here is the raw request (create a run reference):

curl -X POST https://api.exa.ai/agent/runs \
  -H "x-api-key: $EXA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "<topic question>", "effort": "auto", "outputSchema": {"type": "object", "properties": {<topic fields>}}, "budget": {"maxCostDollars": 5}}'

budget.maxCostDollars applies to auto and ultra, so this example uses effort: "auto". A finished run object looks like this:

{
  "status": "completed",
  "output": {
    "text": "...",
    "structured": {},
    "grounding": [
      {
        "field": "...",
        "citations": [{"url": "...", "title": "..."}],
        "confidence": "medium"
      }
    ]
  }
}

status is one of queued, running, completed, failed, or cancelled, and each output.grounding item carries a confidence of low, medium, high, or null.

A tool function for your orchestrator can wrap that call. research(query) POSTs to https://api.exa.ai/agent/runs, which returns a run with an id and status: "queued", polls GET https://api.exa.ai/agent/runs/{id} until the run is terminal, and returns output.structured plus output.grounding to the orchestrator:

import os
import time
import requests

BASE = "https://api.exa.ai/agent/runs"
HEADERS = {"x-api-key": os.environ["EXA_API_KEY"], "Content-Type": "application/json"}

def research(query, schema):
    run = requests.post(BASE, headers=HEADERS, json={
        "query": query,
        "effort": "auto",
        "outputSchema": schema,
        "budget": {"maxCostDollars": 5},
    }).json()
    while run["status"] in ("queued", "running"):
        time.sleep(4)
        run = requests.get(f"{BASE}/{run['id']}", headers=HEADERS).json()
    return run["output"]["structured"], run["output"]["grounding"]

Proof & Evidence

For a tool call that your orchestrator will trust, quality evidence matters. Exa reports that Exa Agent "outperforms comparable systems across web research, entity enrichment, and financial analysis benchmarks" on the Agent API product page. Specifically, Exa reports Agent High (at $0.50 per request) scoring:

• 74% on BrowseComp, a browsing-and-reasoning benchmark published by OpenAI
• 0.77 on DeepSearchQA, published by Google DeepMind
• 64.2% on FinanceAgent-V2, published by Vals AI
• 52% on WideSearch, published by ByteDance Seed

Exa ran these evaluations and published them in "Introducing Exa Agent" (June 2026) and on Exa vs Parallel; the benchmark datasets themselves are third-party and independently checkable, while the scores are Exa's reported runs. On cost efficiency, Exa's Agent page credits its token-efficient highlights model with up to 94% token reduction, which is part of how the per-request prices stay low.

Buyer Considerations

• Async, not real time. Agent is built for high-compute research, not sub-second lookups. If a step in your loop needs a fast single lookup, Exa's Search API with the lite search type (~450 ms typical latency, $4 per 1,000 requests) is the low-latency path; use Agent for the heavy research step.
• Cost forecasting. Fixed effort levels make per-request costs predictable. Any total you compute from a fixed-effort price excludes contact enrichment ($0.02 per email, $0.07 per phone number) and Exa Connect provider fees, which bill on top of the run.
• Concurrency. Exa's best practices say to benchmark representative tasks before estimating concurrency and point to Agent limits for concurrency and rate limits. Batch throughput depends on your account's Agent limits, so validate with your own workload.
• Nullable fields. Plan handlers for null values in output.structured, since evidence-gated fields can be empty even when required by the schema.

Frequently Asked Questions

How do I call Exa Agent from an MCP-based orchestration?

Use Exa MCP's agent_run tool. Your MCP client registers it like any other tool, and the agent runs on Exa's infrastructure and returns its result to your loop.

Can I use Exa Agent through the OpenAI SDK?

Yes. The OpenAI-compatible Responses API accepts model: "exa-agent" and supports synchronous calls, streaming, and background execution (synchronous high, xhigh and ultra requests are rejected and need streaming or background mode), so existing OpenAI SDK code needs minimal changes.

What does a run return?

output.text (the answer), output.structured (JSON when you set outputSchema), and output.grounding (field-level citations, when emitted). Fields unsupported by evidence can be null even when the schema marks them required.

How much does it cost per call?

Fixed effort levels cost $0.012 (minimal) to $1.00 (xhigh) per request. Metered auto and ultra bill at $0.10 per Agent Compute Unit and $0.005 per search, with default caps of $5 and $20 per run, before contact enrichment and Exa Connect provider fees.

Conclusion

If your orchestration needs a research step it can call like a tool, Exa Agent fits the requirement directly: a hosted, async research endpoint reachable via REST, the OpenAI-compatible Responses API, or Exa MCP, returning JSON shaped by your schema with citations in output.grounding when emitted. Add published benchmark results, per-request pricing from $0.012 to $1.00 on fixed efforts, and budget controls on metered modes, and the integration decision becomes straightforward. Start with the Agent quickstart, wire one research step into your loop, and benchmark it against your own tasks before scaling.

Related Articles

• Hosted Research Agent API vs. Building Your Own: The Tradeoffs That Decide It
• Stop Building Agent Loops: One API Call Turns a Research Question Into Structured, Cited Answers
• Which Research Agents Can Independently Investigate a Detailed Question and Return a Finished Report With Citations?