Agentic Enterprise Architecture

A newly stood up enterprise architecture org gets a brief window that an established one does not: it can choose how it will work before the habits choose for it. The default habits are well known. Architects interview stakeholders, build models in a proprietary tool, present decks to a review board, file the artifacts, and watch them go stale from the day they are approved. Within two years the repository describes an estate that no longer exists, and the org’s real product becomes the review meeting itself.
There is now an alternative, and it does not require abandoning the discipline. It requires three decisions, made in order: settle the operating model, change the medium the model lives in, and change who does the operating. This piece takes them in that order, because each one depends on the last.
The model
The reference model I use is one discipline applied at three levels of scope across four focus areas.

Figure 1: The reference model. Business requirements flow in from the left, mission outcomes flow out to the right, the digital ecosystem sits underneath as the thing being architected, and governance runs across the bottom.
The four focus areas are four questions, kept separate because most architecture shops blur them. Strategy asks where we are going. Architecture asks how it should fit together. Roadmaps ask how we get there. Standards ask what governs decisions. The three levels are scope: enterprise (enterprise-wide strategy and ecosystem alignment), systems (structure and integration), and solutions (implementable designs). The same four questions get asked at every level, so a solution architect and an enterprise architect are practicing the same discipline at different scope, not different disciplines that meet once a quarter to compare slides.
Two features of the model matter for what follows. First, it is an operating model, not a method. It says what the org produces, at what scope, under whose governance. Second, it has a direction of flow: requirements in, outcomes out, and the ecosystem itself (people, partners, applications, data, infrastructure, AI and automation, security, platforms) as the substrate being shaped.
This is where The Open Group’s TOGAF Standard belongs, and it is a specific place. TOGAF’s Architecture Development Method is a sound method for developing and maintaining an architecture, and I use it. But a method is not an operating model. TOGAF tells you how to do architecture work. It does not tell a new org what its products are, at what scope, ratified by whom. Confusing the two is how EA orgs end up framework-shaped instead of outcome-shaped: every ADM phase staffed, every artifact templated, and no clear answer to what the org actually delivers. In the model above, TOGAF runs inside the Architecture column. The model is the org. The method serves it.
The model as code
The model as drawn is neutral about medium, and the medium is where EA goes to die. A capability map in a slide deck cannot be diffed. A standard published as a PDF cannot be tested. A roadmap in a planning tool’s database cannot be reviewed as a change. So the second decision: every artifact in every cell of the grid becomes a typed, versioned object in Git.

Figure 2: The same grid, one layer added. The discipline does not change. The medium does.
Concretely: capability strategy as a typed model under version control. Target architecture as a model in Git, not a deck. Roadmaps as versioned plans with explicit dependencies. Solution designs and architecture decision records reviewed as pull requests. And the Standards column compiled into policy-as-code, so conformance stops being a reviewer’s opinion and becomes a test result that either passes or fails.
I did not invent this move, and it is arriving from several directions at once. The Enterprise Architecture Codex makes the case directly: architecture knowledge held as typed objects in Git, distributed to AI assistants as composable skills, because a prompt is not a specification. My own standing rule from architecture work is the same instinct stated as a boundary: whatever is expressible as code becomes code; what is not expressible as code gets described, specified, and verified against observed state instead. Either way, the artifact stops being a document about the architecture and starts being the architecture, in a form that can be checked.
This layer is not the destination. It is the precondition. Nothing in the next section works on a slide deck.
The model, operated
Once the artifacts are code, the operating question changes. A repository of architecture objects can be worked continuously: sensed against the real estate, drafted into, validated, and reconciled. That work is exactly the kind agents are good at, and it is the work human architects are worst provisioned for, because there is too much of it and it never stops.

