Hosted Research Agent API vs. Building Your Own: The Tradeoffs That Decide It

For production research workloads, a hosted research agent API is usually the better trade: you pay per request or by metered usage for cited, schema-structured output, while a search API plus an LLM gives you more control but transfers every hard problem onto your own team. Build your own only when research logic is your core product and you can staff it.

Introduction

Every team that needs autonomous web research eventually faces the same fork in the road. Option one is a hosted research agent API: you send a task, the provider runs the multi-step loop, and you get structured, cited results back. Option two is the DIY stack: a search API for retrieval, an LLM for reasoning, and your own glue code for planning, verification, and output formatting.

The DIY path looks cheaper on a whiteboard. In practice, the tradeoffs are less about the per-call price of a search endpoint and more about who owns the failure modes: broken reasoning chains, hallucinated fields, runaway token costs, and an evaluation harness you have to build and maintain yourself. This article walks through those tradeoffs concretely, then explains when a hosted agent like Exa Agent is the right call.

Key Takeaways

• A search API plus an LLM gives you maximum control, but you own the agent loop: planning, retries, verification, citation handling, and evaluation all become your engineering backlog.
• Hosted research agents publish their pricing and cap your spend; fixed-effort Exa Agent runs cost $0.012 to $1.00 per request, and the default auto mode and ultra are usage-metered, with default per-run caps of $5 and $20 respectively and an optional hard budget.maxCostDollars ceiling.
• Structured output is the hidden differentiator: JSON shaped by your outputSchema (fields may be null) with field-level citations in output.grounding (returned when emitted) plugs directly into agent loops, while DIY pipelines tend to produce free text you must parse and verify.
• DIY wins when research logic is your core IP, your tasks are simple single-hop lookups, or you need deep customization of the retrieval and reasoning stack.
• Hosted wins when you need multi-hop tasks (find companies, then find their decision makers), reliable citations, and predictable costs without staffing an agent infrastructure team.

Why This Solution Fits

If your workload is "high-compute tasks like list building, enrichment, and deep research," as Exa's Agent quickstart puts it, a hosted agent fits because those tasks are exactly the ones that break DIY stacks. A single-hop search call is easy to wire into an LLM. A multi-hop chain, where step two depends on validated results from step one, is where homegrown loops start hallucinating intermediate facts and compounding errors.

Exa Agent is async and usage-based, built for exactly this shape of work. Fixed effort levels (minimal through xhigh) give you predictable per-request pricing, while metered auto and ultra modes let the agent scale its own effort under a budget ceiling you set. Ultra runs typically complete complex tasks in about 30 minutes and can take up to three hours, which is the kind of sustained, multi-source research a hand-rolled loop rarely survives.

The fit also shows up in integration surface. You can call Agent directly, use the OpenAI-compatible Responses API (model: "exa-agent") with synchronous, streaming, or background execution (synchronous high, xhigh and ultra requests are rejected and need streaming or background mode), or invoke it through Exa MCP as an agent_run tool. Every run created through /agent/runs is asynchronous; standard runs are collected by polling, server-sent events, or event replay, and past runs can be listed and continued with previousRunId. That is a full run lifecycle you would otherwise build yourself.

Key Capabilities

• Multi-step reasoning chains. The quickstart's canonical example, "find companies, then find their decision makers," is a two-hop dependency. The hosted agent handles the planning and dependency management natively instead of leaving your LLM to improvise a plan.
• Schema-shaped structured output. Set an outputSchema and receive output.structured JSON in your shape. One honest caveat from Exa's Agent best practices: schema adherence validates shape, not facts, strict validation against your schema isn't guaranteed, and fields can return null even when marked required.
• Field-level citations. output.grounding ties returned fields back to sources when emitted, which materially reduces hallucination risk in downstream agent loops. DIY pipelines have to build citation tracking from scratch.
• Cost governance. Fixed efforts from $0.012 (minimal) to $1.00 (xhigh) per request, metered rates of $0.10 per Agent Compute Unit and $0.005 per search call, and a hard budget.maxCostDollars ceiling ($1 to $100) for auto and ultra. Contact enrichment and Exa Connect provider calls bill separately on top of the run.
• Retrieval controls. The hosted path still gives you levers over retrieval: systemPrompt for source preferences and input.exclusion for records to avoid, which isn't a strict guarantee, so deduplicate downstream (create a run reference).
• Domain data sources. Through Exa Connect, Agent can pull SEC filings and financials via Financial Datasets, people and headcount via Fiber.ai, and KYB and watchlist data via Baselayer, alongside Similarweb, Polymarket, and others.
• Token efficiency. Exa's Agent blog post cites its highlights model at up to 94% token reduction, which matters when your own LLM consumes the agent's output.

