Agentic search ends at the filesystem. Your business doesn’t.

The argument that won

Agentic search is the position that a coding agent should pull its own context at runtime: form a query from the live task, run it against the filesystem, read what comes back, and search again if the first pass missed. It won the retrieval argument for code on four fronts at once. Precision: the agent writes the query from the exact task in front of it, so what returns is what the task needs, not what a similarity score guessed. Freshness: the working tree is read at the moment of the search, so the answer is as current as the code itself, where an index is a photograph that starts ageing the moment it is taken. Simplicity: there is no pipeline to build, embed, or keep in sync. Security: nothing is copied out of the repository to be searched somewhere else.

This page treats that argument as correct, because it is. For everything that lives on the filesystem, the agent forming its own query at runtime is the right retrieval model, and every page on this estate assumes it wherever code is concerned.

Followed to its own end

Every retrieval model has a boundary drawn by its own premises, and agentic search has two. The first is the trigger. A pull model runs when the agent notices a gap and forms a query; noticing is the load-bearing step. When the agent is confident, rightly or wrongly, no gap is noticed, no query forms, and no search runs. The case retrieval most needs to catch, an agent acting confidently against something already settled, is precisely the case that never fires the search.

The second is the reach. A search of the machine returns what is on the machine. Glob and grep are exhaustive inside that boundary and silent beyond it. So the question is not whether agentic search is good; it is what a working session needs that lives beyond the filesystem.

The two cargoes no search of the machine can fetch

The first is your settled judgment. A rules file is a photograph of a judgment: the wording as it stood the day it was written. It does not carry the standing of the decision, whether it still governs, what superseded it, or the reasoning that set the line where it sits. Grep finds the wording and can say nothing about the standing. The judgment itself, the settled position with its why, is in no file.

The second is live operational truth. Last night’s error rate, this morning’s coverage, the current usage curve: none of it is on the machine at all. And here the freshness argument, agentic search’s strongest, quietly inverts. The codebase is freshest read at runtime by the agent. The world is freshest read by a heartbeat that stamps each reading as of when it was taken, because the world, unlike the working tree, does not sit still between searches.

What arrives instead

On a coding surface connected through Unl, the turn opens and the context is already there: the decision that governs this piece of work, carried with the reasoning it was settled on, and beside it the reading that bears on it, stamped as of this morning, measured against the bar you set. Nothing was asked for. The trigger the pull model lacks is supplied structurally: relevance to the turn, not the agent’s sense of doubt, is what fires the serve.

And when a reading bears hard on the work, the agent walks in: it reaches into the source live, in the same turn, reads only, and comes back with the detail. The walk-in is agentic search applied to the world’s data; the same pull the agent already runs against your repository, given the trigger it structurally lacked and a lane that ends at the data instead of the filesystem.

Agentic search ends at the filesystem, and your business does not. The two cargoes no search of the machine can fetch, your settled judgment and the live state of the world, arrive in the conversation unprompted, measured against what you decided; the walk-in is the agent’s own pull, given the trigger it structurally lacks.

Reads through Unl arrive with measured context — in the presence of the decisions you’ve already settled. The reach lane is live: one box, paste anything. If it speaks MCP, Unl can reach it. Readings arrive unprompted, the data beside the criterion; Unl is a courier, not a warehouse, and keeps only your keys and the frame.

Read further

• What the agentic loop diagrams leave out
• Unl vs the rules-file method
• Managing context in a long Claude Code project
• PostHog through Unl