Alignment

Engineering systems differ in how they carry their obligations. Some remain in human expertise, documentation, or practice and must be interpreted when the relevant decision arises. Others are encoded into the engineered environment so that compliance can be evaluated or required mechanically. Software architecture provides one example: an architecture can state permitted dependencies and interactions, while conformance checks determine whether an implementation respects them 11. Gail C. Murphy et al., “Software Reflexion Models: Bridging the Gap Between Source and High-Level Models,” Proceedings of the 3rd ACM SIGSOFT Symposium on Foundations of Software Engineering (New York), 1995, 18–28, https://doi.org/10.1145/222124.222136. 22. Neeraj Sangal et al., “Using Dependency Models to Manage Complex Software Architecture,” Proceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (New York), 2005, 167–76, https://doi.org/10.1145/1094811.1094824. 3.3. Leonardo Passos et al., “Static Architecture-Conformance Checking: An Illustrative Overview,” IEEE Software 27, no. 5 (2010): 82–89, https://doi.org/10.1109/MS.2009.117. System-safety engineering provides a broader precedent, identifying hazards and constraints over the larger system and designing controls, feedback, and operating processes to keep those constraints satisfied 4.4. Nancy G. Leveson, Engineering a Safer World: Systems Thinking Applied to Safety (MIT Press, 2011). Software engineering uses mechanisms ranging from types and access controls to validators and deployment gates for the same purpose.

MAGE calls this move Alignment and treats it as the companion to Modeling. Chapter 2 showed how models can express architectural relationships, behavioral rules, and other engineering decisions while leaving implementation choices open. Alignment connects selected obligations from those models to mechanisms in the engineered environment. The objective is not to make agents follow instructions more faithfully, but to make satisfying those obligations less dependent on what an agent happens to do.

Key Ideas

Alignment Principle. Make selected engineering obligations enforceable through constraints that restrict actions or states, sensors that produce evidence, and gates that evaluate evidence and control whether work may proceed.

Figure 3.0-1 summarizes the arrangement. An engineering model may specify permitted dependencies, legal state transitions, resource bounds, or other properties that a realization must satisfy. Some obligations can be embodied directly in constraints. Types, permissions, and narrow interfaces restrict which actions or states are available, preventing selected violations rather than detecting them afterward. These restrictions can govern the tools an agent uses, the implementation it produces, or the behavior of the resulting system.

Other obligations require evidence about the work. Sensors obtain that evidence from artifacts, proposed actions, or executions. Static analysis can inspect source code, dependencies, and configuration without running the system; dynamic analysis can exercise the implementation and observe its behavior. Security testing provides familiar examples in static application security testing (SAST) and dynamic application security testing (DAST). Instrumentation, tests, and measurements provide other forms of evidence. The model supplies the properties against which the evidence can be evaluated, but obtaining evidence does not itself determine whether the work is acceptable.

Gates use evaluation results to control whether work may proceed. A merge gate may require passing static checks; a deployment gate may require evidence from tests or runtime measurements; an authorization gate may refuse an operation that lacks the required permission or provenance. The gate evaluates the applicable condition and permits or refuses passage. A failed check that merely produces a warning is not enforcement. Conversely, a constraint may enforce an obligation directly, without requiring a separate gate. These categories describe functions rather than necessarily separate tools: one mechanism may restrict an operation, evaluate a condition, and report the result.

Alignment from models to enforcement Engineering models supply selected obligations. One branch restricts agentic work through constraints; another supplies evaluation rules derived from modeled obligations. Sensors obtain evidence from the work. Gates use evidence, evaluation rules, and optional constraint-check results to admit work or refuse it for revision. Constraints can also enforce directly without a gate. Engineering Models Architecture · Behavior · Policy Selected Obligations Properties · Bounds · Rules Constraints Restrict actions or states (types, permissions, interfaces) Evaluation Rules Predicates derived from modeled obligations Agentic Work Proposed actions · Implementation Runtime behavior Sensors Obtain evidence from the work (SAST, DAST, instrumentation) Gates Use evaluation results to control whether work may proceed (merge, deployment, authorization) Admit Refuse / Revise Constraint /check result Alignment functions (constraints, sensors, gates) Models, work, decisions
Figure 3.0-1. Alignment from models to enforcement. Engineering models express obligations that the environment can enforce through constraints on actions or states, and through evidence evaluated at gates. Sensors obtain evidence from artifacts and executions, including through static and dynamic analysis. Gates can also require results from constraint checks. These functions may be combined in one mechanism; each governs only the obligations and evidence within its scope.

The arrangement separates implementation from the authority to accept it. Agents may choose algorithms, organize code, and explore alternatives within the freedom the models leave open. Constraints exclude selected actions or states, while sensors and gates allow the environment to evaluate and refuse work that violates selected obligations. The checks provide assurance only for the properties and cases they cover; passing them does not establish that every engineering requirement has been satisfied. Alignment therefore requires judgment about which obligations to enforce, what evidence is adequate, and where enforcement should occur.

Commodity intelligence makes this separation increasingly valuable. Agents can produce plausible implementations rapidly, including alternatives their engineers did not anticipate. Instructions can influence those implementations, but cannot guarantee that a particular obligation will survive. By encoding selected obligations into the environment, engineers can preserve decisions across successive agents and changes without relying solely on repeated interpretation. Some mechanisms can be established before work begins; others arise when failures expose missing representations, evidence, or enforcement. As the mechanisms accumulate, they become an engineering system that must itself be understood and maintained.

Works Cited

  1. Murphy, Gail C., David Notkin, and Kevin J. Sullivan. “Software Reflexion Models: Bridging the Gap Between Source and High-Level Models.” Proceedings of the 3rd ACM SIGSOFT Symposium on Foundations of Software Engineering (New York), 1995, 18–28. https://doi.org/10.1145/222124.222136.
  2. Sangal, Neeraj, Ev Jordan, Vineet Sinha, and Daniel Jackson. “Using Dependency Models to Manage Complex Software Architecture.” Proceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (New York), 2005, 167–76. https://doi.org/10.1145/1094811.1094824.
  3. Passos, Leonardo, Ricardo Terra, Renato Diniz, Marco Tulio Valente, and Nabor C. Mendonça. “Static Architecture-Conformance Checking: An Illustrative Overview.” IEEE Software 27, no. 5 (2010): 82–89. https://doi.org/10.1109/MS.2009.117.
  4. Leveson, Nancy G. Engineering a Safer World: Systems Thinking Applied to Safety. MIT Press, 2011.
© James C. Davis, 2026–present