Skip to content

§3.2 From Engineering Intent to Enforceable Obligation

Enforcement requires two things: an obligation independent of the work being judged and a boundary where the evidence needed to evaluate that obligation is available. The architectural model requires Reporting to obtain billing data through BillingAPI, preserving BillingDB behind that interface. The job-lifecycle model specifies how events move a job from IDLE through RUNNING to DONE or FAILED. These are accounts of intended construction and behavior against which an implementation can be evaluated.

The environment needs evidence that corresponds to those meanings. A dependency analysis can look for paths from Reporting to BillingDB that bypass BillingAPI; a model-based test can submit job events and compare the resulting states with the specified transitions. The engineer must choose where the relevant evidence becomes available and how the finding should affect the work. A check may inform a later decision, or a gate may use its result to refuse an action or candidate. The obligation can also reside directly in a type, permission, schema, test, or policy. What matters is that it is distinguishable from the implementation being judged and that a mechanism can enforce the resulting decision.

Once an obligation is explicit, engineers need to determine whether the implementation satisfies it. You may be familiar with this work from requirements traceability, which connects a requirement to relevant design elements, implementation, tests, and other evidence 1.1. Jeff A. Estefan, Survey of Model-Based Systems Engineering (MBSE) Methodologies, INCOSE-TD-2007-003-02 (International Council on Systems Engineering (INCOSE), 2008). These connections help engineers examine the design choices made to meet the requirement and find the evidence needed to evaluate the implementation. When a requirement or design changes, the links help identify which parts of the implementation and which checks need to be reconsidered.

Inset — Assurance Cases

In safety-critical engineering, an assurance case makes explicit why a system should be trusted. It connects claims about the system to supporting evidence through an argument explaining why that evidence supports the claims 23.2. ISO/IEC/IEEE, ISO/IEC/IEEE 15026-2:2022: Systems and Software Engineering — Systems and Software Assurance — Part 2: Assurance Case, International Standard (ISO, 2022), https://www.iso.org/standard/80625.html.3. Tim Kelly and Rob Weaver, “The Goal Structuring Notation: A Safety Argument Notation,” Proceedings of the Dependable Systems and Networks 2004 Workshop on Assurance Cases, 2004. This goes beyond requirements traceability. Knowing which tests correspond to a requirement does not establish that those tests adequately verify it.

Suppose DocAble claims to preserve document content during accessibility remediation. Comparing the text before and after processing provides some evidence, but is it sufficient? Text extraction might miss content in images, equations, or annotations. An assurance argument would identify these limitations, explain which additional checks address them, and state what remains unverified. Passing every available test does not establish a claim broader than those tests support.

Assurance cases help engineers justify why a system should be trusted. MAGE helps establish and preserve selected properties on which that justification depends.

If you work under a safety standard such as IEC 61508 or DO-178C, MAGE can complement your existing assurance process 45.4. International Electrotechnical Commission, IEC 61508-1:2010: Functional Safety of Electrical/Electronic/Programmable Electronic Safety-Related Systems — Part 1: General Requirements, International Standard (IEC, 2010), https://webstore.iec.ch/en/publication/5515.5. RTCA, DO-178C: Software Considerations in Airborne Systems and Equipment Certification, Standard (RTCA, Inc., 2011), https://www.rtca.org/do-178/. The claims and arguments in an assurance case can guide what you model, what you check, and what evidence you retain. Agents can help produce and maintain that evidence as the system evolves. The assurance case still needs independent scrutiny. Neither an agent’s report nor a passing check establishes that the overall argument is sound.

Traceability can connect an obligation, its realization, and its evidence without any mechanism enforcing the obligation. A requirement may trace cleanly to a test whose failure is merely reported. Conversely, a permission boundary may enforce firmly without a rich traceability model. Alignment therefore separates the relation among intent, realization, and evidence from the decision to enforce the resulting judgment.

Where an obligation permits variation, the acceptable region must likewise come from the engineering intent that governs the work. A measured implementation can establish what latency it achieved or what dependencies it contains; whether those values are acceptable requires an independent engineering obligation.

A description and the implementation it describes can therefore agree while both violate the intended property. Placement matters as well: if an obligation is enforced at a boundary too small to make it legible, the checker may inspect the wrong thing.

3.2.1 Agreement Is Not Correctness

A drift check can establish a declared correspondence between an engineering model and its implementation. It cannot establish that the correspondence expresses the right intent. Suppose an endpoint is required to be authenticated. If an independently authored policy says so, a check can compare the implementation against that obligation and flag an open endpoint. If instead the representation is derived only from the implementation, it may faithfully record the endpoint as open. Model and code agree; the security obligation is still violated.

