In this reflection, I want to share an about-face I’ve been having in the strategy for defeating “implicit feudalism” with “governable stacks.” Both of these concepts are described in depth in my book Governable Spaces. Implicit feudalism is the widespread tolerance of highly centralized, low-accountability forms of governance in online communities, from big platforms to little group chats. Governable stacks are efforts to build socio-technical systems that can be co-governed by their participants in diverse and accountable ways.
In brief, the story is: I’ve generally assumed that to defeat implicit feudalism you need deterministic software at the foundational level managing governance. The progress of AI agents is making me wonder, quite reluctantly, otherwise.
Determinism and nondeterminism
All governance systems mix deterministic and nondeterministic elements in one way or another. By determinism, I mean mechanisms that follow strict instructions and always produce the same outputs from the same inputs; 51 percent of the vote always wins a majority-rules election. Nondeterministic mechanisms are more like how an emperor rules or a judge presides; decisions emerge in more mysterious ways that might not produce predictable outcomes.
Determinism ideally allows for what Vitalik Buterin helpfully calls “credible neutrality”; although no system is really neutral, the fact that a deterministic one is rigid means that users can assume it will play by its rules rather than follow the whims of interested parties. Nondeterminism allows for flexibility, interpretation, and context; this is what agents do, both human and machine—they make decisions even when the answer is not obvious or clear. Bias may even be welcome.
Functional governance seems to always involve a mix of both, although this mix can take very different forms. The mix ensures that the system includes both space for well-informed agents to make decisions and predictable mechanisms to either check the agents’ power or implement it.
For instance, in the US government:
| Legislative elections | deterministic |
| Legislative debate | nondeterministic |
| Supreme Court decisions | nondeterministic |
| Presidential authority | nondeterministic |
| Presidential impeachment | deterministic |
| Independent bureaucracies | nondeterministic |
Or, take a typical community on Reddit, where the Automod feature allows moderators to program rules for moderation actions:
| Moderator policymaking | nondeterministic |
| Automod moderation actions | deterministic |
| Moderator mediation | nondeterministic |
Governance design is in some respects a matter of ascertaining which type of mechanisms should go where.
Modular politics: base-layer determinism
Together with collaborators in the early days of Metagov, I have argued that a plausible strategy for countering implicit feudalism is “modular politics.” This strategy contends that the foundational layer for allocating power in online spaces should be a platform that allows modular plugins to be mixed and matched, combined and nested. If you want to be able to vote out your group chat’s admin, import the referendum module, and attach it to admin rights. If you want all policies to be approved by a random selection of members, import the sortition module.
This is more or less the model adopted in leading platforms for online governance, such as Decidim (for city-level citizen involvement) and Aragon (for blockchain-based DAOs). I have also attempted to implement modular politics myself in Modpol, initially designed as a governance mod for an online game. Lately I have been playing with a version capable of running a Mastodon server.
Technical systems supporting governance are important. One of the chief drivers of implicit feudalism is that running internet servers requires expertise; the people who run them, and the people who hire those people, have historically been able to claim a lot of power on the internet. They, in turn, have designed user-governed spaces (like Discord “servers” or group chats) with rigidly hierarchical permissions systems, akin to what one finds on a computer. Breaking implicit feudalism probably requires systems that allow non-sysadmins to participate in having sysadmin-like power.
One way to do this is to ensure that technical people are accountable to the governance of the community as a whole. This is what we do at Social.coop, a democratic Mastodon server. The technical team is expected to implement the decisions that the community makes through a decision process. But sometimes they don’t, or do so very slowly. I suppose we could hire a CEO who could hire and fire the technical team, but right now we are all just volunteers rewarded with small stipends. Cooperative platforms are a real solution to modular politics, which is why I have spent so much time trying to support them. But most online communities are not and are never going to be cooperatives.
Modular politics proposes to address this by establishing a deterministic platform underneath online communities, which has access to admin-level powers. Through the modules that they stitch together, users can design how to manage those powers. The modules may be deterministic (like a referendum vote) or nondeterministic (like delegating moderation powers to a rotating group of users). But the underlying system needs to be deterministic if it is to avoid the inevitable drift of power to people with server admin skills, or those who employ them. It needs to be software programmed to carry out admin-style actions under certain conditions. It should not tolerate any margin for error.
Actually implementing modular politics is hard. My own experiment in doing so helped me appreciate the simplicity of hierarchical flows under implicit feudalism. Meanwhile, a platform like Decidim depends on the rare government willing to cede power to it. DAOs built on Aragon have often been subject to various sorts of nightmarish gaming and hacking and principal-agent problems.
When the rules are clear, to paraphrase Goodhart’s Law, someone will find a way to violate their spirit for private advantage. And deterministic systems alone don’t inspire virtues among participants like leadership and good judgment. Worse, these systems might just reinforce the power of technical expertise if they become more than modestly complex. How many of us intuitively understand campaign-finance law or quadratic voting?
I still think we were on to something with modular politics, and it has been gratifying to see some limited implementations of the idea. But perhaps it is also telling that the strategy has not caught fire as we had hoped.
Constitutional agents: base-layer nondeterminism
I have generally been skeptical of the use of AI agents in governance processes. As some of our recent research at Metagov argues, incorporating AI systems in governance likely just displaces effort from human-managed activities to humans managing the bots. Most proposals for AI governance involve putting bots in the middle of a system, such as summarizing discussions or guiding policy implementation. These expect a kind of pseudo-determinism, because the AI is supposed to function as a kind of neutral functionary. The dominant AI models, however, bring with them biases from their training data and design that risk undermining any hope they might have of achieving credible neutrality. I have spent a lot of time playing with local models, coding agents, custom agents, and so forth, and while I feel some real awe for what these things can do, I have not considered them trustworthy with governance.
One data point that began to shift my perspective was reading “Claude’s Constitution” from Anthropic—the nearly 30,000-word love letter that serves as the critical tool for aligning the $350 billion company’s primary product. It is striking that Anthropic has concluded the best way to govern its chatbot is not a long list of conditionals and commands but an extremely human-readable essay. As CEO Dario Amodei recently wrote, the document “encourages Claude to think of itself as a particular type of person.”
A second, less lofty data point is the flurry of activity around the software now known as OpenClaw. While people are dangerously handing their computers over to a vibe-coded agent, and seeing all kinds of mayhem ensue, they are also experiencing how AI agents are able to manage technical systems more or less independently, following natural-language prompts.
These developments together suggest an alternative strategy to modular politics for defeating implicit feudalism: constitutional agents.
For instance, imagine a social platform where each community of users has a governance bot. The creators of a community provide the bot with a preliminary constitution, perhaps using a template and adjusting it to their needs. This is a human-readable document that serves as the bot’s programming. It might include specific stipulations about deterministic processes, such as a vote threshold necessary to revise the constitution. But it might also include less legalistic reflections on the spirit and values of the community, so that the bot can take those into account. The bot can figure out how to implement those mechanisms within the existing platform’s features, rather than requiring bespoke plugins to extend its functionality.
This kind of approach puts nondeterminism at the base layer. AI agents are not old-fashioned computer programs. There is always variation in their outputs, even to the same prompts. Yet they pose at least the promise of achieving credible neutrality. A well-crafted constitution could compensate for the biases in the model’s training. And since agents are capable of being instructed by accessible, human-readable language, it should not require a technologist to design a successful system.
A constitutional agent might implement deterministic mechanisms, such as voting or veto powers. It might simply delegate all authority to a human agent, if that’s what the constitution says. There might be deterministic checks, such as a supermajority vote that can override the bot. A platform that hosts many communities might impose its own meta-constitution that constrains community-level constitutions. But for most of the level where governance hits the underlying technology—there is a nondeterministic agent.
Even if imperfect, constitutional agents may be the most plausible technique for spreading alternatives to implicit feudalism. They could bypass the need to implement platforms with complex, interlocking plugins, or to rely on people with the technical skills to develop them. Insert a human-readable explanation of how the system should work, and an agent does its best to carry it out.
A reluctant conclusion
I am skeptical of AI as a band-aid for most things. I tried to use chatbots to write this post based on some notes, for the fun of it, but I couldn’t stand any of what they created. Still, I think there is reason to take constitutional agents seriously as a strategy that might have real promise for defeating implicit feudalism. Many mainstream social platforms already support bots with admin power. And even if those bots are sort of crude and cold, the constitution can be carefully hand-crafted by its community.
One additional attempt I have made to defeat implicit feudalism is CommunityRule, a web app designed to help communities draft simple bylaws. We’re in the process of redesigning it to be far more usable and friendly. At times, I’ve wondered if we should make the system more deterministic, even to the point that it might export computer code that implements a rule’s provisions. But now I think it is best to lean even more toward helping people craft language that is accessible, comprehensible, and humane. The right kind of machine will appreciate that, too.