Language is built by everybody who speaks it. No individual invented English or Spanish or Mandarin. They emerged from communities, evolved through use, belonged to no one and everyone. And yet we have spent the last century trying to enclose it — through copyright, patents, credentials, and now through language models trained on the corpus of human expression without consent or compensation.
The corpus is a commons. Not metaphorically — structurally. It was produced collectively, by billions of people across centuries, under no single authority’s direction, for no single purpose. No individual or institution created the English language, or the tradition of scientific writing, or the conventions of legal argument. Those things were built collectively, through use, through the ongoing social process of people communicating with each other across time.
The model trained on that corpus is something different. It is a private artifact, owned by whoever built it, whose access is controlled, whose outputs are monetized, whose governance answers to shareholders. The commons went in. The enclosure came out.
Two kinds of enclosure
Open-source software is built on a formal commons: code governed by a precise grammar, discrete and replicable. The commons of code has edges you can see. The governance tools that protect it — the licenses that require derivative works to remain open — work because code is bounded. You can fork a codebase. You can run two versions. You can compare them.
Language models are built on a natural-language commons, and the difference is not a matter of degree. Natural language is not a formal system. Its meaning depends on context, shared assumption, the accumulated pragmatic conventions of communities of speakers, the entire social history of how words have been used. The commons of language does not have edges you can see. It is the shared substrate of human meaning-making.
This changes what enclosure means. When proprietary software enclosed code, what was enclosed was a specific artifact. The commons of code remained available for anyone to use to build something else. The enclosure was partial — damaging, but not totalizing. When a language model encloses natural language, what is being enclosed is not an artifact derived from the commons. It is the commons distilled. The model is the accumulated patterns of human language, compressed and made queryable. Its outputs are reconstructions of the commons. And if access to those reconstructions is controlled — priced, surveilled, withdrawn at will — then the commons itself has been made artificially scarce, by people who did not build it.
The agent in the commons
There is a second difference. A software program runs and produces outputs — it does not participate in the ongoing social process that produces meaning. A language model does. Its outputs become text in the world. People read them, respond to them, incorporate them into their own writing, which becomes training data for subsequent models. The agent is not merely a product of the language commons. It is an actor in it — and at the scale of current deployment, it is reshaping the commons from which it was made.
Who decides what values, what framings, what knowledge, what ways of making meaning get amplified or suppressed? These are not hypothetical future questions. They are present-tense governance questions being answered right now, by default, in the absence of commons governance structures that could answer them differently.
The physical layer
The language commons is immaterial. But the infrastructure required to enclose it is very physical. Training and running large AI systems requires data centers: buildings full of servers, consuming enormous quantities of electricity, requiring water for cooling, occupying land. That infrastructure is being built now, in communities selected because land and power were available and local regulatory resistance was manageable.
The communities hosting this infrastructure bear its costs — the power load on local grids, the industrial footprint, the water consumption. The economic benefits flow partly to those communities and substantially to the owners of the systems the infrastructure serves, who are typically not in those communities.
This is the Narmada pattern in a new form. Arundhati Roy described it for dams: the greater common good is invoked to justify infrastructure whose benefits flow elsewhere and whose costs are borne locally. The data center version of this argument is already in use. In Hampton Roads, Virginia, where data center development is accelerating, the questions of who owns the facilities, who governs them, and whether communities receive structural economic benefit — not just jobs but equity, not just tax revenue but governance — are live questions being answered right now.
What commons governance looks like here
Open model weights — AI systems whose underlying parameters are publicly released — are the first step toward a commons-governed AI layer, in the same way that open-source code was the first step toward a commons-governed software layer. A model whose weights are public can be run locally, modified, audited, and improved by anyone with the compute to work with it. This is not sufficient — releasing weights without releasing training data is like releasing compiled code without the source — but it is a real step.
Data cooperatives address the training commons directly. If the value of a language model derives from the data it was trained on, then the people who produced that data have a governance claim on the resulting system. Data cooperatives make that claim institutional: the data has collective owners, the collective owners have governance rights, and the system trained on their data is accountable to them.
Public compute infrastructure — compute capacity owned and operated as a public utility — addresses the infrastructure layer. The internet’s foundational infrastructure was built with public investment and governed as a commons. The argument for public compute is the same.
This is 1993 for AI governance. Linux existed in 1993. It ran on a small fraction of computers. The decisions made in 1991 and 1992 determined what was possible in 2007 when Android arrived, and in 2015 when cloud computing consolidated, and today when Linux runs the majority of the world’s servers. The decisions being made now — about model weights, training data rights, who owns compute infrastructure, what communities receive in exchange for hosting data centers — will determine the structure of the next technology layer for decades.
The natural-language commons was built by everyone. Governing it as a commons is not a technical problem. It is the same problem the Linux contributors solved in 1991 when they chose a license that prevented enclosure, the same problem the community land trust founders solved in 1969 when they built resale restrictions into the deed. The problem is governance. The solution is the commons. The window is open. It will not remain open indefinitely.