The distinction is between description and independent obligation. A model extracted from code can supply the current is; an independently authored invariant can supply the governing ought. Authorship alone establishes neither role: a hand-authored model may merely repeat the implementation's assumptions, while a derived model can faithfully describe its present behavior. Enforcement requires an obligation against which the work can actually be wrong.

Drift checking therefore has a precise job: preserve a declared correspondence between model and implementation. If they diverge, surface the disagreement. Conformance asks whether the implementation satisfies an independent engineering obligation, which may be represented in that same model. Acceptance is a separate decision: the Governed Engineering Environment (GEE) determines whether the implementation may proceed, considering applicable controls and evidence beyond those associated with any one model.

Stronger verification does not remove this distinction. A proof assistant such as Lean checks proofs that formally stated propositions follow from their assumptions 6.6. Lean, “The Lean Language Reference,” accessed November 6, 2026, https://lean-lang.org/doc/reference/latest. TLA+ lets engineers specify system behavior; the TLC model checker can explore a model to check whether it satisfies stated properties 7.7. Leslie Lamport, Specifying Systems: The TLA+ Language and Tools for Hardware and Software Engineers (Addison-Wesley, 2002). Neither approach establishes that the chosen property captures the engineering requirement. If an agent chooses a property merely because its implementation satisfies it, a valid proof or successful model check may leave the intended obligation untested. Engineers can ask agents to help formalize requirements and develop proofs or checks while retaining responsibility for whether those requirements express what the system must preserve.

For example, an engineer can require a queueing service to bring every accepted job to a terminal state, then ask an agent to develop an analysis of that requirement. The agent may help formalize the obligation and construct the checker. What matters is that the obligation comes from what the service must do, rather than being chosen merely because the current implementation satisfies it.

Figure 3.2-1 shows these three judgments over one implementation. The engineering model is one part of the GEE, whose admission decision may depend on additional obligations and evidence.

Model agreement, obligation satisfaction, and admission The governed engineering environment contains an engineering model, its no-direct-database-access obligation, and an acceptance decision. Correspondence compares the proposed implementation with the model. Conformance compares the same implementation with the obligation. The implementation sits outside the environment and is submitted for acceptance under its controls and evidence requirements. GEE (Governed Engineering Environment) Models, controls, evidence, and admission One engineering model Engineering model Representation of the system One obligation: no direct database access Admission Required evidence Authorization Other admission conditions Correspondence Does the implementation agree with the model? Conformance Does the implementation satisfy the obligation? Acceptance Will the GEE permit the implementation to proceed? Implementation The realized system (code, configuration, etc.)
Figure 3.2-1. Model agreement, obligation satisfaction, and admission. Correspondence concerns agreement between an engineering model and its implementation; conformance concerns satisfaction of an independent obligation represented in the model. Acceptance is the GEE's decision to permit the implementation to proceed, based on applicable controls and evidence that may extend beyond the model shown. Evidence for one relation does not establish the others.

Worked Examples

Siemens. The Siemens reconstruction describes models, implementation, and engineering analyses kept in correspondence across a digital thread without making every disagreement a build-blocking event. In that account, a human confirms the bill of materials while physics solvers carry parts of the evaluation. The example is useful precisely because correspondence and gating are separate design choices: the coupling can hold without a hard gate deciding the instant the two diverge.

Case study

Worked inset — DocAble: A Model That Directs Work and a View That Describes It

DocAble repairs accessibility problems in Office and PDF documents through a sequence of computations. A DOCX table-header repair, for example, establishes information needed by a later table-structure check. The scheduler must preserve that dependency even though the two operations have separate implementations. An explicit computation model records such relationships. The scheduler reads the model to determine what is ready to run, while each computation’s implementation determines how it performs its work.** The computation model describes the pipeline rather than the history of any one remediation. Runtime telemetry can now be joined to computation identities for aggregate measurements such as latency and cost, but the per-session edit record still names realized document mutations rather than computation nodes. DocAble has not yet built a per-run execution graph joining that edit history to the computation model.

While building DocAble as a prototype, I asked several agents to develop support for different document formats concurrently. I wanted to know which parts of remediation the formats could usefully share. To judge that aright, I needed to learn how to work with each format myself. Once I had independent implementations, I asked agents to trace their computations and dependencies. Comparing the implementations revealed common patterns that we could capture in an explicit computation model.

We developed a separate Python graph to inspect those relationships. In the version examined here, it contained 125 computations and 57 typed relations: 32 data-flow edges, 24 control gates, and one cross-service relation. Fifty-five relations came from executable declarations; two were entered by hand. For Office formats, the graph derives dependencies from the registry’s read/write metadata, which the scheduler also uses. For PDF, it projects typed declarations of what computations produce and consume. The scheduler reads the computation model to order the work; the analytical graph lets us query and check those relationships.

