Most people do not have a data problem. They have a cognition problem. The raw information is technically available, but it is just trapped in a form that no human can reasonably work with.
I ran into this firsthand while building a system to analyze co-parenting communication records. The source material was more than 5,000 pages of PDF exports. After parsing and extraction, that became roughly 2,700 messages spanning seven years of back-and-forth: emotionally charged exchanges, scheduling disputes, medical issues, financial discussions, legal references, and long stretches where the signal was buried under repetition.
That is not a document you can read. It is a corpus you need to navigate.
The problem with "AI summaries"
A lot of AI products approach this kind of corpus with a simple move: upload the files, ask for a summary, hope for the best. That works surprisingly well for small documents. It breaks down on high-volume communication archives.
A single summary is too lossy. It may compress the corpus, but it collapses the structure that makes it inspectable. You get a plausible narrative, but not one you can trace back to the source. The model says something about a pattern or a conflict, but where did that come from?
And one level of abstraction is never enough. A person reviewing seven years of messages does not only want "the answer." They need to move between levels: top-level case understanding, recurring themes, timelines, and individual messages with exact language.
That is not a summarization problem. It is a navigation problem.
A better framing: semantic compression
The system I built started from a practical need: take a raw co-parenting platform export, extract the messages, run classical NLP and machine learning over the corpus, and present the results in a way that lets a user move from the high-level picture down to the exact message.
The more I worked on it, the more I realized it was best understood as a semantic compression system.
The job is not to replace the source material. The job is to transform it into a hierarchy of meaning.
At the bottom of the stack is the raw text. Above that are extracted messages and normalized metadata. Above that are classifications, response-time features, flags, and relevance markers. Above that are themes, event clusters, and time-window summaries. At the top are corpus-level views and case-wide synthesis.
The value is not the layers themselves. It is the ability to move between them: to zoom out and understand the whole corpus, or zoom in and verify the exact message.
That is the core design principle: lossy enough to understand, lossless enough to verify.
The architecture of zoom
I think of the system as a multi-resolution interface over a communication archive.
Level 0: Raw source material. The original PDF export, usually ugly, with inconsistent section boundaries, repeated page furniture, embedded metadata in strange places, and formatting noise. You cannot do serious downstream analysis if this layer is unstable, so the first job is reliable extraction.
Level 1: Message objects. Once the PDF is parsed, the archive becomes structured records: sender, recipient, timestamp, subject, body text, page references, and source offsets for traceability. This is where the corpus stops being a document and starts becoming a dataset.
Level 2: Message-level enrichment. With normalized data, a lot of traditional analysis opens up: topic classification, semantic relevance scoring, timing features, sender/recipient distributions, behavioral markers, toxicity screening, entity and issue tagging. This layer makes the archive indexable in ways humans naturally care about. Not just what was said, but what kind of message was this, how often does this pattern occur, who initiates certain categories, how quickly do people respond, what periods are unusually conflict-heavy.
Level 3: Pattern formation. Message-level enrichment is useful, but users do not think in isolated records. They think in episodes. So this layer groups records into higher-order structures: recurring themes, event clusters, dispute sequences, scheduling patterns, medical coordination episodes, legal or financial discussion arcs. Instead of 2,700 messages, the user reasons about a manageable number of recurring patterns.
Level 4: Corpus-level synthesis. At the top, the system generates summarized views: volume and participation patterns, category distributions, flagged message breakdowns, theme summaries, timeline overviews, response-time analysis. This layer is not "the truth." It is a useful map.
Why drill-down matters
The drill-down is not a UI flourish. It is what makes the whole system trustworthy.
A dashboard without drill-down is just a claim. A message list without compression is just a burden. The value comes from combining the two.
If a theme says there were repeated disputes around school pickup, the user should be able to click into that theme, see the underlying messages, inspect the chronology, and read the exact language. If response-time analysis suggests one party routinely delayed viewing messages, the user should be able to inspect the individual records behind that claim. If a message is flagged for review, the user should see the original wording, the surrounding context, and how the flag was derived.
That is the difference between a summary engine and a review system.
Consider what the experience looks like without this kind of compression. A reviewer is effectively scanning thousands of messages, trying to hold patterns loosely in memory: school pickup disputes, delayed responses, recurring medical disagreements, sudden spikes in legal references. After compression, those same dynamics become navigable objects: a timeline segment, a recurring theme, a flagged cluster, a response-time distribution, each linked back to the underlying messages. The reviewer stops searching and starts reasoning.
The real design problem
The hard part is not "using AI." The hard part is deciding what should exist at each level of compression.
Compress too little and the user drowns in detail. Compress too much and the user loses trust. Classifications too broad: vague. Too narrow: noisy. Summaries disconnected from evidence feel magical in the bad sense. If everything is evidence and nothing is synthesized, the user still does all the work.
The real design problem is epistemic: what is the right shape of an explanation for a large text corpus?
A good system lets the user change altitude without losing orientation.
From documents to intelligence surfaces
"Chat with your PDF" is a useful demo. It is not a serious interface for understanding a seven-year communication archive.
The more interesting direction is intelligence surfaces over corpora, interfaces that treat a large body of text not as something to query, but as something to model. A dashboard that summarizes without overclaiming. A timeline that reveals sequence and recurrence. A pattern view that groups related episodes. A screening layer that surfaces candidates for review. A drill-down path that preserves provenance all the way to the source.
The underlying architecture generalizes well beyond any single domain. Anywhere you have long-running message history, too much text for manual review, a need for chronology and recurrence detection, and content that is operationally or emotionally important (legal archives, HR investigations, compliance corpora, insurance claim logs), the same multi-resolution approach applies.
But the product is not a chatbot. The product is a navigable knowledge model.
Closing thought
When we say a system "understands" a corpus, we usually mean it can produce a plausible paragraph about it. For many real-world archives, that bar is far too low.
Understanding has to be inspectable. It has to support synthesis without severing the path back to evidence. It has to help a human move from thousands of pages to a manageable set of patterns, and then from those patterns back to the exact messages that support them.
That is the opportunity here.
Not just summarization. Semantic compression: turning overwhelming communication history into something a human can actually navigate, reason about, and trust.