Skip to content

§2.5 System Knowledge: Connecting the Models

Different questions require different models of the same system. A service catalog names components, a deployment model places them in an environment, a lifecycle model records their states, and an execution record reports what happened. These representations need not become one large model. They need to agree on the identities and relationships that engineering questions cross. MBSE methods connect requirements, design models, analyses, and verification results so that engineers can follow a decision across these representations 11. Jeff A. Estefan, Survey of Model-Based Systems Engineering (MBSE) Methodologies, INCOSE-TD-2007-003-02 (International Council on Systems Engineering (INCOSE), 2008). 2.2. Azad M. Madni and Michael Sievers, “Model-Based Systems Engineering: Motivation, Current Status, and Research Opportunities,” Systems Engineering 21, no. 3 (2018): 172–90, https://doi.org/10.1002/sys.21438.

2.5.1 A Heterogeneous Modeling Substrate

A modeling substrate is the collection of representations through which engineers and agents can recover and relate system knowledge. Its models can differ in shape: a registry, a state machine, a decision table, and a measurement record each preserve what their questions need. A shared service identifier can connect a catalog entry to a deployment and its measurements without requiring those records to share a file format. SysML provides one formal account of views: a viewpoint identifies stakeholder concerns, and a view selects and presents model content to address them 3.3. Object Management Group, OMG Systems Modeling Language (SysML), Version 2.0, OMG Document formal/26-03-02 (Object Management Group, 2026), https://www.omg.org/spec/SysML/2.0.

Suppose an agent is investigating a slow report service. The catalog supplies the service's owner, the deployment model supplies its resource allocation, and the measurement record supplies recent response times. Each record uses the same service identity. The agent can follow those connections to obtain the relevant facts; it does not have to reconstruct from names and directory locations whether the three records describe the same component.

Prefer shared identity and derivation over independently maintained copies of the same fact. A deployment record can refer to the service catalog's identifier rather than copying the service's description and owner. A report can join the two records when it needs their combined information. Where a second representation must contain a copy, make its source and correspondence check explicit. Otherwise every copy becomes another fact engineers must remember to update.

Execution History and Provenance

A static model and a history answer different questions. A workflow model says which tasks depend on which; an execution record says which tasks ran on a particular occasion. Joining duration measurements to task identities can reveal an expensive part of the workflow without turning the dependency graph into a log. The history still needs its own model because the useful events and their grain depend on the question.

For example, a text editor's provenance record might name an insertion or deletion, its target, the resulting change, and the actor or operation responsible. “Document changed” would be too coarse to explain an edit; a trace of every memory access would bury the edit in irrelevant detail. The provenance model selects the events that support explanation. If those edits have defined replay semantics and the original document is available, replay can apply the recorded sequence again. That does not reconstruct the reasoning that led to the edits.

Questions that span models

Some answers require a join. Suppose the policy allows a report service to invoke a renderer. The policy names the two services, while the deployment model records the runtime identity under which the report service runs. Joining the permitted call to that identity determines which principal needs permission to invoke the renderer. Neither model contains that complete answer by itself: the policy does not name the environment's principal, and the deployment record does not decide which calls should be permitted. (For a worked DocAble join and its correspondence checks, see Appendix A.)

A model can also connect an obligation to its evidence. A latency requirement might identify the workload and response-time bound, while a test catalog identifies the measurement that evaluates them. Linking the requirement to that test makes a missing measurement visible. SysML represents this relationship through verification cases that identify the subject and the requirements to be evaluated 3. Whether the test supplies adequate evidence, and whether its result should block release, remain further engineering decisions.

A join only works if it preserves the distinctions the decision needs. A record may use the correct user identifier and still reduce an unlimited entitlement to a finite-credit balance. Shared identity makes the connection explicit; it does not guarantee that the information passed across it is adequate.

An engineer or agent can therefore enter through the object named by a task and follow the relations its question requires: from service to owner, from service to deployment, from deployment to measurement. A query interface makes these connections traversable. The agent needs the connected slice that answers the question, rather than every model in the project.

2.5.2 Maintain Explicit Correspondence

