Resourced Authority A Mechanism-Design Model for Participatory Governance of Deployed AI Agents

Overview§

This paper presents a formal mechanism design framework for continuous participatory governance of deployed AI agents. The core innovation is to treat compute as the governance lever: stakeholder contributions are aggregated into a binary authorization that releases a metered compute budget, enforced in hardware via signed licenses.

Formal Model§

Stakeholders arrive sequentially and contribute $c_i \in \mathbb{R}$ in a governance currency (positive for provision, negative for rejection). Contributions are breadth-weighted and summed into net support:

$$ S_t = \sum_{i \le t} w_i c_i $$

where $w_i$ reflect the verifier's stake or breadth. A two-threshold gate with hysteresis converts $S_t$ into a binary authorization state $H_t \in \{0,1\}$:

$$ H_t = \begin{cases} 1 & \text{if } H_{t-1}=0 \text{ and } S_t \ge \tau_{\rm on} \\ 0 & \text{if } H_{t-1}=1 \text{ and } S_t \le \tau_{\rm off} \\ H_{t-1} & \text{otherwise} \end{cases} $$

The authorization state maps to a compute budget via a coupling function $B_t = g(H_t)$, bounded by an exogenously certified safety ceiling $B_{\max}$: $0 \le g(0) \le g(1) \le B_{\max}$.

Implementation Sketch§

The mechanism is realized by running the agent in trusted hardware that enforces signed compute licenses. When $H_t$ transitions to 1, the hardware mints a license for $B_t$ compute units; when $H_t$ transitions to 0, the license is revoked. This makes the decision self-enforcing: the agent physically cannot exceed its authorized compute, so it has no incentive to disobey.

The following Python snippet simulates the hysteresis gate:

class HysteresisGate:
    def __init__(self, tau_on, tau_off, B_on, B_off):
        self.tau_on = tau_on
        self.tau_off = tau_off
        self.B_on = B_on
        self.B_off = B_off
        self.H = 0
        self.S = 0

    def contribute(self, w, c):
        self.S += w * c
        if self.H == 0 and self.S >= self.tau_on:
            self.H = 1
        elif self.H == 1 and self.S <= self.tau_off:
            self.H = 0
        return self.compute_budget()

    def compute_budget(self):
        return self.B_on if self.H else self.B_off

Key Insights§

Hysteresis prevents authorization oscillation and gives stakeholders a persistence period. Separating governance currency from compute ensures decisions reflect social preference rather than resource arbitrage. The paper characterizes the class of agents governable under this mechanism and identifies manipulation of the governing electorate by the governed agent as the central open problem, introducing several specific challenge directions for future work.