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.
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.
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.
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.
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
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:
MAGE — a theory of engineering in the age of commodity intelligence. It asks how software engineering changes when implementation intelligence becomes abundant.
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.
MAGE
Engineering reliable software with commodity intelligence: the theory, practice, evidence, and implications.
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.
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.
DocAble — depth
The originating production system and the longitudinal record from which the early MAGE concepts emerged.
Independent accounts from Cloudflare, Spotify, Shopify, Docker, Siemens, Zenseact, Uber, and GitLab, examined through the MAGE framework for recurring patterns, differences, and limits.
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.