François Chollet posted a prediction this week: future “Latent Space Archaeologists” will investigate the model weights of the 21st century to reconstruct a long extinct culture. The line landed a thousand likes because it compresses something true. A trained AI model is a cultural artifact, and the culture it preserves is ours. Understanding why requires understanding what weights actually are, which (like most aspects of the actual tech) much coverage of AI skips past entirely.

What a Weight Is

Strip away the mystique and a large language model is a mathematical function. Text goes in, text comes out, and in between sit billions of numbers called weights, or parameters. Each weight is a single value, something like 0.0347 or -1.2091. A frontier model like GPT-5.5 or Claude contains hundreds of billions of them, likely more. That is the whole model. There is no database of facts, no stored library of documents, no lookup table. Just the numbers, arranged in layers, each one determining how strongly one part of the calculation influences the next.

The word “weight” comes from that role. Each number weights a connection, amplifying some signals and dampening others as information flows through the network. Change the weights and you change everything the model knows and how it behaves. The weights are the model.

Where the Numbers Come From

Weights start as random noise. Training is the process of adjusting them, billions of times, until the model gets good at one deceptively simple task: predicting the next word in a piece of text. The model reads a fragment of its training data, guesses what comes next, measures how wrong it was, and nudges every weight a tiny amount in the direction that would have made the guess better. Repeat this across trillions of words scraped from books, websites, code repositories, and forums, and the weights gradually organize themselves into something that captures the structure of human language and, through language, the structure of human knowledge.

Chollet is pointing at the fact that to predict text well, the model has to absorb far more than grammar. Predicting the next word in a sentence about a wedding requires implicit knowledge of ceremony, family, obligation, and joy. Predicting the punchline of a joke requires a statistical model of what a culture finds funny. Predicting a heated Reddit thread requires absorbing how people argue, what offends them, and which topics reliably ignite. All of that ends up encoded in the weights. Not as stored sentences, but as pressure, as tendency, as the shape of the function itself.

The Compression Argument

A useful way to think about a trained model is as a lossy (inexactly preserved) compression of its training data. The training corpus for a frontier model runs to tens of trillions of words, petabytes of raw text. The weights that result fit in a few hundred gigabytes. The model cannot reproduce its training data verbatim, mostly, because there is not enough room. What survives the compression is the statistical essence: the patterns, associations, values, and habits of mind that recur across the corpus.

This is why Chollet’s archaeology framing works. An archaeologist reconstructs a civilization from fragments because the fragments carry the civilization’s patterns. Pottery shards reveal trade routes. Midden heaps reveal diet. Model weights, on this analogy, are the densest midden ever created. A snapshot of internet-era humanity, compressed into numbers, frozen at the moment training stopped.

What Latent Space Means

The “latent space” in Chollet’s post refers to the model’s internal geometry. As text flows through a network, every word and concept gets represented as a point in a high-dimensional space, and the model’s weights determine where everything sits. Concepts that the training data treated as related end up near each other. Directions in this space acquire meaning: there are directions that correspond to gender, to formality, to sentiment, to political valence, none of them programmed, all of them learned.

Researchers already do a primitive version of the archaeology Chollet describes. The field is called interpretability, and it involves probing weights and activations to find where a model stores a concept, how it represents a belief, which internal features fire when it encounters deception or flattery or a particular historical figure. Anthropic’s interpretability team has published work identifying millions of distinct features inside a production model. The tooling is early, but the premise is proven: culture is recoverable from the numbers.

Why the Framing Matters Beyond the Joke

Two implications follow once you take weights seriously as cultural archives.

The first concerns what gets preserved. Weights encode the training corpus, and the corpus reflects choices: which languages dominated, which communities wrote the most, which viewpoints were scraped and which were excluded. A 21st century model is an archive of the anglophone internet above all. The Latent Space Archaeologists of Chollet’s future would reconstruct a specific culture, weighted toward those who published most prolifically online, and would need to correct for that bias the way historians correct for the fact that most surviving medieval texts were written by monks.

