This draft articulates Desirable Property 12 (DP12) as the condition under which communities can define, execute, audit, and evolve the rules governing AI behavior in shared digital environments.
If DP11 defines what ethical AI requires, DP12 defines who decides those conditions and how decisions are translated into runtime behavior, evaluated, and revised over time.
DP12 ensures governance is not abstract or centralized, but participatory, legible, and enforced at the interface where AI behavior is experienced.
DP12 connects DP3 (adaptive governance), DP4 (data conditions for training and inference), DP9 (incentive alignment), DP13 (containment and enforcement), DP14–DP15 (transparency and provenance), and DP20 (community ownership of rules and outcomes).
If DP12 is weak, predictable failures follow: policy theater, centralized control disguised as neutrality, participation without impact, and AI systems that drift away from community-defined norms.
DP12 does not prescribe a single voting system or governance model. It defines minimum conditions for governance to be executable, contestable, and evolvable.
In today’s web, governance of AI systems is largely:
Policies exist, but are not reliably bound to behavior. Communities can express norms, but cannot enforce them across contexts.
This produces recurring failures:
These failures are structural. Governance without execution becomes symbolic.
DP12 reframes governance as an operational system: rules that can be authored, executed, observed, and revised in a continuous loop.
Platforms define rules unilaterally but present them as neutral standards.
Example: A platform updates AI moderation policies without community input while framing the change as a safety improvement.
Why this matters: Governance must align process with actual control.
Policies exist as documents but are not bound to runtime behavior.
Example: A community bans certain AI behaviors, but the system continues to allow them due to lack of enforceable constraints.
Why this matters: Rules must execute to be meaningful.
Participants can comment or vote, but outcomes are not affected.
Example: Feedback is collected but not linked to decisions or policy changes.
Why this matters: Participation must be causally connected to outcomes.
Economic or engagement incentives silently dominate governance outcomes.
Example: Engagement-maximizing behaviors persist despite community-defined limits.
Why this matters: Governance must operate on incentives, not only actions.
Communities are split across tools and contexts, preventing consistent rule application.
Example: The same group encounters different AI behaviors across platforms without shared governance.
Why this matters: Governance must be portable and composable.
Decisions and rationale are not preserved, leading to repeated mistakes.
Example: A harmful behavior resurfaces because prior decisions were not recorded or discoverable.
Why this matters: Governance requires continuity over time.
Automated systems act faster than governance processes can respond.
Example: Agentic systems exploit policy gaps before review cycles occur.
Why this matters: Governance must include rapid response pathways (DP3, DP13).
Policies move across systems but lose meaning, enforceability, or authority.
Example: A policy exported to another environment becomes advisory rather than binding, or is interpreted differently due to schema or enforcement differences.
Why this matters: Governance that cannot survive movement across systems collapses into local silos, undermining legitimacy and continuity (DP7).
AI behavior in the meta-layer must be governed by communities through visible, executable, and evolvable rule systems applied at the point of interaction.
Governance is not a document. It is a living system that binds rules to behavior, preserves memory, and supports continuous revision.
Example: A community defines constraints on AI summarization, enforces them at runtime, logs outcomes, and updates rules based on observed behavior.
What this feels like: You can see the rules, understand them, and participate in changing them, and the system actually follows them.
Without this: AI behavior is shaped by invisible incentives rather than community-defined norms.
Governance in the meta-layer is executed through a shared layer that binds community-defined rules to runtime behavior across interfaces, agents, and services.
This layer makes governance:
Governance is expressed as structured, machine-readable policy objects that include:
These objects are first-class artifacts that interoperate across tools and environments.
Policies must bind at the point of interaction, including:
Binding is deterministic and inspectable: the same inputs under the same policy produce the same governed outcome.
Governance defines constraints; containment enforces them. Systems must provide:
Every material action produces a receipt containing:
Receipts are verifiable, queryable, and link to policy history.
Overrides (by safety systems, operators, or emergency controls) must be:
Silent overrides are non-compliant.
When policies conflict (local vs global, community vs platform, safety vs expression), systems must:
All policy objects, decisions, disputes, and outcomes form a linked, versioned history that supports learning and prevents repetition of past failures.
Communities define rules within specific zones of interaction, aligned with context and risk, with clear boundaries and inheritance where applicable.
Rules are expressed in machine-enforceable formats that bind to runtime behavior and can be tested, simulated, and verified before deployment.
A continuous cycle of propose → implement → observe → contest → revise, with time bounds and clear state transitions.
Decisions, rationale, and outcomes are persistently recorded, searchable, and linked to policy versions and receipts.
Communities can see and influence optimization targets shaping AI behavior, including tradeoffs and red lines that gate unacceptable outcomes.
Rules are enforced through containment mechanisms with graduated responses and clear audit trails.
Governance actions and outcomes are logged with verifiable evidence and accessible summaries for participants.
Participants can delegate governance roles with explicit scope, revocability, and accountability, including term limits where appropriate.
Policies, decisions, credentials, and receipts are portable across tools and contexts with:
Portability without enforceability or authority is non-compliant with DP12.
AI may assist in summarization, simulation, and analysis, but must not replace human ratification for material decisions and must disclose assistance.
Governance must be experienced at the interface where decisions matter.
Participants must be able to:
Communities must be able to:
Example: A user sees that an AI response was modified by Policy A (v3.2) due to safety constraints; they can view the policy, see prior changes, and file an appeal that triggers a review queue with SLA.
Governance is effective only if incentives do not undermine it.
DP12 requires visibility and, where appropriate, control over:
Common failure patterns to detect and constrain:
DP12 therefore expects:
Across systems, consistent signals reveal that governance is failing not at the level of values, but at the level of execution and legitimacy:
These signals are not usability complaints. They indicate structural breaks between rule definition, enforcement, and accountability.
DP12 treats these signals as evidence that governance must be observable, causal, and continuous—not intermittent or symbolic.
DP12 does not:
It defines conditions for legitimate, executable governance.
A DP12-aligned system must meet a baseline where governance is not only declared, but operationally binding.
At minimum, systems must:
If any of these conditions are missing, governance is functionally symbolic, regardless of how comprehensive the written policies appear.
DP12 surfaces a set of unresolved design tensions at the intersection of governance, AI behavior, and cross-system interoperability. These questions are not blockers; they are invitations to experiment with bounded, auditable approaches that can evolve under real-world conditions.
DP12 functions as the execution layer that activates the broader meta-layer system.
Without DP12, other properties remain declarative. With DP12, they become operational.
DP12 assumes governance will be actively contested by both human and automated actors, especially as AI systems scale and adapt.
Likely failure paths include:
DP12 requires pre-mortem design that anticipates these dynamics:
Governance failure is inevitable at scale. Silent, untraceable, or uncorrectable failure is not.
Advancing DP12 requires moving from specification to demonstrated practice: reference implementations, interoperable policy artifacts, and live governance pilots that prove rules can bind behavior across contexts. Progress should be measured by working systems and verifiable outcomes, not declarations alone.
Progress should be demonstrated through working systems, not only specifications.
DP12 is the point at which governance stops being descriptive and becomes authoritative.
It defines whether communities actually control the behavior of AI systems, or whether control resides in hidden incentives, opaque operators, and unaccountable automation.
When DP12 is strong, governance is visible, enforceable, and continuously improving. Communities can shape AI behavior with confidence that rules will hold under pressure.
When it is weak, governance becomes theater: rules exist, but behavior is determined elsewhere.
DP12 is the difference between systems that are governed and systems that merely claim to be.