Meta is Turning Domain Experts into Auditable AI Agents

An Organizational Second Brain

Meta shipped a blueprint this week for turning domain experts into auditable AI agents. They call it an organizational second brain. The pitch is straightforward. Capture how your best people actually think, encode it into structured files, and let an agent handle routine assessments while humans handle the exceptions.

The reality is more specific. This only works if you treat institutional knowledge like source code.

The problem will sound familiar. In large organizations, deep expertise lives in two places. Static documents that rot, and human heads that leave. In compliance, security, or financial risk, the same questions come up across hundreds of reviews. Experts spend days on assessments that should take minutes. Different experts reach different conclusions. The organization loses consistency and burns senior time on work that is fundamentally routine.

Meta's answer has four layers.

• A knowledge system.
• A reasoning pipeline.
• An evaluation framework.
• And a self-improvement loop.

Off-the-shelf LLMs sit at the bottom, but they are not the product. The architecture around them is.

The Core: Treating Knowledge as Code

The knowledge system is the critical piece. Meta distills source documents into curated files with strict taxonomies. Position files capture how the organization actually interprets a rule, including its constraints and boundary conditions. Taxonomy files lock down vocabulary so the agent and the humans speak the same language. Routing indexes map inputs to relevant positions deterministically. They do not rely on embedding similarity alone. Gateway files keep the agent from applying specialized knowledge where it does not belong. Every file declares its dependencies in YAML frontmatter. Change one position file, and you can trace exactly what recipes and other positions might be affected.

This is the opposite of dumping documents into a vector database and hoping retrieval works.

The agent does not re-derive reasoning from raw text on every query. It reads the organization's pre-distilled interpretation. Meta also splits knowledge by density and usage frequency. High-density, frequently referenced sources go into the curated wiki. Sparse, situationally relevant material stays in supplementary semantic search. The agent grounds its core reasoning in the refined wiki, but can still reach for supporting evidence when a scenario demands it.

Early versions used flat semantic search and loaded large volumes of mixed-relevance files into the context window. After restructuring into this filesystem approach with targeted routing, Meta cut tokens consumed per turn by about eighty percent. Context windows are finite. Attention degrades with volume. Delivering the right instructions at the right time directly improves reasoning quality.

Recipes: Separating What from How

Those instructions are called recipes. They are imperative procedures that reference knowledge files but contain no domain facts themselves. Recipes separate what the agent knows from how it reasons. Add an organizational position, and you add a knowledge file and update a routing index. No recipe changes. Fix a flaw in methodology, and you edit a recipe. No knowledge files change. Failures attribute cleanly to one layer.

Recipes compose into pipelines. A top-level routing recipe examines the input and selects downstream sub-recipes for each analytical phase. It works like a makefile for domain expertise. Each step loads only the knowledge relevant to that phase, then moves on.

Keeping Humans in Control

Human experts stay in control through two mechanisms. Checkpoints surface intermediate reasoning for review before the agent proceeds. Escalations trigger when the agent hits genuine ambiguity, handing the decision to a human rather than forcing a resolution. Both serve as training signals for the improvement loop.

The Flywheel: A Self-Improving System

That loop is what makes this more than a fancy prompt. When an expert corrects the agent, the feedback enters a compilation pipeline with four phases.

1. Diagnosis extracts the root cause. The system compares the expert's correction against the agent's full knowledge manifest. Could the agent have reached the right conclusion from its source materials? If yes, it is a recipe problem. If no, it is a knowledge gap. If experts disagree on the right answer, the system flags ambiguity for human discussion rather than guessing.
2. Compilation translates diagnosed issues into minimal file edits. Sub-agents analyze impact in parallel, looking at cross-references, conflicts with existing positions, token budget impact, test coverage, and duplication risk.
3. Trustworthiness checks. Two design choices make this trustworthy. An independent adversarial agent reviews only the proposed diffs in a fresh context. It hunts for contradictions, broken edge cases, and undermined positions. Because it shares no context with the proposing agents, it cannot inherit their blind spots. Then a deterministic linter catches structural issues like dangling references or dependency cycles. This layer is not probabilistic. It passes or fails.
4. Evaluation runs in two stages. Targeted replay feeds the original failing scenario back through the agent, which does not know it is being tested. A blind judge scores the new output against the expert feedback without knowing what was changed. If targeted replay fails, compilation retries. Then regression testing runs the full benchmark suite.

If performance drops anywhere, the pipeline retries with an updated prompt describing the regression. Meta reports zero regressions across improvement cycles. Every landed fix gets folded into the regression suite permanently.

After six weeks, domain SMEs rated agent outputs useful almost all the time. Assessment time dropped from days to minutes. The automated pipeline produced validated edits at a rate that previously required full engineering sprints.

The Sobering Reality: This is a Maintenance Commitment

Here is where a staff engineer would tap the brakes. The architecture is elegant, but look at what you are actually signing up to maintain. Two hundred plus files in a strict taxonomy. YAML frontmatter with bidirectional dependency graphs. Routing indexes that must stay current as the organization evolves. Deterministic linters. Regression suites.

Someone has to write the recipes. Someone has to resolve the ambiguity flags. Someone has to review the pull requests that the flywheel generates. That someone is a software engineer paired with a domain expert. If you do not budget for that partnership, the system stalls.

Meta does not cite how many expert hours went into building the initial two hundred file taxonomy. That upfront cost is real.

Who Is This For? An Adoption Rubric

So who is this actually for?

Picture this. It is Friday at four in the afternoon. Your compliance team needs to sign off on a product review before Monday's launch. The internal policy wiki is three years out of date. The person who wrote the last assessment guide left six months ago. The remaining expert is out sick. In that moment, you do not need a smarter model. You need an organizational memory that can reason through your specific risk positions without hallucinating.

That is the scenario Meta is targeting. If that sounds like your world, here is the adoption rubric.

Experiment Now If...

You are in a large organization with deep, text-based domain rules that already demand consistency across many assessments. Compliance, security review, financial risk, procurement evaluation. Domains where experts spend most of their time applying known frameworks rather than inventing new ones. You also need a team willing to curate and govern the knowledge base continuously. Not once. Continuously.

Wait If...

You are still figuring out your taxonomy. If your organization uses the same term to mean three different things depending on the team, an agent with routing indexes will just encode that confusion faster and make it harder to fix. Lock down your vocabulary first.

You're Solving the Wrong Problem If...

You think this replaces experts. Meta's system keeps humans in the loop by design. Checkpoints and escalations ensure the agent flags uncertainty instead of masking it. The goal is to stop wasting expert time on routine applications of known rules. It is not to remove judgment. The most valuable expert work is genuinely novel and ambiguous. That stays human.

The Deeper Principle: Knowledge as Code

The deeper principle is worth taking away regardless of whether you adopt this exact stack.

Keep complexity in text files that humans can diff, review, and revert. Not in fine-tuned model weights. Every improvement should be a text edit that a domain expert can scan in thirty seconds. Version control and transparency beat black-box updates every time.

Meta's system is not magic. It is a disciplined compiler for institutional knowledge. If your organization has the expertise and the maintenance culture to feed it, the compounding returns are real. If not, it is another beautiful prototype that will rot in a repository nobody checks.

TAKEYOURPILLS.TECH. Go ship something.