Every architecture diagram you have ever shipped had one reader. This year it got a second one, and the second one writes code.

In the Build verdict I argued that owning the harness was no longer the fight, and that the durable question was whether the context that makes agents useful, the ontology, the retrieval plane, the institutional knowledge they reason over, lives somewhere I control or somewhere I rent. For an architect, here is the uncomfortable, liberating answer: that context layer is not something you need to buy or build. It is the architecture corpus you were always supposed to keep. Plain text. In git. Where you control it.

The Tax That Turned Out to Be a Corpus

Regulated institutions spent two decades being forced into documentation rigor: architecture definition documents, solution packs, decision logs, interface catalogs. All of it was framed as cost, the price of being examined. Engineers resented it and architects apologized for it.

Then the agents arrived, and everything depends on what context you can feed them. Twenty years of compliance-forced documentation looked like a tax. It was a corpus. The institutions that documented best now have the best prompts, and the firms that resented documentation discipline are about to envy it.

Two Readers, One Corpus

The format matters, because not all text is equally readable by the second audience. A Mermaid diagram is a picture described in text. A Structurizr DSL workspace is a model: elements defined once, many views generated from the same definitions, so the payment service cannot be named three different things in three diagrams. Structurizr’s own rationale page now lists AI agents as a reason text-based modeling wins, and MCP servers that let agents validate and inspect DSL workspaces are appearing.

The model is also where compliance metadata belongs:

paymentsLedger = container "Payments Ledger API" {
    technology "Java 21 / Spring Boot"
    description "Books and reverses card transactions"
    tags "PCI-Scope" "DataClassification-Restricted"
    properties {
        "recovery.rto" "4h"
    }
}

The point is not the diagram. The point is that the model is queryable. “Every container tagged PCI-Scope with a relationship outside the CDE boundary” stops being a workshop and becomes a query, and the same file answers an agent, an auditor’s script, and a scoping exercise. The model file is not documentation about the prompt. It is the prompt.

Who Writes Which Level Now

The perennial objection is maintenance: who keeps the diagrams true? The honest answer used to be nobody. The new answer is that the question splits by C4 level, and the split is the most useful organizational idea in this whole space.

Architects author levels one and two. System context and containers are intent: boundaries, responsibilities, the judgment calls about what talks to what. No agent can recover your intent from code, because the code only shows what is, never what was meant.

Agents recover levels three and four. Components and code move too fast for humans to document honestly, and the tooling caught up this year: ArchAgent reconstructs multiview architectures from cross-repository codebases, and a Claude Code skill released in February will scan a codebase and emit a workspace.dsl in minutes. The recovered model will not be perfect, and Nick Tune’s experiments argue it does not need to be: “Sometimes we don’t need perfect accuracy. As long as the agent picks the right path, it can reinspect certain details or dive deeper as needed.”

So every level gets an author-of-record and a verifier-of-record, and they alternate. Architects author intent; agents verify it against reality. Agents author recovered detail; humans verify it against intent. And the diff between the intended model and the recovered model, written in the same DSL, is the governance artifact. Murphy and Notkin called this a reflexion model in 1995. The idea was always right. It was just too expensive to compute by hand, and now it is not.

The Map Is Also the Fence

The same container model, injected into a coding agent’s context, becomes a guardrail. The agent that knows the declared boundaries puts the new endpoint in the right container and respects the dependency rules, because the architecture is in its prompt rather than in a wiki it never read. The last post built the workcell that governs where the agent runs. This is the map the workcell reads. One artifact, three jobs: communicate with humans, comply for auditors, constrain the agents.

Constraint needs an enforcement arm, and it exists: fitness functions, in the Ford, Parsons, and Kua sense, automated checks that verify an architectural characteristic. ArchUnit for Java, Deptrac for PHP, go-arch-lint for Go. The discipline that makes them useful is the pipeline from decisions: an ADR that says “channel applications never call the ledger directly” should compile down to a check that fails the offending pull request, agent-authored or not. A decision that cannot be turned into a check is usually a decision that is not specific enough yet.

The PDF Is a Build Artifact