Models and implementations can fall out of correspondence as a system changes. Maintaining their relationships requires deciding which representation is authoritative for each property and how correspondence with other representations should be established and checked. Figure 2.5-1 distinguishes three arrangements:

  • Derive from implementation. When implementation is authoritative, derive models from it. A dependency graph extracted from code, for example, describes relationships in the current implementation. Such models can support understanding, queries, and analysis, but do not independently prescribe how the system should behave. The derivation represents selected properties rather than reproducing the implementation in full.
  • Generate from models. When models are authoritative, generate the corresponding implementation artifacts from them. A service-flow model can generate deployment configuration, for example. The model determines the generated portion of the implementation, while other decisions remain open. A generator maintains this relationship by producing artifacts from the model rather than requiring engineers to update both independently.
  • Trace and check correspondence. When neither representation fully determines the other, maintain explicit relationships between models and implementation, checking the correspondences that can be decided mechanically. A behavioral model might specify required state transitions without determining the algorithms that implement them. An agent can choose those algorithms, while traceability connects the modeled transitions to the relevant implementation and supports checking their correspondence.

An authoritative model can also be interpreted directly during execution, as the build-runner example below illustrates.

The third arrangement is particularly useful when agents implement systems whose models specify only selected properties. The models preserve engineering decisions while leaving other implementation choices open. The three arrangements can coexist within one system, and their coverage can change as engineers learn which properties need explicit representation.

Derive when implementation owns the truth

The model is a projection of the implementation. A component registry can read the directory tree; an observed dependency list can be induced from call sites. A drift check re-derives the selected facts and reports divergence from the maintained view. The correspondence covers what that derivation observes, not every property of the program.

When the model is the source of truth

Generation produces an artifact from a model: code, configuration, or documentation. For example, a schema can generate the types used by interface clients. A freshness check compares the checked-in artifact with current generator output; provenance identifies the model and generation step that produced it. The generator preserves that declared correspondence while leaving open whether the schema expresses the right contract.

Three correspondence patterns Derive extracts selected models from implementation. Generate determines a portion of implementation from a model. Trace and check connect separately maintained model and implementation elements using distinct directional relations; other implementation decisions remain open. DERIVE Implementation is authoritative Model(s) State Response Idle Start() Done Stop() … … Implementation Agent creates implementation from prompts (and iteration) GENERATE Model is authoritative Model(s) State Response Idle Start() Done Stop() … … Implementation Generated portion (determined by model) Other implementation decisions remain open TRACE + CHECK Neither fully determines the other Model(s) State Response Idle Start() Done Stop() … … Implementation Corresponding portion (maintained and checked) Other implementation decisions derive (extract model from implementation) generate (produce implementation artifacts from model) trace (bind related elements) check (evaluate where decidable)
Figure 2.5-1. Three correspondence patterns. Derivation extracts models from implementation; generation produces implementation artifacts from models; traceability connects representations maintained independently. Each relationship covers selected properties or artifacts rather than necessarily determining the entire implementation.

Interpretation uses the model directly during execution, without generating a separate artifact. Return to the build with two independent compilation tasks and one link task. The build declaration names each task and states that linking requires both object files. A runner reads those declarations to decide which tasks are ready: it may start the independent compilations, but it must wait for both results before linking. The compiler and linker still perform the individual operations. Their dependency order comes from the build declaration.

The same declaration can answer a question without running the build. To find what a changed object file could affect, project the declared dependencies into a graph and follow its outgoing edges. In this example, the path reaches the link task. The runner uses the relationships to schedule work; the analytical view exposes them for queries and checks. DocAble's connected-models inset develops these two uses and shows how the correspondence differs across document formats.

WORKED EXAMPLEDEEP DIVE

Worked example — Connecting the views of a document service

DocAble improves document accessibility through passes that analyze or change a document. Workers and services execute those passes, and the product retains evidence about the resulting artifact. Its modeling problem therefore crosses several views: the intended computation, the execution arrangement, and what one run actually changed. The worked question is how those views can share facts without becoming independent accounts that drift apart.

DocAble uses different representations for different engineering questions. Registries describe components and their relations; state machines describe transitions; other models encode contracts, decisions, quantitative relationships, or recorded history. Roughly 130 structured model records plus several data dialects represent component identity and metadata, deployment topology, inter-service edges, data flow, required environment, state machines, and the governance graph itself. They share identities, derivations, query surfaces, and traceability where engineers need to connect them, while retaining the form suited to each question. Figure 2.5-2 illustrates how an engineering question determines which models to traverse. To investigate a slow service, for example, one might identify the service in the registry, use its identity to find the corresponding deployment, and retrieve measurements for that deployment. Other questions would traverse different relationships among the same models.

The models are represented as data rather than importing the implementation they describe. Keeping the representations separate lets engineers check their correspondence. Where a model is intended to provide independent evidence about an artifact, the model must remain distinguishable from that artifact. Chapter 5 shows how this modeling substrate is maintained and used in the governed engineering environment.

