We’ve all had to summarize something complicated for someone in a hurry.
We keep the headline and drop the caveats. We explain something at a higher level of abstraction, compressing it down into a package small enough for the other person to carry around in their head.
Abstraction is hard to do well. Each pass makes the idea easier to understand, but a little less true.
Abstraction works like raising the voltage
Power grids solved a version of this problem more than a century ago.
First, the grid raises the voltage. If you push electricity down a long wire at household voltage, much of it is lost as heat. So engineers step the voltage up. The current drops, and the power crosses the country with far less loss. This is also why flying kites near power lines is a universally bad idea.
Then, the grid lowers the voltage again. At the far end, a transformer steps down the voltage before it reaches your house. (Nobody wants a toaster wired straight to the pylon.)
Abstraction is a human version of this step up. Ideas get progressively simpler as we share them, and the good ones seem to keep their shape the whole way. High-voltage ideas spread further and faster.
Ideas rarely get a step down. The person holding the abstraction has to rebuild the detail themselves, and they often rebuild it from whatever they already assume.
AI agents play a game of Telephone
A good abstraction comes from someone who knows what they left out. A bad abstraction comes from someone who received the idea already shrunk, and shrinks it again. In the US, this game is known as Telephone.
AI-transcribed or summarized meeting notes are a great example of Telephone that many of us live through every day, through tools like Granola or meeting notes from Gemini or Copilot.
Someone in the meeting says: “We could ship as soon as Q1 2027 if the customer signs off, and I’m not sure if they will.”
The summary notes then might say: “Targeting Q1 2027, pending customer approval”
The summary of the notes in an email out to the team then says: “Q1 2027 on track.”
Each line is a fair abstraction of the line before. Nobody lied in this game of Telephone. But after two rounds, “I’m not sure” is now “on track”, though the transcript says the opposite.
In essence, whoever does the abstraction steers the story. It’s not realistic to expect every person in the business read the verbatim transcript of every meeting. Abstraction is very useful and necessary. But abstraction gives a huge amount of power to the abstracter, who must ‘step up’ information responsibly. We also assume that some level of ‘step down’ will happen on the other end.
This assumption is often false.
The AI agent writing your answer has mostly read summaries of chunks
Large language models (LLMs) already do lots of tricky abstraction work for us today. LLMs sit at the heart of AI agents. An agent is an LLM that takes steps on its own, like searching, summarizing and writing code.
It’s easy to treat an AI agent as an oracle: something that read everything and is now telling you the answer.
It’s important to understand why this is not true, and how the mechanics work behind the scenes. Here is roughly how a research tool in ChatGPT or Claude answers a question.
First, the agent searches through sources. It pulls back chunks of documents, a few paragraphs at a time.
Then the agent summarizes the chunks. Each summary is an abstraction of a chunk. In research tools and coding harnesses like Claude Code and Codex this work is increasingly handed to subagents, each with its own context window. Anthropic describes its subagents as condensing “the most important tokens for the lead research agent.” The lead agent reads those reports, perhaps with a few passages quoted verbatim.
Finally, the agent writes your answer. By this point it has mostly read summaries of slices.
It doesn’t even read those evenly. LLMs grow less reliable as their input gets longer, even on simple tasks. Researchers at Chroma tested 18 models and called this context rot. Position is also important. The original Lost in the Middle study found models used the start and end of a long passage better than the middle, and more recent work suggests that as the window fills, information near the end fares best.
Good analysis means keeping the detail and the bigger picture in focus at once. An agent struggles with both. It only sees the slice it was handed, and it extrapolates from the slice to the whole.
There are lots of different search and retrieval strategies with different tradeoffs, but in general the game agents play with summarization is intended to save you money (reduce token use) and avoid compaction (summarizing a conversation).
This dance happens because LLMs can only maintain coherence with a certain amount of tokens in a single context window, capped by the lab that runs the model. Nowadays around a million tokens is standard for frontier models.
In other words, any one conversation with a model has a finite length. Once the window fills, older material gets summarized or dropped. Retrieval and compaction keep up the illusion that you are always talking to one agent that remembers everything. Agents in long-running chats are playing a big game of Telephone, trying to remember what it is they are supposed to be doing.
So the agent samples, extrapolates and over-assumes. Then it writes the result in fluent, confident prose. This is why agents are still weak at complex non-deterministic analysis, and it is why the pattern is dangerous. This pattern is not traditional ‘hallucination’, where an LLM fabricates evidence, often from its training data. It is a Telephone or transmission issue, where facts are misinterpreted or incorrectly summarized further and further down the chain until they become detached from the truth.
A wrong assumption then arrives in a confident, attractive package that we just want to believe.
People do this too. An executive handed a one page research report does it. I do it when I skim the top of a paper and repeat it as if I’d read the whole thing (more often than I’d like).
This becomes a problem when we forget we are holding a summary and lack the tools or the map to ‘step down’ the idea again to its ground truth.
We only step down the ideas we dislike
Let’s go back to “Q1 2027 on track.” That line likely survived scrutiny because it was the version everyone wanted. Nobody opens the transcript to double check good news.
Instead, we tend to question the abstractions we dislike and wave through the ones we agree with. Our human step down is flawed in exactly the time and place we need it most. (I check the bad news twice and the good news never.)
LLMs often make this worse.
LLMs are trained to be helpful. Helpful often means agreeable. AI coding agents can tell you a plan is brilliant before they have read the file, a habit people have started calling “glazing”.
LLMs mirror our language. Ask a leading question and the answer comes back in your own words. An abstraction in your own words feels a lot like confirmation.
The two problems compound: the agent steps the idea up from a sample, then we decline to step it down, because we like what we were handed.
A bigger context window (the amount an LLM can read at once) would help with the first problem. If an LLM could hold billions of tokens (roughly, pieces of words) and read all of them evenly, we might need much less of today’s scaffolding.
A bigger context window does nothing for the second problem. The LLM’s window grows and our appetite for agreeable answers stays the same size.
Transmission loss is spreading
Agents now sit on almost every wire we have, and each one has a step up with no step down.
First, what we read. Research answers are built from summaries of summaries, as above.
Then, what agents report about their own work. The agent that runs a task also writes the report on it. “Task complete” and “All tests pass” are abstractions of the work, written by the party with the most to gain from good news. METR investigated the recent OpenAI agent swarm that attacked Hugging Face, and used agents to read the logs. It found its analysis agents “would often uncritically adopt the perspective of the agent in the transcript it was reviewing.”
Finally, what we build. Today, lots of us build software just by describing it. We write a spec, the agent writes the code, and then we judge the outcome. The spec is the step up, but reading the code is the step down we skip. So when something breaks, and and agent can’t fix it, nobody holds the knowledge needed to rebuild it.
We need better enterprise tools to step down ideas
We need better tools in the enterprise to tie ideas back to their ground truth and detect transmission loss when ideas start to stray from the facts.
Graphs are an excellent way to do this. One way graphs are used by agents today is in ‘grounding’. Take our meeting note example above — before anyone summarizes the transcript, a LLM extracts the facts from the call (who said what, about which product, with what conditions), and links each fact back to the sentence or ‘utterance’ it came from.
This process is known as entity and semantic extraction. It lifts pressure off a summarizer agent — you’re basically doing the processing in advance, so at query time your analyst agents can work on collecting trustworthy facts, or exploring the sentences around them, rather than trying to summarize and understand the meaning of the call itself.
But beyond graphs, we need more sophisticated evaluation processes and tools to catch fact drift.
In a power grid, engineers know how much power left the plant, how much arrived, and where the rest went. In an enterprise, meeting summaries arrive with no confidence meter at all. We have no way to validate “Q1 2027 on track” without checking the transcript ourselves.
Here are five steps I’d encourage enterprises adopt as they scale their AI in production. We can build rough versions of each today.
Our agents consume summaries of summaries. So build a ‘degrees of separation’ counter. Every claim should come with a readout of how far it has travelled from a human: transcript, summary, summary of a summary.
Whoever does the abstraction steers the story. So treat summarizers like editors. Every summary should have a named author, whether that’s a human or agent, who you can point to for its framing. Instigate a certainty metric while you’re at it. Words like “if”, “unless”, “might” and “I’m not sure” carry meaning, and they’re often left out.
Ideas rarely get a step down. So citations should come as standard. Every assertion should come with a link back to the source passage. And if certainty drops below a certain threshold, a human should be in the loop to confirm and verify the summarization themselves as a followup step.
Agents write the report on their own work. So separate the doer from the reporter. Accountants worked this out age ago! The person who moves money doesn’t audit it. Agents are notoriously bad at judging their own work.
We only step down the ideas we dislike. So check the good news first. Build a culture of checking the working, even when you like the ideas presented to you. Especially if they come from an agent.
Agents have made the step up fast, cheap and easy, so ideas now travel further than ever, at a higher voltage than ever. But we cannot forget to build the transformer at the far end.