An audit exposed a gap: a live Office pass ran outside the registry entries that the correspondence checks examined. The checks could therefore report agreement even though they had missed a computation. At the time, the PDF checks blocked changes that failed them, while the Office checks only reported discrepancies. Making the Office checks blocking at that point would still have let the unregistered pass through.

We followed the audit–drain–promote sequence described in §4.3. We brought the missing computations within the checks’ coverage, verified the checks against the repaired surface, and cleared the findings before making the Office checks blocking. Both format families now require their declared correspondence checks to pass at admission.

The case illustrates the three judgments in Figure 3.2-1:

  • Correspondence (model agreement). The parity checks establish whether the analytical graph agrees with its sources over the relationships they examine. The audit asked a different question: which live computations had they missed?
  • Conformance (obligation satisfaction). The scheduler must respect the computation model’s dependency order. Agreement between the graph and its sources does not establish that execution preserves that order.
  • Acceptance (permission to proceed). Once the Office checks became blocking, a discrepancy that previously produced an advisory finding could prevent admission. Promotion changed what happened to the finding; the earlier coverage repair changed what the checks could find.

Traceability can do more than help engineers locate the implementation of a modeled property. When model elements are linked to code and execution records, those relationships can be checked as the system changes. DocAble uses static references to connect model elements to implementation declarations and runtime traces that identify the modeled operations being executed. Static checks can detect when a referenced implementation element is deleted or renamed. Dynamic checks can compare observed operations with the model, revealing modeled operations that were not observed or executions that cannot be associated with a modeled element. These checks complement guidance mechanisms such as dynamic context injection (§3.1): agents can receive relevant model information while working, and the environment can independently check correspondence as the implementation changes.

The appropriate evidence depends on the model and the property being checked. Architectural models often admit static checks of dependencies, interfaces, and component boundaries. Behavioral models may require execution traces to establish which states or transitions actually occurred. These are not exclusive categories. Static analysis can check declared state-machine structure, while runtime instrumentation can expose architectural interactions that source-level checks miss. In each case, the traceability relationships make the relevant evidence available for comparison with the model.

These checks turn traceability relationships into Alignment mechanisms. A change that breaks a model–implementation relationship can produce a finding without requiring an engineer to rediscover the relationship manually. Static references establish that implementation elements still exist, while runtime traces provide evidence about their execution. Neither establishes that the implementation still behaves as intended, nor that the traceability relationships cover every relevant operation. Where the evidence is adequate, a gate can require the checks to pass before accepting a change.

3.2.2 The Semantic Gap

A second problem is placement. An obligation can be stated clearly and still be unenforceable at the boundary where you try to check it. The required evidence may span several changes, or the property may emerge only when components operate together. A semantic gap occurs when the chosen boundary does not expose enough information to decide whether the obligation holds. Figure 3.2-2 illustrates two such cases. Although both arise during software development, they require checks at different boundaries.

A footnote on where the placement rule comes from. It echoes the end-to-end argument in system design: a function that needs end-to-end knowledge cannot in general be implemented completely at a lower layer that lacks that knowledge 8.8. Jerome H. Saltzer et al., “End-to-End Arguments in System Design,” ACM Transactions on Computer Systems 2, no. 4 (1984): 277–88, https://doi.org/10.1145/357401.357402. Their setting was where to place functionality in a distributed system; the setting here is where to place enforcement over engineering work. The design instinct is the same — put the deciding mechanism where the semantics needed to decide the property are available.

The semantic gap: two obligations, two enforcement boundaries Two independent obligations use different boundaries on an illustrative sequence of three commits, build, deploy, and browser execution. An arrow from commit 3 points to model–implementation correspondence, validated at task completion. An arrow from browser execution points to rendered-page correctness, validated in an integrated execution. A bracket below the commits allows intermediate model disagreement. A separate bracket below build and deploy, excluding browser execution, states that earlier source, build, and API checks do not establish rendered-page correctness. Model–implementation correspondence Validate at task completion Rendered-page correctness Validate in an integrated execution (e.g., browser) TASK COMPLETION INTEGRATED EXECUTION commit 1 commit 2 commit 3 build deploy run (in browser) Intermediate disagreement with the model may be permitted Earlier checks (source, build, API) do not establish this obligation
Figure 3.2-2. The semantic gap. Different obligations become decidable at different boundaries. Model–implementation correspondence may be required at task completion even when intermediate commits legitimately disagree; rendered-page correctness requires an integrated execution that earlier source, build, and API checks cannot establish. Place each check at the earliest boundary where sufficient evidence is available.

