MDE and Métacratie
« We must be systematic, but we should keep our systems open. » — Alfred North Whitehead, quoted by John F. Sowa in his Top-Level Ontology
META(Ex × Ty)— the type signature of aLaw.DSLparameterized by a(Space, Time)couple.
This essay is unusual on this blog. It connects the Model-Driven Engineering work documented in the rest of these articles to a separate body of work — the Métacratie philosophical dossier in the philosophy section of this site — and argues that the two are the same gesture applied to two domains. Readers who have followed the Contention over Convention series and the typed-specs walkthrough will recognize half of the argument. The other half is in the philosophy dossier and the essay points to it as we go. The full French version of the same argument, written for readers of the philosophy dossier, is at Appareil et compilateur.
Before I start, one thing I have to clear out of the way. Mixing engineering and political philosophy in 2026 invites a specific objection: « this is Sokal-Bricmont, you're borrowing math vocabulary to dress up political claims. » I take that objection seriously and I want to defuse it before going further. My answer is in three parts. First: the bridge passes through a real technical ancestor — John F. Sowa's Conceptual Graphs (1984) and behind them Peirce and Whitehead — that I learned at age 18 alongside EMF, oAW, and the OMG MOF stack. The lineage is documented and not metaphorical (see Age 18 — discovering the model-driven academic world). Second: the central theorem I isolate (the limits of what you can specify are exactly the limits of what you can verify) is a formal claim, and Foucault wrote essentially the same thing in L'archéologie du savoir in 1969 without anyone calling it scientism. Third: the bridge is operationalized on a falsifiable French case — the 1995 admission by Roland Dumas about the validation of Chirac's manifestly irregular campaign accounts — and the case is verifiable by anyone with access to the archives. Sokal and Bricmont attacked verbal analogies that borrowed mathematical vocabulary without carrying the rigor; this essay does not. It proposes a technical bridge that lives in compilable code and in a verifiable historical reading.
The essay has seven bridges, four contemporary cases, an explicit political position, a section on AI, fifteen named limits, and a constructive program in the form of an open call. It ends with what I think is the clearest formulation of the project: reduce the unhealthy SUFRA latency — the kind that serves the opacity of power and lasts decades without technical necessity — down to the structurally minimal SUFRA latency — the one that is constitutive of any operationalized formal system and that leaves room for democratic deliberation. No more, no less.
Bridge 1 — The layered stack
Both corpora rest on layered architectures where each layer constrains and is constrained by the next, with asymmetric movement speeds that are exactly the same in both registers.
In MOF, the four layers are M3 (the meta-meta-model — five self-describing primitives that describe themselves: [MetaConcept], [MetaProperty], [MetaReference], [MetaConstraint], [MetaInherits]), M2 (the DSLs you build on top of M3 — the DDD DSL, the Content DSL, the Workflow DSL, etc.), M1 (the user models — the C# code annotated with M2 attributes), and M0 (the runtime instances). M3 almost never moves. M2 rarely moves. M1 moves all the time. M0 moves continuously at runtime.
In métacratie, I've distinguished five layers in Silences et Chantiers: SUPRA (the founding myths, the doxa nobody needs to name because everyone already shares it), SUPER (the explicit constitutional and legal discourse, the written laws), INTER (intermediate bodies, networks of actors, milieus), INFRA (material substrates — cables, payment systems, soils, climates), and SUFRA (the layer of contemporary opacity, what is happening in the present but only becomes readable years or decades later, through archive declassification or whistleblower confession). The asymmetry of movement is identical: INFRA almost never moves, SUPRA is silently reframed rather than rewritten, SUPER plays catch-up with what INTER has already done, INTER reconfigures first in any crisis.
The isomorphism is not a metaphor and not a coincidence. Both architectures solve the same problem: how do you account for a system that contains both fast-changing and slow-changing things, without confusing the two timescales? And the answer in both cases is: stack the layers by their rate of change, and explicitly name the constraints that each layer imposes on the faster ones above it. This is what Niklas Luhmann called structural coupling between operationally closed social subsystems in Soziale Systeme (1984), and it's exactly the MOF architecture transposed from software to society. Luhmann is the philosophical ancestor of this bridge. He spent thirty years formalizing an autopoietic theory of social systems in layers that irritate each other without ever speaking directly — and that is exactly the MOF architecture, applied to the social. What I take from Luhmann is the structural rigor; what I add is the conatus (the affective dimension, drawn from Spinoza via Frédéric Lordon, that Luhmann's coldly operational framework leaves out).
But there's an honest objection to the asymmetry table I just laid out, and I have to face it before going any further. In 2026, after fifteen years of cloud-native operations and hyperscaler infrastructure, INFRA does not "almost never move". It moves continuously. A Kubernetes cluster reconciles its desired state every few seconds; a feature flag can change the behaviour of a billion users without redeploying a single binary; a canary release shifts traffic in five-percent increments while a release engineer watches latency dashboards on the other side of the world. The pre-digital intuition — INFRA as cables, soils, payment rails, climate — still holds for those substrates, but it is no longer a complete description of what INFRA is. The objection is correct, and to defuse it I have to make a distinction the original métacratie did not make explicit.
The distinction is between INFRA-as-substrate and INFRA-as-deployable. INFRA-as-substrate is the genuinely glacial layer: TCP/IP, BGP, the C standard library, the x86 ABI, the Linux syscall surface, JSON, UTF-8, the rail gauge, the high-voltage grid, the watershed. These have not moved in thirty years and will not move in another thirty. They map cleanly onto M3 — the five self-describing primitives that haven't changed since they were written. INFRA-as-deployable, on the other hand — containers, Kubernetes manifests, Terraform plans, helm charts, feature flags — moves continuously. And what I want to argue is that INFRA-as-deployable is not INFRA in the metacratic sense at all. It is INTER, with a toolchain. When an SRE pushes a release at two in the morning, she is not touching infrastructure; she is reconfiguring a network of intermediate actors — services, routers, queues, probes, dashboards, and the humans on call who interpret them — that fits the Bridge 1 definition of INTER (« intermediate bodies, networks of actors, milieus ») much better than the definition of INFRA. The asymmetry table survives if we accept that what DevOps has been calling "infrastructure" for fifteen years is, in the métacratie vocabulary, mostly INTER that finally got a grammar. INFRA stricto sensu is still glacial.
And here is the move that turns the objection into a gift. DevOps has operationalized a distinction that political theory has not yet formalized: deployment is not release. Deployment is a technical fact (the code is on the machines); release is a social fact (the code now acts on these specific users, in these specific jurisdictions, at this specific time, under these specific conditions). A feature toggle is, literally, a SUFRA-by-design operator: it manufactures structured, parameterized, conditional opacity, and it does so on purpose. A canary release is, literally, a typed gradual rollout with health probes and approval windows — « what DevOps calls 'deployment' is a typed DAG of side-effecting operations gated by health probes and approval windows; what it calls 'release' is the moment a flag becomes true for some predicate over the user space. » I have already written the technical pieces of this on this site, in the Ops DSL Ecosystem deployment chapter (typed deployment DAG, Canary/BlueGreen/Rolling strategies, health gates and approval windows) and in the CMF ALM DSL chapter (strongly-typed feature flags, percentage and cohort rollout strategies, integration with SLOs). These objects are already DSLs, they exist in production at every serious operator, and they have no name in Foucault, Latour, Luhmann or Lordon. That is the gap the bridge is built to close.
The two-way reading is the real payoff. DevOps → métacratie: the deployment/release distinction is exportable to politics. A new law could be deployed on a canary cohort — one département, one age bracket, one professional category — with social health probes and a reversible approval window, instead of being released all at once at the Journal Officiel. That would be Bridge 7's Law.DSL in the strong sense, and the grammar is already written; it goes by names like Argo Rollouts and Flagger. Métacratie → DevOps: not all feature toggles are democratically neutral. The advertising targeting of Cambridge Analytica (one of the four contemporary cases I treat further down) is a feature-flag system applied to political manipulation. The "premium tier" of every consumer SaaS is an extractive SUFRA — opacity is the business model. A democratic Law.DSL would invert the burden: any flag active on a human being would be public, auditable, dated, and time-bounded by default. The scandal is not the existence of feature flags. The scandal is their currently unregulated use, fifteen years after the primitive matured.
So the asymmetry table from above survives the post-2016 reading, but it survives transformed. INFRA-as-substrate still almost never moves. INFRA-as-deployable is INTER under another name, and the most interesting thing about it is that DevOps has built a precise grammar for it that the philosophical literature has not yet named. Bridge 7 will rely on that grammar more than on anything Foucault wrote.
Bridge 2 — The expressivity theorem, and the 1995 Dumas case
Here is the theorem that makes the rest of the essay possible: you can only specify what you can verify; the specification language is strictly bounded by the available verification apparatus.
This is not my invention. Michel Foucault formulated it, in different vocabulary, in chapter III of L'archéologie du savoir (1969), « L'énoncé et l'archive » — The Statement and the Archive. A statement does not exist except within the system that makes it formulable, and the « conditions of possibility of a statement » are precisely the layers of practice, institution, and materiality that make it verifiable. When I say today that « the verification layer bounds the specification language », I am restating Foucault without his epistemic vocabulary but with his exact gesture. The difference is that Foucault stayed descriptive — he was an archaeologist who exhumed past epistemes — while MDE fabricates the verification apparatus instead of describing it. Foucault gives me the theory; the compiler gives me the praxis. The connection is rigorous and it has to be named.
On the software side, the theorem takes this form. When my typed-specs piece says « you can only specify what your tests can verify », and when the current version of the line about layered tests notes that « with a DOM adapter and a state machine, most logic is unit-testable » but « what still needs E2E is what the adapter can't fake: real-browser layout, requestAnimationFrame timing », I'm describing a movable but structural boundary. You can push the boundary out by abstraction (a DOM adapter, a pure state machine, a smart mock) and lift more and more behavior into the testable language. But there's always a kernel that remains unfalsifiable by the tools currently installed, and that kernel is, at any given moment, beyond reach of the specification language. The boundary moves as new verification layers get installed — it never disappears.
On the political side, the theorem takes the form of SUFRA. SUFRA is the thickness of the present that only the future can read, because the verification layers that would make the present readable (archives, declassifications, investigations, confessions) are not yet installed. It is exactly the DOM-adapter-that-doesn't-exist-yet. And the mechanism by which a metacratic transition becomes readable is nothing more than the gradual installation of a verification layer — through the work of historians, journalists, whistleblowers, or the voluntary betrayal of an actor who speaks after a long silence.
The paradigmatic case I want to develop here, because it is purer than the 2008 case treated in Silences, is the decision n° 95-86 PDR of the French Constitutional Council, dated October 11, 1995. For methodological reasons I prefer a case where the act is dated, the actors are named, and the declassification happened through a recognizable mechanism rather than through an anonymous flood of archives. The Dumas–Constitutional Council–1995 case meets all three criteria with a clarity the 2008 financial crisis does not.
The facts, verified through the press and the archives that opened after 25 years: in the summer of 1995, after the second round of the presidential election that saw Chirac elected against Jospin, the Constitutional Council had to validate the campaign accounts of the principal candidates. Its own rapporteurs noted manifest irregularities in the accounts of both Chirac and Balladur. Roland Dumas, then president of the Council, proposed to the eight other councillors the key choice: « Soit nous les suivons [les rapporteurs], soit nous exerçons imagination et habileté. » — « Either we follow them [the rapporteurs] or we exercise imagination and skill. » The councillors chose imagination and skill. The Council shaved the figures down to make them pass under the legal ceiling. Decision 95-86 PDR officially validated the accounts. A few years later, the Balladur affair (which would lead to the Karachi, Sarkozy, and broader political-financing investigations of the 1990s) emerged through the courts. But the constitutional dimension of the case — the fact that the Council had known and had deliberately decided to cover up — remained invisible until the archival opening of the deliberations at 25 years, around 2020.
It was at that moment, and only then, that the verification layer got installed. And it got installed through a double mechanism: the 25-year archive rule (a regulatory mechanic) and the voluntary admission by Dumas himself (a moral mechanic). Decades after the fact, Dumas spoke to the press. He acknowledged that the accounts were « manifestement irréguliers » — « manifestly irregular ». He provided in the same gesture a retroactive justification: he believed he had « sauvé la République » — « saved the Republic » — because « l'annulation de l'élection de Chirac aurait eu des conséquences terribles » — « the annulment of Chirac's election would have had terrible consequences ». And his successor Jean-Louis Debré (president of the Council 2007–2016) publicly accused Dumas of having betrayed the secrecy of the deliberations by speaking.
This sequence is SUFRA stricto sensu, and it has three structural moments. First: the institutional opacity organized in 1995 — what we technically call the secret of deliberations functions as an opacity layer. Second: the betrayal of SUFRA by a high-profile actor around 2020 — Dumas speaks, and provides in the same gesture a retroactive justification that is itself a first-order metacratic object, because it is the literal invocation of an implicit SUPRA (the « saving the Republic » as higher reason of state) crushing the explicit SUPER function (the Council as guardian of the law against majoritarian pressure). Third: the reactive defense of SUFRA by the survivors — Debré accuses Dumas not of having validated a fraud, but of having spoken. The institutional rule that enables SUFRA (the secrecy of deliberations) is defended by the other actors in the name of that very rule, and the attack on Dumas is the attack on the one who stopped playing his role as opacity layer. SUFRA is not an epistemic accident. It is a structural function of the institution, and its declassification is felt by the institution itself as a violation.
And here is what bridge 2 makes visible when applied to this case. If a sufficiently developed Law.DSL had existed for France in 1995, the shaving of the figures would have been a compile error on the day of the deliberation. The Council would have had to either validate sincerely (and therefore invalidate the election) or refuse to compile and assume the disagreement publicly. The « shaving » would be technically impossible in a DSL where the constraints of ceiling, justification, and sincerity are checked by the compiler, not by the « good will » of the councillors. The 25-year SUFRA latency would have been reduced to zero. The transgression would have been nameable and named in the moment.
This is why I'm writing this essay. Not because the bridge between MDE and métacratie is philosophically pretty, but because it suggests that a tooled metric apparatus, deployed by and for the sovereign people, can reduce the SUFRA latency down to its structural minimum — the one that's constitutive of any operationalized formal system and that leaves room for deliberation — without ever pretending to eliminate it entirely. Zero latency would kill deliberation. But 25 years of latency kills democracy. The project is to aim for the structurally necessary minimum, and to treat any latency above that as a political exploitation of opacity.
Bridge 3 — The attack on the implicit
Both corpora make the same case against the implicit, and both propose the same constructive gesture: make the implicit explicit and verifiable by construction.
On the software side, this is the thesis of the Contention over Convention series. A convention requires three artifacts that drift apart over time: the documentation, the enforcement code (typically tests, linters, code reviews), and the implementation. When a developer changes the implementation and forgets to update the documentation, or when a test was written in a spirit no longer reflected in the code, drift sets in. What was meant to be guaranteed by convention becomes a polite lie that has to be maintained. Contention replaces the three artifacts with one: a compiled attribute whose documentation, verification, and implementation are fused into a single typed object. The attribute cannot drift, because it is its own truth.
On the political side, this is precisely the critique of implicit SUPRA that I develop in Silences et Chantiers §5. In a pluralist society, the SUPRA in force is never explicitly written — it is the shared doxic background that nobody needs to name because it is obvious to all those it concerns. That is exactly why it can be silently reframed. When Dumas says in 2020 « sauver la République », he invokes a SUPRA that was implicit in 1995 and remained implicit throughout the interval. Nobody, in the public debate of 1995, would have written the sentence « the Constitutional Council should validate even fraudulent accounts of candidates if their annulment would have terrible political consequences ». But this sentence was spoken quietly in the deliberation room in 1995, and it guided the decision. Implicit SUPRA governs without being named — that is its function and its mode of power.
The constructive gesture is the same in both registers. In CMF, it's the transformation [Convention] → [Contention]: you take a rule that was carried by usage and you carve it into a compiled attribute that the compiler enforces. In métacratie, it's the explicit writing of the SUPRA-STRUCTURE — precisely one of the four blank slides in the 2017 source that Silences et Chantiers §5 undertakes to fill, and that Commun.DSL (which I describe in bridge 7) would handle technically by typing the common/public/private status of goods and requiring a typed democratic procedure for any crossing of that boundary.
I have to mention here a precedent that was missing from my reading for too long: Lawrence Lessig, an American legal scholar at Harvard, who wrote in 1999 (then republished in 2006 as Code: Version 2.0, available free at codev2.cc) the book whose argument fits in three words: « Code is Law. » Lessig means two things at once. First that in cyberspace, what can be done and what cannot is determined by software architecture far more than by written state laws — so code is already a form of law, de facto, and we have to treat it as such. And normatively: if code is law, then we have to subject technical architectures to the same demands of transparency, deliberation, and contestation as written laws. Lessig observed from the outside, as a lawyer watching engineers work; I'm proposing the inverse gesture, as an engineer who proposes to subject the law to the tooling his peers already use on code. But the bridge was opened by Lessig 25 years ago, and any contemporary discussion of « regulation by architecture » is in his debt, whether it knows it or not.
Susan Leigh Star and Geoffrey Bowker, in Sorting Things Out: Classification and Its Consequences (1999), demonstrated empirically, on three long cases (the International Classification of Diseases, racial classifications under South African apartheid, and the Nursing Interventions Classification), that every classification is a political act — because it decides who counts and who does not, what is visible and what is invisible. And the more a classification becomes infrastructural, the more it becomes invisible, and therefore the more politically powerful it becomes. Star and Bowker forge the concept of torque to describe what happens when a rigid classification is applied to a reality that does not fit it: individuals whose lives don't fit the categories experience a torsion that can become unbearable. This is exactly the SUFRA mechanism applied to classificatory infrastructures: contemporaries of a transition feel a torsion (anxiety, sense of injustice, diffuse anger) without being able to name it, because the available description categories no longer match the META that is reconfiguring.
Bridge 4 — End-to-end traceability, or the refusal of stalled triptychs
Both corpora build a complete chain of traceability, and in both cases any missing link is a typable defect.
On the MDE side, the typed-specs chain runs: Feature → Acceptance Criterion → Test → Coverage Report → Quality Gate. Each feature is encoded as an abstract class, each AC as an abstract method, each test as a decorator that points to the AC it verifies. The compiler catches the typos, the scanner cross-references features and tests, the quality gate fails the build if a critical feature is not covered. The chain is mechanized end to end, and any unverified link is a compiled defect. Beyond typed-specs, the Feature Compliance Verification system I designed for this blog requires at compile time that every Feature has a [FeatureImplements] pointing to the implementing code and that every AcceptanceCriterion has a [FeatureTest] pointing to the verifying test. The absence of either fails the build. It is a moral requirement turned into a mechanical constraint.
On the métacratie side, Transitions méta-cratiques builds a homologous chain: Affect (fear, anger, hope) → Captured or freed conatus → Reflection (adequate ideas, in the sense of Spinoza's Ethics IV) → INTER reconfiguration → SUPER law → SUPRA reframing → SUFRA readability. Any missing link is a stalled triptych in the typology developed in Silences §3: Imperium without Reflection (pure repression), Reflection without Recreation (adequate ideas circulate but do not converge on a new political subject — this is the post-2008 sequence in the West), Captured Recreation (the new Imperium is immediately reabsorbed by the old META — Thermidor). A failed metacratic transition is, in typed-specs vocabulary, a feature whose ACs are not covered. And the [FeatureImplements] / [FeatureTest] system is, literally, the compiler refusing stalled triptychs in the software domain.
A point I want to make here, because it comes from the technical practice and has a precise political counterpart. In my code I have a strict rule: every module must be traceable to an identified business AC. A module that doesn't connect to any business acceptance criterion is, in my vocabulary, a code smell, not an acceptable default. The political counterpart is exactly what I wrote in Silences §3 about the post-2008 sequence: the Reflection phase did happen (Indignados in Spain in 2011, Occupy Wall Street the same year, Nuit debout in 2016, Piketty's Capital in the Twenty-First Century in 2013), but it did not converge on a new political subject. Adequate ideas circulated, the Spinozist imitatio affectuum propagated affects across INTER, but no new INTER configuration crystallized around them. This is why most participants in the anti-capitalist sequence of the 2010s remember it as a defeat: not because Reflection didn't happen, but because the Recreation phase that followed was captured. A political transition that doesn't connect to any mobilized affect is in the same situation as a module without an AC: a code smell, a typable defect, a moral compilation failure that should have been detected on the spot.
Bridge 5 — The fixed point and the lineage
Both corpora rest on a formal fixed point, and that fixed point has a common lineage I can name.
On the MDE side, the fixed point is the self-description of M3. The five primitives [MetaConcept], [MetaProperty], [MetaReference], [MetaConstraint], [MetaInherits] are themselves annotated using these very primitives. M3 describes M3, with no M4. And tspec, the typed-specs system, tracks its own requirements using its own format — it eats its own dog food. The fixed point is circular but it is productive: the system guarantees itself by accepting that its guarantee passes through itself.
On the métacratie side, the fixed point is in Silences et Chantiers §9. There I apply the metacratic framework to the metacratic framework itself: the four blank slides of the 2017 source (the four section titles that I had raised but not written) are read as the SUFRA proper to the writer-citizen of 2017. What I had not been able to write in 2017 about those four concepts was the part of my present I could not yet read about myself, and that 2026 is starting to be able to read because the SUFRA of 2017 has been partially declassified by the nine intervening years.
And here is the bridge. Both frameworks derive their formal apparatus from the same source: John F. Sowa's Conceptual Graphs, themselves grounded in Charles Sanders Peirce. Sowa, in Conceptual Structures (1984) and in his top-level ontology, builds an ontological metamodel parameterized by three binary distinctions (Independent / Relative / Mediating — directly inheriting from Peirce's categories of Firstness, Secondness, Thirdness × Physical / Abstract × Continuant / Occurrent), which produce twelve top-level categories. It is, structurally, an ontological M3, and it is the conceptual ancestor common to the entire MOF stack (which the OMG drew on in the 1990s) and to the directed-graph formalization toward which Silences et Chantiers §6 is moving.
I encountered Sowa at age 18, in parallel with the Eclipse tooling of the time, and he shaped my thinking durably. I tell that encounter in the biographical page age-18-model-driven, because it predates my metacratic work of 2017 and probably explains, a posteriori, certain architectural gestures whose lineage I had not seen at the time. What struck me about Sowa then and still strikes me now is his intellectual honesty about the limits of his own framework. He writes, about his top-level ontology: « the other axioms cannot be stated formally until a great deal more has been fully formalized », and he acknowledges an infinite-regress problem that he does not resolve. This admission is not a defect. It is exactly what Tarski proved formally in 1933 (the truth of a language requires a strictly more expressive meta-language) and what Gödel proved in 1931 (any system rich enough to describe itself is incomplete or inconsistent). A meta-metamodel can be syntactically self-describing without being semantically self-grounding, and the honest move is to inherit that limit rather than hide it.
This honesty is the strength of the project, and it is exactly what the philosophical position in the epigraph requires: We must be systematic, but we should keep our systems open. Whitehead, whom Sowa quotes as the keystone of his own ontology, is himself a mathematician-philosopher who walked the path from the Principia Mathematica (1910–1913, with Russell — one of the high points of 20th-century formal logic) to Process and Reality (1929 — his open processual metaphysics, which accepts the incompleteness of the formalizable by construction). His maxim is not a pose. It is the lesson of a life of practice. And it is, in seven words, what resolves in advance the objection Castoriadis would later launch against all structuralisms: no, métacratie does not pretend to exhaust the instituent; it is systematic in what it can name and open to what it cannot yet name.
Bertrand Meyer, without probably having read Whitehead, formulated the same thing in 1988 under the name Open/Closed Principle (open for extension, closed for modification). It is the O of SOLID, and it is exactly the gesture of open DSLs and Source Generators. Be systematic = engineering rigor + Source Generators = no drifts, as I've written elsewhere. Local non-drift guaranteed by rigorous formalization, global extensibility guaranteed by open architecture. This is SOLID applied to political thought.
I should mention here the historical inventory of attempts at producing self-describing operational ecosystems, because the question matters and the answer is instructive. EMF / ecore in the Eclipse world is the purest success of operational self-description, with its ecore.ecore that describes Ecore in Ecore — but EMF never escaped Eclipse, and Roslyn in the Microsoft world rebuilt much of what EMF did without drawing on it. OMG MOF is a perfect international standard on paper and little implemented in practice. Executable UML (xtUML, fUML) was a relative failure of the 2000s–2010s, for three cumulative reasons: action languages as verbose as Java without readability gains, sociological refusal of developers to draw rather than type, and above all universality kills precision — a metamodel that tries to cover everything ends up covering nothing precisely. BPMN with Camunda and Activiti is probably the largest success outside Eclipse, in a well-defined niche (business processes). AtlanModZoo at INRIA Atlantic in Nantes, under the direction of Jean Bézivin and Frédéric Jouault in the 2000s, carried the most ambitious French project: a zoo of cooperating metamodels with ATL for transformation. The zoo was rich academically and is no longer actively maintained. MDA from OMG in 2001 was a near-total failure — top-down, bureaucratic, no usable tools. The general lesson is clear: universal attempts have failed, and specialized attempts have succeeded in their niche. And this is exactly the lesson that justifies the architecture of métacratie: not a universal meta-framework of power (a 20th-century attempt that failed), but a specialized framework for reading transitions of power indexed on Space × Time, that cooperates with other specialized frameworks without claiming to replace them.
Bridge 6 — Talk, decide, type: the Parliament of Things, operationalized
Bruno Latour spent thirty years trying to build what bridge 5 just named: a framework that takes non-humans seriously as political participants. He called it the Parliament of Things in Politics of Nature (1999), then reformulated it in An Inquiry into Modes of Existence (2012). The central idea is that rivers, climates, bacteria, molecules, algorithms are not a depoliticized outside to be consulted — they are already political, and they should have an institutionalized voice. Latour spent his career demolishing the « nature » / « society » opposition in favor of an ecology of human and non-human actors.
But Latour stayed narrative. He wrote books and organized colloquia. He did not, as far as I know, build the Parliament he was describing. And here I see the most direct connection with my own practice: in software, we talk, we decide, we type. The operational political gesture — creating a cross-domain attribute, getting it recognized by peers, integrating it into the shared metamodel — is exactly the Parliament-of-Things gesture transposed to a domain where it already works. Source Generators are the generative apparatus in the strong sense. A C# attribute that describes a domain, a Source Generator that produces its consequences as YAML, DLL, config, API — that is a technical Parliament of Things, in which non-humans (attributes, types, constraints) are literally participants who speak in the compiled output. Not by metaphor: by traceable causal chain. When my Source Generator refuses to compile because an attribute is misarticulated with another, that is a non-human speaking, and saying no.
Where Latour describes, MDE does. This difference is not a superiority of MDE over Latour — it is a complementarity. Latour gives the conceptual framework (non-humans speak, you have to listen to them), MDE gives the technical tooling. Without Latour, MDE would just be a tool with no philosophical reach. Without MDE, Latour would remain a beautiful idea. Métacratie is a third term: it takes the Latourian framework (non-humans as political participants), it materializes it through MDE tooling (Source Generators as operational parliament), and it applies it to a specific domain — reading the transitions of power indexed on Space × Time.
And here is the gesture that follows, and that opens bridge 7: we can do the same for anything. Not just for software running on servers. For laws, for example. For ecological constraints. For the boundary between commons and private. For the application of decrees. For public algorithms. For contracts between the state and consulting firms. For anything that deserves to be typed, verified, and traced. That's what the rest of the essay builds out in detail.
Bridge 7 — The Law.DSL, or the constructive horizon
I arrive at the constructive culmination of the project. Bridges 1 through 6 were analytic — they described a junction between two existing corpora. Bridge 7 is constructive — it proposes a program to carry out, whose technical bricks already exist and whose philosophical bricks do too. What's missing is to assemble them.
The central idea: we can write a meta-DSL parameterized by (Space × Time) that produces, for each couple, a Law.DSL specific to the law applicable in that space at that time. The metacratic formula META(Ex × Ty), which until now was a philosophical notation, then becomes a type signature in the strict computer-science sense. The meta-DSL is the M2 that takes (Space, Time) as parameters and instantiates a particular Law.DSL; and the metacratic transition META(Ex × Ty) → META(Ex × Ty+1) becomes literally the migration between two Law.DSL instances — what changes, what stays, what needs to be recompiled, what produces breaking changes.
One thing the code below assumes, and that I have to name explicitly: a Law.DSL operates over a typed ontology of the things it regulates. The compiler needs to know what PotableWater, PersonalData, SocialHousing, ConsumerElectronics, the ConstitutionalCouncil, the CouncilOfState, the AdemeOpenData.SelectiveSorting data source and the Decision_99_421_DC Council ruling are — as types, not as strings. The program of Bridge 7 therefore has two layers: the meta-DSL LawDSL<Ex, Ty> that I describe here, and a set of typed ontology libraries — RegulatedTargets, OpenDataSources, Jurisprudence, Authorities — that the meta-DSL references by typeof(). Crucially, those libraries do not need to pre-exist. The architecture is open by construction: an OntologyDslGenerator (a Source Generator in the same Roslyn family I already use everywhere on this site) takes a short ontology declaration and emits the typed artifacts the Law.DSL will consume. A bootstrap Law.DSL can run on a minimal ontology of three or four types; a mature one grows as new regulated domains are declared and the generator produces the corresponding types — exactly the way Catala has been growing the typed surface of the French Tax Code one section at a time. The grammar of Law.DSL is closed; the vocabulary of things it regulates is open. The strings you see in the code below are the ones that legitimately survive (URLs, identifiers of real-world artifacts that have no type to give them); everything else is a typed reference, because magic strings are exactly the kind of opacity Bridge 2 says we should refuse.
Here is what a minimal RegulatedTargets library looks like — the kind of thing an OntologyDslGenerator could just as easily emit from a YAML or RDF declaration:
// RegulatedTargets — the ontology of regulable things
public abstract class RegulatedTarget { }
public abstract class NaturalResource : RegulatedTarget { }
public class PotableWater : NaturalResource { }
public abstract class DigitalAsset : RegulatedTarget { }
public class PersonalData : DigitalAsset { }
public abstract class HousingType : RegulatedTarget { }
public class SocialHousing : HousingType { }And here is the meta-DSL itself, with the country instance for France 2026 and its 1995 counter-instance:
// The meta-DSL: Law.DSL<Ex, Ty>
[SpaceTime(Space, Time)]
[SourceOfLaw(Type, Rank, Producer)]
[HierarchyRule(Strict)]
[Authority(SourceType, Producer, Procedure)]
[ControlMechanism(Type, Authority)]
[ChangeRule(SourceType, Procedure, RequiredMajority)]
// Instance: France2026.LawDSL
[SpaceTime(Space="France", Time="2026")]
[SourceOfLaw(typeof(ConstitutionalBlock), Rank=0)]
[SourceOfLaw(typeof(OrganicLaw), Rank=1)]
[SourceOfLaw(typeof(OrdinaryLaw), Rank=2)]
[SourceOfLaw(typeof(Ordinance), Rank=2,
RequiresRatification=true,
RatificationDeadlineMonths=18)]
[SourceOfLaw(typeof(Decree), Rank=3)]
[HierarchyRule(Strict=true)]
[Authority(typeof(ConstitutionalBlock),
ControlAuthority=typeof(ConstitutionalCouncil))]
[ControlMechanism(typeof(ConstitutionalBlock),
Type=ControlType.APriori,
QPCAvailable=true)] // QPC since 2008
public class France2026LawDSL : LawDSL { }
// Counter-instance for the historical case: France1995.LawDSL
[SpaceTime(Space="France", Time="1995")]
// ... same as above, BUT:
[ControlMechanism(typeof(ConstitutionalBlock),
Type=ControlType.APriori,
QPCAvailable=false)] // No QPC in 1995
public class France1995LawDSL : LawDSL { }From this, one can write a cross-compiler that takes two or more DSLs as input and emits compatibility errors. The most immediate case is the cross-compiler Law.DSL × Ecology.DSL. Ecology.DSL is a metamodel describing the state of the Earth as infrastructure — Rockström's nine planetary boundaries (2009, revised by Richardson et al. in 2023, which show that six of the nine are already crossed in 2023), the IPCC's remaining carbon budget for the 1.5°C objective, the biogeochemical cycles of nitrogen and phosphorus, available freshwater per watershed, ocean acidification, soil degradation. An instance France.Ecology.2026 contains the concrete values for France at this moment — for example a residual carbon budget of 180 MtCO2eq for the period 2026–2050. And the cross-compiler France2026.LawDSL × France.Ecology.2026 checks that any law coded in the first instance respects the constraints of the second:
[Compile Error CRX001]
LawAuthorizingShaleGas would emit 230 MtCO2eq over the duration
of the permit (30 years).
This violates France.Ecology.2026.CarbonBudget2026:
estimated emissions = 230 MtCO2eq
remaining carbon budget = 180 MtCO2eq
overshoot = +50 MtCO2eq (+27.8%)
→ law not compilable in (France2026.LawDSL × France.Ecology.2026)
Suggested resolutions (none automatic — political deliberation required):
1. Reduce the scope of the authorization
2. Compensate by an equivalent withdrawal in another sector
3. Revise CarbonBudget2026 (update Ecology.DSL with new IPCC data,
AND public deliberation on whether France assumes overshooting 1.5°C)
4. Cancel the legislative project
Note: this constraint is physical, not political.
The laws of the atmosphere cannot be voted away.This compile error is, literally, the material constitutionalization of law by ecology. And it has a precise French juridical and philosophical lineage: Mireille Delmas-Marty (the commons as a new juridical category in her Aux quatre vents du monde, 2016), Marie-Angèle Hermitte (rights of nature, juridical status of the living), Catherine Larrère (French environmental ethics in Penser et agir avec la nature, 2015), Christine Noiville (the precautionary principle as an operational juridical category), and the Grande-Synthe ruling of the French Council of State (2020 and 2021), which for the first time enjoined the French government to take additional measures to respect its own climate commitments. The cross-compiler Law.DSL × Ecology.DSL is, literally, the technical instrument that materializes the spirit of the Grande-Synthe ruling and extends the program of Delmas-Marty and her heirs. Where these jurists pleaded for legal evolution, I propose a technical implementation that makes their theories executable.
The architecture extends one more level. Above each particular law encoded in a Law.DSL instance, we can add an ad-hoc tracking DSL that specifies how the law should be instrumented in operational reality. The architecture becomes a six-layer stack: M3 (Sowa), M2(a) (the meta-DSL LawDSL<Ex, Ty>), M2(b) (the country instance France2026.LawDSL), M1(a) (a particular law, e.g. LawAGEC — France's anti-waste circular-economy law of February 2020), M1(b) (the ad-hoc tracking DSL LawAGEC.TrackingDsl), and M0 (operational execution: the actual database, the public dashboard, the API, the reports). The M1(b) is the innovation over the original MOF: it makes explicit that in the political domain, a law has a juridical dimension (the text) and an operational dimension (the apparatus that measures its application), and that the gap between the two is precisely SUFRA in miniature. A law that is voted but not instrumented for tracking is a law whose effect is invisible to its subjects.
And this is where I have to name Catala as my most important discovery during the writing of this essay. Catala is a programming language for the law, developed at INRIA Paris (Prosecco team) starting in 2019 by Denis Merigoux, Nicolas Chataing, and Jonathan Protzenko, presented at POPL 2022 (paper at arXiv:2103.03198, project at catala-lang.org). The central idea: written law (the Tax Code, the Social Security Code) is already quasi-formal — it has a logical structure of conditions, exceptions, special cases, derogations — that lawyers manipulate by hand but that could be executed if written in a suitable language. Catala does exactly that. And the most striking empirical result is that Catala has been used to encode part of the French Tax Code and found errors in the existing implementation by the French DGFiP — not legal errors, but codification errors where the tax administration's program did not exactly match what the written law specified. The Catala compiler, by enforcing a verifiable correspondence between legal text and program, made these gaps visible. This is exactly the expressivity theorem of bridge 2 in practice: the verification layer (Catala) installed a readability (the law/code gaps) that did not exist before.
This discovery changes the status of bridge 7. While I was writing this essay, I realized that a program I had the intuition for already exists partially, under the name Catala, at INRIA, in France. This discovery does not change the thesis; it confirms it empirically and shifts the task: it's no longer about proposing a horizon, it's about helping build it. Bridge 7 is not an isolated utopia. It's a junction with a living French program that needs to be extended.
And the program extends one more notch with what I call the dynamic compiler. So far I've described static verification: the compiler emits errors when the law is written, just as a C# compiler emits errors when code is written. But we can go further. The compiler can produce code that verifies continuously, at runtime, that the terms of the law are validated in reality. This is the application of what Bertrand Meyer has called Design by Contract since 1986 in Eiffel and in his canonical Object-Oriented Software Construction (1988, second edition 1997): preconditions, postconditions, invariants. A law has preconditions (the conditions for it to apply), postconditions (the expected, measurable results), and invariants (the states that must be maintained throughout its validity — its intelligibility, its conformity to the constitutional bloc, its non-overshoot of the carbon budget). The dynamic compiler generates, from these contracts, the instrumentation code that measures in reality whether the contracts are satisfied — and that triggers alerts if the trajectory drifts, suggests corrections, publishes everything as open data under Etalab license.
[ImplementsLaw(typeof(LawAGEC))]
[Deadline(Year=2030, Month=12, Day=31)] // applies to MunicipalSelectiveSorting2030 below
[Postcondition(Name="MunicipalSelectiveSorting2030",
Target=0.60, Tolerance=0.05,
Source=typeof(AdemeOpenData.SelectiveSorting),
IngestionFrequency=Frequency.Monthly)]
[Postcondition(Name="ReparabilityIndex",
Target=7.0, Tolerance=0.5,
ApplicableTo=typeof(ConsumerElectronics),
Source=typeof(DgccrfOpenData.ReparabilityIndex))]
[Invariant(Name="ConstitutionalBlockCompliance",
VerifiedBy=typeof(ConstitutionalBlockAnalyzer),
Frequency=Frequency.Continuous)]
[Invariant(Name="IntelligibilityComplexityMax",
VerifiedBy=typeof(LawComplexityAnalyzer),
ThresholdMax=60,
ConstitutionalReference=typeof(ConsConst.Decision_99_421_DC))]
[TrajectoryCorrection(IfBelow=0.40, Action=AlertLevel.Red,
Notify=Audiences.Prefects | Audiences.Rapporteur
| Audiences.EnvironmentalNGOs | Audiences.Public)]
[OpenDataPublication(Endpoint="/api/agec/v1/...",
License=DataLicense.Etalab2_0,
Format=DataFormat.Json | DataFormat.Csv | DataFormat.Rdf,
UpdateFrequency=Frequency.Monthly,
PublicAccess=true,
Authentication=Auth.None)]
public class LawAGECRuntimeContract
: RuntimeContract<LawAGEC, France2026LawDSL> { }From this declaration, the dynamic compiler automatically generates: an ingestion service that continuously queries the declared data sources (ADEME.OpenData.SelectiveSorting, DGCCRF.OpenData.ReparabilityIndex); a metric calculator that aggregates by commune, watershed, and product category; a public dashboard at theLaws.fr/agec/dashboard; a graduated alerting system that notifies according to thresholds; a trajectory divergence detector that projects current trends to the target date; and continuous open-data publication. All this generated automatically from a single contract declaration, by the C# Source Generators I already master.
The dynamic compiler is the missing link between specification (typed-specs), tracking (the ad-hoc DSL), and trajectory correction (the democratic feedback loop). It makes the whole cybernetic in the strong sense of Norbert Wiener (Cybernetics, 1948). And I have to name its historical ancestor here: Cybersyn, Stafford Beer's real-time economic governance project in Allende's Chile (1970–1973), which wanted to push economic indicators continuously from the factories to a central control room. Cybersyn was destroyed by Pinochet's coup in September 1973. The crucial difference between Cybersyn and what I propose is this: Cybersyn was centralized and vertical, the dynamic compiler I propose is democratic-distributed and horizontal. Data is publicly open, contracts are publicly open-source, alerts are notified to the general public alongside authorities, and suggested corrections remain proposals that the sovereign people can accept, modify or reject through democratic procedures. It's the Cybersyn that history could have produced if Pinochet had not staged his coup, and if Stafford Beer had read Whitehead, Sowa, Meyer, Ostrom, and Dupuis-Déri.
And the cooperating-DSL gallery doesn't stop at law and ecology. Construction.DSL (construction concentrates 40% of global CO2 emissions and a French regulatory labyrinth that cost eight lives in Marseille's rue d'Aubagne in November 2018); Health.DSL (which would have made Health Data Hub non-compilable in 2019); Labor.DSL (which would have made asbestos non-compilable from the first cross-referenced epidemiological studies of the 1970s); Energy.DSL (which would render any new fossil power plant non-compilable against the carbon budget); Digital.DSL (which would have made Cambridge Analytica non-compilable in 2014); Justice.DSL (which would render French prison overcrowding visible in real time as a continuing violation of CEDH article 3); Food.DSL (which would have made the procrastination on glyphosate visible as a continuing violation of the Environmental Charter); Migration.DSL (which would render every placement of a minor in administrative detention non-compilable against the Popov v. France 2012 case law); Information.DSL (which would have rendered each successive acquisition by the Bolloré group non-compilable against the constitutional value objective of media pluralism recognized since the December 1984 decision). The list is open by construction. That is exactly the AtlanModZoo dream of Bézivin, transposed from academic software to operational political-democratic activism.
And all of this, let me be clear to dispel any doubt, is immediately doable with the tools I already master — Roslyn Source Generators, C#, OpenAPI for endpoints, Prometheus and Grafana for dashboards, existing open-data sources (data.gouv.fr, ADEME, INSEE, Légifrance, Eurostat). The modest bootstrap fits in six steps over nine months: minimal Law.DSL and France1995.LawDSL coding the 95-86 PDR decision to demonstrate the compile error on the Dumas shaving (months 1–2); LawComplexityAnalyzer applied to the Tax Code to publish its unintelligibility scores and make media noise (month 3); minimal Ecology.DSL and cross-compiler on a few current gas and oil authorization projects (months 4–5); minimal Construction.DSL on ten recent public building permits to demonstrate what the analyzer would have said before their delivery (month 6); public platform theLaws.fr exposing everything as open data, API and dashboards (months 7–8); and a call for contributors to enrich the DSLs (month 9 onward). At the end of the process, the project becomes itself a digital common in the strict sense, democratically governed, with shared maintenance and an unprivatizable usage. The tool embodies its own theory.
Four contemporary cases
The 1995 Dumas case is enough to carry the bridge 2 theorem, but it is historical. Methodology asks for cases from the present too. Here are four, briefly.
The EU AI Act (regulation 2024/1689, in progressive application 2025–2027) is the case where you can see SUFRA latency installing itself in real time. The law is voted, but its real effects on practices are opaque, fragmented, hard to measure. This is precisely the open test case where the metacratie/MDE project can contribute in real time — not as a retrospective exercise. If a Digital.DSL coupled to EU2026.LawDSL were operational now, we could continuously track the declarations of high-risk AI systems, the sanctions applied, the derogations negotiated behind closed doors. It's the case that justifies the project's urgency: there's a window, it's open, and it will close.
The Health Data Hub (Microsoft Azure, 2019–ongoing) is the case where implicit SUPRA (« the American cloud is inevitable ») crushes explicit SUPER (GDPR, the CJEU's Schrems II ruling of July 2020 invalidating the Privacy Shield, several CNIL adverse opinions). The Council of State found illegality in interim ruling October 2020 then on the merits in March 2022, without ordering immediate migration. Five years after the decision, French health data is still hosted by Microsoft. It is the exact transposition to digital of the Dumas-1995 « exercising imagination and skill », moved from the Constitutional Council to the central administration. A Health.DSL coupled to France2026.LawDSL would have made the Microsoft Azure choice an immediate compile error in 2019. Five years of SUFRA latency reduced to zero.
The McKinsey-Macron case (French Senate report of March 2022, criminal investigation ongoing) is the case where INTER (the consulting firms) captures SUPER (the public administration) by making itself invisible. Over a billion euros in 2021, vertiginous growth since 2018, McKinsey in dominant position, notes drafted by the firms and used as-is by ministers without parliamentary oversight or public traceability, firms that paid no corporate income tax in France for years despite the public turnover. This is, in the typology of Silences §3, a counter-cyclical Recreation at the institutional level: a triptych that did turn (the managerial modernization of the state did happen), but that closed the French institutional META instead of opening it, by transferring state functions from parliamentary control to commercial secrecy. It's the exact contemporary analog of the Dumas shaving in 1995, transposed from the Constitutional Council to the central administration.
The Cambridge Analytica + Brexit referendum affair (2014–2018) is the case where a technological SUFRA — opaque microtargeting algorithms even to their designers — operates on a major political event (a sovereign referendum). It's the case that demonstrates that contemporary metacratic transitions don't stop at national borders and that they are also algorithmic transitions. The British SUPER was modified (Brexit) by an American INFRA operation (Facebook + Cambridge Analytica) that passed through a transnational INTER layer (digital political consultants). And it's the case that most directly justifies the Marxist-Hegelian reading of digital extractivism: personal data is extracted as a natural resource, without consent, and turned into political-manipulation tools at the service of the highest bidder.
Position — democratic in the strong sense, in the lineage of the French constituent left
A philosophical text in 2026 with no named political position is automatically read as liberal by default, because that's the doxic ground of the implicit — exactly what this essay attacks from bridge 3 onward. Silence would be incoherent with the project. So I have to say where I'm speaking from.
I am first democratic, before being republican in the sense the word has in 2026. Democratic in the strong sense that Francis Dupuis-Déri documents in Démocratie. Histoire politique d'un mot (Lux, 2013, reissued 2019) — direct government by the people, recallable imperative mandate, rotation of offices, continuous popular control, refusal of delegation to experts, refusal of cooptation by the political professional class. Dupuis-Déri demonstrates that the word « democracy » was an insult in the 18th century mouth of American and French republican elites (Madison, Sieyès, sometimes Robespierre), who defended themselves against being democrats because they associated « democracy » with the rabble, with direct government, with majority tyranny. What they defended was the Republic — a representative government where elected elites filter the popular will. The Republic was thought of as a bulwark against democracy, not as its synonym. The semantic reversal that made « democracy » the positive word designating exactly what was the « Republic » in the 18th century is a product of the 19th and 20th centuries, and it has emptied the word « democracy » of its strong content. Dupuis-Déri proposes to recover it.
I'm part of the lineage of the French constituent left, the one of the Tennis Court Oath of 20 June 1789 — the act by which the deputies of the Third Estate, locked out of the Estates General hall, gathered in the Versailles tennis court and swore not to disband until France had a written Constitution. That is the constituent act par excellence: a people that arrogates to itself the power to write its own law through sovereign deliberation, without waiting for the king's permission. The lineage runs through Robespierre (the 1793 Constitution and its article 35 on the right to insurrection), Hugo (the idea that the people carries a legitimacy superior to any instituted authority), Jaurès (the synthesis of socialism and republicanism), Blum (the Popular Front of 1936 as proof that democratic deliberation can produce material results), and Mendès France (the republican ethics of rigor and refusal of opacity). This is a left that has constantly wanted to refound the Republic in a more democratic direction, against the elite tendency to lock it into an aristocratic republic.
I also have a Marxist-Hegelian understanding of capitalism, and I have to name it. I use Marx (started with Capital) as an analytic tool to understand capital's dynamics — not as a political program, which remains constituent-republican as above. And I'm specifically Marxist-Hegelian — meaning I take dialectics seriously as a way of thinking movement and contradiction, in the continental French lineage of Henri Lefebvre, Lucien Sève, Emmanuel Renault, and contemporarily Frédéric Lordon (whom I read regularly and consider the most important living French theorist for the position I'm describing). Dialectics is precisely what allows us to think transitions as internal movements of the system that produce their own overcoming through the accumulation of affective, juridical, and infrastructural contradictions. This is exactly what métacratie wants to do with its META(Ex × Ty) → META(Ex × Ty+1) transitions.
And I have a dialectical eco-socialist reading of the effect of capitalism on what I call the Earth as infrastructure. The references are John Bellamy Foster (Marx's Ecology, 2000, who rediscovered the Marxian concept of metabolic rift between humans and nature that the Marxist-Leninist tradition had buried under productivism), Andreas Malm (Fossil Capital, 2016, who demonstrates that the 19th-century shift from water to coal was driven by the capital's need to discipline labor by relocating factories away from rivers), Jason W. Moore (Capitalism in the Web of Life, 2015, with the concept of capitalocene rather than anthropocene), Kohei Saito (Marx in the Anthropocene, 2022 — phenomenal success in Japan), Jean-Baptiste Fressoz (with Christophe Bonneuil, L'événement Anthropocène, 2013, who debunks the « energy transition » narrative), and Bruno Latour late (Where to Land?, 2017, Memo on the New Ecological Class, 2022, who explicitly joined the political critique of extractivism in his last books).
The question I want us to deliberate together is the boundary between private and public. It's the main terrain on which contemporary liberalisms have been advancing for forty years (privatization of public services, commodification of the living, patenting of genetic code, financialization of housing, uberization of work, capture of personal data). And this is what the Tennis Court left is trying to re-deliberate: not to fix an abstract boundary, but to give the sovereign people back the power to decide, for each generation and for each domain, what should remain commons and what can be marketable. The intellectual lineage: Karl Polanyi (The Great Transformation, 1944, on the « fictitious commodities » that are land, labor, and money), Elinor Ostrom (Governing the Commons, 1990, and her 2009 Nobel Prize for empirically demonstrating that commons can be sustainably governed by collectives without recourse to either private or state property), David Bollier on contemporary digital commons, Pierre Dardot and Christian Laval (Commun, 2014, La Découverte), Mireille Delmas-Marty, and Hardt and Negri in Commonwealth (2009).
And the practical idea: a third cooperating DSL, Commons.DSL, that describes which objects are currently classified as commons in a given (Space, Time) (drinking water, healthcare, education, social security, certain infrastructures, certain public data), which are classified as private, which are in contested gray zones (personal data, social vs speculative housing, renewable energy, water in bottle vs network, seeds), and what rules govern crossings between categories. The cross-compiler Law.DSL × Commons.DSL would then check that no law crosses the private/public boundary without typed prior democratic deliberation. A law that privatizes a good classified as commons without an explicit democratic procedure would be a compile error.
And the formula that condenses this position is one I want to quote literally: it's not for a Dumas (who shaved the accounts in 1995 « with imagination and skill »), nor for a Debré (who later defended the secrecy of the deliberations against the late confession), nor for any co-opted magistrate to decide on our behalf where the line runs between commons, public, and private. These decisions belong to the sovereign people, who must be able to deliberate them, measure their consequences, demand accountability, and recall those who decide. This project is the tooling of that demand.
A precise legal argument fortifies the project: the principle of clarity and intelligibility of the law is a constitutional value objective in French law since Constitutional Council decision n° 99-421 DC of 16 December 1999. This decision rests on article 6 of the 1789 Declaration of the Rights of Man (« the law is the expression of the general will » — which presupposes that this will can be understood) and on articles 4 and 5. The Council has reaffirmed it in several subsequent decisions, and has even struck down provisions for excessive complexity. An unintelligible law is, to some degree, unconstitutional. Therefore the Law.DSL and its LawComplexityAnalyzer are not just desirable democratic tools — they are tools that strengthen the constitutionality of existing law by making laws clearer, more accessible, more traceable. When a journalist or commentator says « this is scientism, you can't type laws », the answer is: the French Constitutional Council has been requiring intelligibility since 1999; the project proposes a technical instrument to meet that requirement; refusing the instrument means refusing to meet the requirement. This is legally airtight.
AI: tool under democratic safeguards
I work daily with an AI — Claude, by Anthropic — as a programming partner. The biographical page about this site mentions it explicitly. This entire essay was co-written, by me and by Claude, across many sessions of writing and re-reading. A philosophical project that proposes technical tools for democracy cannot be silent about its own relationship to the most powerful contemporary technical tools. So I have to name my position on AI.
My position is: AI is a tool under democratic safeguards. Neither blind techno-utopianism (Kurzweil), nor primitivist rejection (some readers of Heidegger), nor complacent acceptance of the great platforms' extractivism. A dialectical position in the strong Hegelian sense: you use the tool while simultaneously working to make it democratically controllable. It's exactly Gramsci's gesture about culture (« use the dominant's tools while working to turn them against domination »), transposed to contemporary AI.
The first move is to refuse the naturalization of AI as an « agent ». An AI is not an agent in the strong sense — it has no intention, no moral responsibility, no political autonomy. An AI is a statistical tool that produces outputs from inputs by following a model (often opaque even to its designers). Any discourse that presents AI as an agent is already a political act: it shifts responsibility from the humans who decide how it's used to a fictional « entity » supposedly « deciding ». When you talk about « AI risk », you should be talking about « the risk that certain humans exercise disproportionate power via this tool ». The grammar changes everything.
From there, the position implies precise conditions of use. For any AI deployment in a public function or with high impact: traceability of the model (which version, which parameters, which training data), traceability of inputs and outputs, readability of statistical properties (error rates per subpopulation, documented biases), identifiable human accountability for each decision, refusal of blind delegation, reversibility of automated decisions, independent audit for high-impact uses. These eight conditions are, literally, [Constraint] typable in an AI.TrackingDsl in the sense of bridge 7. The European AI Act is starting to impose part of these conditions by law, which creates an immediate field of application.
About my own practice with Claude. The git log of my commits shows my own decisions; Claude is the accelerator, not the decider. I read every output before I validate it, I reject, I redirect, I rewrite. I sign the commits and I'm responsible for the content. The conditions of traceability, reversibility, and refusal of blind delegation are met at my individual scale. What is not met — access to model weights, full independent audit, detailed knowledge of training data — falls under political regulation, not the responsibility of the individual user. And this is exactly what the metacratie/MDE project is building: the political tooling that will eventually impose these safeguards collectively on all models deployed in Europe and France. I use the tool and I work to make it more politically controllable, in parallel. Both gestures are coherent and necessary.
And, because this is consistent with the eco-socialist reading: contemporary AI consumes massive amounts of energy, water for cooling data centers, and rare minerals for GPUs. The project must name this material footprint and inscribe it in the critique of fossil capitalism. The AI.TrackingDsl must include ecological metrics (kWh per query, water consumed per data center, dependency on conflict minerals) alongside social and legal ones.
Limits and precedents
I have to honestly name the limits of the project and the precedents I have to face. Hiding a limit makes it dangerous. Naming it turns it into a condition of use of the project. Here are fifteen, in order of importance to me.
Performative vs constative (Austin, 1962). A political decision is performative — saying it does it. A compiled attribute is constative — it describes. Different ontological status. Answer: the compiler, in refusing to compile, becomes performative (it brings about a failure, not just describes one). And my métacratie is constative by explicit declaration, so it's compatible with Austin without tension.
Observer asymmetry. The MDE compiler is mechanical and apolitical. The metacratie observer is in a political position. Answer: assume the asymmetry; métacratie names and dates its observer (me, in France in 2026, in the lineage declared in the Position section), MDE lets the observer build their own cross-domain attributes. The asymmetry becomes a complementarity.
Tarski (1933). The truth of language L cannot be defined in L. It requires a strictly more expressive meta-language L'. Infinite regress. Answer: inherited from Sowa's own admission.
Gödel (1931). Any system rich enough for arithmetic is incomplete or inconsistent. Answer: constative métacratie does not claim exhaustiveness.
Castoriadis (The Imaginary Institution of Society, 1975). The instituting magma escapes any formal structure. The objection is internal to my own lineage. Answer: métacratie is constative and inherits the Whitehead/Sowa position — be systematic, keep systems open. It's an open structuralism that accepts by construction that there's an outside it doesn't touch. Castoriadis would probably have been an ally.
Foucault (L'archéologie du savoir, 1969). Serious engagement in bridge 2. Direct acknowledgment of the debt. What I add to Foucault: operationalization. Foucault stayed descriptive; MDE fabricates the apparatus instead of just describing it.
Luhmann (Soziale Systeme, 1984). Serious engagement in bridge 1. What I add to Luhmann: the Spinozist-Lordonian affective dimension. Where Luhmann is coldly operational, my métacratie carries the layers as configurations of mobilized conatus.
Latour (Politics of Nature, 1999; An Inquiry into Modes of Existence, 2012). Engaged in bridge 6. Latour describes the Parliament of Things, MDE does it.
Scott (Seeing Like a State, 1998). Engaged in bridge 3. SUFRA is the inverse of Seeing Like a State: non-readability of the present from the subject, vs readability of the subject from the state. Two faces of the same problem.
Simondon (On the Mode of Existence of Technical Objects, 1958). French ancestor of the thinking of layered technical individuation. Simondonian concretization (optimization through interlacing of functions, which is an efficiency gain and a readability loss) explains why optimized political institutions become unreadable. The DSL is an effort to return to the abstract.
Kittler (Aufschreibesysteme 1800/1900, 1985; Gramophone, Film, Typewriter, 1986). « Medien bestimmen unsere Lage » — media determine our situation. Exactly what the metacratie/MDE project says, written in German by a media theorist in the 1980s.
Sokal and Bricmont (Fashionable Nonsense, 1997). Defused in the introduction. Three answers: the Sowa-Peirce ancestor is real and not metaphorical, the theorem is formal and not verbal, the 1995 test case is falsifiable.
Lawrence Lessig (Code: Version 2.0, 2006). Engaged in bridge 3. Direct theoretical ancestor of the Law.DSL.
Catala (Merigoux, Chataing, Protzenko, INRIA, POPL 2022). Engaged in bridge 7. French empirical proof that the « DSL for laws » program is feasible and already partially realized. The project is no longer a utopia — it is a junction with a living French program.
Scientism risk / technocratic utopia. Cybersyn, Gosplan, smart cities. Strong answer: the generative apparatus is one of readability and refutation, not government. The dynamic compiler of bridge 7 is democratic-distributed, where Cybersyn was centralized-vertical. And the political position makes the project coherent: democratic in the strong sense, the tool does not decide, the sovereign people remain sole judge.
Refutation test
Following the practice I've adopted in Silences et Chantiers, I have to name what would refute this essay.
Two things would suffice, either of them. First: a documented case where an MDE system succeeded in compressing a domain's readability delay without typing its implicit conventions — that is, a case where bridge 2's theorem (limits of expressivity = limits of verification) would be empirically false. I know of none, but discovering one would reopen the bridge. Second: a documented case where a successful metacratic transition (e.g., a successfully completed democratic refoundation) proceeded without making explicit any of its SUPRA-layer doxa — that is, a case where bridge 3's attack on the implicit would be empirically contradicted. I know of none either.
To these two pure criteria I add a third, more practical: if within the next three years, a minimal Law.DSL written for France1995 fails to produce a compile error on decision 95-86 PDR with the campaign-account-control constraints, then bridge 7 is wrong and the project must be revised. This is a short-term empirical criterion, and I commit to testing it.
Coda — the same mental gesture
What's left to say after fourteen sections is short. The two corpora I've been carrying in parallel for years — technical MDE and philosophical métacratie — are, I now believe, two executions of the same mental gesture, applied to two distinct domains. The gesture consists of refusing to let tacit conventions govern in silence, of making formally explicit what was left to drift, of accepting that this act is political in the strong sense, and of operationalizing the result — through a compiler, through a philosophical text, or (and this is the next step) through a tooled metric apparatus that serves popular sovereignty rather than replacing it.
The biographical fact, that one self-taught author working outside institutions builds these two frameworks in parallel by drawing on the same technical sources (Sowa, Peirce, Whitehead, Meyer) and the same philosophical sources (Spinoza, Castoriadis, Lordon, Maturana, Morin, Foster, Malm), is no accident. It's the same mental gesture applied to two domains, and that's what makes the junction not just possible but quasi-obligatory in retrospect. What I did not see at age 18 reading Sowa with EMF open in Eclipse, I see now: this lineage had a political afterlife, and the afterlife is being written in France and Europe in 2026 under different names — Catala at INRIA, La Quadrature du Net against algorithmic opacity, the jurists of the National Digital Council, Lordon at La pompe à phynance, Fressoz on the history of the Anthropocene, the heirs of Delmas-Marty and Hermitte on commons and rights of nature.
The project ends in one sentence: reduce the unhealthy SUFRA latency — the kind that serves the opacity of power and lasts decades without technical necessity — down to the structurally minimal SUFRA latency, the one that is constitutive of any operationalized formal system and that leaves room for democratic deliberation. No more, no less.
And this project is not a thesis to debate — it's a toolbox to build collectively, to publish in open source under the Etalab 2.0 license, to offer the sovereign people as an instrument of their own deliberation, to enrich through practice and contributions, to govern democratically as a digital common in the strict sense. It's a call to build together, as living heirs to both the Tennis Court Oath of 1789, the metabolic rift of Capital book III, Whitehead's 1929 maxim, Sowa's 1980s ontology, the meta-DSL parameterized by (Ex × Ty) that this essay proposes, and Catala (INRIA, 2021) which proves that the program is already begun but needs to be extended, enriched, politically owned, democratically governed.
This is how the bridge between MDE and métacratie ends — not as a conclusion, but as a preamble to a praxis. The bridge is named. The program is open. It belongs now to those who want to join it.
The full French version of this argument, written from the philosophy side rather than the engineering side, is at Appareil et compilateur. The biographical trace of meeting Sowa at age 18 is at Age 18 — discovering the model-driven academic world.