How do we safely grant autonomy to commodity intelligence?

Model-Based Agentic Engineering

A Case Study in Software Engineering

Model-Based Agentic Engineering (MAGE) is an engineering methodology for environments in which AI agents perform substantial implementation work.

MAGE has two principles that apply throughout the work. Modeling makes important engineering knowledge and intent explicit. Alignment makes important requirements effective by checking the work against them.

MAGE does not assume that engineers get everything right the first time. Software engineering routinely proceeds from incomplete, imprecise, and evolving requirements, and autonomous work exposes gaps that were not apparent in advance. MAGE therefore also emphasizes governance conversion: changing the engineering environment so that future work can inherit what was learned rather than rediscover it.

MAGE in One Page

Software engineering has always had to manage more complexity than any one person can hold in mind. AI agents face the same problem, but they change its economics: we can now produce implementation work much faster than we can grow the engineering knowledge and judgment needed to guide it.

MAGE responds by making important knowledge explicit, checking autonomous work against important requirements, and improving the engineering environment as experience reveals what was missing.

The six claims below summarize the argument.

The six claims, connected Claims one and two motivate two parallel principles: Modeling and Alignment. Both guide and govern engineering work. Recurring failures and judgment lead to governance conversion; feedback adapts models and controls for future work. Engineering capital depends on later benefit. Claim six is a separate prediction about the reorganization of engineering work. 1 · Commodity intelligence changes the economics of software engineering Implementation capacity becomes abundant relative to engineering judgment. 2 · Scale creates a reasoning problem Large software systems exceed the reasoning horizon of humans and agents. 3 · Modeling Purposeful models can reduce the cost of engineering reasoning. Capture consequential knowledge and intent while leaving irrelevant choices open. 4 · Alignment Explicit obligations can make autonomous implementation governable. Constraints restrict; sensors observe; gates control admission. Governed engineering work Substantial implementation freedom; control over the properties that matter. 5 · Governance conversion Recurring judgment becomes durable structure. Future work inherits models and controls. Engineering capital when later work keeps benefiting. 6 · Predicted reorganization of engineering work Engineering work will reorganize around what remains scarce. Representation · evidence · governance · coordination · judgment Responsibility for consequential decisions remains. motivate the two principles guide and govern recurring failures and judgment adapt models adapt controls

Claim 1

We can now write a lot more code, but our engineering know-how hasn't grown nearly as fast.

As implementation gets cheaper, deciding what to build, understanding the system, and determining whether the result is acceptable become relatively more important.

In the figure: Commodity intelligence → New engineering imbalance

Claim 2

Large systems are too complex for any one person or agent to understand in full.

Software engineering deals with scale through abstraction: preserving the information needed for a particular task while leaving unnecessary detail out. Without useful abstractions, humans and agents must repeatedly reconstruct important knowledge from code and other lower-level artifacts.

In the figure: Scale × finite reasoning → New engineering imbalance

Claim 3

Models make important knowledge easier to reason about and reuse.

A model is a concise representation of some aspect of a system, chosen for an engineering purpose. It may be incomplete or approximate, but it must be useful for that purpose. Models let humans and agents reason about important properties without repeatedly reconstructing them from lower-level artifacts.

In the figure: Modeling — the green region

Explore Modeling →

Claim 4

Important requirements should actually affect the work.

It is not enough to tell an agent what matters. We must also have probabilistic and deterministic means of checking the agent's output against those requirements.

In the figure: Alignment — the orange region

Explore Alignment →

Claim 5

Recurring failures should improve the engineering system.

When failures recur or engineers repeatedly supply the same judgment, fixing the immediate result is not enough. Governance conversion changes the engineering environment so that future work can inherit what was learned rather than rediscover it.

When those changes continue to save work or prevent failures, they become engineering capital. When the same reconstruction and judgment must instead be repeated, MAGE calls that engineering churn.

In the figure: Governance conversion; Engineering Capital vs. Engineering Churn

Explore the MAGE method →

Claim 6

When writing code gets easier, more of the hard work moves to figuring out what to build, whether it is right, and how to keep it that way.

Agents may increasingly help with that work too. The enduring engineering responsibility is deciding what matters, what evidence is sufficient, what can be delegated, and what tradeoffs are acceptable.

In the figure: the whole figure

Model what matters. Check the work against what matters. Learn from failures. Build what you learn back into the engineering environment.

Resources

MAGE is developed through books, research, teaching materials, and talks.

Two books develop complementary parts of the argument:

  1. MAGE — a theory of engineering in the age of commodity intelligence. It asks how software engineering changes when implementation intelligence becomes abundant.
  2. The Software Engineering Handbook — a judgment and decision-making approach to software engineering. It makes explicit the engineering underneath MAGE: the decisions engineers make about requirements, specification, architecture, design, validation, and the other activities of software engineering.

MAGE asks what changes when agents can do much of the work. The Handbook develops the engineering judgment that engineers need to remain in control over the resulting systems.

Software Engineering Handbook cover

The Software Engineering Handbook

The engineering judgment underneath MAGE: what engineers decide, why those decisions matter, and how evidence supports them.

Using MAGE

MAGE is a methodology, not a prescribed toolchain. These resources provide practical ways to apply it to an existing engineering system.

QuickStart

Install the MAGE skills and start identifying knowledge that is repeatedly reconstructed, judgments that are repeatedly made, and requirements that are not reliably checked.

The Method

Apply Modeling and Alignment to the work, then use recurring failures and repeated judgment to improve the engineering environment.

Model Workbench

Open a MAGE model system in the browser, check it against the semantics, and run saved questions over it. The page runs entirely on your machine: no account, no install, and the model is never uploaded.

Evidence

MAGE began with one production system studied in depth and was then compared with independently described industrial systems. The originating case shows how the ideas emerged and evolved over time; the industrial cases show other ways similar engineering problems have been addressed.

Industrial cases — breadth

Independent accounts from Cloudflare, Spotify, Shopify, Uber, Amazon, and GitLab, examined through the MAGE framework for recurring patterns, differences, and limits.

Research

MAGE is also a research program. It raises questions about what engineering knowledge should be made explicit, which requirements can be reliably checked, how engineering environments should improve over time, when those improvements are worth their cost, and where human judgment remains necessary.

Read the theory → Explore the research agenda →