Techno-Memetic
Commons.

The open-source success story

The GPL was a foundational achievement — copyright weaponised against itself to keep software free. Creative Commons extended the principle to creative works. Linux, Wikipedia, Apache, PostgreSQL, the GNU toolchain, the entire infrastructure of the modern web stands on these movements. They succeeded.

And then they were eaten.

The enclosure that happened anyway

The current configuration of cloud computing is, almost in its entirety, open-source software wrapped in proprietary services that charge rent. AWS, Azure, and GCP generate hundreds of billions of dollars annually by hosting software they did not write, contributing minimally back to the projects they host.

ElasticSearch, MongoDB, Redis, Confluent, HashiCorp — every one of these companies was eventually forced to abandon their original open-source licenses because cloud providers were strip-mining their work. The "source-available" license wave (SSPL, BSL, RSAL) is a defensive response to a structural failure: the licensing framework that built the commons could not prevent the commons from being enclosed.

The AGPL tried to close the network-access loophole — you must share modifications if you serve the modified software over a network. It is a real improvement. But it cannot reach the deeper enclosure: a company that builds massive internal advantage on open-source foundations and never makes its derivative work externally visible at all. Internal LoRA adapters, orchestration layers, internal forks, configuration schemas that encode years of operational knowledge — all of it stays private because no clause in any existing license can reach it.

The same pattern, now happening to AI

The pattern is repeating in real time with AI. Open-weight models — Llama, Mistral, the original Stable Diffusion releases — are being fine-tuned and deployed by closed-shop enterprises that contribute nothing back. The LoRA adapters and orchestration layers that constitute the actually deployed intelligence are universally proprietary. We are watching the enclosure of the AI commons that just opened.

The window to fix the licensing layer is small. Within a few years, the dominant deployed-AI pattern will be set — for the same reason QWERTY keyboards and x86 architecture got set: path dependency. The licensing infrastructure built now will lock in for a decade or more.

The diagnosis: freedom is the wrong primitive

Free Software Foundation framing — software freedom as the ground value — has been load-bearing for forty years. It works when the alternative being defended against is restriction. It fails when the alternative being defended against is extraction without contribution.

Freedom-based licensing creates permission structures. Permission structures can be exploited. What is needed is reciprocity-enforced governance — a licensing primitive that treats the act of using as the trigger for obligation, not just the act of distributing.

TMC stands on Ṛṇa, not on freedom

Under freedom-based licensing, the user is granted rights. They can do certain things; some things are forbidden. The relationship is permission-shaped.

Under TMC, the user enters into obligation. The act of using the commons creates a debt to the commons — an operational debt with specific contribution requirements. There is no exit-by-restriction (you do not lose rights by failing to contribute). There is exit-by-default (failing to contribute is a default on obligation, with consequences). The underlying principle is the Indic one: Ṛṇa has no write-off.

The reframe is structural. Once you stop treating the commons as something you have permission to use and start treating it as something you have obligations to, the enclosure dynamics flip. Strip-mining the commons is no longer a permitted strategy that exploits a license loophole; it is a default on a public ledger.

The two reinforcing pillars

1. Universal copyleft with internal-use trigger

Every artifact in a TMC-governed commons is licensed such that any derivative work, including internal-use modifications, must be contributed back within 45 days of first production use.

• Code returns as full diffs with tests.
• Workflows return as orchestration definitions with example runs.
• ML fine-tunes return as weights-under-TMC, or as parameter-delta-plus-training-recipe-plus-reproducibility-test.
• Configurations return as Abstracted Templates — secrets stripped, structure preserved.

The 45-day production-use trigger reaches all the way down. There is no "private internal advantage" surface for derivative work. The commons stays whole.

2. The Stewardship Mark / trademark moat

While the engine is open, the identity is protected. The Stewardship Mark — name, logo, certification — is retained by the Stewardship Board (initially 2014P_ plus community appointees, evolving toward broader federation). You may fork the code and build derivatives. You may not call them by the official name, claim endorsement, or use the marks to imply affiliation. Small lineage references ("based on Sāmatvārtha Interchain") are permitted.

This combination — open engine, protected identity — is what makes TMC structurally unenclosable. A bad actor can fork the commons. They can do so only without the trust signal the official name carries, and only by accepting the contribution obligation. The economic equilibrium points strongly toward staying inside.

Operational secrets: how legitimate withholding works

Some operational realities require withholding — credentials, personally identifiable information, regulated data, security- sensitive runtime details. TMC is not naive about this.

Withholding under TMC requires a public Exemption Notice that:

• Describes what is being withheld at a structural level (the secret is the credential, the structure is the workflow);
• States the legal basis for withholding (PII regulation, security, regulated industry compliance);
• Provides an Abstracted Template — the same artifact with secrets stripped and structure preserved.

Exemption notices are public, community-scrutinised, and board-adjudicated when contested. The commons gets the structural knowledge — the actor keeps the credentials. Both interests honoured.

Why TMC matters for the Sāmatvārtha Interchain

The Sāmatvārtha Interchain runs on TMC. Every protocol, every playbook, every schema, every AI agent template, every workflow definition is a TMC-governed artifact. This means the Interchain has structural enclosure resistance that India Stack does not have.

India Stack's components are openly published but use traditional permissive licenses; their derivatives are being privately enclosed by enterprises building proprietary services on top. The pattern is the same one that ate ElasticSearch and is now eating Llama. Sāmatvārtha Interchain corrects this by design. Every successful private derivative adds to the commons rather than extracting from it.

Compounded over a decade, this is the architectural difference between public infrastructure that empowers a thousand local economies and public infrastructure that is gradually privatised into rent-extraction platforms. The choice is being made now, in the design phase. After deployment it cannot be retrofitted.

How TMC compares with adjacent governance work

The relationship to Ostrom

Elinor Ostrom's commons-governance design principles — clear boundaries, congruent rules, collective choice, monitoring, graduated sanctions, conflict resolution, recognised right to organise, nested enterprises — are the most rigorous existing empirical science of commons that survive over time. TMC is the digital-commons operationalisation of Ostrom's principles for the AI era.

• Clear boundaries — Stewardship Mark, license scope.
• Congruent rules — contribution obligations matched to artifact type (code, weights, configs).
• Collective choice — Stewardship Board with federated community appointees.
• Monitoring — public exemption notices, contribution flow audit.
• Graduated sanctions — Mark revocation, trust-signal loss, escalation to legal in egregious default.
• Conflict resolution — board adjudication of contested exemptions.
• Right to organise — federation built in.
• Nested enterprises — TMC artifacts compose; each artifact can have its own Stewardship locally.

What this means operationally

• If you build open infrastructure — adopt TMC or a TMC-equivalent licensing layer for new projects. Existing AGPL projects are stronger than they look; new projects under permissive licenses are leaving the door open.
• If you build AI products on open-weight models — the fine-tunes you keep private now are the proprietary surface you will defend against tomorrow's open-tune competitors. Inverting that — contributing tunes back under TMC — produces a commons advantage that compounds in the field.
• If you fund DPI — the licensing layer is not a detail. It is the structural decision that determines whether the public infrastructure remains public over a decade. Insist on enclosure-resistance by construction.
• If you architect policy — TMC is a policy primitive, not just a licensing one. The same mechanism (obligation-on-use, Stewardship Mark) can be applied to genetic data, water rights, traditional knowledge, and other commons that are currently being enclosed under permissive frameworks.