Heterogeneous models over shared identities A service performance question follows the service registry into the shared-identity hub, out to deployment topology, back through the hub, then out to measurements. Four other representations have thin connections to the same hub. Traverse via shared identities e.g., investigate a service’s performance Service registry (identify service) Provenance records Computation graph Entitlement policy State machines Deployment topology (where it runs) Measurements (how it performs) 1 2 3
Figure 2.5-2. Heterogeneous models over shared identities. An engineering question selects a path through the available representations. The highlighted traversal follows a service from its registry entry through deployment topology to performance measurements, using shared identities to connect the models. Other models remain available for different questions.

One dependency used for execution and analysis

DocAble's remediation subsystem illustrates how one set of declarations can support both execution and analysis. For a DOCX job with table-header repair enabled, one pass marks table headers and another checks the table's structure. The registry declares that the repair pass writes table-header information and that the structure check reads it.

Matching that write to that read gives a dependency: repair must precede the check. The scheduler uses the dependency to order the work, so the check examines the table after the header pass has run.

The Office registry also emits its resource dependencies for a separate Python graph view. The edge from table-header repair to the structure check therefore comes from the same read/write metadata used by scheduling. An engineer can inspect which computations depend on table-header information, or join their identities to measurements, without executing the remediation pipeline. The Python graph provides the analytical view; the execution machinery does not schedule from it.

PDF uses a different connection. Its analytical edges are projected from parallel typed declarations of what each pass produces and consumes, including information consulted only to decide whether a pass runs. Blocking checks hold those declared relationships in correspondence with the executable pipeline.

One source of truth can thus support execution and analysis at once. The execution machinery uses the declared relationships to schedule work; the analytical view exposes the structure needed for queries and checks. The important question is which representation owns each fact and how each consumer remains connected to that source. Where separate declarations are necessary, as in the PDF view, checked correspondence carries that connection.

What one document run changed

A static computation graph does not record the mutations performed during a particular run. DocAble records consequential document changes as typed operations: each operation names its target, the mutation made, the responsible remediation pass, and the retained evidence. That history supports audit, debugging, and a changelog. Recording only “document modified” would lose the very distinctions those uses need.

During a PDF remediation session, typed edit values form a per-session log. A replay engine can apply the same sequence deterministically. This record preserves the mutations while omitting the reasoning, analyses, control decisions, and retries that produced them. The computation graph asks what may compose; the edit record asks what happened to this artifact. Figure 2.5-3 contrasts these two reductions.

DocAble’s PDF changeset interface also represents edits before they happen. A changeset is an ordered collection of typed operations, each naming a target and a supported mutation, such as assigning alternative text or changing a structural tag. The proposing computation does not manipulate PDF objects directly. An applier resolves the targets against the current document and returns a result for each operation. The proposal expresses intended mutations; the results and attribution record show what was actually applied.

A specialized remediation pass, a general-purpose agent, or a human editor can propose operations using the same vocabulary. The interface preserves the information needed to apply and inspect the change while leaving its producer’s reasoning unspecified. Chapter 3 examines the constraints on applying such proposals; Chapter 5 returns to the reasoning strategies that can produce them.

Computation structure versus recorded history Two reductions of the same remediation system, side by side. Left: the static computation graph — named passes joined by a typed data edge and a typed control gate, modeling what computations may compose. Right: one session's edit record — a run that emits a sequence of typed PdfEdit operations, recording what mutations did occur. A dashed link between them marks that they are not joined today; a shared computation identity would join them, and the join is added when a question needs it. Computation graph what computations may compose Edit record what mutations one run did emit Analyze pass Remediate pass Route gate DATA_FLOW CONTROL_GATE Session run PdfEdit · SetAltText PdfEdit · TagFigure PdfEdit · SetReadingOrder static structure recorded history not joined today
Figure 2.5-3. Computation structure versus recorded history. Declared computations and a run’s actual mutations answer different questions. A shared computation identity can join the recorded edits to the static model when needed, while preserving the distinction between what was declared and what happened.

DocAble joins staged-run latency and cost to stable computation identities, so measurements can be queried alongside the static graph. The per-session edit log remains a separate provenance record; it is not a per-run execution graph over computation nodes. Recording attribution is also distinct from ensuring that every mutation records it. A structural check requires typed mutation operations to emit attribution, but it cannot establish that the semantic explanation inside the record is correct.

Joining a call to its deployment permission

