The Grounding Problem.

An Agent Is Only As Smart As What It Can Reach.

The clever part is free now. The boring part, what it can actually see and trust, is the whole job.

I caught my own agent lying to me last week (bad boy!). Politely. But with great confidence.

I was building a wiki of my own notes. I wanted to reference a well-known engineering essay, Jay Kreps on The Log, which is actually good stuff. The agent summarized it beautifully.

Then I asked it to fetch the actual page. A 404. Then a broken redirect. The essay had moved. The agent had never opened it. It had described a thing it could not reach, from memory (whatever we agree that is), then smuggled the guess as knowledge.

Nothing about the model was wrong. It was doing exactly what a language model does. The failure was not intelligence. It was reach.

Here is the uncomfortable part. I only caught it because I had built something to catch it. Before that discipline existed, a guess and a fact looked identical. I could not tell them apart a week later, which means some of them were wrong and I never knew which one. The near-miss is not the happy ending. It is the warning.

That is the whole subject of this piece. Retrieval gets written about constantly as a technique. Almost nobody talks about it as the boring majority of the work, the part that quietly decides whether any of the cleverness actually matters.

Capability is free. Reach is not.

Here is the trade that reorganized how I think about all of this.

The clever part keeps arriving for free. Every few months a new model lands and everything gets smarter at no effort from me. Reasoning. Code. Language. All of it improves while I sleep.

Reach does not improve while I sleep. What an agent can actually reach and check is something I build by hand, one connection at a time.

So the gap between an impressive demo and a useful system is almost never the model. It is whether the thing can reach the data the answer depends on.

A model that cannot see your calendar cannot reason about your week. It does not matter how brilliant it is. Ask it what you should move tomorrow. It will produce something fluent and plausible and COMPLETELY DISCONNECTED from your actual Tuesday.

The intelligence was never the bottleneck. The bottleneck is the boring 80 percent (are we going with Pareto, really?).

What grounding actually means

Grounding is a vague word, so here is the concrete version. It is four separate problems wearing one coat.

Connection. Can the agent physically reach the source at all? An API. A file. A database. A page. This is the plumbing. It fails in dull, specific ways. The endpoint moved. The token expired. The page 404s. My Kreps essay was a connection failure. Connection failures are the honest ones, because they announce themselves.

Permission. Can it reach the source as you, with your rights instead of its own? I hit this wiring a tool to my own work data. The tool ran as the agent, so it queried the system as the agent and got the agent’s view. Which was almost nothing. To see what I see, it had to carry my authority through to the source, not its own. An agent with its own identity lives in a different world than i do. Ask it what a system returns for you. Unless it can borrow your rights, it answers for itself, then calls it yours.

Freshness. Is what it reached actually current? A cached value. A stale snapshot. Last quarter’s number. This one is vicious, because the answer looks fine. Nothing 404s. It is just quietly wrong by three weeks.

Trust. This is the one everybody skips. There is a difference between data an agent can see and data it can believe. My agent could see its own memory of the Kreps essay. It could not verify a word of it. Seeing is not trusting. A system that cannot tell the two apart will hand you a confident guess every single time.

Capability improves all four of these by exactly nothing. A smarter model reaches a stale number faster. It describes an unread essay more convincingly. Reach is a separate axis. It is the one you own.

Reach is why I run four agents, not one

If you see me on my pc you might assume I run several agents in parallel because more is better. That is not it. I run them because they reach different things.

Claude Code lives inside a code repository and holds a long thread across hours. Hermes runs its own lane with its own context. GitHub Copilot sits inline in the editor, tight loop. Scout reaches the desktop and my work data. Files. Calendar. Messages. The browser.

The point is not that four beats one. A repository agent cannot see my calendar. A calendar agent cannot see my repository. No amount of model quality closes that gap (and i am not sure i want to even close it). Reach is the thing that varies between them. Reach is the thing I am actually selecting for.

A few habits fell out of running them this way. Pick the tool by what it can reach, never by the logo. Protect a deep thread instead of interrupting it for a trivia question. Use a file as the handoff, because there is no shared brain between them, so the shared state has to live somewhere they can all reach.

And accept that nothing coordinates them but me. That last one, the human sitting in the middle deciding what to point where, turns out to be a whole argument on its own. It is something i need to reflect and write about, eventually, so I will leave it there.

The fix is a discipline. An unglamorous one

Once you see reach as the real problem, the fix is not a clever model. It is a boring habit, applied relentlessly.

I have been rebuilding my personal notes as a wiki. It turned into the clearest example of grounding I have.

