Executable Institutions: A New Runtime for Civilization
RaC as the backbone, Ethereum as the prototype runtime, and LLMs as the nervous system of governance.
What if societies could not only write agreements, but actually run them?
Rule as Code (RaC) tried to answer this by compiling consensus into executable logic. Ethereum pushed the experiment further, building a runtime where smart contracts, DAOs, and programmable treasuries proved that governance could literally execute itself. Both were designed before the LLM era—rigid, deterministic, assuming ambiguity was always a bug. They gave us methodologies and runtimes, but also technical debt: brittle protocols, fragile governance, and crises when code diverged from intent.
Now LLMs change the equation. They show that ambiguity is not an error, but a feature to be managed. They can surface multiple readings, simulate adversarial debate, and reconcile consensus with execution. Together, RaC, Ethereum, and LLMs sketch the outline of a possible new paradigm: executable institutions that are auditable, adaptive, and alive.
A Personal Guessing Toward a New Paradigm
When I look at RaC and Ethereum side by side, I can’t help but see them as Act I of a much larger story. Both were born before the LLM era, in a world where ambiguity was considered an error to be eliminated, not a feature to be managed. The assumption was simple: if we wanted machines to execute rules, then every rule must be hand-crafted, deterministic, and final. This worldview produced important breakthroughs, but it also left behind a legacy of rigidity, fragility, and what I call pre-LLM technical debt.
RaC codified a methodology. It showed us that rules could be treated as code: discover them, model them, validate them, deploy them, monitor them. It insisted on auditability, provenance, and traceability. That insistence gave RaC its legitimacy. Even though most of its pilots struggled to scale, its core mythology—the conviction that consensus can be compiled—remains foundational.
Ethereum extended the experiment into runtime. For the first time, rules weren’t just modeled; they were actually executed inside a live, permissionless environment. Smart contracts, DAOs, programmable treasuries—they all showed what governance looks like when rules enforce themselves. But Ethereum also revealed the brittleness of determinism. When code diverges from intent, immutability becomes a liability, and remedy requires extraordinary interventions like hard forks. Ethereum proved that execution is possible, but also that execution without interpretation is dangerously incomplete.
Both RaC and Ethereum were designed in a world where machines couldn’t “understand” language at scale. That’s why they treated ambiguity as a bug to be eliminated upfront. The result was systems that were precise but heavy, auditable but slow, legitimate but brittle.
Now, in the LLM era, the puzzle looks different. Ambiguity is no longer fatal—it is manageable. In fact, ambiguity can even be productive. LLMs can surface multiple plausible interpretations of a rule, simulate adversarial debates between competing readings, and reconcile consensus with execution in ways that deterministic systems could never attempt. They don’t remove the fuzziness of human governance; they mirror it. And that mirroring, paradoxically, makes them powerful.
If I sketch out what this suggests, I see the outline of a hybrid governance machine:
RaC as the bones. The backbone of legitimacy, methodology, and auditability. RaC’s mythology—rules as code, lifecycles, provenance—remains the skeletal structure on which everything else must rest. Without bones, there is no form.
Ethereum as the muscles. The runtime and enforcement environment. Not necessarily Ethereum itself, and not necessarily on-chain, but the broader archetype of execution engines that make rules run. Muscles are clumsy, sometimes overstrained, but they give power and movement.
LLMs as the nervous system. The interpretive, discursive layer. The capacity to feel ambiguity, explore multiple readings, debate, reconcile, and align execution with evolving consensus. Nervous systems are probabilistic, messy, and adaptive—precisely what governance has always been.
Put together, these components begin to look less like tools and more like a new runtime for civilization. RaC gives us the legitimacy of bones, Ethereum (or any runtime archetype) provides the muscles of execution, and LLMs inject the nervous system of interpretation.
This is not a finished theory—only my personal foresight, my attempt to guess at the direction things are drifting. Maybe we’ll call it Consensus-as-Code, maybe something else. But what feels clear is that RaC, Ethereum, and LLMs are not random, disconnected experiments. They are converging into a paradigm where societies no longer just write agreements on paper, but run them, argue over them, and evolve them continuously in real time.
Not Endorsing Ethereum, But Learning From It
I want to be precise here: I am not endorsing Ethereum. Ethereum is not the solution, nor is it the endpoint of executable governance. To me, Ethereum is better understood as a proof-of-concept laboratory—a living experiment that revealed both the promise and the fragility of protocol-first institutions.
Ethereum’s greatest contribution was to show that “code is law” could be more than a slogan. Smart contracts demonstrated that agreements could run deterministically inside a shared environment, enforced not by judges or regulators, but by execution engines themselves. DAOs and programmable treasuries took that logic further, creating the first glimpse of institutions that exist primarily as software. In that sense, Ethereum proved the possibility of executable institutions.
But Ethereum also exposed the brittleness of such systems. Execution without interpretation is fragile. When a smart contract behaves in ways that contradict community intent—as in the DAO hack of 2016—the system faces a crisis. Immutable code cannot adapt; remedy requires extraordinary interventions like hard forks, which themselves undermine the very principle of “code is law.” The broader lesson is not that Ethereum “broke governance,” but that it exposed the unavoidable role of governance beyond code.
In parallel to, or preceding, Ethereum’s mass adoption, the RaC movement highlighted another path: consensus is not just text but something that can be modeled, tested, and executed. Its insistence on methodology—discovery, modeling, validation, deployment, monitoring—was not bureaucracy for its own sake, but a way of ensuring legitimacy. RaC’s mythology is that rules can be code, but only if the code remains tied to consensus through auditability and provenance.
Ethereum, by contrast, showed us what happens when you try to skip that methodology. You gain power and speed, but you also accumulate technical debt: rigid protocols, costly audits, governance disputes when execution diverges from social intent. Ethereum ran fast and scaled quickly, but what it revealed was that rules-as-code cannot escape the social and institutional scaffolding that legitimizes them.
This is where LLMs may enter the picture. Their role is still currently experimental, but with strong potential as interpretive engines. Where RaC lacked scalability, and Ethereum lacked fidelity to consensus, LLMs could help fill the gap. They can accelerate the discovery and modeling processes of RaC by parsing vast corpora of rules and drafting formal structures. They can also act as a probabilistic interpretive layer Ethereum never had—surfacing multiple readings, simulating adversarial debates, and reconciling execution with social consensus.
The key foresight here is that the runtime of the future does not have to be blockchain. Ethereum was an important archetype, but it is not destiny. The runtime may emerge as new architectures, hybrid systems, or institutional platforms not yet invented—systems that combine RaC’s mythology of legitimacy, Ethereum’s lessons about execution, and LLMs’ emerging interpretive capacities.
In this light, Ethereum remains invaluable, not because it solved the problem, but because it showed us the cracks. It forced the debate about accountability, remedies, and constitutional alignment. It proved that execution without interpretation is incomplete. It also taught us that governance technologies cannot rely on determinism alone; they need interpretive, adaptive layers.
So no, I am not endorsing Ethereum. But I am learning from it. And I believe its lessons will be folded into a broader paradigm: one where RaC provides the backbone of legitimacy, Ethereum represents the first runtime experiment, and LLMs bring the interpretive capacity that reconciles execution with consensus. The future of executable institutions lies not in a single blockchain, but in a hybrid ecosystem where methodology, runtime, and interpretation converge into something far larger: a runtime for civilization itself.
Ethereum was the first real runtime for rules-as-code—powerful but brittle. Built on pre-LLM determinism, it pushed consensus off-chain and exposed fragility in immutability and audits. Yet as a messy laboratory, it mattered: not an endpoint, but a prototype kernel for governance.
Toward Executable Institutions
If I step back and look at the larger arc, what I see is a slow convergence—a set of experiments that at first looked disconnected but now begin to align. RaC, Ethereum, and LLMs each emerged in different contexts, each with their own limitations, but together they sketch the outline of what I’d call Executable Institutions.
RaC as the backbone of legitimacy.
RaC’s lasting contribution is not any single pilot or technical standard but its paradigm: the conviction that consensus is more than text. Rules can be modeled, tested, validated, deployed, and monitored—with auditability, provenance, and traceability built into the lifecycle. This discipline offered the bones of an executable governance methodology. Yet RaC also reminds us: legitimacy precedes code. Rules become executable only when rooted in legitimate institutional processes; without that anchor, code alone risks collapse.
Ethereum as the runtime archetype.
Ethereum demonstrated what RaC only theorized: rules could actually run in a live environment. Smart contracts enforced themselves; DAOs and programmable treasuries turned institutions into software. But Ethereum was also brittle, deterministic, and often diverged from human intent. Hacks, forks, and costly audits exposed the weaknesses of “code is law” in practice. Still, Ethereum matters—not as the final form, but as the first prototype of a governance runtime. In my view, it is like the rough “kernel” of an operating system for institutions: flawed, but historically important.
LLMs as the interpretive nervous system.
This is the tectonic shift. Governance has never been purely logical; it is discursive, interpretive, saturated with ambiguity. Pre-LLM systems treated that ambiguity as a bug to be eliminated. LLMs, by contrast, absorb it. They can surface multiple readings, simulate adversarial debates, and reconcile code with consensus. They act as middleware, a probabilistic layer between the determinism of RaC/Ethereum and the fuzziness of human societies. Still experimental, but with strong potential, LLMs may give governance systems the adaptive capacity they have always lacked.
Put these three components together and a pattern emerges:
RaC = the bones (methodology, legitimacy, auditability).
Ethereum = the muscles (runtime and enforcement environment—whether on-chain or off-chain).
LLMs = the nervous system (interpretation, debate, reconciliation).
This hybrid machine begins to look less like a collection of tools and more like the runtime for civilization. Not just metaphorically, but literally: an environment where societies can draft rules, run them, debate them, and evolve them continuously in real time.
Of course, this remains foresight—an attempt to connect fragments into a possible paradigm. Maybe the name will be “Consensus-as-Code,” maybe something else. The details will change, runtimes will evolve, and Ethereum may or may not remain central. But the trajectory feels clear:
From RaC we inherit legitimacy.
From Ethereum we inherit execution.
From LLMs we inherit interpretation and adaptability.
Together, they point toward executable institutions: systems that do not just express consensus but enforce it, test it, debate it, and refine it. A world where governance is no longer confined to text and interpretation alone, but operates inside a living runtime—a new operating system for society itself.
Consensus-as-Code.
