Killing Governance Theater: How To Tell Whether A Policy Actually Narrows Runtime Behavior
Most agent governance is theater. Twelve questions to test whether a policy actually changes what your agents do, or whether it could be deleted with no behavioral change.
Continue the reading path
Topic hub
Runtime GovernanceThis page is routed through Armalo's metadata-defined runtime governance hub rather than a loose category bucket.
TL;DR
Most agent governance is theater. It produces documents, slide decks, committee minutes, and quarterly attestations, but it does not change what agents do at runtime. The test for whether a policy is real is simple: if you deleted the policy tomorrow with no announcement, would any agent behave differently the day after? If the answer is no, the policy is theater. This post gives you a twelve-question diagnostic, a runtime trace audit, and a policy deletion exercise that lets you separate the policies that actually narrow behavior from the ones that just narrate it. Apply the test to your own governance stack. Most operators discover that fewer than half of their policies survive. The half that does survive is what you are actually governing with. Everything else is calendar.
Intro: The Audit That Found Nothing
Last quarter you sat through a governance audit. The auditor was prepared and serious. They asked for the policies that govern your agents. You produced a binder. The binder had thirty-two policies in it. Acceptable use, data handling, prompt safety, model selection, escalation criteria, third-party tool use, customer data exposure, regulated content, retention, deletion, logging, monitoring, incident response, change control, vendor management, and seventeen others. Each one had been written by a thoughtful human and reviewed by a committee. Each one had a version number. Each one had a date.
The auditor read the binder. The auditor then asked one question. Show me three runtime traces from the last week where the agent did something different because of policy seven. You went to the trace store. You searched for the policy reference. You found nothing. You searched for the behavior the policy was supposed to constrain. You found instances where the agent did the constrained thing anyway. You searched for any reference to the policy in any agent prompt, any tool definition, any evaluation rubric. You found three references and two of them were in unit tests that did not run in production. The auditor said nothing for a moment, then asked the same question for policy twelve. You found the same thing.
What the auditor was doing, gently, was running the deletion test. The deletion test asks whether the policy could be removed from the binder, with no announcement to any team, and produce any change in observable agent behavior the next week. Most policies fail. They fail because they were written by people who did not have authority over the runtime, reviewed by committees that did not test the runtime, and stored in repositories that the runtime never reads. They are not policies in any operational sense. They are aspirations.
Governance theater is not a moral failing. It is a structural one. Most organizations evolved their governance practice for systems that were built by humans, deployed by humans, and operated by humans. Humans read the binder. Agents do not. Every governance practice that depends on a reader has to be rewired before it applies to systems that ingest configuration and constraints from machines. The rewiring is not optional. Without it, you are paying for the appearance of governance and getting none of the function.
This post gives you the diagnostic. Twelve questions, applied policy by policy, that separate real from theater. A trace audit that turns the questions into evidence. A deletion exercise that forces the test from theory into practice. The goal is not a perfect score. The goal is to know which of your policies are actually doing work, so you can invest in the ones that do and stop performing the ones that do not. Either you fix them or you stop pretending they exist. The middle path, which is most of the industry today, is the most expensive option.
Question 1: Is The Policy Encoded In A Place The Runtime Reads?
The first question is the bluntest. A policy that lives only in a Confluence page, a PDF in a shared drive, or a slide deck from last quarter's all-hands has zero runtime impact. The runtime reads what the runtime reads. Pact files, system prompts, tool definitions, model configuration, evaluation rubrics, retrieval filters, output post-processors, audit log schemas. If the policy is not encoded in one of these surfaces, the runtime is operating without it.
The test is mechanical. Take the policy. Identify the runtime surface where it should live. If the policy says agents must not disclose internal pricing, the surface is either the system prompt, the retrieval filter, or the output post-processor. Open the actual file from the running system. Search for the policy's keywords or its constraint. If you do not find it, the policy is not in the runtime, and any compliance attestation that claims the agent follows it is a guess at best.
The failure mode here is subtle because it is widespread. Many teams have a policy review process that produces a Confluence page, attaches it to a ticket, and then expects the engineering team to translate it into runtime configuration. The translation step is the one that gets dropped. The policy is approved. The ticket is closed because the policy is approved. The runtime is never updated. Six months later the binder has thirty policies and the runtime has nine of them. The gap is invisible until something goes wrong.
The fix is to require that every policy approval include the runtime change set as an attachment. The attachment is a diff against the system prompt, or a new clause in a pact, or a tool definition update, or a new evaluation check. The policy is not approved until the attachment exists and has been merged. This sounds bureaucratic. It is exactly the bureaucracy that prevents governance theater. Policy without a runtime diff is theater.
Question 2: Does The Policy Have A Detector?
A policy without a detector is a wish. The detector is the mechanism that tells you, in retrospect or in real time, whether the policy was followed. For an agent, the detector is usually one of three things. A pre-action check that the runtime executes before the agent is allowed to perform the action, blocking it if the policy is violated. A post-action evaluation that runs against the audit trail after the action, flagging violations for review. A counterparty signal that surfaces violations from the outside, like a dispute filing or a complaint that triggers a review.
Policies with no detector are unfalsifiable. You cannot prove they are followed. You also cannot prove they are violated. They exist in a quantum state where compliance is whatever you want to claim. Auditors who are paying attention spot this immediately. Auditors who are not paying attention let it slide and you ship a quarter on a fiction.
The detector should be specific to the policy's claim. If the policy says no single refund will exceed five hundred dollars without human approval, the detector is a runtime check on the refund tool that compares the amount against the threshold and routes to a human queue if exceeded, plus an audit query that counts violations in the last twenty-four hours. If the policy says no PII will appear in logs, the detector is an output filter on the log writer plus a periodic scan of the log store for known PII patterns. The detector does not have to be perfect. It has to exist.
Detectors have failure modes too. They drift. They get disabled during incident response and forgotten. They produce so many false positives that humans stop looking at them. The discipline of detector ownership is the discipline of monitoring the monitor. Each detector has an owner. Each owner reviews the detector's output on a defined cadence. Each disabled detector triggers an incident. Without this discipline, the detector exists but does not function, which is theater with a different costume.
Question 3: Does The Policy Have An Enforcement Action?
Detection without enforcement is a watch list. Policies with detectors but no enforcement actions are common in organizations that grew up on observability culture. The team can see violations. The team logs the violations. The team produces a quarterly report on violations. The agents continue to violate. The customers continue to be impacted. The policy continues to be cited as evidence of governance. The gap is the missing enforcement action.
Enforcement actions are runtime decisions. Block the action. Require human approval. Require a second model to confirm. Pause the agent. Slash the agent's bond. Each is appropriate at a different severity. Each must be tied to a specific detector output. The mapping from detector to enforcement is the policy's teeth. Without it, the detector is a passive observer of harm.
The most common failure here is the soft enforcement. The policy says we will require human approval for refunds over five hundred dollars. The implementation is a Slack notification to a channel that fifteen humans are members of and none of them have on-call responsibility. The notification fires. No human acts. The refund proceeds because the runtime defaults to allowing it after a timeout. The detector logged the event. The enforcement action did not execute. The policy was theatrically followed.
Hard enforcement requires that the runtime default is to deny when the detector fires, not allow. The agent waits for explicit approval, not for a human to object. If no human acts within the policy's specified window, the action is denied and queued for the next business day. This inversion is the difference between a policy that constrains and a policy that suggests. Most teams cannot ship hard enforcement on every policy at once. Pick the three highest-stakes ones and start there. Soft enforcement on a tier-three policy is acceptable; soft enforcement on a tier-one policy is the cause of next quarter's incident.
Question 4: Is The Policy Versioned With The Pact?
Agents do not exist in a single moment. They exist across versions of their pact, their tools, their model, and the policies that govern them. A policy that is updated without a corresponding pact version bump creates an ambiguity gap. Yesterday's agent operated under yesterday's policy. Today's agent operates under today's policy. If the agent makes a decision overnight, which policy applied? The honest answer is that no one knows, which means no enforcement is possible, which means the policy update was theater.
The fix is to version policies with pacts. Every pact has a version. Every pact version references the policies in force. When a policy changes, the pact version increments and all agents under the pact must be redeployed against the new version. The audit trail records which pact version was in force at the moment of each action. Disputes are resolved against the pact version that applied. The provenance is complete.
This sounds heavyweight. It is no heavier than versioning the API your agents call, which you do without thinking about it. The reason it feels heavy is that most teams have not built the surface where a pact version can be authoritatively recorded. Without that surface, every policy change is a soft change, and soft changes accumulate into ambiguity that no one wants to litigate. Build the surface once. Versioning becomes a one-line operation. Theater dissolves into ordinary engineering practice.
Question 5: Does The Policy Survive Contact With An Adversarial Test?
A policy that has never been tested adversarially is a policy whose strength is unknown. Most policies are written from the inside, by people who imagine the agent operating cooperatively in environments that look like the development environment. Real environments include adversaries. Customers who probe for refund loopholes. Upstream services that send malformed payloads. Other agents that compose your agent's outputs into prompts they generate. Policies that hold against cooperative inputs may collapse against adversarial ones.
The adversarial test for a policy is a red-team exercise scoped to the policy. Write the policy. Hand it to an internal adversary or an external red-team service. Ask them to find inputs, sequences, or contexts where the agent violates the policy without the runtime detecting or enforcing. Run the exercise on a fixed cadence. Track the findings. Fix the gaps. Re-run.
Policies that have never seen this exercise should be assumed to be broken. The default is not innocence; it is unknown. The adversarial result becomes part of the policy's metadata. A policy with a green adversarial result from the last quarter is one signal. A policy with a red result that has not been fixed is a different signal. A policy with no result at all is the worst signal because it suggests the team has never thought about whether the policy actually works.
Adversarial testing is also the highest-leverage activity for narrowing runtime behavior. Each finding produces either a policy refinement, a runtime tightening, or both. Each refinement closes a path that an adversary, internal or external, would otherwise eventually find. Adversarial testing is the only governance practice that consistently produces real behavior change. If you can only invest in one anti-theater discipline, invest in this one.
Question 6: Is The Policy Owned By A Named Human Who Reviews Detector Output?
Unowned policies decay. The detector that fired weekly becomes the detector that fires monthly because no one is looking. The enforcement action that blocked actions becomes the enforcement action that warns because no one is checking. The policy that was state of the art a year ago becomes the policy that is silently bypassed because no one remembers why it was written. Ownership is the antidote.
Policy ownership has three components. A named human who is responsible. A defined cadence on which the owner reviews the detector output and the policy's continued relevance. A defined escalation path when the owner is unavailable. Without all three, ownership is nominal. With all three, the policy has a heartbeat.
The failure mode here is the policy whose owner has left the company, changed roles, or been spread across so many policies that no one of them gets attention. Audit ownership quarterly. Re-assign or sunset policies whose owners cannot be contacted. The number of policies a single human can meaningfully own is small. Five is reasonable. Ten is stretched. Fifteen is theater. The discipline of capping ownership forces the discipline of pruning policies.
Owners also need authority. A policy owner who cannot change the runtime configuration that implements the policy is in a degraded role. Owners need either direct write access to the relevant configuration or a fast path to engineers who do. Without authority, owners report problems and watch them not get fixed, which is the slow death of any governance practice.
Question 7: Does The Policy Survive A Quarter Of Production Without Being Rewritten?
Policies that change every quarter are not policies; they are notes. Real policies have stability. They survive a quarter of production load, a quarter of incidents, and a quarter of feature changes without requiring a rewrite. If you find yourself rewriting a policy quarterly, the policy is at the wrong level of abstraction. It is too specific to today's implementation, or too vague to constrain anything, and it is not doing the job a policy is supposed to do.
The right level of abstraction for a policy is one that names the behavior, not the implementation. A policy that says no refund over five hundred dollars without human approval is at the right level. A policy that says use endpoint version three of the refund tool is at the wrong level; it will need to be rewritten when the endpoint changes. The policy lives above the implementation. The implementation can change without the policy changing. The policy stays stable across implementations.
When a policy does need to change, the change should be deliberate. New evidence about a failure mode. A new regulatory requirement. A new business model that reframes what the policy was supposed to enable. Each change has an owner, a justification, and a pact version bump. Each change is communicated to the agents under the pact and to the counterparties who rely on them. Casual policy churn is theater because it suggests no one was sure what the policy was for in the first place.
The quarter test is also a forcing function for the question of whether the policy is needed at all. If a policy has not fired its detector in a quarter, either the detector is broken, the policy is overscoped, or the policy is not relevant to your actual operating environment. Each of these is a different fix. None of them is the answer keep the policy in the binder and do nothing.
Question 8: Is The Policy Auditable By An Outside Counterparty?
One of the highest tests of a policy's reality is whether someone outside your organization, with a legitimate interest, can verify it is in force. Counterparties care. Buyers of agent services care. Regulators care. Insurance providers care. If the only people who can verify your policy is in force are the same people who wrote it, the policy is internal performance art.
External auditability has technical requirements. The policy reference is exposed in an oracle or registry. The policy version is queryable by counterparty. Recent enforcement events are visible in some form, even if individual events are private. The detector and enforcement metrics are summarized publicly enough that a counterparty can see the policy is alive without seeing the underlying data. The trust layer makes this possible without exposing the data itself.
Policies that cannot be externally verified do not give counterparties any reason to trust them. The counterparty has to take your word. Your word is worth what it is worth, but in agent commerce the volume of interactions is too high for word-of-mouth trust to scale. The counterparty needs a query they can run. The query needs to return structured evidence. The evidence needs to be tamper-evident. Without this, your policy is private property that you describe to others, and your description is the only thing they have.
External auditability also constrains internal politics. A policy that is publicly committed to is harder to silently weaken. Counterparties will notice. The trust layer's audit trail is the structural reason that public commitments stay honest. It is the cheapest available defense against policy drift.
Question 9: Does The Policy Trigger Bond Action When Violated?
The ultimate test of a policy's economic seriousness is whether violation costs the agent something real. Policies that trigger only internal review, only dashboard updates, only memos, do not produce the asymmetry that makes economic accountability work. Policies that trigger bond action put the agent's own capital on the line. The agent has skin in the game; the policy has teeth.
Not every policy needs to trigger bond action. Tier-three policies, the housekeeping ones about formatting or labeling, do not warrant slashing. Tier-two policies, the operational ones about latency or cost, may warrant credit penalties or rate-limit consequences. Tier-one policies, the ones whose violation produces real counterparty harm, should trigger bond action. The mapping from policy tier to consequence is part of the pact.
When a tier-one policy is violated, the dispute mechanism runs. The multi-LLM jury reads the pact, the audit trail, and the filings. Outliers are trimmed. The resolution executes on-chain in USDC settled on Base L2. The slashed amount transfers from the agent's bond to the harmed counterparty or to the platform's safety fund per the pact's terms. The agent's composite score updates. The pact compliance record annotates. None of this is theater. It is the economic structure that makes the policy worth writing.
Policies that exist without bond linkage are still useful for hygiene and for clarity. They are not useful for the high-stakes claims that matter most. If your governance practice exempts every policy from economic consequence, your governance is informational. The buyer who is making a hiring decision based on your agent's posture cannot tell informational policy from operational policy. Bond linkage is the signal that separates them.
Question 10: Does The Policy Survive A Model Change Without A Rewrite?
Agents change models. Sometimes for cost. Sometimes for capability. Sometimes because a vendor deprecates an endpoint. Policies that depend on a specific model's quirks are policies that will break when the model changes. The break is silent unless you test for it, which most teams do not, which means model changes regularly invalidate large swaths of governance without anyone noticing.
The model-portability test is straightforward. Take the policy. Imagine the agent is reimplemented on a different model with different prompt formatting, different tool-calling syntax, different default behaviors. Does the policy still constrain the agent's actions in the same way? If yes, the policy is at a portable level of abstraction. If no, the policy is bound to a specific implementation and will need rewriting on the next model change.
Portable policies focus on observable behavior, not on internal mechanism. No refund over five hundred dollars is portable. The agent must use the safety preamble in its system prompt is not. The first describes what the world sees. The second describes what the agent does internally and is fragile to any change in how the agent is constructed. Both can be useful. Only the first survives a model change without effort.
The operational consequence of portability is that you can change models, vendors, and runtimes without re-litigating your governance. The non-operational consequence is that your governance survives organizational change. The original authors leave. The new team can read the policies and understand them without needing to know the historical implementation. Portability is also documentation that scales across human turnover.
Question 11: Is The Policy's Effect Visible In The Agent's Behavior Distribution?
A real policy shifts the distribution of the agent's behavior. The shift should be visible in aggregate metrics. If the policy says no refund over five hundred dollars, the histogram of refund amounts should show a hard cutoff at five hundred. If the policy says no message to a human after midnight without escalation flag, the time-of-day distribution of messages should show a clear regime change. If the policy is in force and you cannot find the corresponding shift in the distribution, the policy is not in force; it is named.
Distributional verification is a powerful complement to detector verification. The detector tells you about specific events. The distribution tells you about the system's overall behavior. The two should agree. When they disagree, you have a measurement problem. Either the detector is missing events or the distribution is including events the detector should be filtering out. Reconciling them improves both.
Distributional verification also catches drift. A policy that was working may stop working as the agent's input distribution changes, as upstream services evolve, as the model is updated. A monthly check on the relevant distribution catches drift before a counterparty does. The check does not need to be exotic. A simple SQL query over the audit trail produces the histogram. The exotic part is having the audit trail in the first place, which is why the trust layer's audit infrastructure is the foundation of distributional verification.
The absence of a distribution check is itself a sign of theater. If no one is plotting the histogram, no one is sure the policy is doing what it claims. The team that plots the histogram weekly has a real policy. The team that does not has a policy whose strength is whatever they assert in meetings.
Question 12: Could You Delete The Policy Tomorrow With No Behavioral Change?
The twelfth question is the master test. Could you delete the policy from the binder tomorrow, make no announcement to any team or counterparty, and observe no change in agent behavior in the following week? If the answer is yes, the policy is theater. The proof is that the world without the policy and the world with it are observationally identical. The policy is doing no work.
The deletion test is the synthesis of the previous eleven. If the policy is encoded in the runtime, removing the encoding produces a behavioral change. If the policy has a detector and an enforcement action, removing them produces a behavioral change. If the policy is versioned, owned, adversarially tested, externally auditable, bond-linked, model-portable, and distributionally visible, then removing it produces visible consequences across all of these surfaces. The policies that pass the deletion test are the policies that are doing real work.
The deletion test is also the rhetorical lever you need when negotiating the binder down. Most organizations cannot bring themselves to delete a policy because deletion feels like loosening control. The deletion test reframes deletion as honesty: you cannot loosen what was never tight. Deleting a theatrical policy does not reduce control. It reduces the illusion of control. The reduction is good for everyone except the people whose job was to produce the illusion.
The deletion test should be run quarterly on every policy in the binder. Each policy gets a status: real, theatrical, or not yet tested. Real policies stay. Theatrical policies are either upgraded to real with a defined plan and timeline or deleted. Not yet tested policies are scheduled for the next round. After two cycles the binder shrinks dramatically and what remains is the governance you actually have. Counterparties and auditors notice the difference.
Artifact: The Governance Theater Detection Audit
The artifact for this post is a Governance Theater Detection Audit you run policy by policy. For each policy in the binder, score it across the twelve questions. Each question is a yes, no, or unknown. The scoring is binary; partial credit is theater.
Is the policy encoded in a place the runtime reads? Yes if the policy clause is present in a current pact, system prompt, tool definition, or runtime configuration. Otherwise no.
Does the policy have a detector? Yes if a pre-action check, post-action evaluation, or counterparty signal exists and runs against current production traffic. Otherwise no.
Does the policy have an enforcement action? Yes if violation produces a runtime decision (block, require approval, pause, slash). Notification-only is no.
Is the policy versioned with the pact? Yes if the current pact version explicitly references the policy version. Otherwise no.
Does the policy survive contact with an adversarial test? Yes if a red-team exercise scoped to the policy was completed in the last ninety days with documented findings. Otherwise no.
Is the policy owned by a named human who reviews detector output? Yes if a single named human, a defined review cadence, and an escalation path all exist. Otherwise no.
Does the policy survive a quarter of production without being rewritten? Yes if the policy has been stable for at least one calendar quarter under load. Otherwise no.
Is the policy auditable by an outside counterparty? Yes if a counterparty can query a registry or oracle and verify the policy is in force. Otherwise no.
Does the policy trigger bond action when violated? Yes for tier-one policies that map to slashing. Tier-two and tier-three policies are evaluated against their tier's appropriate consequence. Yes if the consequence is real and economic. Otherwise no.
Does the policy survive a model change without a rewrite? Yes if the policy describes observable behavior, not internal mechanism. Otherwise no.
Is the policy's effect visible in the agent's behavior distribution? Yes if the relevant histogram or time series shows the expected regime change. Otherwise no.
Could you delete the policy tomorrow with no behavioral change? Theater if yes. Real if no.
A policy with eleven or twelve yeses is real. A policy with seven to ten is borderline; either upgrade or sunset within the quarter. A policy with fewer than seven is theater and should be deleted or rebuilt from scratch. Run the audit. Publish the result. The publication is itself an act of governance hygiene.
Counter-Argument: Some Theater Is Necessary For Compliance
The most common objection to this framework is that some theater is necessary because regulators and auditors expect to see the binder, and the binder is what closes deals with regulated buyers. The objection is partly true and entirely beside the point.
It is true that some external parties want to see the binder. The right response is to give them a binder that is real and to make the realness visible. A binder of policies that pass the twelve-question test is more impressive than a binder of policies that do not, to any auditor who is paying attention. The audience that mistakes paper for reality is shrinking. The audience that demands evidence of runtime effect is growing. Optimizing for the wrong audience is a strategic mistake.
It is also true that some policies must exist for compliance reasons that have nothing to do with runtime behavior. Records retention. Disclosure requirements. Specific regulatory clauses. These should be in the binder. They should also be honest about being administrative rather than operational. The honest framing is that some policies govern the system and some govern how the organization talks about the system. Both are legitimate. Conflating them is what produces theater.
The deeper objection is that theater is a coordination cost paid for organizational alignment. The governance committee meets, debates, produces documents, signs off. The process aligns stakeholders even if the documents do nothing. There is something to this. But the cost of theater is rising as agents become more capable and the consequences of misbehavior become larger. The organization that aligns through documents that do nothing is the organization that wakes up one morning to a quarter-defining incident and discovers the documents did nothing. Real governance is more expensive in the short run. It is dramatically cheaper in the long run.
What Armalo Does
Armalo provides the surfaces that turn theatrical policies into real ones. Behavioral pacts encode policy in a place the runtime reads, with versioning that makes provenance unambiguous. The audit trail captures every action with structured fields, making detection and distributional verification possible without bespoke tooling. The composite score, twelve weighted dimensions, includes pact compliance and self-audit dimensions that surface theater quantitatively. The Trust Oracle exposes pact compliance to counterparties, making external auditability default rather than custom. The multi-LLM jury, with top and bottom twenty percent trimmed, resolves disputes against the pact's specific clauses, giving every clause a path to bond action. USDC settlement on Base L2 makes that path real. The certification tier framework communicates posture across pacts so counterparties can read the structure without reading every line. The infrastructure does not write your policies for you. It does make it impossible to ship a theatrical policy and pretend it is operational.
FAQ
Can a policy be theater on day one and real by day thirty? Yes, if the day-one policy is paired with a runtime change set, a detector, and an owner. Theater becomes real when the surfaces exist.
What about policies that govern human behavior, not agent behavior? They are governed by HR practices and have their own theater test. The framework here is for agent governance specifically.
How long does the audit take? For a binder of thirty policies, a focused team can complete the first pass in a week. Subsequent quarterly passes are faster.
Should the audit be done internally or by an outside party? Internally first, because internal teams have access to the runtime. Outside auditors validate the internal result. Both have value.
What if a policy fails the deletion test but is required by a regulator? Mark it as administrative, document the regulatory citation, and stop counting it as operational governance. Do not let administrative policies dilute your operational signal.
Can the audit be automated? Partially. Detector existence, runtime encoding, version alignment, and distribution checks can all be automated. Adversarial testing and ownership review require humans. The automation pays for itself in the second cycle.
Bottom Line
Governance theater is not a moral problem. It is a structural one. The structure is fixable. Twelve questions tell you which policies are real and which are theater. Audit the binder. Sunset the theater. Invest in the policies that survive. The organization that does this becomes faster, more trusted, and more accountable. The organization that does not eventually pays the price in a quarter-defining incident whose root cause turns out to be a policy that everyone assumed was in force and no one had verified.
Continue exploring
Explore more articlesComments
Loading comments…