A permitted interservice call requires several models to agree. A typed edge records that one service may call another. Deployment configuration identifies the environment variable carrying the callee's URL. The caller's runtime identity determines which invocation grant the cloud's access-control configuration must contain. Joining the edge to these records determines both how to reach the callee and who is permitted to invoke it; a further comparison checks agreement with the service catalog's documented topology. Twenty-eight modeled call edges produce ten distinct invocation grants once shared runtime identities are accounted for. No single source artifact contains that deployment plan.

DocAble introduced the join after service URLs were wired correctly but the matching invocation grant was absent, taking staging down with authorization errors. The repair made URL wiring and authorization two consequences of the same modeled edge, so a later change could derive them together rather than requiring another bespoke grant.

Connections can create information that no individual model contains. The call model does not contain the environment-specific runtime identity; the deployment environment does not independently state the intended call topology. Joining them determines the permission that should exist.

Connecting a property to its checker

Models can also identify the evidence required to evaluate their properties. Chapter 3 examines how those requirements become verification policies and enforcement mechanisms.

Each connection has a specific purpose. Resource declarations supply a dependency, computation identities connect measured cost to a pass, an edit record explains a document change, and a call joined to a deployment identity determines a permission. Keeping those relations explicit lets engineers inspect the connection that an analysis depends on, instead of treating membership in a model family as evidence that the models agree.

An analytical graph remains a view even when its edges are derived. It can suppress method bodies, internal algorithms, runtime history, timing, and most application state while keeping the relationships needed for a structural question. Deriving an edge avoids maintaining that edge independently. It does not show that the declared dependency is desirable, or that the graph includes every relationship a different question might need.

Trace and check where neither owns the truth

Where neither side can be fully derived from the other, traceability records their relationship explicitly. A behavioral model might link a transition to the functions that implement it while leaving their algorithms unspecified. The relation lets an engineer or agent find the relevant implementation from the model and identify which model elements may need review after a code change. Each link needs a defined meaning and a target that can be identified in the current system. These links make the claimed correspondence available for inspection and checking.

The Limits of Model Coverage

The boundary of what engineers choose to model can change with experience. A failure may reveal a property that the existing models do not represent. Making it explicit brings that property within the modeled surface, where it can support reasoning and, potentially, mechanical checking. The reverse is also possible: a distinction that no longer serves an engineering purpose can be removed, reducing the cost of maintaining the model. Figure 2.5-4 illustrates both movements. Chapter 4 examines how failures and other observations lead engineers to revise the models and controls that govern subsequent work.

Dynamic coverage of model correspondence The modeled surface contains two regions: decidable claims checked mechanically, exemplified by no two owners for the same job, and semantic claims requiring judgment, exemplified by a meaningful result. Outside the modeled surface, unmodeled properties have no model-based coverage. An arrow from outside to the outer modeled boundary represents a newly consequential property; the opposing arrow removes an unnecessary distinction. Both changes apply to the modeled surface as a whole. Modeled surface Outside the modeled surface Decidable claims mechanical checks Expressed in model Checked automatically Example: No two owners for the same job Semantic claims judgment required Expressed in model Judgment required Example: A meaningful result Unmodeled properties no model-based coverage Not represented Example: A failure mode outside the model remove an unnecessary distinction represent a newly consequential property
Figure 2.5-4. The modeled surface and its limits. Models may represent properties that can be checked mechanically and properties that require semantic judgment. Properties outside the modeled surface have no model-based coverage. Over time, engineers can expand this surface by representing newly consequential properties or contract it by removing unnecessary distinctions.

For invariant-bearing models, one useful executable pattern is a structured schema plus checked predicates over that schema. The schema defines entities, relations, fields, or states; the predicates state properties that a checker evaluates over the declared domain. Other executable models may instead drive generation, simulation, transformation, or analysis. A schema alone does not establish correspondence to a changing system; checks or derivations are needed where that correspondence matters.

A synchronized model may still be incorrect, express a poor architecture, or omit a relationship that matters. A pointer can resolve while its meaning has changed; a schema and its generated client can agree while a live producer emits something else. The guarantee the machinery offers is narrower:

For the surface the model claims, check the correspondence that can actually be decided.

Derive views from the implementation when it supplies the facts. When the model supplies them, generate artifacts from it or let execution read it directly. Where neither fully determines the other, maintain traceability and check the declared correspondence.

2.5.3 Modeling Makes Properties Available to Engineering

