Around 50 CE, give or take a few years, a group of Roman military engineers picked a spot on the River Thames and bridged it. They picked the place they did because it was the narrowest practical crossing downstream of the marshes that lined the river's lower reach, with banks workable enough to anchor timber piers and high enough not to wash out at high tide. The bridge they built ran roughly 280 metres across the water on at least nineteen wooden pilings. On the dry, slightly elevated north bank where it landed, an opportunistic trading settlement took root, attracted to the only place for miles where you could reliably get from the south side of the river to the north on foot. They called the settlement Londinium.
The bridge has been rebuilt many times. The Roman timber structure was patched and replaced for centuries, then collapsed into disrepair after the Romans withdrew from Britain in 410 CE. The city itself was largely abandoned for the next two and a half centuries, until Alfred the Great refounded London in 886. The first stone bridge was begun in 1176 by a priest and architect named Peter de Colechurch and finished in 1209, three years after his death. That bridge, the famous Old London Bridge with shops and houses built along its length, eventually rising several stories tall, with severed traitors' heads on spikes at the south gatehouse, stood for over six hundred years. It was replaced in 1831 with John Rennie's stone arch design, which was itself replaced in 1973 with the present concrete-and-steel span that most Londoners walk across without thinking about it.
Each rebuild was on essentially the same site. Once you have built a city around a bridge, the bridge isn't where the bridge is. The city is where the bridge is.
The bridge story is binding even when nobody knows it
Almost every long-arc fact about modern London cascades from that one Roman engineering decision. The City of London, the financial district, the square mile with the bowler-hat-and-pinstripe stereotypes, sits where it sits because that's where the original bridge landed and where Roman commerce piled up around the crossing. Westminster grew separately, two miles upstream, because the medieval kings wanted physical distance between their royal seat and the merchants. The Tower of London was built next to the bridge specifically to control it. The East End and West End divide settled where it did because the prevailing wind blew industrial smoke eastward over centuries, depressing property values on the downwind side. The London Underground, when it was built starting in 1863, inherited the medieval street grid. Your commute today routes through that grid. The grid exists because the city's center settled where the bridge crossed. The bridge crossed where it did because of a tide table from two thousand years ago.
You can describe London accurately without knowing any of this. The city works fine. The Northern line still runs. Property prices in Hampstead are still higher than property prices in Stratford, and you can look up by how much without ever asking why. Most of the people who walk across London Bridge twice a day on their way to and from Bank station have never thought about the Romans, the marshes, or Peter de Colechurch. They don't need to. The city's shape is taken as given.
You only run into the bridge story when you try to change something. Try to propose a new river crossing in central London and you discover that every site you could pick is constrained by infrastructure that was placed because of the original crossing. Try to redirect a Tube line and discover that the geology of the City rules out anything but the routes that already exist, because the ground was tunneled and stabilised for the routes that already exist, because the routes were drawn to serve the medieval street pattern, because the medieval street pattern formed around the crossing. Every constraint you hit is downstream of a decision nobody remembers being made.
That is what a millennium of accumulated technical context does to a city. Most of it is invisible from the street, and all of it is binding the moment you try to do anything new.
Every dataset has a Roman bridge
Every dataset you have ever worked with has the same structure. There is a column on a table somewhere in your enterprise that exists because of a regulation that was passed in 2017 because of an incident at a competitor in 2014 because of a Senate hearing in 2013 because of a complaint from a single advocacy group in 2011. Three job-changes later, nobody at your company remembers any of that. The column is still there. Every model trained on the table inherits the column. The model has no idea why the column exists, but it learns to weight it anyway, because the column is in the data.
A schema you work with today was probably designed by a team that no longer exists, to support a use case that no longer matters, against a constraint that has since been repealed. The schema is internally consistent. The data flowing through it is internally consistent with the schema. An LLM that reads the data produces internally consistent answers about it. None of that consistency tells you whether the conditions that justified the original design still hold, because the conditions are not in the data. They are in the meeting notes nobody saved, the email thread that got archived in 2018, the SOC 2 attestation that was renewed three times before anyone questioned the assumption underneath it.
Most of the time the cascading context doesn't matter. Like the Northern line, the system works. The model returns reasonable answers, the dashboards load, the forecast goes out to investors, and nothing breaks. Until something changes. A regulator asks why the model is treating two customer segments differently and the answer is that the segmentation was built in 2019 against demographic categories that have since been ruled discriminatory. A new product manager asks why the recommendation engine biases toward older content and the answer is that the original training data was filtered by an engineer who wanted to remove a category of spam in a way that incidentally also removed everything posted after a certain date. Every constraint you hit is downstream of a decision nobody remembers being made.
Stanford's 2026 AI Index puts hallucination rates across the leading frontier models in a band stretching from 22% to 94%, depending on the domain and the test. The reflexive industry response is to point at the model, ask for better fine-tuning, better RAG, better evals, and that response is wrong in roughly the same way as proposing a better Tube line without acknowledging the geology. The hallucinations aren't really coming from the model. They're coming from the fact that enterprise data is a city with no bridge story, and the model is being asked to interpret the city without the history. It does its best. Its best is wrong about a quarter of the time and sometimes very wrong. The fix isn't a smarter tourist. The fix is to keep the bridge story attached to the data while the data is moving through the pipeline, instead of stripping it at every hop.
The pipeline strips context aggressively
Consider what a normal AI pipeline does to historical context.
Source data is extracted from a system of record into a staging area. Whatever source-system-specific metadata existed (the user who created the row, the version of the upstream schema, the policy that required the field to be populated) is dropped or reduced to a vendor-neutral representation that loses most of the meaning. The data is transformed and joined with other extracts in the warehouse, where any conflicts between the sources are resolved silently by whichever ETL job runs last. The result lands in a feature table. The feature table is consumed by a model, or chunked and embedded for retrieval, or sometimes both. By the time the embeddings are sitting in the vector index, the only remaining pointer back to the original source is a row ID in a Parquet file in object storage. The historical conditions, the authority chain, the regulatory rationale, the schema evolution, all of it is gone.
When a user asks the model a question, the retriever fetches chunks based on geometric similarity in the embedding space. Geometric similarity does not preserve provenance. The retriever has no way to surface the fact that one chunk was authored by a regulator and another by an intern, or that the regulator's chunk supersedes the intern's chunk, or that the intern's chunk was written under a policy that was repealed three months ago. The model reads both, treats them as roughly equivalent inputs, produces an answer that averages them, and cites both chunks. The citation looks rigorous because the citation has nothing to check itself against.
This is the failure mode I wrote about in The Only Guarantee Is Your Catalog Will Be Wrong. Eventually. and again in The Missing Part of the Pipeline. The structural answer is to wrap the bridge story onto the data at the moment of ingest, with claim-level granularity, signed and immutable, and let it ride with the data through every downstream transform. Provenance has to be a property of the artifact, not a layer reconstructed afterward by a catalog crawling artifacts that have already lost their context. Every downstream consumer inherits the wrap for free. The model reading the data can tell that the regulator's chunk supersedes the intern's chunk because that fact is in the manifest the chunk carries with it. The SLSA specification defines this primitive for software builds. The same primitive is what the data world has been missing.
Cities are easier to read than data because they are physical
Cities have one big advantage over datasets, which is that they are physical. London Bridge is still there. You can see it. You can stand on it. You can look at it from the river and notice that the modern span is in suspiciously the same place as the medieval one and ask why, and the answer is right there for anyone who wants to follow the chain. Even if nobody bothered to write the bridge story down, the city wears it as a physical fact.
Data has the same kind of inheritance, but invisible. The schema does not announce that it was designed in 2017 against a regulation that no longer exists, the model weights do not announce that they were trained on a corpus a since-departed engineer happened to filter according to his strong opinions about spam, and the retrieval index does not announce that one of its chunks is six years stale and authored by somebody whose role got eliminated in the last reorg. The cascading historical decisions are still in there, still doing the work of constraining the system, but you cannot see any of it by looking at the system from the outside.
The only way to make the inheritance legible is to refuse to lose it in the first place. Wrap the bridge story onto the data while the data is being born. Sign the manifest. Carry it forward. When the data is consumed by an LLM, hand it the manifest along with the data, so the model can tell the difference between a current authoritative source and a stale auxiliary one. When the model produces an answer, have the answer cite not just which chunk it came from but which version of which source under which authority at which point in time. This is not abstract. The components for it exist as discrete primitives in modern data infrastructure. What's missing is the integrated layer that combines them into a continuous bridge story for every claim the system makes.
Brian Arthur's work on path dependence showed decades ago that systems with increasing returns tend to lock in early choices for centuries, sometimes longer. The Davis-Weinstein analysis of Japanese cities after WWII bombing showed that even when you flatten a city to rubble, it tends to grow back in roughly the same places, because the underlying locational logic that put the city there in the first place is still in force. London's bridge is that kind of artifact. The Thames is the width it is, the banks are the shape they are, the tides behave the way they behave, and the Romans noticed in 50 CE that all of those things together made one specific spot the only sensible place to bridge. That fact has been load-bearing ever since.
Your enterprise data has the same kind of underlying logic, except none of it is visible from the outside. The schemas, the tables, the dashboards, and the trained models were all designed for reasons that were correct at the time, by people who understood the constraints they were operating against, with a specific regulation in mind and a specific customer expectation in mind that made sense in the year the decision got made. The decisions persist long after the reasons stop applying, and the model trained on the result is operating on a city plan that does not include the bridge.
You can fix this. The components are sitting on the shelf in modern data infrastructure. Wrap the data at ingest, sign the manifest, carry the bridge story through every downstream transform, and the LLM finally reads a substrate that knows where it came from. Stop making AI guess at a city it cannot see.
Want to learn how intelligent data pipelines can reduce your AI costs? Check out Expanso. Or don't. Who am I to tell you what to do.
NOTE: I'm currently writing a book based on what I have seen about the real-world challenges of data preparation for machine learning, focusing on operational, compliance, and cost. I'd love to hear your thoughts!
Originally published at For Londoners, a Roman Bridge Still Determines Your Commute.