Meta built an AI agent that captures specialist knowledge in a form that survives beyond individual experts. The core problem is real: organizations hoard expertise in people's heads, and when those people spend days answering routine questions, their actual expertise goes unused. The system addresses this by splitting knowledge into two distinct layers. One layer stores what the organization knows—structured files capturing positions, constraints, vocabulary, and decision frameworks. The other layer handles reasoning—explicit procedures that mirror how domain experts actually think through problems. Crucially, this separation means experts can correct the agent and those corrections stick permanently without retraining the underlying model. They tested it in compliance work, where the same questions repeat across hundreds of product reviews, but the architecture generalizes to finance, security, or any domain with deep specialist knowledge written in text. The knowledge architecture itself is the practical innovation. Instead of dumping thousands of documents into a retrieval system and hoping the model re-derives expert reasoning each time, Meta pre-digests the reasoning offline. They organize 200+ files into a strict taxonomy: position files encode how the organization interprets domain questions and when to apply them, taxonomy files act as a single source of truth for terminology, routing indexes make retrieval deterministic rather than similarity-based, and gateway files prevent the agent from applying knowledge where it doesn't belong. Every file declares dependencies in YAML frontmatter, creating a bidirectional graph. When something changes, you can trace exactly what breaks. They also split knowledge strategically—high-density, frequently used material goes into the structured wiki where it stays current, while sparse reference documents get retrieved on demand through conventional search. This keeps the agent's core reasoning grounded in refined organizational thinking. The reasoning layer uses what they call "composable recipes"—imperative procedures that capture the step-by-step methodologies experts actually follow, not just facts they recall. A financial analyst works through valuation models sequentially; a security engineer follows threat modeling procedures; compliance experts apply decision trees. The system encodes these workflows so the agent can execute them reliably. An evaluation framework gates every change before it's incorporated, regression-testing updates to catch breakage. The self-improvement loop then feeds expert corrections back into both the knowledge files and reasoning procedures, compounding institutional memory over time. The whole thing only works because the layers depend on each other—remove the structured knowledge files and automated editing becomes impossible; remove explicit procedures and you can't trace where failures originate; remove the evaluation framework and you lose safety; remove the feedback loop and you're back to one-off corrections that vanish.