Open any MBSE vendor's 2025 release notes and search for "AI." You'll find the same story everywhere: a chat sidebar that answers questions about your model, a quality checker that flags passive voice in requirements, maybe an assistant that generates test cases from natural-language descriptions. These are useful features. They are also, architecturally, identical to bolting ChatGPT onto a spreadsheet and calling it intelligent.
The MBSE industry has adopted AI the way a government agency adopts new technology: cautiously, superficially, and in a way that changes nothing fundamental about how the tool works. The model is still manually decomposed. The architecture is still manually drawn. The requirements are still manually traced to verification. The AI is an advisor, whispering suggestions from the margins. It never touches the model. It never proposes structural changes. It never does engineering.
Chat Is the Wrong Interface for Model Operations
When an engineer asks an AI to "decompose the Power subsystem into functional assemblies," the expected output is not a paragraph of prose. It is a set of specific, structured model mutations: three new nodes with names, descriptions, and parent-child relationships; six new interfaces connecting them; twelve requirements allocated to the new structure. These mutations must be consistent with the existing model, reversible if wrong, and reviewable before they take effect.
A chat interface cannot do this. It can describe what it would change, in English, and hope the engineer translates that description into manual edits without error. This is the equivalent of a code review conducted entirely in prose, without a diff viewer, without line-level comments, without the ability to click "approve" or "reject." Software engineering abandoned that workflow twenty years ago. Systems engineering hasn't started.
Five Stages, One Contract
The alternative to a monolithic chat call is a pipeline — a sequence of focused stages, each with a clear mandate and minimal context. The metaphor: instead of handing one engineer the entire specification binder and saying "figure it out," a project lead reads the table of contents, pulls the relevant chapters, and hands them to the right specialist.
Each stage is independent — no conversational threading between them. Each model call receives the context it needs via its system prompt and assembled payload, nothing more. The Router runs on Claude Haiku 5.5, the small, fast model. It reads the request and a light outline of the project and picks the specialist for the job (the Architect for structure, the Requirements specialist for requirements, and so on) and the nodes in scope. If the router call fails, a keyword classifier in plain code picks instead, so a request is not lost to routing. A request that asks for several things at once is split into subtasks, run in the order they depend on each other, each seeing what the earlier ones would add, and their changes arrive together as one ChangeSet.
Context assembly is code: it fetches what that specialist needs about those nodes. The Specialist, with its domain-specific instructions, runs on Claude Sonnet 5.5 by default, or on Claude Opus 5.5 if you choose it with your own Anthropic key. The checks after it are deterministic code, not a model at all. Post-processing renames ids that clash with the model, fills in units and data types, completes partial updates, settles any brief the AI rewrote, and adds the deletes that a delete implies, so you see everything a removal takes with it. Then the validators check structure (ids, references, required fields, allowed values) and each specialist's own rules.
When something goes wrong, the pipeline says what. Output that isn't readable is retried with stricter instructions. A proposal that fails validation goes back to the specialist once, with the errors listed. If Claude declines a request, Cairn reports it as a refusal and asks you to rephrase, rather than showing a broken reply.
The critical innovation is not the pipeline itself — it's the contract between stages. Every specialist, regardless of domain, produces the same output structure: a ChangeSet.
The ChangeSet: Git Diffs for System Models
In software engineering, the pull request solved a fundamental governance problem: how do you let multiple contributors modify a shared codebase without chaos? The answer was a structured diff — a machine-readable description of exactly what changed, presented in a reviewable format, with the ability to approve, comment, or reject.
Systems engineering models have no equivalent. When an AI chatbot suggests "you should decompose the Power subsystem into Battery Management, Distribution, and Thermal Regulation," there is no structured artifact representing that suggestion. No diff. No review interface. No undo if it was wrong. The suggestion exists as text in a chat log — ephemeral, unstructured, and disconnected from the model it describes.
A ChangeSet is the structured artifact that's been missing. It is a self-describing, atomic transaction containing every operation the AI proposes: nodes to create, requirements to allocate, interfaces to add, traces to establish. Each operation carries complete before-and-after snapshots — not partial patches — so the review interface can render exactly what changed, undo is trivial (swap "after" back to "before"), and the history log can restore any past model state. The store records each "before" from its own state when the change applies, so undo never depends on what the AI said was there.
This is not a future feature. It is how Cairn works. Every AI request — whether decomposing a system, writing requirements, defining interfaces, or generating state machines — flows through the same pipeline and produces the same reviewable ChangeSet. In Change Review you tick the operations you want and apply them as one change, or discard the lot. The engineer is never surprised by a model change they didn't approve. History records every AI change alongside every hand edit, with the request that started it, the specialist and model that wrote it, and what it cost, and any change can be undone.
The Wrapper Problem and the Way Out
The criticism leveled at most AI-powered tools today is that they are "thin wrappers" — a UI skin over an API call, adding no structural value that couldn't be replicated in an afternoon. For chatbot-style AI integrations, this criticism is largely correct. The chat interface adds convenience but not capability. The model could hallucinate an incorrect requirement, and nothing in the architecture would catch it before it entered the model.
This is the difference between building on quicksand and building on bedrock. The LLM is a capable but unreliable component — it hallucinates, it varies between runs, it improves unpredictably with each new release. The pipeline absorbs that unreliability. The Router constrains scope. The Specialist operates on focused context. The checks catch errors. The human reviews the result. The guard checks it once more. No single point of failure. No unreviewed mutation. No silent corruption of the engineering model.
The MBSE tools that will matter in five years are not the ones that added a chat widget to their sidebar. They are the ones that rethought the relationship between human judgment and machine capability — treating AI not as an oracle to be consulted, but as an engineer to be supervised, through the same structured review processes that engineering teams already trust with their most critical decisions.