# How Meta built the agentic infrastructure that drives 50% of its code changes | LinearB Blog

> Guild.ai CEO James Everingham reveals how Meta scaled AI productivity with source control-native agents and an AI control plane—boosting developer experience and driving 50% of code changes. Learn why the future of engineering lies in a centralized AI Control Plane.

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._

[Blog](https://linearb.io/blog)

/

How Meta built the agentic infrastructure that drives 50% of its code changes

# How Meta built the agentic infrastructure that drives 50% of its code changes

![Photo of Andrew Zigler](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

By [Andrew Zigler](https://linearb.io/blog/meta-ai-control-plane-james-everingham-guildai#andrew-zigler)

|

March 31, 2026

![Blog_Meta_built_agentic_infrastructure_2400x1256_1_2b2cab0440](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Meta_built_agentic_infrastructure_2400x1256_1_2b2cab0440?_a=BAVMn6ID0)

When [James Everingham](https://linearb.io/dev-interrupted/podcast/james-everingham-guild-ai-control-plane-agents) returned to Meta to lead Dev Infra, a thousand-person organization supporting 40,000 engineers, he discovered something counterintuitive. The real productivity gains from AI were not coming from better autocomplete. They were emerging from treating AI as sentient fabric woven throughout the entire software development lifecycle.

The result was DevMate, an agent platform that grew so organically within Meta that its agents eventually submitted 50% of all code changes. Now, as CEO of guild.ai, Everingham is bringing those lessons to engineering organizations everywhere.

## Embedding agents across the software lifecycle

The initial instinct at Meta mirrored the rest of the industry: build better in-editor assistance. They achieved near feature parity with tools like Cursor through their internal Code Compose product. But the results were uneven. Junior engineers and some very senior engineers saw gains, but the broad middle of the organization experienced minimal impact.

The breakthrough came from repositioning AI from an authoring tool to an infrastructure layer. By moving agentic behavior closer to source control, where teams, tools, and processes already converge, Meta unlocked higher-leverage use cases across the development lifecycle.

The most effective adoption pattern was not mandate-driven. Instead, ambitious business challenges pushed teams to discover where agents genuinely solved problems. For example, leadership did not tell the team to build a "diff risk score" tool. Instead, they issued a challenge to the company: how do we eliminate code freeze?

This challenge-driven approach surfaced unexpected solutions. Engineers built diff risk scoring using LLMs to assess production crash risk, which enabled Meta to eliminate traditional [December code freezes](https://linearb.io/resources/software-engineering-benchmarks-report). Another team created self-healing infrastructure that could automatically detect crashes, write fixes, generate test cases, and land changes responsibly while minimizing the impact radius of an outage.

Testing workflows also evolved beyond scripted checks. Instead of trying to achieve 100% code coverage through traditional unit tests, teams built agents that simulated realistic user behavior. These agents would virtually walk down the street taking photos and searching for restaurants, exercising code paths that humans would actually trigger in production.

## Scaling agents safely with an AI control plane

As agent usage expanded from individual experiments to organization-wide systems, Meta confronted a new challenge: governance at scale. Running agents in "single player mode," where engineers spin up Claude or other tools on their local laptops, created unacceptable security, compliance, and operational risks.

"You need a control plane to be able to manage these," Everingham explains. "You need to be able to understand what these agents are doing in your infrastructure instead of just give them access to everything and let them yolo it."

The required capabilities extended far beyond simple deployment. A production-grade AI control plane needed several critical features:

* **Access management and credentials:** Scoped permissions preventing agents from accessing everything.
* **Rollback and versioning:** The ability to quickly revert problematic agent behavior.
* **Observability and debugging:** Session history and execution logs for troubleshooting.
* **Cost tracking:** Token spend visibility across concurrent agents.
* **Security guardrails:** Preventing credential leakage and malware installation.

The recent Open Claude incident, where users inadvertently exposed passwords and security keys, illustrated these risks vividly. What might be tolerable on a personal laptop becomes catastrophic at enterprise scale. Everingham likens the future of agentic infrastructure to a [managed software center](https://linearb.io/blog/platform-engineering) in an enterprise that dictates what software users are allowed to install.

Ownership of this control plane necessarily spans multiple functions. Infrastructure teams handle setup and management, security teams configure guardrails, and finance teams audit token spend. The shift from single-player to multiplayer mode requires cross-functional visibility and control.

## Driving gains with source control-native agents

The strongest productivity gains emerged when agents operated at the source control layer rather than in individual editors. Source control serves as the canonical source of truth where code, history, team structures, and tool integrations converge.

This architectural choice enabled agents to intercept tool connections and invoke workflows at critical junctures in the development process. Rather than assisting with individual coding tasks, agents could participate in code review, testing, deployment, and operational feedback loops.

DevMate provided a centralized platform where engineers could discover, inspect, fork, and extend agents. This created compounding leverage. Developers could see what agents were available, dig into how they worked, branch them, and build their own based on those existing models rather than starting from scratch.

An onboarding agent built by an engineer trying to familiarize himself with a new codebase exemplified this leverage. It transformed source control into an interactive interface. New engineers at Instagram could ask where camera filter code lived and receive not just file paths but system diagrams and historical context, essentially having conversations with the codebase itself.

At Meta's scale, reducing "time to first diff" by even a few days translated to hundreds of reclaimed person-years annually. This pattern repeated across use cases, from diff risk scoring to production change analysis.

## Measuring AI by onboarding speed and release reliability

[Measuring AI's impact on developer productivity](https://linearb.io/blog/ai-measurement-framework) proved more complex than anticipated. Promising demos did not automatically translate into organizational gains, and traditional metrics failed to capture meaningful outcomes.

"It's not even clear what the holy grail of metrics is, and it isn't lines of code," Everingham notes. "Some of the most productive developers delete more code than they create."

The measurement challenge stemmed from productivity being context-specific rather than universal. What mattered at Meta included onboarding speed, release reliability, and the ability to ship during constrained periods. Those priorities might differ substantially at other organizations.

Lines of code proved insufficient as a proxy. The most productive developers often simplified architectures and improved maintainability in ways that raw output metrics missed entirely. Feature velocity carried similar limitations because it failed to account for quality, sustainability, or strategic value.

Meta's approach centered on defining local success criteria first and then instrumenting accordingly. "Time to first diff" provided a concrete onboarding metric. Eliminating code freezes demonstrated operational impact. Broadening who could contribute beyond traditional engineering roles indicated the democratization of development capability.

These outcome-based metrics proved more meaningful than adoption counts or AI usage statistics. The question was not how many engineers used AI tools, but whether the organization could accomplish previously impossible things, like shipping safely during peak traffic periods or onboarding engineers in days instead of weeks.

## Setting ambitious challenges to drive transformation

Everingham's advice for organizations without Meta's measurement infrastructure is to start by defining what productivity means locally. Challenge teams with ambitious goals that force creative thinking about tools and processes.

You do not achieve these goals by asking for incremental improvements. You have to put crazy challenges out to your organization and push for order-of-magnitude changes. These ambitious problems demand new approaches and naturally surface where AI can provide genuine utility.

The transition from AI as a coding assistant to AI as development infrastructure represents a fundamental shift in how engineering organizations operate. Meta's experience with DevMate demonstrates that the highest-value outcomes come from embedding agents throughout the software lifecycle.

Success requires more than deploying tools. It demands centralized governance through control planes, source control-native architectures that leverage existing context, and [measurement frameworks](https://linearb.io/resources/apex-framework) grounded in organizational outcomes. Most critically, it requires leaders willing to set ambitious challenges that push teams to discover where agents genuinely create value.

To hear more about the future of agentic infrastructure, listen to James Everingham discuss these ideas in depth on the Dev Interrupted podcast. 

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

![Headshot3_d7231cbda7](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

## Andrew Zigler

Andrew Zigler is a GTM Engineer at LinearB and the host of Dev Interrupted, a twice-weekly podcast and newsletter where 40k+ builders decode the transition to AI-native development and agentic orchestration. A classicist by training with a degree from The University of Texas at Austin, Andrew spent his early career teaching in Japan before channeling his interdisciplinary instincts into the tech world. His polymath background informs everything he builds, from automated workflows to the stories he tells about the seismic shifts reshaping software creation.

### Connect with

[](https://www.linkedin.com/in/andrewzigler)
[](https://substack.com/@zigler)
[](https://x.com/andrewzigler)

## Your next read

[![Cover image for Rippling's employee graph turns HR data into an agentic AI platform](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_be5ec4183f?_a=BAVMn6ID0)](https://linearb.io/blog/rippling-albert-strasheim-employee-graph-agentic-ai)

AI

[Rippling's employee graph turns HR data into an agentic AI platform](https://linearb.io/blog/rippling-albert-strasheim-employee-graph-agentic-ai)

Rippling CTO Albert Strasheim explains why the employee graph serves as the essential context layer for enterprise agentic AI. Discover how unifying HR, IT,...

[![Cover image for Deterministic guardrails must evolve to control probabilistic AI systems](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_5_f5375661ec?_a=BAVMn6ID0)](https://linearb.io/blog/launchdarkly-cameron-etezadi-deterministic-guardrails-probabilistic-ai-darkfactory)

AI

[Deterministic guardrails must evolve to control probabilistic AI systems](https://linearb.io/blog/launchdarkly-cameron-etezadi-deterministic-guardrails-probabilistic-ai-darkfactory)

LaunchDarkly CTO Cameron Etezadi explains why traditional engineering pipelines are breaking down in a probabilistic, AI-driven world. Discover how to safely...

[![Cover image for Slack turns channels into the context engine for agentic AI](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_077524ba8b?_a=BAVMn6ID0)](https://linearb.io/blog/slack-jaime-delanghe-mcp-agent-context-channels)

AI

[Slack turns channels into the context engine for agentic AI](https://linearb.io/blog/slack-jaime-delanghe-mcp-agent-context-channels)

Slack Chief Product Officer Jaime DeLanghe breaks down how channels serve as the foundational context layer for human-agent collaboration. Learn why Slack is...

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io/",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How Meta built the agentic infrastructure that drives 50% of its code changes",
  "url": "https://linearb.io/blog/meta-ai-control-plane-james-everingham-guildai",
  "author": {
    "@type": "Person",
    "name": "Andrew Zigler"
  },
  "datePublished": "2026-03-31T07:00:00.000Z",
  "dateModified": "2026-03-31T07:00:00.000Z",
  "image": "https://assets.linearb.io/image/upload/v1775016050/Blog_Meta_built_agentic_infrastructure_2400x1256_1_2b2cab0440.png",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "Guild.ai CEO James Everingham reveals how Meta scaled AI productivity with source control-native agents and an AI control plane—boosting developer experience and driving 50% of code changes. Learn why the future of engineering lies in a centralized AI Control Plane."
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Register now](https://linearb.io/event/engineering-productivity-gap)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)