§3.5 When Controls Become a System
As governance mechanisms accumulate, they become control machinery: the constraints, sensors, and gates through which the environment governs agentic work. The machinery can fail even when every individual control is reasonable. Controls may impose incompatible demands, interfere with one another, outlive their purpose, or leave important obligations uncovered.
Figure 3.5-1 shows three ways to examine this machinery. A catalogue identifies the controls and their purposes; an interaction graph relates controls through the resources they access; and a coverage view compares the controls with independently established engineering obligations. The views share control identities but answer different questions. Maintaining them requires recording where each control acts, which resources it accesses, and what justifies its existence.
3.5.1 Model Interactions Between Controls
The squash rule and diff-size guard in Figure 3.5-1 both act on the commit set. If a task’s changes exceed the size limit for a single commit, neither order of execution can satisfy both requirements.
The interaction graph uses controls as nodes and shared resources as the principal join key. A resource may be ordinary — a lock, a file, a commit-set, a deployment slot — or operational, such as a lifecycle event or a context budget. Controls need not call one another to interact; they only need to make potentially incompatible demands on the same modeled resource.
A shared resource is a conservative signal of interaction, not proof that every conflict has been captured. Within the represented surface, it lets engineers and tools ask useful questions before the controls interact in production work: which controls fire on this event, which touch this resource, which pairs have no declared order, and which known combinations impose incompatible requirements.
Some candidate conflicts can be evaluated mechanically, such as a cycle in declared ordering requirements. Others need judgment. A static check can show that two controls touch the same commit set; a validator or human reviewer must determine whether their requirements conflict. The graph exposes the interaction for evaluation before it disrupts work. Conflicts can arise from incompatible obligations or from mechanisms that interfere while enforcing compatible obligations. The first requires reconsidering the requirements or specification. The second may be resolved by changing the mechanisms or their interaction without weakening either obligation.
DocAble’s implemented interaction analysis covers one class of interaction: potentially conflicting access to a shared resource. I adopted an interaction model borrowed from concurrency control’s read/write conflict test 1.1. Philip A. Bernstein and Nathan Goodman, “Concurrency Control in Distributed Database Systems,” ACM Computing Surveys 13, no. 2 (1981): 185–221, https://people.eecs.berkeley.edu/~brewer/cs262/concurrency-distributed-databases.pdf. For each governance mechanism, the model records when it executes and which resources it reads or writes. Two mechanisms running at the same event have a potential conflict if they access the same resource and at least one writes it. For example, a post-commit code-style formatter writes a file that a subsequent checker reads. If the checker must inspect the formatted result, it must run afterward. The conflict graph identifies such interactions; the governance model records their resolutions.
Case studyWorked inset — DocAble: When Controls Compete for Context
Two DocAble hooks share a finite context budget at the end of an agent turn. In Claude Code (as of 2026), lifecycle hooks run configured checks at defined events and can prompt an agent to continue working when it tries to stop 2.2. Anthropic, “Automate Actions with Hooks,” accessed November 8, 2026, https://code.claude.com/docs/en/hooks-guide. The first, recurring failure, prompts Claude to reflect on notable failures or repeated issues in its recent history that might warrant conversion into durable governance mechanisms (§3.4), either through human review or autonomous follow-up. The other, stranded work, prompts the orchestrator to compare the subagent’s completed and landed work against its original brief to identify work that may have been lost. Both consume context, and the stranded-work inspection may exhaust the remaining context window before recurring-failure reflection can complete its analysis. Each hook is useful independently, but their order matters. The governance model therefore requires the recurring-failure hook to run before the stranded-work hook.
The governance graph records conflicts and their resolutions, including ordering, merging mechanisms, separating execution points, or accepting an interaction. Topological sorting computes a sequence from the declared ordering constraints and reports cycles; a separate check compares the governance model with the configured mechanisms.
The hook interaction also illustrates a limit of the simple read/write model I adopted for DocAble. The stranded-work inspection can exhaust the context needed by recurring-failure reflection. This is a resource-consumption dependency rather than an ordinary read/write conflict. DocAble does not model that distinction separately; the required order is recorded directly. Read/write conflicts are one way to discover interactions, not a complete account of them. The broader engineering question is whether one mechanism can interfere with another’s ability to fulfill its obligation. Larger engineering environments may benefit from modeling resource dependencies explicitly, particularly when several mechanisms compete for limited context, time, or execution capacity.
The squash rule and diff-size guard expose a different limit of read/write analysis. Both checks may only read the commit set, so the conflict test can miss incompatible obligations. Resolving that conflict requires revisiting what the checks demand.
3.5.2 Trace Obligations to Mechanisms
To find an uncovered obligation, start from the obligations engineers expect the environment to govern. An inventory assembled from existing controls alone would omit any obligation for which no control was built.
Tracing in both directions yields two findings:
- Coverage gap. A consequential obligation for which the intended evidence or enforcement is not adequately supplied.
- Orphan. A mechanism that no longer traces to a current obligation, failure class, or documented purpose. An orphan is a finding to reconcile, not proof that the mechanism should be deleted.
3.5.3 Add, Reconcile, and Retire Controls
Governance conversion and coverage auditing provide complementary pressures. Conversion adds durable structure when experience exposes a recurring gap; coverage auditing finds controls that are missing, redundant, or obsolete. The audit can therefore lead to consolidation or retirement.
The control model must remain connected to the controls it represents. An entry can identify the script or configured permission that implements a control, while a correspondence check reports missing or unrecognized targets. The check should expose a gap in the relation rather than silently treating an unmatched control as covered. This applies the broader rule from Chapter 2: a model of the engineering environment must stay connected to the machinery that engineers and agents use it to reason about.
Do not recursively govern every relation merely because it can be modeled. Extend the control model only when a recurring engineering question or observed failure justifies the added machinery.
The worked control-machinery model is grounded primarily in the originating case. Its broader value is a hypothesis for other engineering environments: the catalogue, interaction, and coverage views provide concrete questions to test when a growing set of controls becomes difficult to manage.
Preserve Engineering Freedom
Alignment must preserve two kinds of freedom. The first is freedom of implementation: which acceptable realizations remain available after obligations are enforced. The second is freedom to extend the engineering environment: whether additional controls can coexist with those already installed. The realization-space model in §3.3 addresses the first question; the governance graph addresses the second.
Agents may explore implementation alternatives without being authorized to merge, deploy, or otherwise commit them. The engineer decides which choices remain open and which require stronger control. The same judgment applies to the engineering environment itself: adding a control may prevent one failure while interfering with mechanisms already in place.
Modeling and Alignment are therefore not one-time design activities. As engineering work proceeds, new evidence can change what engineers understand about the system, which obligations matter, and how those obligations should be enforced. The models and controls must change accordingly.
Chapter 4 follows that process in practice. Rather than examining models and mechanisms individually, we will see how they are introduced, revised, and combined as an engineering problem unfolds.
Works Cited
- Bernstein, Philip A., and Nathan Goodman. “Concurrency Control in Distributed Database Systems.” ACM Computing Surveys 13, no. 2 (1981): 185–221. https://people.eecs.berkeley.edu/~brewer/cs262/concurrency-distributed-databases.pdf.
- Anthropic. “Automate Actions with Hooks.” Accessed November 8, 2026. https://code.claude.com/docs/en/hooks-guide.