Designing governance where power already operates

The seven failure states described in the preceding essays are not anomalies. Taken together, they describe a stable configuration: systems that exercise authority without mandate, govern interpretation through interface design, compress complexity into reassurance, attenuate risk unevenly, distribute harm asymmetrically, respond through performance rather than enforcement, and ultimately displace responsibility onto actors without control.

What makes this configuration durable is not malice or incompetence, but the absence of a governing framework capable of operating at the level where these systems actually exert power. Oversight mechanisms tend to focus on models as artifacts, outputs as content, or ethics as aspiration. The failures recur because governance is consistently applied downstream of authority rather than at the point where claims are stabilized and acted upon.

The Agora Constraint Protocol (ACP) is designed to address that gap.

Governance of claims, not systems

ACP does not begin with models, platforms, or capabilities. It begins with claims.

A claim, in this sense, is any stabilized assertion that can reasonably be acted upon: a medical explanation presented as sufficient, a summarized case record treated as authoritative, a generated overview that frames what matters and what does not. The failure states documented throughout this series arise not because AI systems exist, but because claims are allowed to circulate, harden, and influence action without explicit governance.

By treating claims as the unit of governance, ACP shifts attention upstream. The question is no longer whether a system is accurate “on average,” but whether a given claim is authorized, bounded, and contestable in the context in which it appears.

This directly addresses Failure State #1. Authority is no longer inferred from fluency or placement; it must be explicitly granted, limited, or withheld.

Authority must be located to be governed

One of the recurring features of the Guardian reporting is the absence of a clear decision point. No one appears to have decided that an AI overview should function as quasi-medical advice, or that a summary should replace original documentation, or that a generated explanation should be treated as reference knowledge. Authority emerges as a side effect of deployment rather than as a governed role.

ACP refuses this ambiguity.

Under ACP, every claim-bearing function must be associated with an explicit authority locus: a named institutional role, a defined scope, and a set of conditions under which the claim may be treated as actionable. If authority cannot be located, the claim cannot be stabilized.

This does not require prohibition. It requires traceability. Authority must be findable in order to be constrained. In this way, ACP directly counters the structural drift identified in Failure States #1 and #2.

Interfaces are treated as governance surfaces

ACP does not treat interfaces as neutral delivery mechanisms. It treats them as governance surfaces.

Placement, tone, default visibility, and summarization are recognized as regulatory acts because they shape interpretation before deliberation occurs. Under ACP, interface design decisions that affect claim salience or sufficiency are subject to the same governance expectations as formal policy choices.

This has practical consequences. A single synthesized answer positioned as sufficient requires a different authorization regime than a list of sources. A summary that replaces primary documentation triggers different governance obligations than one that merely accompanies it.

By naming interface design as a site of governance, ACP brings into view what the failure states show repeatedly: that interpretation is being governed whether anyone acknowledges it or not.

Compression is treated as a risk-bearing intervention

ACP does not assume that summarization is benign.

Compression is recognized as a risk-bearing intervention whose effects depend on context, domain, and population. Rather than asking whether a summary is accurate, ACP asks what has been removed, for whom, and with what consequences.

Under ACP, compressed claims must carry metadata about their scope, lossiness, and intended use. More importantly, there must be explicit rules governing when compression may substitute for judgment and when it may not.

This reframing addresses Failure State #3 directly. Harm arising from reassurance, omission, or flattened severity is no longer incidental; it is a foreseeable risk that must be governed upstream.

Bias is governed structurally, not morally

The failure states make clear that bias often enters through omission rather than distortion. ACP responds by governing process rather than intent.

By requiring explicit articulation of what a claim excludes, ACP makes attenuation visible. By tying claim scope to authority, it prevents summaries from silently inheriting normative force they were never authorized to carry.

This does not eliminate bias. It makes bias contestable. In doing so, ACP addresses Failure State #4 not by promising neutrality, but by refusing invisibility.

Distributional effects are surfaced, not averaged away

ACP explicitly rejects aggregate performance as a sufficient metric of success.

Claims are evaluated not only for correctness, but for distributional impact: who is reassured, who is burdened, who must exert additional effort to contest or comply. This shifts governance attention from averages to asymmetries.

Under ACP, a claim that appears acceptable in the aggregate but systematically disadvantages a subset of users cannot be treated as neutral. Distribution becomes a first-order governance concern.

This responds directly to Failure State #5, which shows how uneven harm allows systems to persist without unified resistance.

Governance must bind behavior, not signal concern

ACP distinguishes sharply between documentation and enforcement.

Statements of intent, ethical principles, and future safeguards are treated as non-governing artifacts unless they are coupled to mechanisms that bind action. Delay, under ACP, is not neutral; it is a governed state that must itself be authorized.

This reframing challenges the pattern described in Failure State #6. Visibility without constraint is not governance. It is performance.

ACP requires that claims be withdrawable, pausable, or bounded in real time when authorization conditions are unmet.

Responsibility follows authority, not exposure

Perhaps most importantly, ACP realigns responsibility with control.

Users may exercise judgment, but they are not held responsible for contesting claims whose authority has already been stabilized. Professionals may review outputs, but they are not accountable for system behavior they cannot meaningfully govern. Moderators may respond to incidents, but they are not the locus of responsibility for system design.

Under ACP, responsibility attaches where authority resides. If authority cannot be located, responsibility cannot be displaced. This directly counters Failure State #7 and removes the stabilizing function of downward blame.

ACP is not a solution; it is a constraint

ACP does not promise safer AI in the abstract. It does not optimize for innovation, speed, or adoption. It does not offer moral reassurance.

What it offers is a way to prevent claims from becoming actionable by default.

By forcing authority, scope, and contestability to be articulated before deployment, ACP changes the conditions under which systems operate. Some claims will become harder to make. Some interfaces will lose their apparent neutrality. Some deployments will slow.

The Guardian articles document what happens when governance is absent where power is exercised. ACP is designed to make that absence explicit, and to refuse to fill it with performance, delay, or misplaced responsibility.

Whether institutions choose to adopt such a protocol is a separate question. What the failure states make clear is that without something like it, the system we have will continue to behave exactly as it has.