Large language models are not databases with a cute front-end. They are lossy, geometric compressions of human discourse that happen to speak in our language. That one-sentence frame carries the rest of the argument: when the map itself can talk back, the interface is the thing. How we name it, design around it, and explain it to users is going to matter more than whatever we think “agents” are doing.
A Lineage of Speaking Systems
We’ve been here before, in spirit.
Lisp collapsed program and data into the same stuff. You could read, transform, and extend Lisp from within Lisp. Macros weren’t a feature; they were a stance: the language and the tooling for changing the language lived in one place.
Smalltalk made the entire system a live, inspectable image. You didn’t compile and run over there; you poked around inside the thing you were building while it was running. The debugger, browser, and runtime were all the same organism.
Emacs invited you to extend the editor in its own Lisp. Your config was code that joined the environment. The tool was its own medium.
The Unix shell turned words into composition. Grep, sed, awk—narrow tools strung into pipelines—made ad-hoc programming something you did in a sentence.
Spreadsheets quietly taught the world to program. Hundreds of millions of people manipulate logic and dataflow with a grid and formulas that read like English. They don’t call themselves programmers; they don’t need to.
The pattern across all of them is the same: they collapsed the gap between the tool and the language we use to talk about the tool. You didn’t just use these systems; you inhabited them.
The Structural Break
Now the break. Those systems were read-write. You could reach into Lisp and change it with Lisp. Extend Smalltalk from within the Smalltalk image. Reprogram Emacs from inside Emacs. They were live environments you shaped at runtime.
LLMs are different. They are read-only artifacts. You consult them through a language interface, but you do not rewrite them through that interface. Fine-tuning, adapters like LoRA, retrieval-augmented generation—these are external writes. They patch or condition behavior from the outside. They don’t turn the oracle into an environment.
This may prove to be a spectrum more than a hard line—in-context learning, adapters, and emerging memory architectures might soften the boundary over time. That possibility is real; it doesn’t change the present tense. Today’s dominant interaction is read-only at the interface. You speak; it answers. One of us talks to a map. Neither of us reaches inside.
The practical consequence is blunt: we gained a universal translator to a compressed map. We lost the workshop feel of a system we can open and rewire mid-flow.
The Agentic Hysteria
Agents aren’t new. News monitoring scripts, web crawlers, workflow automation, RPA, BPM pipelines—this has been an unglamorous backbone of software for decades. My first job was building news monitoring agents that parsed wires and routed alerts. The architecture and ambition are familiar.
What’s new is the interface.
When you can say “track these three clients, summarize changes weekly, and email me the delta,” and the system understands enough to orchestrate tools and APIs, you don’t have to write the YAML, compose the pipeline, or learn the SDK. The “agentic revolution” is a language revolution. Fluency mimics agency. The mimic is the story: the appearance of a partner you can describe tasks to. The mechanism underneath is still automation.
Agents are the downstream effect. Language is the upstream cause.
One Surface, Many Modes
Open a chat window and watch the modes slide, unannounced.
You ask a fact: “What’s the population of Norway?” That’s retrieval. You ask for a comparison: “Is that high or low for the Nordics?” That’s reasoning. You ask for an edit: “Make this clearer for a 10-year-old.” That’s writing. You ask for a landscape: “What are the main arguments about immigration policy in Norway?” That’s synthesis. You ask for a gut check: “Does that make sense?” That’s conversation.
Same model, same thread, same voice. No [RETRIEVAL] or [REASONING] banners. No flag when it stops recalling and starts inventing connective tissue. No moment where it says, “I’m switching modes.”
This is not a bug. It’s intrinsic to language. Humans don’t preface answers with mode markers either; we infer mode from context and tone. A general-purpose language interface will be polymorphic and unmarked.
Why the Muddle Matters
Intrinsic doesn’t mean benign. Our cognitive wiring uses fluency as a truth signal. Confident, grammatical, well-structured prose reads as authoritative whether it’s retrieval, careful reasoning, or a guess.
That is the mechanism behind what we call hallucination. The same mapping that gives you a brilliant synthesis also gives you a plausible falsehood. The compressed map speaks with authority even when it doesn’t match the territory.
Korzybski named the trap: identification—collapsing the abstraction layers and mistaking the map for the territory. LLMs automate description. By design they cannot guarantee correspondence.
Two underplayed facts make the muddle sharper.
The cognitive burden shifts to the user. In a shell, a broken pipeline throws an error. In a spreadsheet, a bad reference screams #REF!. In chat, there is no failure mode—only confidence. You are left to do epistemic triage on a stream that never tells you which parts came from where.
The opacity is incentivized. A tool that hesitates, flags uncertainty, or visibly changes voice when it leaves the retrieved territory is less seductive than one that speaks with seamless authority. The seamless muddle isn’t just a property of language; it’s a product choice.
Borges’s warning lurks here, too. The empire that tried to make a 1:1 map collapsed under the weight of its own ambition. The satire wasn’t about cartography; it was about control. A fluent, totalizing voice that appears to cover everything can stifle inquiry: if the map sounds like it is the territory, why check?
What RAG Is, and What It Isn’t
Retrieval-augmented generation puts a seam in the system: a retriever fetches, the generator speaks. When implemented thoughtfully, you get fresher knowledge, fewer hallucinations, and the possibility of provenance.
RAG is a retrieval pattern, not a honesty guarantee. It can be used opaquely. And regardless of the plumbing, the generation layer often retains the same voice. Summaries and paraphrases flow in the same cadence as inventions. The muddle travels with the language.
The responsible stance is narrow and specific. In ordinary chat, there often is no RAG—the model is doing everything from its frozen map. In RAG systems, the interface should not pretend the problem is solved. It should show where a statement came from, expose the distance between retrieved text and generated summary, and make the handoff visible. Otherwise, RAG becomes a provenance prop.
Calling the seam out in code is not the same as making it legible to users.
What the Terminal Taught Us
There’s a feeling many developers remember: the first time a Unix shell did something you meant. The machine felt cooperative. You could say what you wanted, in its language, and it did it.
That’s the echo people feel with LLMs. The intent-action gap narrows. You don’t need to think like a compiler to get somewhere useful.
But the analogy hides a trade-off. The shell exposed its mechanics. You saw commands, pipes, exit codes. You could reason backward. With models, you typically see none of that. The outer behavior is cooperative; the inner path is opaque.
One Thing, Two Things
A design maxim says: one thing that tries to be two things causes trouble. Using one undifferentiated interface for retrieval and reasoning is an invitation to confusion.
This is not fixable at the language level; language lacks mode markers. But it is addressable in the system you build around the model.
Baseline moves: surface provenance as a first-class citizen, not a footnote. Where possible, cite down to excerpted spans, not just URLs. Use simple, consistent markers like [RETRIEVED], [GENERATED], [CHAIN-OF-THOUGHT]—cheap signals that help recalibrate trust. Show uncertainty; offer graceful “I don’t know” affordances rather than guessing.
The harder version: labels are a band-aid on a monolith. If we take the maxim seriously, retrieval should be a subsystem users can inspect and re-run. Reasoning traces should be a first-class view you can step through. Generation should sit downstream of both, with clear boundaries. That’s more than UX chrome; it’s an architectural choice to restore inspectability.
The punchline is simple. We did not invent a better database. We invented an interface to a compressed map that speaks in the same language the map is made of. That is new.
The muddle is intrinsic to the medium. Opacity is a choice. If your system acts like the map is the territory, your users will too.
The so-called agentic revolution is downstream. The interface is upstream. When anyone can describe an automation in their language, anyone can compose agents. Fluency mimics agency. That’s the trick. It’s also the hazard.
The honest way to use this power is to name what it is: an extraordinarily capable, read-only oracle to a lossy map. Build the workshop around it. Make the seams visible. Refuse the totalizing voice. And remember Korzybski’s old advice in a new key: don’t mistake the model’s description for the world it describes.