Meta's second brain: agents that learn from experts

On September 2, Meta's engineering blog published an architecture worth reading closely: a domain-expert agent that turns experts' tacit knowledge into auditable, regression-tested, continuously evolving institutional memory — via structured knowledge files, composable recipes and a self-improving compilation loop — with zero model retraining.

The problem: the most valuable knowledge lives in experts' heads

Large organizations share the same dilemma: some specialist knowledge is written down as models, playbooks, checklists and frameworks, but the most valuable part lives in people's heads and is rarely captured durably. In compliance domains, the same question types recur across hundreds of product reviews, expert assessments take days of manual research, and inconsistency between assessments creates real organizational risk.

More often than not, experts spend more time answering routine questions than on genuinely novel and ambiguous work where their judgment matters most. Meta's answer is a system that captures how experts reason and makes it available to everyone who needs it — rather than piling up documents for the agent to re-derive each time.

Four layers: knowledge system + reasoning + evaluation + improvement loop

The system has four layers, each solving a distinct problem, and they depend on each other: the knowledge system's file structure makes automated editing possible; the reasoning layer's explicit procedures make failure attribution tractable; the evaluation framework gates every change; and the improvement loop feeds back into both knowledge and reasoning. Remove any one layer and the others degrade.

The core design choice is separating what the agent knows from how it reasons: knowledge files are declarative and contain no procedures; recipes are imperative and contain no domain facts. Adding an organizational position means adding a knowledge file and updating a routing index — no recipe changes. Fixing a flaw in methodology means editing a recipe — no knowledge files change. Failures attribute cleanly to one layer: was the knowledge wrong, or the procedure?

The second brain: a strict taxonomy of 200+ files

Meta makes implicit knowledge explicit ahead of time: a long-running offline process reasons through source documents and distills them into structured knowledge files. The organization's 200+ files sit in a strict taxonomy — Position files capture authoritative stances and boundaries; taxonomy and vocabulary files maintain a single source of truth for terminology; routing indexes map input characteristics to relevant files, making retrieval deterministic and auditable; gateway files define threshold tests the agent must pass before entering an analytical domain.

Every file declares its dependencies and consumers in YAML frontmatter, forming a bidirectional dependency graph. When one file changes, you can trace exactly what else might be affected — essential when the self-improvement loop proposes automated edits. The industry is converging on the same idea: Karpathy's LLM Wiki structures agent knowledge as a navigable graph of files, and Google's Open Knowledge Format standardizes it for cross-agent interoperability. Knowledge should be pre-extracted, explicitly structured and progressively disclosed, not re-derived on every query.

Progressive disclosure: 80% fewer tokens

Recipes also enable progressive disclosure. Early versions used a single flat instruction file with semantic search, pulling a large volume of mixed-relevance files into the context window on every run. After restructuring into recipe-driven stages, each query touches only a small, targeted subset — cutting tokens consumed per turn by around 80%. Context windows are finite and attention degrades with volume; delivering the right instructions at the right time directly improves reasoning quality.

The self-improvement flywheel: maintenance as a compilation problem

This is the most distinctive part of the system. Interdependent files make manual maintenance impossible to scale — translating expert feedback into precise file edits can take weeks, requiring understanding of the full dependency graph and verification that nothing breaks. Meta treats it as a compilation problem and automates it: diagnose (attribute feedback to root cause), compile (sub-agents analyze impact in parallel and produce minimal edits, with an independent adversarial review that shares no context to catch blind spots), validate (targeted replay plus regression testing, with judges kept blind to prevent confirmation bias), then expert review.

Once the loop completes, the original failing scenario and its validated correct answer join the regression suite — every fix permanently raises the bar, and future changes must preserve the just-corrected behavior. The pipeline's output is a pull request (diff) with a complete audit trail; a human expert reviews a proven fix rather than debugging a raw failure.

Results and transferability

After six weeks across three development sprints: domain SMEs rated outputs useful almost all the time, a significant improvement from early versions that frequently required substantial rework; individual assessment time dropped from days to minutes; automated self-improvement produced validated knowledge edits at a rate that previously required full engineering sprints; and there were zero regressions across improvement cycles. Experts reported the agent handles the vast majority of the analytical work, letting them focus on the genuinely ambiguous cases that require human judgment.

The architecture is domain-independent. It applies wherever specialist knowledge lives as tribal knowledge in experts' heads, consistency across assessments matters, work volume exceeds expert capacity, and off-the-shelf LLMs produce inadequate analysis. Concrete fits: regulatory compliance, protocol adherence, financial risk assessment, security review, engineering standards compliance and procurement evaluation.

The bottom line

The deeper principle: keep the complexity in text files readable by both humans and agents, rather than fine-tuned model weights. Every improvement is a text edit a domain expert can review in 30 seconds; every change is version-controlled, diffable and reversible. For teams building enterprise knowledge systems, the four transferable requirements are: a structured knowledge system with explicit file boundaries and a dependency graph; a procedural layer that separates domain knowledge from methodology; an automated evaluation suite that grows with each improvement cycle; and human-in-the-loop checkpoints calibrated to risk tolerance. No model retraining, continuous knowledge evolution — a deployable version of compounding expert effort.

References

• Meta Engineering: An Organizational Second Brain: Building an AI That Learns From Experts (2026-09-02) — https://engineering.fb.com/2026/09/02/ml-applications/organizational-second-brain-ai-learns-from-experts/
• Karpathy: LLM Wiki — https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f
• Google Cloud: Open Knowledge Format — https://cloud.google.com/blog/products/data-analytics/how-the-open-knowledge-format-can-improve-data-sharing