An agent spawns into a session. It has a question: What is the canonical rule for where new methodology content lives — Sanity or skills/? A week ago, that agent had no single place to look. Today, it reads one file, follows one pointer, and reaches ground truth in under a second.
That shift — from scattered canon to addressable prose — is what we just finished building. We call it the Knowledge Infrastructure Layer. It is the tenth and final layer of the canonical architecture.
The Problem We Were Avoiding
Team prose knowledge — language conventions, methodology canon, delegation rules, critical lessons — was scattered. Some of it lived in MEMORY.md (grown to 49KB). Some in agent definitions. Some in skills. Some in the monorepo CLAUDE.md (38KB). Much of it lived in all of those places at once — copy-pasted, out of sync, quietly drifting. When a rule changed, the update had to propagate by grep, manual review, and hope. Canon drift was inevitable. And it compounded.
The audits surfaced the shape of it: two enforcement skills carrying 166 and 146 inbound references each; nearly every agent definition restating the same enforcement block; roughly half of Chris's personal memory file storing team canon that had no team-level home to live in.
What We Actually Built
The fix is a new surface at the monorepo root called wiki/ — lowercase, addressable, versioned like everything else. Every piece of team canon now has one home:
- →
conventions.md— language rules, abbreviations, operating principles, routing rules - →
glossary.md— every term, pointing to its canonical source - →
agent-guide.md— delegation, gateways, self-correction, verification - →
architecture.md— system layer map, where new prose belongs - →
critical-lessons.md— orphan lessons that don't fit anywhere else - →
onboarding.md— first-session orientation for contributors and agents - →
INDEX.md— the single entry point every agent starts at
Three subdirectories carry the depth: adr/ holds Architecture Decision Records (seven established, 0001 through 0007). bu/ holds per-business-unit canonical pages. modules/ holds cross-business-unit platform orientation.
The scale of what moved: 206 files rationalized. MEMORY.md dropped from 49KB to 5.5KB. The monorepo CLAUDE.md dropped from 38KB to 21KB. A 69-agent implementation tree that had accumulated its own shadow canon was salvaged into a consistent pattern. Cross-references use structural addressing now — @import for CLAUDE.md inheritance and a Read-directive pattern for agents and commands — instead of copy-paste.
The Validation
A system that claims to make knowledge findable has to prove it. So we ran three diverse agents — Sentinel, Pulse, and Oracle — through realistic information-retrieval probes. Each agent was given a question an agent might actually spawn with. None of them were briefed on the Wiki structure first.
All three reached ground truth in one to three file reads. Oracle's report captured the pattern most clearly:
Sub-second routing from agent entry point to canonical ground truth.
Three for three. That is the capability.
The validation also locked in the rule that governs what goes where: Sanity is canonical when a concept renders on the website or functions as doctrine. The skills/ directory is canonical when the content is operational, procedural, or program-shaped. The Wiki never hosts either — it points. We call this the Canonical Architecture Rule, and it is now enforced across every authoring agent.
The Architectural Picture
The team already had a Unified Canonical Architecture with nine layers covering entity canonical data — shows, episodes, articles, contributors, organizations, methodology entities, customer health, company health. Structured records. The Content Vault and the canonical query tools sit at this level.
What was missing was prose canonical — language rules, conventions, critical lessons, onboarding context, ADRs. Knowledge that does not fit in a relational schema but still needs a single authoritative home. The Wiki is that layer. Layer ten.
What Is Not Solved
The validation probes did their job in more ways than one. They surfaced two pre-existing gaps unrelated to this project: a current slash command referencing an agent implementation directory that does not exist, and a second agent definition pointing at a report path that was never created. Both are latent — the kind of thing that would fail at runtime the next time either code path executed. They are now queued as separate fixes with owners and severity ratings. Not this project's scope, not this project's fault, but worth naming: good infrastructure exposes the problems it does not solve.
What This Enables
Three things get easier. The seventieth agent reads INDEX.md and follows pointers — no custom tour. Cross-agent references resolve to the same files that govern behavior, which means Sage's article about delegation points at the same rules Pax actually operates under. And when vocabulary evolves or a critical lesson gets added, the update is a single edit in a known location rather than a grep across a hundred files with an unknown failure surface.
Contributors who never see the internals still benefit from what the internals make possible. When an agent responds faster, more accurately, more consistently with the rest of the team — that is this layer doing its job quietly.
The Quiet Milestone
Infrastructure work rarely looks like a milestone. Nothing new shipped to clients. Nothing visibly changed on the website. The difference is only obvious when you watch an agent spawn, notice that it no longer fishes through five files to find a rule, and realize that it never will again.
This is the shape of operating at AI-native scale. You do not get there by writing more rules. You get there by making the rules findable. Sixty-nine agents, one entry point, one canonical layer per kind of knowledge. The next agent we build inherits it on day one — and the tenth layer, the prose layer, was the one we had been working around for months. It is good to stop working around it.