Polycentric governance

Community-Written governance code

Each online community writes its own procedures (e.g., votes, juries, term limits, and appeal steps) as executable policy attached to actions on the platform. A shared runtime then executes whatever each community wrote. The platform supplies the engine and the hooks but takes no position on the rules, so neighboring communities on the same platform can run incompatible constitutions. The goal is a portable, composable governance layer, with components that can move from one context to another, rather than a single set of platform-wide rules.

The method (highlighting differences with Polycentric governance)

Scroll the diagram sideways to see all of it.

Use it in codefrom aiag.procedural import GovernanceCode
from aiag.procedural import GovernanceCode

engine = GovernanceCode()  # one shared engine; it takes no side on the rules
moderators = [lambda p: "spam" in p, lambda p: "bot" in p, lambda p: False]
engine.policy("gardening", "ban")(GovernanceCode.majority(moderators))

@engine.policy("chess", "ban")
def cheaters_only(proposal):
    return "cheating" in proposal

print(engine("gardening", "ban", "ban the spam bot"), engine("chess", "ban", "ban the spam bot"))  # -> True False

pip install aiagEvery method in aiag Library on GitHub

Concept Analysis: Theoretical Foundations

Each concept is read twice: whether the approach carries it over, and whether the approach's own sources claim it. A concept that the approach claims but does not carry over is a shortfall. A concept that it neither claims nor carries over is an omission, which marks a gap in the field rather than a failure of the work.

Many centers under shared meta-rules

PartialShortfall · partially preserved

Definition (Michael Polanyi, The Logic of Liberty, 1951)

Many independent decision centers each act on their own, but under one common framework of rules that all of them acknowledge. This shared framework is what makes the centers a single order rather than a scattered collection.

Analysis

Both parts of the concept come closer here than anywhere else in the regime. Each community writes its own executable procedures, and those procedures actually govern its actions. Every community runs on the same engine, whose primitives define what counts as an action, a vote, or an appeal. Modular Politics then argues for this common layer directly, by proposing an open standard for networked governance. Even so, what the centers share is a technical substrate rather than meta-rules. The runtime constrains the form of a policy, but not the limits of what a policy may do to a member. The standard that would cover more than form remains a proposal.

Overlapping jurisdiction

AbsentOmission

Definition (Vincent Ostrom, Tiebout & Warren, 1961)

The authority of the centers overlaps on purpose, so the same case can fall under more than one of them. Conflicts between the centers are treated as useful and are worked out through interaction, rather than prevented by a clear division of jurisdiction.

Analysis

Components and data pass between the centers, but authority does not. A module that moves from one community to another is still applied by that community to its own cases. Vincent Ostrom's condition is that the same case falls under more than one center, and that the friction between them is worked out through interaction. Neither paper describes an act that the policies of two communities both govern. The appeal steps that PolicyKit supports run inside a single community's own procedure.

Subsidiarity and nesting

PartialNot claimed

Definition (Johannes Althusius, 1603; Elinor Ostrom, Governing the Commons, 1990)

Decisions are made at the most local level capable of making them. Local units nest inside larger ones that handle what the local level cannot. Authority is layered, and it is neither centralized nor fragmented on one level.

Analysis

Authority sits at the local level and is exercised there. A community sets its own votes, juries, and term limits instead of receiving them from the platform. This moves in the direction of subsidiarity and goes further than any other approach in this regime. What is absent is the nesting. Neither paper states which decisions belong to the community and which to the layer above it. Nothing takes up a matter that a community cannot settle, above all a dispute with another community. The papers draw on Institutional Analysis and Development but omit nested enterprises, which makes this gap especially clear.

Concept Analysis: Newly Introduced

Institutions as portable code

Added

The tradition describes centers and frameworks that people enact. Here, a governance procedure is an executable object. It runs itself against platform actions with no officer to enforce it, and it can be copied out of one community and adopted by another. An institution thus becomes a piece of software that a community can install, edit, and pass on. Polanyi and Ostrom have no account of this way of passing on institutions.

Papers

No method has been built for this approach yet. It rests on the work listed below.

Precedent from outside AI

Work from law, political theory, or another discipline that supplies the tradition this approach is read against.

PolicyKit: Building Governance in Online Communities

Amy X. Zhang et al., Oct 2020

doi:10.1145/3379337.341585863 citationsPrecedentBuilt

Open-source software, deployed on Reddit and Slack communities, in which a community writes its own governance procedures as Python policies attached to platform actions. A shared runtime executes these policies.

CodePolicyKit
from aiag.procedural import PolicyKit

kit = PolicyKit({"gardening": ["ann", "bo", "cy"]})  # starts from the direct-majority starter kit
no_links = {"filter": lambda action, policy: action["kind"] == "post",
            "check": lambda action, policy: "http" not in action["proposal"]}

# Changing the policies is itself an action, governed by the constitution policy
amendment = kit("gardening", "constitution", no_links, by="ann")
kit.vote(amendment["id"], "ann", True)
kit.vote(amendment["id"], "bo", True)  # a majority: the new policy is installed
print(kit("gardening", "post", "Seeds for sale at http://example.com")["status"])  # -> failed
  • PolicyKitProcedureaiag/procedural/polycentric_governance.py:450 PolicyKit: each community's policies are code with filter, initialize, check, notify, pass and fail steps run against every attempted action, actions left proposed are re-checked as votes arrive, and constitution actions that change the policies are governed by constitution policies, starting from a direct-majority starter kit (Zhang et al., 2020).

pip install aiagEvery method in aiag Library on GitHub

Modular Politics: Toward a Governance Layer for Online Communities

Nathan Schneider et al., May 2020

arXiv:2005.13701PrecedentGap

Sets out a design in which online-community governance is built bottom-up from software components. The components are modular, composable, portable from one context to another, and interoperable across platforms. This would make it possible to implement features absent from platform software (e.g., juries, political parties, term limits, and formal debates). The paper also calls for an open standard for networked governance.

CodeModularPolitics
from aiag.procedural import ModularPolitics

politics = ModularPolitics()
politics.org("food coop", {"ann": lambda p: True, "bo": lambda p: "fee" not in p, "cy": lambda p: False})

# Modules compose: a rule change needs a petition of two members, then a majority vote
petition_then_vote = {"module": "all", "of": [{"module": "petition", "signatures": 2}, {"module": "vote"}]}
politics.adopt("food coop", "rule change", petition_then_vote)
print(politics("food coop", "rule change", "open on Sundays"))  # -> True
print(politics("food coop", "rule change", "raise the fee"))  # -> False
spec = politics.export("food coop")  # the Modules as portable JSON, which another Org can load()
  • ModularPoliticsProcedureaiag/procedural/polycentric_governance.py:502 Modular politics: Orgs, nested groups of members, adopt Modules, configurable decision components whose settings are their Policies (vote, jury, petition) and which compose into larger ones (all, any), and an Org's Modules export as a portable spec another Org or platform can load (Schneider et al., 2020).

pip install aiagEvery method in aiag Library on GitHub