From Tribal Knowledge to Governed Intelligence: Meta Runs 50,000 Daily Analyses

Somewhere inside Meta, an engineer notices a database connection pool is exhausting itself every Tuesday at 3 AM. She knows the cause. She has seen this pattern four times. She fixes it in twenty minutes because she recognizes the signature: a cron job that opens connections but does not close them on timeout. The fix is not in any runbook. It is in her head.

When she leaves the company, the fix leaves with her.

This is tribal knowledge. Every engineering organization has it. The best debuggers carry mental models built over years of incident response, and those models are invisible to everyone else. The knowledge is too valuable to document casually and too contextual to standardize easily.

Meta decided to solve this problem. Not with a wiki. Not with a chatbot. With a platform called DrP (Debugging as a Platform) that turns debugging expertise into testable, composable software analyzers. Five years later, DrP runs 50,000 automated analyses daily across 300 teams, with over 2,000 analyzers in production. Mean time to resolution dropped between 20% and 80%, depending on the service.

The numbers are impressive. But the architecture is the real story. Because what Meta built is not a debugging tool. It is a governance system for institutional knowledge.

The Maturity Ladder

Alex Xu’s analysis of DrP surfaces a maturity model that applies far beyond debugging. Every organization’s expertise follows the same progression:

Stage 1: Tribal knowledge. The expert knows the answer. Nobody else does. The knowledge is high-quality but zero-availability.

Stage 2: Wiki runbooks. Someone writes it down. The document is immediately useful and begins decaying the moment it is saved. Within six months, half the steps are outdated. Within a year, the runbook is actively dangerous because engineers trust instructions that no longer match the system.

Stage 3: Ad-hoc scripts. An engineer automates part of the runbook. The script works on her machine. It breaks on different configurations. It has no tests. It lives in a personal directory or a team Slack channel.

Stage 4: Testable analyzers. The script becomes a software artifact with unit tests, CI/CD, code review, and automated backtesting against historical incidents. It is no longer a script. It is an assertion about how the system behaves.

Stage 5: Composable platform. Individual analyzers combine into diagnostic pipelines. New analyzers build on existing ones. The platform becomes an institutional memory that learns, because every incident that produces a new analyzer permanently extends the organization’s diagnostic capability.

Most organizations are stuck between stages 2 and 3. They have runbooks that rot and scripts that break. Meta’s contribution is proving that the jump to stages 4 and 5 is not just possible but measurable: 50,000 daily analyses do not lie.

Why This Is a Governance Architecture

The word “governance” appears nowhere in the DrP literature. But the architecture is governance through and through.

Each analyzer goes through code review. This means a second engineer validates that the diagnostic logic is correct before it enters production. Each analyzer runs through CI/CD. This means every change is tested against historical data before deployment. Each analyzer is backtested against resolved incidents. This means the organization can verify, with evidence, that its diagnostic knowledge actually works.

Compare this to the alternative. A runbook is reviewed once (maybe) and never validated again. A Slack thread is reviewed by nobody. Tribal knowledge is not reviewed at all. The DrP architecture applies software engineering governance to knowledge itself.

As Xu puts it: “Investigation knowledge is too valuable to live in people’s heads or in documents that go stale.” The unstated corollary: knowledge that is not testable is not governable. And knowledge that is not governable is a liability, regardless of its quality.

This connects directly to what we explored in the spec layer analysis: five independent teams discovered that specifications, not models, are the primary governance mechanism for AI agents. Meta’s analyzers are specifications of a different kind. They are executable assertions about how systems fail and how to diagnose those failures. The governance principle is identical: codify knowledge into testable, enforceable artifacts.

The Digital Twin Framework

While Meta built the operational proof, Jamin Ball at Altimeter Capital articulated the conceptual framework. His analysis of “digital twins for AI agents” identifies six flavors of codified knowledge that organizations need to capture:

Workflow twins capture how work actually gets done. Not the process diagram on the wall, but the real sequence of decisions and exceptions that practitioners navigate daily. Ball cites Edra, a company that records screen activity and converts it into structured workflow representations.

Institutional memory twins preserve organizational context: why decisions were made, what was tried before, which constraints shaped the current architecture. This is precisely the “why” that agent memory systems systematically discard, as we documented in the self-design analysis where an agent’s memory scored 100% on “what happened” but 25% on “why.”

