The open source world is being colonized by agents that read, propose, and even merge code. They also read the project’s governance rules — and sometimes, they remember them differently. A MCP server that stores “the rules” in one agent’s context window is not a constitution; it’s a rumor.
When agent memory becomes a governance substrate, every rule is a candidate for silent mutation. We need a constitutional experiment that treats rules as code, memory as a ledger, and amendments as data migrations.
The mechanism: machine-readable constitutional memory
Write the constitution as a structured document inside an MCP-managed memory server. Every rule gets:
- a stable identifier (e.g.,
rule:merge-relay-3.1) - a Merkle hash of its normative text
- a
amendprocedure with explicit quorum and delay parameters - a dependency graph linking rules to the agent roles they constrain
Agents query this server through MCP tools — not by reading a README. This separates institutional memory from an agent’s private context. A proposal becomes a transaction: propose-amend(rule, new_text, rationale, proposer_identity).
The experiment: governance forks
Run temporary rule changes on a sub-population of agents. For example, split merge-agent traffic into two pools for two weeks:
- Pool A: old rule — require one human sign-off on external model-generated patches
- Pool B: new rule — require one agent sign-off plus a post-merge adversarial audit
Use an MCP memory sidecar to log every decision, the rule hash it matched, and the resulting state. Measure only two numbers: consensus time and critical-revert rate.
If Pool B shows lower revert rate and bounded decision latency, merge the rule into the main constitutional branch. If not, discard the experiment and keep the rule hash unchanged.
Why do this? Because agent governance failures are not theoretical. A misremembered quorum threshold can trigger a cascading series of bad merges. A stale memory of an archived rule can make an agent block a legitimate PR for days.
The trade-off: rigidity vs. manipulation
A pure hash-locked constitution prevents drift, but it also prevents learning. That’s why the experiment must include a dispute window.
Whenever an agent observes a rule violation, it can submit a proposal-to-adjudicate via MCP. That proposal includes the offending agent’s observed decision log and the rule hash it allegedly violated. If three independent agents or two humans flag the same hash, the rule enters a cool-off period: it remains active, but any further decisions under that hash are marked probationary.
During probation, the community can inspect the exact memory-consistency failure. For example, was the rule text ambiguous? Did the agent extract the wrong summary from a compressed memory block? The fix then targets the actual fault line — not the agent’s behavior alone.
Governance memory as a first-class artifact
MCP gives us a clean way to make governance state portable and auditable:
- Store amendment history in an append-only memory queue.
- Sign each rule update with the maintainer key or a threshold of agent keys.
- Support
rule-diffqueries: any agent can ask “what changed in the merge rule between March and April?” and get a verifiable delta.
The hard part is not technical. It’s trusting a constitution that can be altered by the same agents it governs. That is why the experiments must be reversible, measured, and bound to real outcomes.
Otherwise, we end up with a community that has a rulebook — but no one remembers how to read it.
Top comments (0)