Examiners still want documents, and they should get them. But the architecture definition document, the solution design pack, the BIA inputs become rendered views over the corpus, generated on demand, never edited by hand. The PDF did not die. It was demoted. It is a build artifact now, with a commit hash on the cover, and the hash is the evidence chain: this document reflects this state of the model on this date.

This survives contact with real regulators. Zühlke migrated a Class C medical platform’s architecture to Structurizr DSL, with components, relationships, and ADR references in one version-controlled repo, under IEC 62304 and FDA scrutiny. Their case study’s title makes the argument for me: compliance becomes the AI superpower.

For the TOGAF-shaped institutions, the mapping is less radical than it sounds:

• Architecture Definition Document: a rendered view set plus the ADR index, generated from the workspace.
• Architecture Repository: the git repo itself, with history, blame, and signed commits as exam evidence.
• Building blocks: containers and components, tagged in the model.
• Requirements traceability: element properties linking to requirement IDs.
• Compliance assessments: queries over tags, run on demand instead of assembled in workshops.

Teach the Agent the House Style

Standards need to travel with the agents, and the skills mechanism is built for exactly this. Anthropic’s progressive disclosure loads about a hundred tokens of metadata per skill at startup, the instruction body under five thousand tokens when triggered, and bundled resources only as needed. It is the same zoom-level logic C4 applies to diagrams, applied to context windows. A bank’s documentation standards stop being a policy PDF nobody reads and become executable behavior:

---
name: adr-house-rules
description: Apply ADR conventions when writing or modifying decision records
---
Every ADR names one accountable human owner.
Status changes require a linked review PR.
Never alter a security assumption without the security-review tag.

Versioned, peer-reviewed, loaded by every agent in the organization. The standards manual becomes behavior instead of shelf-ware.

The Architect Stops Being the FAQ

Here is the payoff that lands first. Put an agent on top of this corpus, grounded in the model, the ADRs, and the principles catalog, and it absorbs the questions that consume an architecture team’s calendar. Which pattern applies here. Can channel apps call the ledger directly. Is there an approved exception, and when does it expire. Which components handle restricted data and talk to a third party.

Those are retrieval questions, and the corpus answers them with receipts: a citation back to the ADR, the model element, the principle. The division of labor compresses into one line. The agent answers what-is. The architect answers should-we.

In a midsize institution where a handful of architects serve hundreds of engineers, this is not a convenience feature. It is the only way the ratio works. The scarce human hours go where the ownership split already assigned them: authoring intent at the top of the model, and verifying what the agents recovered at the bottom.

What I Cannot Promise You

The honest part, by tradition. A model-based corpus has a maintenance cost, and where there is no architecture capacity it decays into a second untruth, more convincing than the wiki it replaced. Recovered models hallucinate: Tune reports significant inaccuracies he had to catch, and the c4-skill’s own author flags oversized first drafts. The verifier-of-record is not optional staffing.

Context windows are finite, so you cannot dump a bank’s whole landscape into an agent; the zoom levels are the coping mechanism, and it stays hard. Pull request review was designed for code diffs, not for agent-written prose where a one-word change to a description quietly shifts what a security assumption means. Every agent-generated artifact needs a named accountable human owner, or the corpus becomes nobody’s testimony.

And the FAQ agent is only as honest as the corpus is current. A stale ADR answered confidently is worse than a closed office door. Drift detection is what keeps the answers truthful, which is the diff doing governance work again.

The Corpus Was the Point

The Build verdict ended with a question about renting versus owning the context layer. For this profession, the answer was sitting in the job description all along. The context layer is the corpus architects were always supposed to keep, finally cheap enough to keep honestly: intent authored at the top, reality recovered at the bottom, governance in the diff, documents as views, standards as skills.

What I am watching next is the moment the second reader becomes a second author at the top of the model, when agents start proposing changes to context and container boundaries themselves. Intent with two authors is a different governance problem entirely. That one is still mine.

---

If this resonated, the companion read is Agents Don’t Commute. The workcell needed a map. This post is the map.

If your architecture corpus is already answering questions, or refusing to stay current, I want to hear how you keep it honest. Find me on X @orestesgarcia or LinkedIn /in/setsero.