Modeling makes a property explicit; engineers decide how to use it. To illustrate this, let’s return to the eight-worker pool from earlier in the chapter. Suppose its model records the number of running jobs and the capacity available to execute them. The comparison may help an operator plan a larger pool, help the system tune admission, or supply a hard rule that refuses work above the bound. Those uses require different mechanisms. The quantities and their units make the comparison meaningful; they do not decide what crossing the bound should do.

A measurement can supply evidence without being a hard limit. Engineers must decide how the quantity is collected, who sets its reference value, and whether the result should merely inform decisions or constrain subsequent work. Chapter 3 examines how selected obligations become enforceable.

Model analysis can guide design decisions before implementation. A dependency graph may reveal that an execution boundary is artificial; a behavioral model may expose a recovery protocol that should change; a quantitative model may show that an otherwise plausible decomposition cannot meet its resource envelope. In each case, analysis of the model can change the architecture before implementation commits to the choice.

AIDEEP DIVE

Beneath commodity intelligence: why structure helps

Research on context engineering and agent architectures treats the organization of work as part of the reasoning system. Across this literature, external memory, selective retrieval, tool interaction, and task decomposition determine what information a reasoning step receives and what it must do with that information 44. Lingrui Mei et al., A Survey of Context Engineering for Large Language Models, arXiv preprint arXiv:2507.13334, 2025, https://arxiv.org/abs/2507.13334. 5.5. Lei Wang et al., “A Survey on Large Language Model Based Autonomous Agents,” Frontiers of Computer Science 18 (2024): 186345, https://doi.org/10.1007/s11704-024-40231-1. Access to state remains different from reasoning over it. Keeping a record available does not ensure that the agent will recover the relationships needed for a particular decision. Organizing the information and dividing the work can reduce what each step must search, reconstruct, or infer. Anthropic's agentic coding guidance separates exploration and planning from implementation and recommends explicit tests 6.6. Boris Cherny, “Claude Code: Best Practices for Agentic Coding,” Anthropic, April 18, 2025, https://www.anthropic.com/research/claude-code-best-practices.

Engineering models supply a further kind of structure: a representation of the system that gives those reasoning steps shared meaning. A harness may divide a change into tasks. Kiro, for example, organizes the work in requirements, design, and task documents that developers can review 7.7. Nikhil Swaminathan and Deepak Singh, “Introducing Kiro,” Amazon Web Services, July 14, 2025, https://kiro.dev/blog/introducing-kiro/. An architecture model can identify the components and permitted calls those tasks must respect. A behavioral model can expose an ordering that spans several tasks. Links between models and implementation let an agent move from a modeled relationship to the affected code and follow connections into other parts of the system. Engineers can therefore shape both how the agent performs the work and the system knowledge through which it reasons.

Explicit models also make delegated implementation easier for engineers to direct. This follows the MBSE practice of making system specifications, design decisions, and their verification explicit and traceable 2. Engineers can inspect the relationships a proposed change must preserve and decide which failed checks should block acceptance. Agents can use those representations to plan work and choose how to implement it within the declared bounds. Because the decisions are recorded in project artifacts, engineers can carry them forward when they change the foundation model or harness. They can also revise the models and checks when the requirements change. The same structure that reduces reconstruction for agents keeps the decisions governing their work available for human inspection and revision.

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. Madni, Azad M., and Michael Sievers. “Model-Based Systems Engineering: Motivation, Current Status, and Research Opportunities.” Systems Engineering 21, no. 3 (2018): 172–90. https://doi.org/10.1002/sys.21438.
  3. Object Management Group. OMG Systems Modeling Language (SysML), Version 2.0, OMG Document formal/26-03-02. Object Management Group, 2026. https://www.omg.org/spec/SysML/2.0.
  4. Mei, Lingrui, Jiayu Yao, Yuyao Ge, et al. A Survey of Context Engineering for Large Language Models. arXiv preprint arXiv:2507.13334, 2025. https://arxiv.org/abs/2507.13334.
  5. Wang, Lei, Chen Ma, Xueyang Feng, et al. “A Survey on Large Language Model Based Autonomous Agents.” Frontiers of Computer Science 18 (2024): 186345. https://doi.org/10.1007/s11704-024-40231-1.
  6. Cherny, Boris. “Claude Code: Best Practices for Agentic Coding.” Anthropic, April 18, 2025. https://www.anthropic.com/research/claude-code-best-practices.
  7. Swaminathan, Nikhil, and Deepak Singh. “Introducing Kiro.” Amazon Web Services, July 14, 2025. https://kiro.dev/blog/introducing-kiro/.
© James C. Davis, 2026–present