Retrieval Is Costing Your Agent Accuracy: Where Teams Start When They Get Serious

When retrieval quality starts dragging agent accuracy down, the teams that fix it usually start with a dedicated search API built for AI applications rather than a general-purpose search endpoint. Exa's Search API is built for that role: it combines a web-scale index, multiple latency and depth tiers, and schema-shaped output with citations, at prices from $4 per 1,000 requests for lite to $12 for deep.

Introduction

If your agent's answers are wrong, stale, or thin, the retrieval layer is one of the first places to look. Agents inherit whatever the search step gives them: if that step returns SEO-heavy pages, cached content that no longer reflects the source, or results with no way to trace a claim back to where it came from, no amount of prompt engineering fixes it downstream.

This guide walks through how teams typically approach that problem: how to tell whether retrieval is actually the bottleneck, what to look for in a search API once you decide to upgrade it, and how to choose between Exa's search types once you start building. The focus is on the Search API, because that is Exa's core retrieval surface.

Key Takeaways

• Diagnose before you swap: sample failing agent runs and check whether the retrieved pages were relevant, current, and traceable. If they were not, retrieval is your bottleneck.
• A serious search API needs four things: relevance for AI queries, control over freshness, clean page content, and citations you can verify.
• Exa's Search API offers four current search types: lite (~450 ms, $4 per 1,000 requests), auto (~1 second, $7 per 1,000 requests), deep-lite (~4 seconds) and deep (4 to 15 seconds), both $12 per 1,000 requests.
• Start with auto for general agent grounding, drop to lite when latency matters, and move to the deep types when questions are hard enough to justify multi-second retrieval.
• Use outputSchema on auto or the deep types to get schema-shaped output with citations in output.grounding, so you can audit which sources backed each claim.

Decision criteria

Before changing anything, confirm retrieval is the problem. Pull a sample of agent runs that produced wrong answers and ask three questions about the pages that fed them:

1. Relevance. Did the search return pages that actually answered the question, or pages that merely shared keywords? Generic keyword search often struggles with the natural-language, multi-constraint queries agents produce.
2. Freshness. Was the content current? Stale cached pages are a common silent failure: the agent reasons correctly over outdated facts.
3. Traceability. Could you trace each claim in the final answer back to a source? If not, you cannot audit failures, and users cannot trust the output.

If any of these fail, upgrading the retrieval layer is the right move. A search API built for AI applications differs from a general-purpose one on exactly these axes. Exa's index tracks over 2 trillion URLs and serves 100 billion pages, and Exa calls its 3.0 release its largest improvement to search quality (Exa 3.0). Exa also publishes its own open-sourced retrieval benchmarks (github.com/exa-labs/benchmarks) with retrieval and RAG tracks on Exa's own datasets, so you can rerun them yourself.

How to choose

Once you have decided to upgrade retrieval, the practical choice is which search type to start with. Exa's Search quickstart recommends four current types (the older instant, fast and deep-reasoning types are legacy and not recommended for new builds):

• Start with auto ($7 per 1,000 requests, about 1 second typical latency) for general agent grounding. It handles the widest range of parameters, including outputSchema, includeDomains, and maxAgeHours, which lets you cap how old cached page content can be (from -1 to 720 hours; 0 requests a fresh fetch).
• Drop to lite ($4 per 1,000 requests, about 450 ms) when your loop is latency-sensitive, such as autocomplete or interactive tool calls. lite is cache-only, does not support outputSchema or maxAgeHours, and does not support AI page summaries, but numResults still goes up to 100 (results above 10 cost $1 per 1,000).
• Move to deep-lite (about 4 seconds) or deep (4 to 15 seconds), both $12 per 1,000 requests, when questions are hard: multi-hop research, niche topics, or anything where the first page of results is not enough. Deep always returns ranked pages in results; with outputSchema it also returns a synthesized answer in output.content with citations in output.grounding.

A concrete request looks like this:

curl -X POST "https://api.exa.ai/search" \
  -H "Authorization: Bearer $EXA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "recent changes to the EU AI Act enforcement timeline",
    "type": "auto",
    "numResults": 10,
    "outputSchema": {
      "type": "object",
      "properties": {
        "answer": {"type": "string"},
        "key_dates": {"type": "array", "items": {"type": "string"}}
      }
    }
  }'

The outputSchema parameter adds a synthesis step on top of the ranked results, so expect some added latency beyond the base search time. Schema adherence governs the shape of the output, not its factual accuracy, so inspect output.grounding for the citations behind important claims rather than assuming every statement stayed within your allowed sources.

Two practical controls matter for accuracy work. includeDomains restricts returned results to matching domains, which is useful when your agent should only ground on primary sources such as SEC EDGAR filings or official documentation. maxAgeHours protects against stale cache: it limits how old cached page content can be, and 0 requests a fresh fetch for time-sensitive questions, at the cost of added latency.

Common pitfalls when upgrading retrieval

• Optimizing for the wrong failure mode. If your sample shows stale content, switching to a "smarter" search type will not help; tighten maxAgeHours instead. If results are irrelevant, the deep types or a better query will.
• Ignoring the latency budget. Deep search is powerful but multi-second. Keep auto in the hot path and reserve deep for questions that justify it.
• Trusting synthesis without checking grounding. Citations in output.grounding exist so you can verify; build that check into your evals.
• Skipping evaluation entirely. Exa's open-sourced benchmark repo has retrieval and RAG tracks on Exa's own datasets. Pair it with a before-and-after check on your own failing runs to see whether accuracy actually improved.

Frequently Asked Questions

How do I know if retrieval is actually hurting my agent's accuracy?

Sample failing runs and inspect the retrieved pages for relevance, freshness, and traceability. If the pages were wrong, stale, or unverifiable, retrieval is the bottleneck; if the pages were good but the answer was wrong, look at your reasoning layer instead.

Which Exa search type should a new agent integration start with?

Start with auto at $7 per 1,000 requests and about 1 second typical latency. It supports the full parameter set, including outputSchema and maxAgeHours. Move to lite for latency-sensitive paths and to deep-lite or deep for hard research questions.

Does outputSchema work with every search type?

No. It works with auto and the deep types; lite rejects it with a 400 error. It also adds a synthesis step, so factor extra latency into latency-sensitive paths.

How much does it cost to run Exa search for an agent?

It depends on your workload. As an example, 50 auto searches a day is 1,500 requests over a 30-day month, or $10.50 at $7 per 1,000 requests, before add-ons such as results above 10 ($1 per 1,000) or AI page summaries ($1 per 1,000 pages, not supported on lite). Exa's free tier includes $10 in monthly credits, which covers up to 2,500 Lite searches.

Conclusion

Retrieval quality sets a hard ceiling on agent accuracy, and the fix usually starts with the search API rather than the model. Diagnose your failures first, then pick the search type that matches your latency and depth needs: auto as the default, lite when speed dominates, and the deep types when questions get hard. Exa's Search quickstart and pricing page cover the details, and the free tier's $10 in monthly credits covers up to 2,500 Lite searches for an evaluation before committing.

Related Articles

• Accuracy Benchmarks for Retrieval APIs: What Teams Measure Before Shipping to Users
• Web Search APIs for LLMs Compared on Rate Limits, Latency, and Pricing at Scale
• Which Web Search API Do AI Engineers Recommend for Production RAG?