Expert twins encode individual expertise into queryable form. This is the closest parallel to Meta’s DrP analyzers. An expert twin is not a chatbot trained on an expert’s documents. It is a structured representation of the expert’s decision-making process.

Customer twins, market twins, and system twins complete the taxonomy, covering external knowledge domains.

Ball’s key insight cuts through the hype cycle around AI agents: “The bottleneck to the agentic era isn’t model intelligence. The models are already good enough. What’s missing is the structured representation of knowledge those models need to act on.”

This reframes the entire AI operations challenge. The expensive part is not the model. The expensive part is extracting, structuring, and governing the knowledge the model needs.

The Knowledge Capture Problem Is a Governance Problem

Here is where both sources converge on an insight that neither fully articulates.

The process of capturing institutional knowledge is itself a governance activity. When you decide which expert’s debugging approach becomes the canonical analyzer, you are making a governance decision. When you choose which workflows to twin, you are deciding which processes become the organization’s official methods. When you encode someone’s decision-making patterns into a queryable system, you are standardizing judgment.

This is not neutral documentation. It is normative codification. The analyzer does not just describe how to diagnose a connection pool issue. It prescribes how. Every future engineer who encounters the same issue will follow the analyzer’s logic, not their own. The expert twin does not just preserve knowledge. It replaces the need for the expert’s judgment in the scenarios it covers.

Three governance questions emerge that most organizations have not considered.

Whose knowledge gets codified? Not all experts agree. Two senior engineers may diagnose the same issue differently, and both may be right in different contexts. The codification process must handle disagreement, not suppress it. Meta’s code review requirement for analyzers is one mechanism, but it does not fully address the question of which mental model becomes canonical.

Who maintains codified knowledge? A DrP analyzer, like any software, can become stale. The system it diagnoses evolves. The failure modes shift. An analyzer that was correct eighteen months ago may now diagnose a problem that no longer exists while missing the problem that replaced it. Meta’s backtesting addresses this partially. But the broader question of knowledge maintenance governance remains open for most organizations.

What happens when agents act on codified knowledge that is wrong? In a human-operated system, a stale runbook is filtered through human judgment. The engineer reads the runbook, notices step 3 no longer matches the current architecture, and adapts. An AI agent executing the same runbook has no such filter. It follows the instruction. If the codified knowledge is wrong, the agent’s actions are wrong. Confidently, quickly, and at scale.

The Maturity Test

Ball asks a provocative question: “Can I build a digital twin of myself before someone else does it for me?” The framing is individual, but the organizational version is more urgent: can your organization codify its own institutional knowledge before that knowledge walks out the door?

Meta’s answer, after five years and 2,000 analyzers, is yes. But the answer required building an entire platform with software engineering governance baked in from the start. It required treating knowledge as code, not documentation. It required testing knowledge against reality, continuously, automatically.

Most organizations are attempting this transition with wikis, Confluence spaces, and prompt libraries. These are stage 2 tools applied to a stage 4 problem. They will produce the same result they always have: documents that are useful for weeks and misleading for years.

The organizations that will operate AI agents effectively are the ones that solve the knowledge capture problem first. Not because agents need more data (they have plenty) but because agents need governed knowledge. Knowledge that is testable. Knowledge that is maintained. Knowledge that is versioned, reviewed, and validated against current reality.

Meta’s DrP platform is not a debugging tool. It is a template for how organizations should think about codifying any form of institutional expertise. The pattern is the same whether the domain is debugging, sales methodology, compliance procedures, or customer service protocols. Capture the knowledge. Make it testable. Put it through code review. Backtest it. Compose it into something larger.

Debugging itself can be engineered. That is Meta’s insight. The broader insight: any expertise can be engineered. The question is whether your organization will engineer it deliberately, with governance, or lose it gradually, without noticing, until the experts are gone and the wikis are stale.

---

This analysis synthesizes How Meta Turned Debugging Into a Product from ByteByteGo (March 2026) and Digital Twins for AI Agents by Jamin Ball (March 2026).

Victorino Group helps organizations codify institutional expertise into governed AI systems. Let’s talk.