How do we safely grant autonomy to commodity intelligence?

Model-Based Agentic Software Engineering

Model-Based Agentic Software 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 MAGE method — scale creates the enduring reasoning problem; commodity intelligence changes its economics; Modeling and Alignment turn engineering effort into capital rather than churn. A single centre spine reads top to bottom: Scale and Finite reasoning combined in one node, a New engineering imbalance, the Modeling Principle, the Alignment Principle, the Governed Engineering Environment, and Engineering Capital. Scale is the enduring source of a finite reasoning horizon: large systems exceed any one reasoner, so relevant state must be abstracted or reconstructed, which makes judgment scarce at scale. Commodity intelligence enters laterally at the New Engineering Imbalance, making implementation abundant while judgment, representation, evidence, and enforcement stay scarce; it changes the economics of the imbalance but does not cause the reasoning horizon. The Modeling Principle answers the imbalance by making consequential knowledge and intent explicit at useful scales, which exposes those properties for analysis and reaches the Alignment Principle, where selected obligations are enforced through constraints, sensors, validators, and gates. Passing through Alignment the spine enters the Governed Engineering Environment — the synthesis of both principles — and effort compounds as Engineering Capital when future value exceeds its carrying cost. A single subordinate governance-conversion loop feeds recurring failures and judgment back to adapt the models and controls, strengthening the environment. Two dashed failure paths lead to Engineering Churn: weak representation is repaid as reconstruction, weak enforcement as repeated adjudication. A light dotted long-range rail marks capital reopening the reasoning problem as scope grows. ↻ greater scope reopens the reasoning problem Scale × finite reasoning large systems exceed any one reasoner; relevant state must be abstracted or reconstructed makes judgment scarce at scale New engineering imbalance implementation abundant while judgment · representation · evidence · enforcement stay scarce Modeling Principle make consequential knowledge + intent explicit at useful scales exposes properties for analysis Alignment Principle enforce selected obligations constraints · sensors · validators · gates Governed Engineering Environment where Modeling and Alignment work together when future value exceeds upkeep Engineering Capital effort compounds over time can depreciate · maintain or retire Commodity intelligence implementation cheap and abundant relative to judgment changes the economics Governance conversion recurring failures + judgment adapt the models + controls Engineering Churn the same work gets paid for again weak representation → reconstruction weak enforcement → repeated adjudication

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.

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, Docker, Siemens, Zenseact, Uber, 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 →