The second concerns who holds the archive. Weights are files. They can be copied, transferred, seized, subpoenaed, and export-controlled, and increasingly they are treated as strategic assets. The United States already restricts the export of certain model weights. When a nation’s institutions run on models trained elsewhere, the compressed cultural record shaping their AI systems belongs to someone else’s corpus and sits under someone else’s jurisdiction. The archive question and the sovereignty question are the same question wearing different clothes.

For the first time in history, a culture is producing a machine-readable compression of itself as a byproduct of building tools. Every training run is an act of accidental preservation. The weights of the 2020s will outlast the servers they run on, the companies that made them, and possibly the internet they were trained on. Whatever finds them will find us.

The comparison to source code (which has been made) fails at the level of authorship. Source code earned qualified First Amendment protection in cases like Bernstein v. Department of Justice because it is written by humans, read by humans, and communicates ideas between them; a cryptographic algorithm in C is a text that a person composed to express a method, and a court can treat it the way it treats a mathematical proof or a recipe. Weights have no author in that sense. No human wrote 0.0347 into position four billion and six, no human can read it out again, and the full parameter set communicates nothing to any person who inspects it. The numbers are the residue of an optimization process, closer to a measurement produced by an instrument than to a sentence produced by a mind. What a developer authors is the training code, the architecture, and the data selection, and those choices may well carry expressive weight. The artifact that falls out the other end functions like a machine part. First Amendment doctrine has long distinguished expression from function, and courts have upheld regulation of even code-adjacent artifacts where the government targets what the thing does rather than what it says. A weights file does things: it powers inference, generates exploits, designs molecules. Regulating its transfer restricts a capability, along the lines of restricting the export of a jet engine, and a jet engine built by an algorithm no one can read is a strange candidate for the protections we built for pamphleteers.

Addendum: What Comes From the Weights and What Comes From Around Them

When you talk to a deployed AI product, the weights are only one layer of what produces the response. Separating the layers matters for anyone evaluating what a model “knows,” and confusion between them drives a lot of bad coverage.

The weights carry everything learned during training: language ability, reasoning patterns, world knowledge, style, associations, and biases. All of it is frozen at the moment training ends. This produces the knowledge cutoff. A model trained on data through early 2026 has no weight-level awareness of anything that happened afterward, regardless of how recently the product around it shipped. Version numbers and cutoffs move independently. A vendor can release a new model version with an old cutoff, or refresh a product interface without touching the underlying weights at all.

Everything else arrives at inference time, layered on top of the frozen weights:

• The system prompt. Vendor instructions injected before every conversation, shaping tone, behavior, and refusals. Change the prompt and the same weights produce a noticeably different product overnight.
• The context window. Whatever you paste, upload, or say in the conversation. The model reasons over it fluently, and none of it touches the weights. Close the session and it is gone.
• Retrieval and search. Live tools that fetch current information the weights lack. A model correctly reporting a product released last week is reading, without knowing.
• Memory and personalization layers. Stored summaries of past conversations, injected into context. These simulate continuity while the weights remain identical for every user.

A live illustration: while working on this piece, the model (Mythos Fable 5.0) editing referenced (and corrected a draft!) GPT-4 as a current frontier system. Its weights predate GPT-5.5. Corrected itself, it ran a web search, confirmed the April 2026 release, and updated the draft. The fluent, current-sounding answer that followed came from retrieval, and the outdated one before it came from the weights. The cutoff for factual information varies by model, it tends to be months, sometimes many months, behind. Same model, same conversation, two different sources of truth.

The practical test is simple. If the information could only exist after the training cutoff, it came from a tool or from you. If the behavior changes between two products running the same model, it came from the prompt layer. Only what survives across every deployment, every prompt, and every conversation is actually in the numbers. That is also what makes Chollet’s archaeologists possible. The scaffolding around the weights will rot first. The weights keep only what they were trained on, and that is precisely why they work as a record.