Skip to content
Product

Four Questions Your Model Can't Answer

Every systems engineer asks them instinctively. The model rarely answers them. Here's what changes when it is smart enough to answer back.

Greg DogumApril 20268 min read

Your system model knows what things are called. It knows how they connect. If you've been disciplined, it knows what each component requires and how those requirements trace to verification. This is valuable — it took months to build — and it answers exactly one category of question: what is the system made of?

But that's not the question that keeps you up at night. The questions that matter — the ones you ask in design reviews, argue about in hallways, and lose sleep over before critical milestones — are different. They are structural questions about the system's readiness, completeness, coherence, and reasoning history. And the model rarely answers any of them for you.

We've identified four. Each one corresponds to a different analytical lens — a different way of computing insight from the same underlying model data. Each one reveals something the others miss. Together, they transform a system model from a static archive into a thinking tool.

A model that can only tell you what the system is made of is an inventory. A model that can tell you what's underneath it, what's missing from it, what it means, and how it got here — that's engineering intelligence.
Causality Lens
"What must exist before this can be realized?"
Every part of your system sits at the top of a pyramid of what it rests on: the components and parts it is built from, the connections between them, and the knowledge that says what it must do. Robert Harney calls this the Pyramid of Causality. If any stone in it is immature, the part above carries risk that the decomposition tree cannot show you.
The Causality lens turns the tree into that pyramid. The node you select is the capstone. Its parts are the domain technologies beneath it, their parts the components, and everything deeper the parts and materials, with the interfaces that join them and the requirements beneath it all. Each stone carries a maturity stage: concept, prototype, in development, tested, in production or mature. The capstone can be no further along than the least mature stone it rests on, and the lens names that limit and the stones that set it. Stages are set by hand in the inspector, or assessed by AI through Change Review, which never overwrites a stage a person set.
Example: the rover template
The LIDAR Array is in production, the Hub Motors are mature and the Nav Computer is a prototype. The rover itself is marked in development. But Thermal Management is still a concept, its cooling approach waiting on a trade study, so the lens says the rover can be no further along than concept and names Thermal Management as the stone that sets the limit. Most stones are not assessed yet, and the lens says those could set it lower still. None of this shows in the system tree, where Thermal Management looks like any other subsystem.
Completeness Lens
"What's missing from this model?"
A system model's fidelity isn't a single number — it's multidimensional. Following Pace and Loper, completeness can be read along four independent axes: what it is (is it described, broken into parts?), what it does (does it have a state machine, use cases?), how it connects (requirements, traces, interfaces), and how we know (verification). A node can be fully decomposed and have no behavior at all — it's been broken down, but nobody defined how the parts actually work.
The Completeness lens asks those questions of the selected node as checks, each read from what another lens already knows. Checks that don't apply are left out, so a part isn't faulted for having no parts. There is no percentage to chase: each check is met or it is a gap. A gap opens the lens that fixes it and, where AI can help, offers a prompt ready to send, whose answer comes back through Change Review. While the lens is open, the system tree shows each node's gap count, so you can see where the model is thin without opening every node.
Example: the rover template
The Drivetrain is broken into parts, each described, and it has requirements. But it has no state machine, two of its three requirements are not traced to what satisfies them, one has no verification, and the Hub Motors and the Suspension System connect to nothing. Each is a gap, and each leads somewhere different: Behavior for the state machine, Requirements for the traces, Verification for the missing method, Architecture for the interfaces.
Narrative Lens
"What does this system actually do?"
Every system has a story — a primary transformation chain that turns what it takes in into what it is for. For the rover, the story is: Ground Control dispatches orders to Communications, which relays routes to the Navigation Subsystem, which steers the Drivetrain to the recipient's door. That's the mainstay — the reason the system exists, expressed as a narrative arc.
The Narrative lens draws a node's parts and the links their interfaces make as a systemigram, after John Boardman: a diagram where parts are nouns and links are verbs, readable as a sentence. The graph comes from the model and is drawn before any AI runs. AI then picks the mainstay and a verb for each link and writes the story, as a change you review in Change Review, and the lens says when the parts or the links have moved on since. The result is a one-page diagram that a stakeholder who has never seen a SysML diagram can read, understand, and question.
Example: the rover template
Off the mainstay, the Power Subsystem powers the Drivetrain and Thermal Management cools the battery and the navigation computer. Reading the systemigram, a reviewer might ask why Thermal Management cools those two but not the hub motors, which give off heat under load. The diagram makes the question easy to ask because it shows relationships as a readable story, not as a wiring diagram only an engineer can parse.
Dendritic Lens
"How did we arrive at this design?"
Every system model is the result of hundreds of decisions. Most of those decisions eliminated alternatives — hull geometries that were evaluated and rejected, materials that failed under the wrong loading regime, communication approaches that couldn't meet bandwidth constraints. The finished model shows the surviving paths. It says nothing about the dead ones. And the dead paths contain the engineering judgment that justifies the living ones.
The Dendritic lens keeps the dead paths in the model. For each node with parts, it shows what was chosen, the alternatives set aside and what is still open. Each alternative records what it was weighed against, why it lost, the first principle that decided it, the kind of decision, and its phase, from establishing the physics to filling the envelope. The lens also says which decisions record no alternative, rather than inventing one. Alternatives are recorded by hand in the inspector, or suggested by AI through Change Review. The model remembers its own intellectual history.
Example: the rover template
The template keeps three dead branches. A fuel cell was weighed against the Battery Pack and lost once the hydrogen storage and the plant around the cell were counted. Tracked drive was weighed against the Hub Motors and lost: on pavement, tracks add mass and noise to solve a traction problem the rover doesn't have. Tethered operation lost at the system level, because a tether limits range and delivery routes are set at dispatch. A reviewer asks what else was considered for cooling. The lens shows that the Thermal Management decision records no alternative at all — a gap in the analysis, surfaced by making the record explicit.

Four Views of One Model

These are not four separate features. They are four computations over the same entity store — the same nodes, interfaces, requirements, and behaviors that the model already contains. Each lens reads the same data and reveals a different dimension of it. And they reinforce each other in ways that no single view can achieve alone.

How the Lenses Converge on One Node: the Rover's Thermal Management
Completeness finds the gaps: no state machine, a requirement not traced to what satisfies it, two of its three requirements with no verification, and the Cooling Loop and Heat Exchangers connected to nothing.
Causality shows why they matter: Thermal Management is still a concept, the least mature stone under the rover, so it sets the limit on how far along the whole rover can be.
Narrative places it off the mainstay: it cools the battery and the navigation computer, a supporting role, so a fault in it stops the chain without ever appearing on it.
Dendritic explains the history: the decision that chose its parts records no alternative, though its maturity note says a liquid-versus-air cooling trade study is still pending.
Four lenses, one conclusion: this node needs attention. No single number says so. Each lens shows part of it, and together they show that Thermal Management is the least settled part of the rover.

This is what becomes possible when a model is more than an archive. When the same data that describes a system can also be queried for readiness, completeness, coherence, and reasoning history, the model stops being a documentation burden and becomes the most valuable artifact in the engineering process — a living representation of what you understand about the system, which grows as the design matures.

Four questions. Four lenses. One model. That's the architecture we set out to build, and it is in Cairn today. Causality and Dendritic are covered in more depth on the design decisions page.

Cairn is the AI engineering workbench for systems that matter.

Sign up and start building for free.