Consider an agent changing a system’s call graph. The architectural model must agree with the implementation when the task is complete, but several intermediate commits may legitimately leave them inconsistent. Requiring correspondence after every commit would reject valid intermediate work. At task completion, the accumulated code changes and model updates can be checked together. The obligation belongs to the completed task, not to each commit.

A different obligation requires the assembled system to behave correctly. A deployment can pass source, build, and API checks yet serve a blank page. Those checks establish useful properties, but not that the application displays the expected content. A browser smoke test can load the page and check its rendered output. The test belongs at the earliest boundary where the integrated application can be exercised, such as a preview or staging deployment. A successful HTTP response alone does not establish that the page rendered correctly.

Epic. A tracked unit of work larger than one commit: a feature or effort with its own file, plan, and definition of done, carried out over several agent dispatches.

Definition of done (DoD). The explicit list of conditions a unit of work must meet to count as finished — tests present, docs updated, the model in sync — checked at the end rather than assumed.

3.2.3 The Earliest Decidable Boundary

Both examples illustrate the same rule for placing enforcement:

Place enforcement at the earliest boundary where the obligation is both legible and decidable.

Earliest matters because delay makes a failure more expensive to repair. Legible matters because moving the check earlier than the property permits produces false refusals or meaningless checks. The rule explains the whole mechanism menu at a glance:

  • Static type checks evaluate expressions against declared types before execution, once the relevant code and type information are available.
  • Action hooks act at one tool call, one command — where a single move is legible.
  • Task-completion checks act at the work-unit boundary — where "done" first becomes readable across a body of commits.
  • Deployment gates act after broader evidence has accumulated — the last boundary before the artifact is accepted.

And some properties stay illegible until later still: a leak visible only across ten calls, a cost overrun visible only across a season of jobs. No boundary makes them readable sooner.

Chapter 2 and Chapter 3 therefore use companion selection rules:

Modeling — choose the reduction that makes the engineering question answerable without carrying unnecessary detail.

Alignment — choose the earliest boundary at which the obligation becomes legible and decidable.

Both rules keep irrelevant detail from driving the engineering decision.

  • Modeling avoids carrying detail the question does not need.
  • Alignment avoids enforcing an obligation before the necessary evidence exists.

Choose the wrong abstraction in Chapter 2 and the required property is not represented. Choose the wrong boundary here and the required evidence is not available.

Real boundaries sometimes require a margin for the mechanism to act. Suppose an agent must preserve a durable hand-off before its working context is compacted. Waiting until no room remains may leave too little capacity to write it. A practical trigger can act earlier, when context is becoming full and the durable record is stale. The trigger approximates the desired boundary while preserving enough time and capacity to complete the required action.

With an independent obligation and a boundary where it becomes legible, the next question is what the mechanism at that boundary actually does.

Works Cited

  1. Estefan, Jeff A. Survey of Model-Based Systems Engineering (MBSE) Methodologies. INCOSE-TD-2007-003-02. International Council on Systems Engineering (INCOSE), 2008.
  2. ISO/IEC/IEEE. ISO/IEC/IEEE 15026-2:2022: Systems and Software Engineering — Systems and Software Assurance — Part 2: Assurance Case. International Standard. ISO, 2022. https://www.iso.org/standard/80625.html.
  3. Kelly, Tim, and Rob Weaver. “The Goal Structuring Notation: A Safety Argument Notation.” Proceedings of the Dependable Systems and Networks 2004 Workshop on Assurance Cases, 2004.
  4. International Electrotechnical Commission. IEC 61508-1:2010: Functional Safety of Electrical/Electronic/Programmable Electronic Safety-Related Systems — Part 1: General Requirements. International Standard. IEC, 2010. https://webstore.iec.ch/en/publication/5515.
  5. RTCA. DO-178C: Software Considerations in Airborne Systems and Equipment Certification. Standard. RTCA, Inc., 2011. https://www.rtca.org/do-178/.
  6. Lean. “The Lean Language Reference.” Accessed November 6, 2026. https://lean-lang.org/doc/reference/latest.
  7. Lamport, Leslie. Specifying Systems: The TLA+ Language and Tools for Hardware and Software Engineers. Addison-Wesley, 2002.
  8. Saltzer, Jerome H., David P. Reed, and David D. Clark. “End-to-End Arguments in System Design.” ACM Transactions on Computer Systems 2, no. 4 (1984): 277–88. https://doi.org/10.1145/357401.357402.
© James C. Davis, 2026–present