Figure 3: The same grid, final layer. Agents run the loop across all twelve cells. The governance bar at the bottom becomes a ratification gate.
The loop has five stages. Agents sense: they inventory the actual estate from cloud APIs, CMDBs, and telemetry, and reconcile observed state against the modeled state. They draft: models, options, and decision records appear as pull requests, not as meeting pre-reads. They validate: every proposal is checked against the Standards column automatically, because the standards are code. They propose: changes arrive with trade-offs stated and evidence attached. And humans ratify: the Architecture Review Board stops being an authoring body and becomes a decision gate over agent-proposed changes. Drift between the modeled state and the real estate is treated as a defect with an owner, which is the standard I argued for in Done Means Accounted For.
None of this fits the framework EA inherited, and the misfit is specific. In Ordinal Systems Architecture, my paper on a control grammar for enterprise AI authority, I argued that TOGAF’s metamodel treats an agent as an application component: something deployed, not something that acts. An agent is a delegated actor. It holds authority someone granted it, inside bounds someone set, and its actions are attributable to the organization that delegated it. I made the operational version of that case in Every Agent Needs an Identity and Delegation Is Not Inheritance: identity and bounded delegation are not features of an agent platform, they are the preconditions for letting an agent act at all. An agentic EA practice needs both halves of that correction. The metamodel needs agent objects with identity and delegation bounds. And the practice needs agent operation under governed execution: admission of what an agent may touch, authority limits, complete records, and closure. I laid out that governance pattern in Governed Execution in Multi-Mode Agent Harnesses.
The records point is not bookkeeping. It is the same argument as the SOX-for-AI series on this blog, most recently in Agent Conduct Is Company Conduct: when an agent acts for the company, the company owns the conduct, and the evidence trail is what makes that ownership survivable under audit or subpoena. Architecture artifacts produced by agents get the same treatment as any governed change: an author, a diff, a validation result, a ratification, a history.
What changes for the org
Three things, practically. First, the architect’s job moves up a level of abstraction: from producing diagrams to exercising judgment about trade-offs, exceptions, and the proposals agents bring. The scarce human skill was never diagram production. It was always adjudication, and the document model buried it under production work.
Second, compliance changes tense. In the document model, compliance is periodic and retrospective: a review, a finding, a remediation plan. When standards are code and validation runs on every proposed change, compliance is continuous and prospective. The board sees fewer, better decisions, because everything mechanical has already been checked before a proposal reaches it.
Third, coverage. A small EA org cannot manually serve every stakeholder the function owes work to. I wrote in Your AI Architecture Has Two Scorecards that architecture is graded on business outcomes and mission outcomes at once. Agentic operation is what lets a small team keep both scorecards current instead of choosing which one to let go stale.
Five recommendations for a new EA org
- Adopt the operating model before the tooling. Settle the four focus areas at the three levels, the products each cell owes, and who ratifies. Buy tools after, to serve the model.
- Put the artifacts in Git from day one. No architecture artifact exists only in a deck or a tool database. If it cannot be diffed and reviewed as a change, it is not yet an artifact.
- Write standards as policy-as-code wherever a check is mechanical. Reserve human review for the judgments machines cannot make, and stop spending board time on checks a test can run.
- Stand up the reconciliation loop early. Observed state against modeled state, on a cadence, with drift tracked as a defect. The loop is what keeps the other four recommendations true six months later.
- Give agents the drafting and checking work, under governed execution, and keep ratification human. Admission, bounded authority, complete records, closure. The board ratifies. It does not compete with agents at production, and it does not abdicate decisions to them.
The discipline was never the problem
Enterprise architecture’s reputation problem was never its discipline. Strategy, architecture, roadmaps, and standards, applied at the enterprise, systems, and solutions levels, is the right model, and TOGAF is a sound method for working it. The problem was the medium (documents that decay on contact with reality) and the operation (manual, periodic, and therefore always behind). A new org inherits neither by necessity. Settle the model, hold it as code, and operate it agentically with humans on the ratification gate, and the practice compounds instead of decaying.
That is the offer in front of every EA org standing up right now: not a better framework, but a discipline that finally runs at the speed of the estate it describes.
Follow-up: The concrete companion to this piece is The Architecture Repository, which lays out the Git repository the model runs on: numbered baselines, the four focus areas as folders at every level, schemas and policies checked by CI, and the ratification map written as CODEOWNERS.
Thinx-Tank