Quick answer: Agentic search is when an AI system treats search as a multi-step process it controls: it decides what to look up, runs a query, reads the results, decides what it still doesn't know, and searches again, looping until it can answer. That's different from classic RAG or a single web lookup, where one retrieval happens and the model must answer from whatever came back.
The distinction sounds subtle. In practice it's the difference between an assistant that guesses from one page of results and one that behaves like a competent researcher.
The Loop That Defines It
A traditional search-augmented answer works like a vending machine: question in, one retrieval, answer out. Agentic search replaces that with a loop the model drives:
- Decompose. Break the user's question into things that need finding out.
- Search. Issue a query for the first gap.
- Read. Fetch and actually read the promising results, not just the snippets.
- Assess. Decide what's answered, what's contradicted, what's still missing.
- Repeat with refined queries until the gaps are closed, then synthesize.
Steps 4 and 5 are where the "agentic" part lives. The model is making control-flow decisions: this source is stale, search again with a date filter; these two sources disagree, find a third; this answer needs a number the snippet doesn't show, fetch the full page.
You can watch this happen in modern tools. Ask ChatGPT or Claude a research question and you'll see it fire several reformulated queries, open specific pages, and revise its plan mid-stream. We logged this behavior in detail in what happens when ChatGPT searches the web.
Why It Beats One-Shot Retrieval
Single retrieval fails in predictable ways. The first query is phrased wrong, so the good sources never surface. The answer spans two documents, and one retrieval returns only one. The top result is confidently outdated. A fixed pipeline has no recourse in any of these cases; it answers from what it got.
An agentic loop recovers from all three, because bad results become information: "that query didn't work, try different terms." In my experience building research agents, the second and third queries are where most of the value shows up. The first query mostly teaches the agent what the terminology actually is.
The cost is real, though: more searches, more fetches, more tokens, more latency. Agentic search is the right default for research-shaped questions and the wrong one for "what's the capital of France."
How Do You Actually Build It?
You need three ingredients, and only one of them is the model:
A search tool the model can call repeatedly with structured results. Snippets alone starve the loop; the agent needs titles, URLs, and descriptions it can reason about.
A fetch tool so the agent can read pages it selects, ideally as clean Markdown rather than raw HTML, because every wasted HTML tag is context-window budget the agent can't spend on thinking.
A loop harness: the agent framework that lets the model call tools, observe results, and decide to continue. Any modern tool-calling setup (MCP, function calling, LangGraph, whatever you prefer) works.
Here's the search half wired up with link.sc, which returns Google results as structured JSON:
import requests
def web_search(query: str) -> list[dict]:
resp = requests.post(
"https://api.link.sc/v1/search",
headers={"x-api-key": "YOUR_API_KEY"},
json={"q": query},
)
return resp.json()["organic_results"]
def fetch_page(url: str) -> str:
resp = requests.post(
"https://api.link.sc/v1/fetch",
headers={"x-api-key": "YOUR_API_KEY"},
json={"url": url, "format": "markdown"},
)
return resp.json()["content"]
Hand those two functions to a tool-calling LLM with a prompt like "search until you can answer with citations, then answer," and you have a working agentic search system. It's genuinely that little code; the hard parts (SERP parsing, rendering, block handling) live behind the API. If you're using Claude Desktop or Cursor, the same two tools are available with zero code through the link.sc MCP server.
The Failure Modes to Watch
Agentic search inherits agent problems. Three worth designing around:
Loops that don't terminate. Cap the iterations (five to eight searches covers almost everything) and force an answer from what's gathered.
Confident synthesis of junk. The agent reads three SEO spam pages and treats them as three independent confirmations. Mitigate by having it prefer diverse domains and primary sources. AI search engines themselves struggle with this, as we found when testing how confidently wrong they can be.
Token blowout. Full web pages are enormous. Feeding Markdown instead of HTML cuts roughly 85 to 90 percent of the tokens, which is often the difference between a loop that can read eight sources and one that dies after two.
The Bottom Line
Agentic search is search with a feedback loop: query, read, assess, refine. It turns retrieval from a single roll of the dice into a process that converges on an answer. If you're building anything research-shaped in 2026, this is the architecture to reach for, and the infrastructure question reduces to giving your agent a good search tool and a clean fetch tool.
Give your agent real search and fetch tools in five minutes: create a free link.sc account with 500 requests a month included.