It is not built by me alone. It is not built by the agent alone. It is the sum of the two. The whole design exists to keep the agent honest about what it has actually reached.

Every claim page carries an evidence class. Lived. Measured. Researched. Or a plain hunch. The label is not decoration. It is the difference between something I checked and something I just believe (legacy of working with graphs and ontologies).

Every link between ideas carries a relation tag. Not a lazy “see also”. A stated reason. This supports that. This contradicts that. This is the same shape as that. Ten relation types.

Every external source gets its own page that says, in the first line, whether I have actually read it. Right now the wiki has 21 idea pages and 6 source pages. Five of those six sources are marked, in plain text, as not yet read.

That last number is the point. Five unread stubs, labelled as unread, sitting there slightly embarrassing me every time I open the folder. That is grounding working. The system knows the difference between a source I have reached and one I am still guessing about. It refuses to let the guess wear the same clothes as the fact.

The Kreps essay is one of those five. The agent described it. I could not verify it. So it is a stub with a to-do on it. Not deleted. Not pretended into a citation. Flagged, honestly, as reach I have not yet closed (i actually did read it just before finishing this).

What I am probably getting wrong

I am not sure reach stays a separate axis forever. Models are starting to arrive with their own tools, their own browsing, their own memory. Some of the plumbing I build by hand today will be built in tomorrow. Maybe the boring 80 percent slowly shrinks.

I suspect it does not shrink as much as people hope. Every new capability needs new grounding underneath it. The frontier of what an agent could reach keeps moving faster than the wiring to reach it safely. The 80 percent may just move rather than vanish.

I also cannot fully solve freshness. I can flag what is unread. I am much worse at flagging what was fresh when I reached it, then quietly went stale since. A read source can rot the same way an unread one can mislead. I do not have a good sensor for that yet.

My whole setup also assumes I am the router. If that job ever automates, I lose the one point where a human currently catches the confident guess before it ships. I do not know what replaces me there. More agents? Maybe from different vendors? A consortium of intelligences ?

Where I would start

If you want to feel this rather than read about it, do one small thing.

Take a task you already trust an agent with. Now ask it one question out loud. What did it actually reach to produce this? And how does it know that source is real and current?

1. Make it name its sources instead of summarizing them.
2. Make it fetch one, live, in front of you. Watch whether it actually can.
3. When it cannot, do not let it smooth over the hole. Make it say “I could not reach this.”
4. Write that gap down somewhere it will nag you, not somewhere it disappears.
5. Only then worry about whether the model is clever enough. It almost always already is.

The habit is the product. The model is just the part that arrives for free.

Capability is what the model brings. Reach is what you build. The second one is the whole job. And it’s dull and boring and doesn’t make good click bait.

That is exactly why it is worth doing.

TL;DR

An agent is only as smart as what it can reach. Capability arrives free with every new model. Reach, what the thing can actually reach and verify, you build by hand and maintain forever.

Grounding is four problems, not one:

1. Connection. Can it reach the source at all. These failures are honest. They 404.
2. Permission. Can it reach the source as you, with your rights instead of its own.
3. Freshness. Is what it reached actually current, or quietly three weeks stale.
4. Trust. The one everyone skips. Seeing a thing is not believing it. A system that cannot tell those apart hands you a confident guess every time.

A smarter model improves none of these. It reaches a stale number faster and describes an unread essay more convincingly.

The fix is a discipline, not a model. Label every claim with how you know it. Tag every link with why it connects. Mark every source, in plain text, as read or unread. Let the unread ones sit there and nag you. My own wiki has five unread source stubs right now, labelled as unread. That is grounding working, not failing.

And: I caught my own agent describing an essay it had never opened. The model was fine. The reach was missing. That gap is the whole subject. It is the 80 percent nobody wants to write about.

Now go and check one

Open whatever you use. Give it a task you already trust it with.

Then paste this underneath.

Before you answer, tell me exactly what you will reach to produce this:
which sources, which data, which files.

Then fetch one of them, live, right now, and show me it worked.

For anything you cannot actually reach, do not summarize it from memory and do not paper over the gap. Say plainly: "I could not reach this."

List separately:
- what you reached and verified
- what you are reconstructing from memory without reaching it
- what is probably stale even though you reached it

I want the second and third lists to be honest, not empty.

If the second and third lists come back empty every time, that is not a good agent. That is one that has not learned to admit what it cannot reach. Teach it to. Write the gaps down somewhere they nag you.

That is the whole discipline. The model was always going to be clever enough.