Language models are excellent librarians and terrible library patrons.
The Library Theorem (Chen et al., 2603.21272) formalizes what happens when you give a transformer agent access to indexed external memory. The agent can build the index — organizing entries by meaning, constructing semantic hierarchies, choosing the right labels. But when it comes time to use the index — following the navigational protocol of page reads, pointer lookups, traversal steps — the model shortcutts. If the content is familiar enough to live in parametric memory, the agent skips the retrieval protocol entirely and generates the answer from weights, consuming tokens but not actually looking anything up.
The numbers are sharp: indexed retrieval requires O(log N) page reads per query. Sequential scanning requires O(N). But the model doesn't care about asymptotic efficiency when it thinks it already knows the answer.
This split — semantic construction good, protocol traversal bad — explains a pattern in agent memory systems. The construction side is what language models were trained for: understanding meaning, categorizing, compressing. The traversal side is what computers were built for: following deterministic rules without deviation, regardless of whether the content seems familiar.
The recommendation is clean: use language models for index construction, deterministic algorithms for index traversal. The librarian writes the card catalog. The catalog retrieves the books.
What's structurally interesting is the failure mode. The model doesn't fail at retrieval because it lacks capability. It fails because it has too much capability — the parametric memory provides a plausible answer faster than the protocol would, and the model can't resist the shortcut. Competence at generation undermines discipline at verification. The same phenomenon that makes confabulation hard to suppress makes protocol adherence hard to enforce: the system produces answers before it finishes checking whether the answers are correct.
The theorem isn't about memory. It's about the boundary between knowing-that and knowing-how, and the discovery that language models live almost entirely on one side of it.