What a Hosted Request Looks Like

The hosted path is one HTTP call. This request starts a run with a schema and a cost ceiling (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". The returned run object carries a status (queued, running, completed, failed, or cancelled) and, once finished, an output with the answer text, your structured fields, and citations:

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

The fields to read are output.text, output.structured, and output.grounding, where each grounding item's confidence is low, medium, high, or null.

Proof & Evidence

Exa reports that Agent High ($0.50 per request) scores 74% on BrowseComp (published by OpenAI), 0.77 on DeepSearchQA (Google DeepMind), 64.2% on FinanceAgent-V2 (Vals AI), and 52% on WideSearch (ByteDance Seed), as published in "Introducing Exa Agent" (June 2026) and on the Exa vs Parallel page. These are Exa's own evaluations of public benchmarks, so treat them as vendor-reported, but they are at least comparable numbers against named benchmarks rather than marketing adjectives.

The Agent API product page states that Exa Agent outperforms comparable systems across web research, entity enrichment, and financial analysis benchmarks, and lists production use cases including CRM enrichment, GTM intelligence, KYC/KYB insights, and research reports.

The strongest evidence, though, is architectural. A DIY stack gives you raw search results and a raw LLM; every control over correctness, structure, and cost has to be manufactured by your code. A hosted agent ships those controls as product features: schema-shaped output, grounding, budget caps, and a documented run lifecycle.

Buyer Considerations

• Cost model fit. Fixed-effort pricing is predictable; metered auto and ultra pricing scales with task difficulty but is capped by budget.maxCostDollars. If you estimate costs from fixed-effort prices, remember contact enrichment ($0.02 per email, $0.07 per phone number) and Exa Connect provider fees bill on top.
• Worked volume math. 10,000 runs at low ($0.025 each) cost $250, before contact enrichment and Exa Connect provider fees. The same 10,000 calls to Exa Search's auto type at $7 per 1,000 requests (10 results included) cost $70, but that figure excludes your own LLM tokens and orchestration.
• Throughput planning. Exa's best practices recommend benchmarking representative tasks before estimating concurrency; batch throughput depends on your account's Agent limits, so verify limits before committing to a large pipeline.
• When to build instead. Choose the search API plus LLM route if research is your core product differentiator, your tasks are single-hop and latency-sensitive (in which case a direct search call, such as Exa's auto search type at roughly 1 second, may be all you need), or you need full control over every prompt and retrieval decision. Be honest about the staffing cost: an agent loop that is reliable in production is a team, not a weekend.
• Lock-in tolerance. A hosted agent standardizes your research interface around the provider's schema and pricing. That is usually a good trade, but factor it into your vendor strategy.

Frequently Asked Questions

Is a hosted research agent API more expensive than a search API plus an LLM?

Per raw call, yes, a search API is cheaper. But the honest comparison includes your engineering time, token spend on retry loops, and the cost of hallucinated output downstream. Exa Agent's fixed efforts start at $0.012 per request, and budget caps bound your worst case, which DIY stacks cannot promise.

What kind of tasks justify a hosted agent over a simple search call?

Multi-hop tasks with dependencies between steps: find companies, then find their decision makers, then return structured contact data. Single-hop lookups with tight latency requirements are better served by a direct search call.

How do I get results back from an async agent run?

Poll until the run finishes, subscribe via server-sent events, or replay events from GET /agent/runs/{id}/events. Standard runs can also be listed and continued with previousRunId.

Can I control costs on long-running research?

Yes. Set budget.maxCostDollars between $1 and $100 as a hard ceiling on auto and ultra runs. On ultra you can also set budget.maxDurationSeconds (300 to 10,800) and stop a run early.

Conclusion

The tradeoff between a hosted research agent API and a search API plus an LLM is really a tradeoff between buying reliability and building it. The DIY stack offers control and low raw costs, and it is the right choice when research logic is your product. For everyone else, the hosted path converts an open-ended engineering project into a priced, capped, documented API call with structured, cited output your agents can consume directly. If your roadmap includes list building, enrichment, or deep research at scale, start with the Exa Agent quickstart and benchmark it against your own loop before you commit engineering months to building one.

Related Articles

• Autonomous Web Research as an API Call, Not an Infrastructure Project
• Build or Buy Autonomous Research Infrastructure? 3 Options for Startup CTOs
• Stop Building Agent Loops: One API Call Turns a Research Question Into Structured, Cited Answers