Meta Deploys AI Agents to Fix Fleet Code in Minutes, Saving Megawatts

Autonomous Infrastructure: Building AI Agents for Global-Scale Capacity Efficiency With Meta — Ai4

Ai4

Meta found autonomous infrastructure optimization only succeeds when teams replace monolithic models with modular, engineer-authored domain skills that prioritize patch precision over pull-request volume.

AI-assisted summary of Autonomous Infrastructure: Building AI Agents for Global-Scale Capacity Efficiency With Meta — original source. Check the original for full context.

Source published: 2026-08-16

Detailed notes

## Background Published on YouTube by the Ai4 channel on August 16, 2026, this presentation features Meta software engineer Tommy Tran discussing autonomous infrastructure for global-scale capacity efficiency. The session details how Meta transitioned from manual telemetry triage to deploying specialized AI agents that safely optimize production compute resources at scale.

## TL;DR At hyperscale, resolving profiler signals and optimizing resource consumption manually creates a severe engineering bottleneck. Meta addressed this by building an autonomous capacity agent framework that translates raw telemetry into structured efficiency opportunities, cleanly separating raw data retrieval via a Shared Access Layer from modular, expert-authored domain skills. Each generated code patch undergoes rigorous offline checks, staging canaries, and live metric tracking in a closed-loop feedback pipeline designed to prioritize high precision over low-quality AI pull requests. This autonomous workflow compresses deep investigations from several hours down to approximately six minutes while reclaiming megawatts of global data center power.

## Atmosphere & style The presentation has the pragmatic, authoritative feel of an engineering deep dive grounded in real production realities. Tommy Tran maintains an engaging and candid narrative, directly acknowledging developer frustrations with low-quality 'AI slop' and illustrating high-stakes failure modes like broken cache keys with relatable clarity. It comes across as disciplined, sharp, and focused on genuine operational rigor rather than generic generative AI hype.

## Key takeaways - [00:04](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=4s) At hyper-scale infrastructure companies, detecting resource waste is solved by profilers, but translating high-volume telemetry into safe, verifiable code optimizations remains the primary bottleneck. - [00:04](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=4s) Autonomous agents cannot succeed with open-ended prompts; profiler signals must be translated into structured 'efficiency opportunities' with clear behavioral invariants and concrete production metrics. - [00:04](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=4s) Capacity optimization progresses through a three-stage lifecycle: opportunity investigation and diff generation, staging and canary validation, and global rollout with feedback loops. - [02:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=164s) A Shared Access Layer uses typed adapters to decouple agent execution workflows from underlying backend services, APIs, and query languages. - [02:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=164s) The agent framework strictly separates mechanical data retrieval ('Tools') from expert heuristics and domain judgment ('Skills'). - [05:12](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=312s) Naive automated optimizations risk critical production bugs—such as caching recommendations across different users if memoization keys omit viewer IDs. - [05:12](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=312s) Monolithic optimization agents are unreliable; modular, version-controlled domain skills (e.g., PyTorch precision, model concurrency, data batching) are necessary for safe code transformation. - [08:19](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=499s) Proposed optimizations are validated in staging and canary environments against live production traffic to verify compute reductions prior to merging. - [08:19](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=499s) A closed-loop evaluation system uses successful patches as positive benchmarks while funneling rejected diffs into failure analyses to refine skill rules. - [08:19](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=499s) To prevent developer burnout from low-quality pull requests ('AI slop'), the agent system is deliberately optimized for high precision over recall. - [10:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=644s) Autonomous agents reduce the end-to-end investigation and patch formulation time from multiple engineering hours down to approximately six minutes. - [10:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=644s) Automated capacity diffs have saved megawatts of data center energy at global scale, shifting performance engineers from manual patching to skill authoring.

## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=4s) The Bottleneck in Capacity Efficiency and Structuring Agent Tasks

Capacity efficiency engineering at hyper-scale infrastructure companies like Meta traditionally begins when telemetry signals alert engineers to potential waste. A profiler or static analysis tool flags a specific configuration or code path consuming disproportionate CPU cycles or memory. Historically, resolving these flags required an entirely manual, labor-intensive workflow: a performance engineer had to trace the hot execution path, reconstruct the underlying logic, deduce why resource consumption was sub-optimal, determine what modifications were safe without breaking functionality, and hand-craft the code optimization. Profilers provide vast streams of raw diagnostics, but they do not provide actionable remedies. As systems grow, detection is no longer the bottleneck; rather, the challenge is transforming high-volume diagnostic signals into safe, verifiable, and production-ready optimizations.

```mermaid flowchart TD accTitle: Three-Stage Capacity Optimization Lifecycle subgraph S1["1. Investigation & Proposal"] A["Telemetry & Profiler Signal"] --> B["Efficiency Opportunity Definition"] B --> C["Agent Resolution & Diff Generation"] C --> D["Offline Checks & Peer Review"] end subgraph S2["2. Validation & Rollout"] D --> E["Staging / Production Canary"] E --> F["Live Metric Verification"] end subgraph S3["3. Feedback Loop"] F --> G["Capacity Savings Reported"] F --> H["Eval Benchmark & Skill Refinement"] end ```

Automating this process with AI cannot be achieved by simply prompting an agent to *"go and fix this, make it more efficient."* Open-ended instructions lack the boundaries necessary for reliable systems code. Instead, raw profiler signals must be translated into structured, testable hypotheses termed "efficiency opportunities." An efficiency opportunity precisely defines: - The target source code or configuration path. - The technical justification of why the optimization matters. - The critical behavioral invariants that must remain unchanged. - The concrete production metric to evaluate (such as latency or time-per-request).

Once an opportunity is framed, it advances through a three-stage lifecycle: the agent gathers relevant telemetry and proposes a code change for offline metric verification and human review; the change enters staging or canary environments to validate real-world production performance; and, once verified, the optimization rolls out globally to deliver capacity savings.

---

[02:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=164s) Architecture: Shared Access Layer and Tools vs. Skills

Building an autonomous capacity agent presents severe integration hurdles. An individual investigation might require querying real-time production profiles, inspecting source repositories, mapping call graphs and upstream callers, and referencing past successful patches. If every optimization workflow directly connects to each underlying service, every pipeline must individually handle distinct authentication protocols, bespoke query languages, and shifting payload schemas. To prevent combinatorial complexity, Meta adopted a **Shared Access Layer**. Each backend infrastructure system is wrapped in a single dedicated adapter hidden behind a stable, typed contract, decoupling the agent's reasoning workflows from underlying API changes.

```mermaid flowchart LR accTitle: Shared Access Layer and Tools vs Skills Architecture subgraph Backends["Backend Infrastructure"] B1["Profilers"] B2["Source Code"] B3["Call Graphs"] end subgraph AccessLayer["Shared Access Layer"] A1["Typed Adapter"] A2["Typed Adapter"] A3["Typed Adapter"] end subgraph AgentFramework["Agent Execution Engine"] T["Tools (Data Retrieval)"] S["Domain Skills (Engineering Judgment)"] end Backends <--> AccessLayer AccessLayer <--> T T --> S S --> P["Reviewable Optimization Diff"] ```

Within this architecture, the agent’s execution engine strictly separates data retrieval from domain intelligence through **Tools** and **Skills**: - **Tools**: Purely mechanical utilities that interface with the Shared Access Layer. They retrieve hot function profiles, extract caller graphs, and fetch code snippets without performing any reasoning on the data. - **Skills**: The core engineering judgment authored by specialized capacity engineers. Skills codify the rules and domain heuristics previously locked in expert engineers' minds. For example, a caching skill evaluates cache invalidation and key completeness, while a numerical precision skill for PyTorch determines acceptable margins of floating-point error.

---

[05:12](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=312s) Resolution Workflows, Memoization Pitfalls, and Domain Skills

The resolution workflow combines tools and domain skills to safely mutate code. A tool gathers source context and profiling evidence, while the domain skill dictates the transformation rules—replicating the precise reasoning steps an experienced performance engineer would execute before generating a reviewable diff.

The necessity of strict domain skills is illustrated by a memoization optimization in a hot path ranking social media stories:

``` // Conceptual Scenario: Story Ranking Function function rankStories(viewerId, stories) { // Hot execution path } ```

A naive agent attempting to optimize CPU usage might blindly wrap the function in a memoization decorator or cache layer. However, if the `viewerId` parameter is omitted from the cache key or null, the cache will serve the first computed user's recommendations to every subsequent user. While the naive fix technically reduces CPU cycles, it causes severe product degradation by serving mismatched recommendations across accounts. A specialized caching skill embeds safety rules to verify that the cache key is fully populated, evaluates cache invalidation, checks data freshness, and verifies invariant consistency.

Meta initially attempted to build a single monolithic efficiency agent to handle all optimizations, but this unified model proved unreliable. The system was re-architected around modular, domain-specific skills that can be plugged into a shared resolution workflow: - **Data Pipeline Optimization**: Stream tuning, batching, and shuffle reduction. - **Model Serving Parameters**: Worker concurrency, dynamic batch sizing, and memory pooling. - **Numerical Precision**: PyTorch quantization and floating-point adjustments tailored to strict tolerance thresholds. - **Independent Versioning**: Each skill is authored by domain specialists, version-controlled, and validated against continuous test suites of positive and negative historical examples.

---

[08:19](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=499s) Production Validation, Feedback Loops, and Combating AI Slop

The final stage of the workflow evaluates generated diffs against real-world workloads. Once a patch passes automated offline checks and engineer review, it enters staging and canary environments to measure compute utilization against baseline production traffic. If the telemetry confirms measurable compute reductions without regression, the optimization is merged; if metrics are ambiguous, the change is flagged for engineer inspection.

```mermaid flowchart TD accTitle: Closed-Loop Evaluation and Skill Refinement A["Proposed Optimization Diff"] --> B["Canary / Staging Deployment"] B --> C{"Production Outcome"} C -- "Verified Compute Savings" --> D["Positive Eval Benchmark"] C -- "Metric Regression / Failure" --> E["Failure Analysis"] D --> F["Continuous Skill Suite"] E --> G["Update Domain Skill / Detector Rules"] G --> F ```

This pipeline forms a closed learning loop: - **Positive Reinforcement**: Successful optimizations are integrated into the agent’s evaluation benchmark as positive regression suites. - **Failure Analysis**: Failures and rejected pull requests expose edge cases in detection logic or skill rules, driving targeted updates and new automated tests.

During the presentation, Tommy polls the audience on developer burnout: *"Who here has received more PR that they could just review and just get overwhelmed by AI slop?"* Acknowledging widespread frustration across engineering teams with low-quality automated pull requests, he emphasizes that Meta’s agent infrastructure is tuned deliberately for **precision** over recall. The objective is not to flood developers with speculative diffs, but to ensure that every pull request delivered to human reviewers has a high probability of acceptance and zero negative side effects, thereby establishing developer trust in autonomous infrastructure.

---

[10:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=644s) Impact: From Hours to Minutes and Saving Megawatts at Scale

Deploying autonomous capacity agents has fundamentally shifted performance engineering at Meta from manual investigation to scalable rule-authoring:

- **Investigation Latency**: Deep investigations into profiler data, hot path tracing, and safe patch formulation that previously required hours of an engineer's time are now executed by autonomous agents in approximately **6 minutes**. - **Global Energy & Capacity Savings**: Autonomous optimizations deployed across global fleet infrastructure have reclaimed **"tons of megawatts"** in data center power and computational capacity. - **Elimination of Toil**: Performance engineers no longer spend time on repetitive manual refactoring; once an optimization pattern is proven, engineers codify it into a versioned skill, allowing the autonomous system to execute and land the optimizations at scale.

## Notable quotes > [00:04](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=4s) detection is no longer the bottleneck; rather, the challenge is transforming high-volume diagnostic signals into safe, verifiable, and production-ready optimizations. — Tommy Tran

> [00:04](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=4s) go and fix this, make it more efficient. — Tommy Tran

> [02:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=164s) Each backend infrastructure system is wrapped in a single dedicated adapter hidden behind a stable, typed contract, decoupling the agent's reasoning workflows from underlying API changes. — Tommy Tran

> [02:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=164s) Skills codify the rules and domain heuristics previously locked in expert engineers' minds. — Tommy Tran

> [05:12](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=312s) A tool gathers source context and profiling evidence, while the domain skill dictates the transformation rules—replicating the precise reasoning steps an experienced performance engineer would execute before generating a reviewable diff. — Tommy Tran

> [08:19](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=499s) Who here has received more PR that they could just review and just get overwhelmed by AI slop? — Tommy Tran

> [08:19](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=499s) The objective is not to flood developers with speculative diffs, but to ensure that every pull request delivered to human reviewers has a high probability of acceptance and zero negative side effects — Tommy Tran

> [10:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=644s) Deep investigations into profiler data, hot path tracing, and safe patch formulation that previously required hours of an engineer's time are now executed by autonomous agents in approximately 6 minutes. — Tommy Tran

> [10:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=644s) tons of megawatts — Tommy Tran

> [10:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=644s) once an optimization pattern is proven, engineers codify it into a versioned skill, allowing the autonomous system to execute and land the optimizations at scale. — Tommy Tran

## Mentioned Ai4, Meta, PyTorch, Shared Access Layer, Tommy Tran

## Video description Tommy Tran - Software Engineer, Meta

Autonomous Infrastructure: Building AI Agents for Global-Scale Capacity Efficiency

[Source](https://www.youtube.com/watch?v=ai5GyxE5_nU)

中文简报

Meta部署AI智能体数分钟内修复集群代码，节省兆瓦级电力 Meta发现，只有当团队用模块化、由工程师编写的领域技能取代单体模型，并将补丁精确度置于PR数量之上时，自主基础设施优化才能取得成功。在超大规模集群中，手动分析性能剖析（profiler）信号并优化资源消耗会造成严重的工程瓶颈。Meta针对这一问题构建了一个自主容量智能体框架，将原始遥测数据转化为结构化的效率优化机会，并通过共享访问层（Shared Access Layer）将原始数据检索与模块化、专家编写的领域技能明确分离开来。每个生成的代码补丁都会在闭环反馈流水线中经历严格的离线检查、预发布金丝雀测试以及实时指标跟踪，旨在优先保证高精确度而非产生低质量的AI拉取请求。这一自主工作流将深度排查时间从数小时压缩至约6分钟，同时为全球数据中心挽回了数兆瓦的电力消耗。在超大规模基础设施公司中，资源浪费的检测已由性能分析器解决，但将海量遥测数据转化为安全、可验证的代码优化仍然是主要瓶颈。 (0:04) 自主智能体无法依靠开放式提示词取得成功；性能分析器信号必须转化为具有明确行为不变量和具体生产指标的结构化“效率机会”。 (0:04) 容量优化经历三阶段生命周期：机会调查与diff生成、预发布及金丝雀验证，以及带反馈循环的全局推广。 (0:04) 共享访问层（Shared Access Layer）使用类型化适配器将智能体执行工作流与底层后端服务、API和查询语言解耦。 (2:44) 该智能体框架将机械化的数据检索（“工具”）与专家启发式经验和领域判断（“技能”）严格区分开来。 (2:44)

Reading summary

Meta addresses hyper-scale capacity efficiency bottlenecks by translating profiler telemetry into bounded, testable hypotheses rather than issuing open-ended AI prompts. By decoupling mechanical data retrieval from modular engineering skills and enforcing canary validation, the system prioritizes patch precision over volume to safely optimize fleet infrastructure. Structuring Raw Telemetry into Bounded Hypotheses (0:04) In hyper-scale infrastructure, detection is no longer the operational bottleneck; profilers and static analysis produce continuous streams of diagnostic flags identifying inefficient CPU and memory consumption. Historically, resolving these flags required performance engineers to manually trace execution paths, deduce inefficiencies, and hand-craft safe optimizations. Unstructured instructions asking an AI agent to simply make code more efficient fail because systems software requires explicit operational boundaries. Meta resolves this by converting raw telemetry into formalized "efficiency opportunities." Each opportunity explicitly defines the target source code or configuration path, the technical rationale for the change, the critical behavioral invariants that must remain unchanged, and the concrete production metric—such as latency or time-per-request—used to evaluate success. Decoupling Mechanical Retrieval from Domain Intelligence (2:44) Integrating autonomous agents directly with underlying infrastructure creates combinatorial complexity, as each investigation requires querying profilers, source repositories, and call graphs across disparate authentication protocols and schemas. Meta addresses this by deploying a Shared Access Layer, wrapping each backend service in a dedicated typed adapter to insulate agent workflows from backend API changes. Within this framework, the execution engine strictly separates data retrieval from domain intelligence. Purely mechanical utilities called "Tools" interface with the access layer to extract call graphs, profiles, and code snippets without performing analytical reasoning. In contrast, "Skills" codify domain heuristics authored by capacity specialists, applying specific rules such as cache key validation or numerical precision thresholds in PyTorch. Preventing Failure Modes with Modular Skills (5:12) A monolithic agent architecture proved unreliable across varied systems tasks. Unconstrained automated modifications can introduce severe application failures while appearing technically successful; for example, an agent attempting to optimize a social media story ranking function might memoize the execution path but omit the viewer ID from the cache key, inadvertently serving one user's personalized recommendations to all subsequent users. To prevent logic regressions, Meta abandoned unified models in favor of modular, domain-specific skills. Dedicated skills govern areas such as data pipeline stream tuning, model serving concurrency parameters, and floating-point quantization tolerances. Each skill is maintained as an independently versioned module validated against continuous regression suites composed of historical positive and negative examples. Canary Verification and Preserving Developer Trust (8:19) Generated diffs must pass automated offline checks and engineer review before progressing to staging and production canary environments, where compute utilization is measured against baseline live traffic. The pipeline operates as a closed feedback loop: patches that confirm compute reductions expand positive evaluation benchmarks, while regressions or rejected pull requests trigger failure analyses that update domain skill rules. To counter engineer burnout from reviewing low-quality automated pull requests—termed "AI slop"—the agent framework is tuned deliberately for precision over recall. Rather than generating a high volume of speculative code changes, the architecture aims to deliver pull requests with a high probability of acceptance and zero negative side effects, preserving developer trust in autonomous changes. According to the presentation, automating investigation workflows has reduced the time needed to trace hot paths and formulate safe patches from multiple hours to approximately 6 minutes, while reclaiming megawatts of data center capacity across Meta's fleet. The system shifts human performance engineers away from repetitive manual refactoring toward authoring and maintaining versioned domain rules executed by autonomous agents.

精炼阅读摘要

Meta展示了如何通过构建自主容量智能体，将超大规模基础设施的性能优化从耗时的人工排查转变为结构化的自动化工作流。该系统通过解耦数据获取工具与专家工程技能，并在生产金丝雀验证中坚持精确度优先，实现了数兆瓦计算容量与功耗的回收。优化瓶颈转移与结构化机会定义 (0:04) 在超大规模基础设施运营中，性能分析工具已能持续告警低效代码或配置，但排查热点路径并手工编写安全补丁仍然耗费大量人力。随着系统规模扩大，容量优化的瓶颈已不再是发现低效现象，而是如何将海量诊断信号安全转化为符合生产标准的补丁。直接让智能体执行开放式的优化指令往往因缺乏边界约束而失败，因此必须将性能告警重构为明确的“效率机会”。一个规范的效率机会需要精确界定目标代码或配置路径、优化背后的技术依据、执行过程中必须保持不变的行为约束，以及具体的生产评估指标（如请求耗时或延迟）。只有以此为基础，优化补丁才能在离线审查、金丝雀分流验证与全局部署等阶段中可靠流转。共享访问层与工具技能解耦架构 (2:44) 性能优化智能体需要同时与实时画像系统、源码仓库以及调用图谱等多种异构后端对接。若为每个优化流程分别开发直连逻辑，将导致认证协议与查询接口的维护极其复杂。Meta为此引入了“共享访问层”，使用统一的类型化适配器封装各底层系统，从而隔离底层API的频繁变动。在执行架构上，系统严格分离了“工具”与“技能”。工具是纯机械性的数据提取接口，专门通过访问层抓取热点函数或调用图，不包含任何业务推理；技能则由资深容量工程师编写，负责将工程经验与判定规则代码化，例如校验缓存失效机制是否完备，或评估PyTorch在数值精度调整时所允许的浮点误差范围。模块化领域技能规避盲目优化陷阱 (5:12) 若缺乏严格的领域技能约束，智能体在追求降低算力消耗时极易破坏业务正确性。以社交内容排序函数的记忆化改造为例，如果智能体盲目添加缓存而遗漏了查看者ID参数，虽然CPU利用率得以降低，却会导致不同用户之间串取推荐内容，造成严重的功能降级。专业的缓存技能会预先验证键值完整性、数据时效性以及业务不变性。 Meta最初尝试构建单一通用的优化智能体，但由于可靠性不足，最终转向了模块化的可插拔架构。数据管道批处理、模型服务并发控制以及数值精度量化等专业优化场景被拆解为独立的领域技能，各项技能由专家单独维护版本，并通过包含历史正反例的测试集持续进行回归检验。金丝雀闭环评估与重视高精确度 (8:19) 智能体生成的代码补丁在通过自动化离线检查与人工审查后，会部署到预发及金丝雀环境承接真实流量，以验证计算资源利用率的实际改善。验证成功的案例会被纳入正向评测基准，产生回退或失败的案例则触发归因分析以反哺探测规则与技能库的迭代，形成闭环学习机制。演讲者Tommy指出，许多工程团队正面临低质量AI生成代码（AI slop）带来的审查疲劳与抵触情绪。因此，Meta的容量智能体在调优时明确将精确度置于召回率之上，宁可减少补丁推送数量，也要确保送交人工审查的代码具备极高采纳率且无副作用。目前，单次性能调查耗时已从过去的数小时缩短至约6分钟，并已在全球数据中心回收了数兆瓦规模的电力与计算容量。 Meta的实践表明，在大规模基础设施中成功部署AI智能体依赖于领域规则的代码化与闭环验证，而非开放式代码生成。通过将工程重心从手工优化转向编写具备独立测试用例的专业技能，团队在保证系统稳定性和开发者信任的同时实现了规模化容量节省。

Detailed notes — zh

## Background 本内容由 Ai4 频道于 2026 年 8 月 16 日在 YouTube 平台发布。视频由 Meta 软件工程师 Tommy Tran 主讲，主题为《自主基础设施：为 Meta 全球级容量效率构建 AI Agent》。 ## TL;DR 面对超大规模基础设施中性能信号海量却难以落地优化的瓶颈，Meta 研发了一套面向容量效率优化的自主 AI Agent 体系。架构上，团队将性能瓶颈抽象为具备严格约束的“效率机会”，通过共享接入层解耦底层异构系统，并将资深工程师的专业判断固化为模块化的领域技能库。系统结合真实生产流量验证与闭环反馈，将以往数小时的人工排查压缩至 6 分钟，并通过极致追求高精确度避免“AI 垃圾代码”，最终在全球规模下实现了兆瓦级的物理算力能耗节约。 ## Atmosphere & style 演讲展现出严谨务实且直击痛点的顶级大厂工程风格，叙事条理清晰、抽丝剥茧。讲者以沉稳自信的技术语言拆解复杂架构，期间抛出对泛滥“AI 垃圾代码”的灵魂拷问，瞬间拉近了与一线开发者的距离。整场分享既有对底层架构演进的深思，又充满了将理论落地并节约巨额物理能耗的硬核工程自豪感。 ## Key takeaways - [00:04](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=4s) 在大规模基础设施中，算力能效瓶颈不在于静态工具与 Profiler 发现问题，而在于缺乏将海量离散信号转化为安全落地优化的自动化手段。 - [00:04](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=4s) 提出结构化的“效率机会”（Efficiency Opportunity）概念，通过精确限定目标代码路径、系统不可变行为及核心指标，将模糊的排查转变为边界清晰的可验证任务。 - [00:04](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=4s) 优化的端到端生命周期严格划分为三个阶段：Agent 调查取证与代码生成、工程师离线评审、生产/预发环境实测验证与收益核算。 - [02:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=164s) 通过“共享接入层”（Shared Access Layer）与稳定类型契约隔离异构后端 API，有效避免了各优化工作流与底层系统的网状直连耦合。 - [04:08](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=248s) 架构上将“工具”（数据与信息检索）和“技能”（工程判断与业务规则）严格解耦，技能负责指挥 Agent 做出符合资深工程师水准的严谨决策。 - [04:08](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=248s) 专家技能对高风险场景实施严密约束（如记忆化缓存的键值完整性与时效校验），防止无脑优化导致数据陈旧或推荐漂移等业务事故。 - [07:13](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=433s) 摒弃难以收敛的全能型单体 Agent，演进为“通用解析引擎 + 领域专家技能库”的模块化架构，便于快速横向扩展至数据流、模型推理及 PyTorch 等多样化基础设施场景。 - [07:13](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=433s) 领域技能支持独立版本控制，并在包含正向范例与反向错误用例的评测集中进行持续回归测试，保障输出质量的可靠性。 - [08:19](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=499s) 建立生产灰度验证与自适应反馈闭环：成功变更合并上线并沉淀为评测用例，失败案例则作为反例驱动技能规则迭代更新。 - [09:40](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=580s) 核心设计原则将“精确度”（Precision）置于首位，宁缺毋滥，从源头杜绝制造让工程师疲劳的“AI 垃圾代码”（AI Slop），以此建立团队信任。 - [09:40](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=580s) 自动化系统将原本耗时数小时的性能调查压缩至 6 分钟，并在 Meta 全球基础设施规模下实现了以兆瓦（Megawatts）为量级的物理电力与算力节省。 ## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=4s) 效能工程的瓶颈与“效率机会”的结构化定义在大型互联网基础设施中，算力与容量的能效优化（Capacity Efficiency）通常始于底层监控发出的异常信号。性能分析器（Profiler）或静态分析工具会敏锐地指出某段代码或配置路径消耗了超出预期的 CPU 或内存。然而，传统的应对流程极度依赖人工介入：性能工程师必须手动追踪热点调用链路（Hot Path），推演代码原本的设计逻辑与出错诱因，评估在此处实施优化是否安全，进而决定采取何种方案。这类工具虽然能提供海量数据，却无法给出具体的行动指南。随着系统规模扩张，当前基础设施的瓶颈早已不是“发现问题”，而是“如何将源源不断的告警信号转化为安全、可衡量的优化落地”。面对这种困境，简单的自动化思路往往行不通——你绝不能直接对一个 AI Agent 抛出一句模糊的指令：“去把这段代码优化一下”。为了让系统能够自动化执行调查，必须将离散的性能信号升华为一种具备明确结构和可验证假设的概念，即“效率机会”（Efficiency Opportunity）。一个合格的“效率机会”必须精确框定目标代码或配置路径、该瓶颈为何至关重要、系统绝对不能改变的行为约束，以及必须在生产环境中监控的核心指标（如单次请求耗时 Time per Request）。这种机制将原本开放式、无边界的工程调查转变为任务边界清晰的工程作业。在此定义下，优化的生命周期严格经历三个阶段：首先由 Agent 收集证据并生成代码变更，交由工程师进行离线指标评审；随后变更进入预发或分期验证环境（Staging），观察其在真实流量下的表现；最终在各项指标完全达标后全量上线，正式产出算力节约收益。 ```mermaid flowchart TD accTitle: 效率机会的端到端生命周期 subgraph S1["信号与机会定义"] A["Profiler / 静态分析信号"] --> B["结构化『效率机会』 (代码路径 / 不可变行为 / 核心指标)"] end subgraph S2["Agent 调查与生成"] B --> C["Agent 收集多源证据"] C --> D["生成优化变更 (PR)"] end subgraph S3["验证与闭环"] D --> E["工程师离线评审"] E --> F["生产/预发环境验证"] F --> G["全量上线并核算能效收益"] end ``` ### [02:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=164s) 共享接入层：打破工具集成与后端耦合的壁垒在构建自动化系统的起步阶段，首要遇到的技术壁垒是跨系统的多源数据集成。为了彻底排查一个效率机会，Agent 需要同时访问生产环境性能画像（Production Profiles）、源代码仓库、代码路径的上下游调用者上下文，甚至需要检索过往同类型的成功优化案例。如果采用点对点的直连集成模式，系统每增加一种优化工作流，该工作流都必须重新理解所有后端系统的鉴权认证机制、查询接口及返回格式。这种网状的复杂度会随接入系统的增加呈爆炸式增长。为了解决这一痛点，架构中引入了“共享接入层”（Shared Access Layer）。在该层级中，系统为每一个后端服务编写专属的适配器（Adapter），并将其隐藏在统一且稳定的强类型契约（Stable Typed Contract）之后。各类优化工作流在运行时仅依赖这一标准化契约，彻底与底层后端 API 解耦。当某一内部后端系统发生接口变更或升级时，工程师仅需更新对应的单个适配器，而上层编排的众多优化工作流完全不受波及。 - **直连集成的缺陷**：工作流必须深度耦合所有后端的认证逻辑、专属查询语法与异构响应体，扩展成本极高。 - **共享接入层的价值**：以稳定类型契约隔离底层易变性，实现“单点适配器更新，全局工作流复用”。 ### [04:08](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=248s) 工具与技能的解耦：将专家工程判断固化为 Agent Skills 解决了底层数据访问后，系统面临的更深层挑战在于：数据本身不等于工程决策。为了赋予 Agent 真正的分析能力，架构将系统能力清晰地拆分为“工具”（Tools）与“技能”（Skills）两个正交维度。工具负责依托共享接入层执行确定的操作，例如检索热点函数、拉取相关画像或查询调用链路；而技能则承载了原本只存在于资深容量与性能工程师头脑中的专业“工程判断”（Engineering Judgment）。这种分工明确划定了边界：“工具不提供思考，它们只允许 Agent 检索数据或信息；而技能才是告诉 Agent 应该做什么的指挥官”。在执行优化时，工具收集代码上下文与生产证据，特定模式的技能则施加严格的工程规则。以高频热点路径上的记忆化缓存（Memoization）为例，一个缺乏领域知识的浅薄 Agent 可能会盲目地在排序函数上加上缓存注解，表面上确实能削减计算消耗，但如果该函数在特定分支遗漏了受众标识（Viewer ID），就可能引发灾难性的业务漂移——用户最终会看到本应推荐给其他人的动态内容。针对缓存优化的专家技能会强制执行严密的校验规则，包括“键值是否完备”、“数据何时会变陈旧”，在确保业务语义毫秒不差的前提下输出可被同行评审的代码变更。 - **缓存优化技能**：主动审查缓存键的完备性、穿透风险以及数据失效机制。 - **数值精度技能**：在 PyTorch 等数值计算场景中，精确界定精度调整可容忍的误差阈值。 ### [07:13](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=433s) 模块化架构演进：从单一 Agent 到领域专家技能库在项目早期，研发团队曾尝试训练或编排一个包揽全部效能工作的“全能型单体 Agent”，但实践证明这种方式极易崩溃且难以收敛。系统的最终演进方向是确立一套通用的解析工作流程（Shared Resolution Workflow），通过插拔不同的配置与领域技能来纵向扩展优化领域。在这种模块化架构下，除了常见的记忆化缓存，系统能无缝拓展至多样化的复杂基础设施场景，例如数据流水线吞吐优化、模型推理服务参数调优、PyTorch 算子数值精度转换等。每新增一种性能优化范式，工程师无需重写工作流，只需由该领域的资深专家编写一套对应的 Skill 模块。这些技能具备独立的版本控制，并在大量精选的正向范例与反向错误用例中进行持续回归测试，从而稳定输出高质量的代码优化候选方案。 ```mermaid flowchart LR accTitle: 模块化专家技能系统架构 subgraph Engine["通用解析引擎"] W["共享解析工作流 (Shared Resolution Workflow)"] end subgraph DomainSkills["版本化领域技能库"] S1["缓存优化 Skill (Cache Completeness)"] S2["模型服务调优 Skill (Model Serving Tuning)"] S3["数据流水线 Skill (Pipeline Throughput)"] S4["数值计算精度 Skill (PyTorch Precision)"] end DomainSkills --> Engine ``` ### [08:19](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=499s) 生产环境验证与闭环反馈机制代码生成与同行评审仅仅是优化的起点，任何自称能提升算力效率的变更都必须经受真实生产流量的严苛检验。当优化变更通过离线测试与人工代码审查后，系统会将其推入灰度测试或分期部署环节（Staging），与生产环境基线数据进行实时对照分析，精确核算其是否切实削减了算力开销。如果线上测试结果符合预期，优化将正式合并发布；若数据波动或收益不明确，则交由值班工程师介入分析；一旦验证失败，系统会执行回滚。整个过程构筑起一个自适应的演进闭环：成功的优化案例会自动沉淀为高质量的正向评测集（Positive Evaluation Cases）；而连续遭遇失败的案例则是一面镜子，直接暴露出检测规则的盲区或对应技能的逻辑缺陷。工程师团队会根据失败暴露的边缘场景，编写新的测试用例并迭代发布新版本的专家技能，驱动系统认知不断进化。 ### [09:40](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=580s) 拒绝“AI 垃圾代码”：以高精确度赢得工程师信任与规模化效益在谈及开发体验时，讲者抛出了一个直击当下痛点的共鸣问题：“现场有谁收到了多到看不过来的 PR，并且正被各种‘AI 垃圾代码’（AI Slop）搞得苦不堪言？”当下 AI 辅助研发最大的信任危机往往在于低质代码轰炸造成的评审疲劳。因此，该系统的核心设计哲学是将“精确度”（Precision）置于一切指标之上，宁缺毋滥——系统考核的关键是推送上线的代码中能够最终被工程师无异议接受且零错误生效的比例，以此确立工程团队对自动化基础设施的底层信任。在落地效益方面，这套自主能效 Agent 体系展现出了惊人的业务价值： - **效率飞跃**：过去资深性能工程师需要耗费数小时收集性能画像、翻阅代码与论证方案，如今在 Agent 协作下整个调查流程被压缩至短短 **6 分钟**。 - **物理能耗节约**：在 Meta 的全球化基础设施规模下，系统累计节省了以**兆瓦（Megawatts）**计的巨额电力与机房算力容量。 - **工程师体验改善**：彻底解放了人力，将工程师从重复、单调的排查套路中解脱出来，把成熟的工程优化经验固化为可复用的自主资产，在全球规模的底层架构中释放长效价值。 ## Notable quotes > [00:04](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=4s) 去把这段代码优化一下 — Tommy Tran > [00:04](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=4s) 当前基础设施的瓶颈早已不是“发现问题”，而是“如何将源源不断的告警信号转化为安全、可衡量的优化落地” — Tommy Tran > [02:44](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=164s) 单点适配器更新，全局工作流复用 — Tommy Tran > [04:08](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=248s) 工具不提供思考，它们只允许 Agent 检索数据或信息；而技能才是告诉 Agent 应该做什么的指挥官 — Tommy Tran > [04:08](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=248s) 键值是否完备 — Tommy Tran > [04:08](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=248s) 数据何时会变陈旧 — Tommy Tran > [09:40](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=580s) 现场有谁收到了多到看不过来的 PR，并且正被各种“AI 垃圾代码”（AI Slop）搞得苦不堪言？ — Tommy Tran > [09:40](https://www.youtube.com/watch?v=ai5GyxE5_nU&t=580s) 将“精确度”（Precision）置于一切指标之上，宁缺毋滥 — Tommy Tran ## Mentioned Tommy Tran, Meta, Ai4, PyTorch, CPU ## Video description Tommy Tran - Software Engineer, Meta Autonomous Infrastructure: Building AI Agents for Global-Scale Capacity Efficiency [Source](https://www.youtube.com/watch?v=ai5GyxE5_nU)

Source quotes

[0:04] Tommy Tran: 去把这段代码优化一下 [0:04] Tommy Tran: 当前基础设施的瓶颈早已不是“发现问题”，而是“如何将源源不断的告警信号转化为安全、可衡量的优化落地” [2:44] Tommy Tran: 单点适配器更新，全局工作流复用 [4:08] Tommy Tran: 工具不提供思考，它们只允许 Agent 检索数据或信息；而技能才是告诉 Agent 应该做什么的指挥官 [4:08] Tommy Tran: 键值是否完备 [4:08] Tommy Tran: 数据何时会变陈旧 [9:40] Tommy Tran: 现场有谁收到了多到看不过来的 PR，并且正被各种“AI 垃圾代码”（AI Slop）搞得苦不堪言？ [9:40] Tommy Tran: 将“精确度”（Precision）置于一切指标之上，宁缺毋滥

Source quotes

[0:04] Tommy Tran: detection is no longer the bottleneck; rather, the challenge is transforming high-volume diagnostic signals into safe, verifiable, and production-ready optimizations. [0:04] Tommy Tran: go and fix this, make it more efficient. [2:44] Tommy Tran: Each backend infrastructure system is wrapped in a single dedicated adapter hidden behind a stable, typed contract, decoupling the agent's reasoning workflows from underlying API changes. [2:44] Tommy Tran: Skills codify the rules and domain heuristics previously locked in expert engineers' minds. [5:12] Tommy Tran: A tool gathers source context and profiling evidence, while the domain skill dictates the transformation rules—replicating the precise reasoning steps an experienced performance engineer would execute before generating a reviewable diff. [8:19] Tommy Tran: Who here has received more PR that they could just review and just get overwhelmed by AI slop? [8:19] Tommy Tran: The objective is not to flood developers with speculative diffs, but to ensure that every pull request delivered to human reviewers has a high probability of acceptance and zero negative side effects [10:44] Tommy Tran: Deep investigations into profiler data, hot path tracing, and safe patch formulation that previously required hours of an engineer's time are now executed by autonomous agents in approximately 6 minutes. [10:44] Tommy Tran: tons of megawatts [10:44] Tommy Tran: once an optimization pattern is proven, engineers codify it into a versioned skill, allowing the autonomous system to execute and land the optimizations at scale.

Original transcript

[0:04] I'm Timmy, I'm a software engineer. I work at Meta. Um and today I'm going to [0:08] talk you through how um I use AI agents to make capacity efficiency savings at Meta. [0:14] Um so, to start, uh just about efficiency work in general, um efficiency work usually starts with [0:22] um a signal, like a profiler or like a static analysis uh points to like code or like a config [0:28] path um that's using more memory or more CPU than it should. And then from there, [0:34] usually like the process is usually very manual, like um like an engineer like traces the hot path, [0:42] um like reconstruct like, you know, why the code like why why why could what could be [0:47] going wrong with the code, um and then that way decides like whether they should implement a [0:52] uh an optimization or not, and what can be safely done here. Um but the issue is that, [0:57] you know, this takes a lot of time, and usually like those like signals tools that you have, like [1:03] profilers that they give you like data, but they don't really tell you like what to do. Um and so [1:10] um the the bottleneck here now is usually not detection, uh instead it's turning [1:15] these growing streams of um signals into like safe and measurable optimization. [1:24] Um so, how how do we automate part of that investigation? Um you can't just tell an agent, [1:31] "Hey, like go and fix this, make it more efficient." Um you have to turn this [1:35] signal into like a structure a structured like hypothesis and testable hypotheses, what I call [1:42] um an efficiency opportunity. Um so, it identifies like the code or the configuration path, um [1:48] why it matters, um what behaviors must not be changed, and the production metric that you care [1:53] about. Uh for example, like that could be a time per request. Um and so that gives the agent like [1:59] a bounding engineering task rather than like an open-ended investigation. And so once you [2:05] have this that opportunity um the life cycle um happens in three stages. Um so the first one is [2:13] the agent gathers uh and proposes proposes change. Um and before it lands like you know an [2:19] engineer reviews it to make sure that the offline metrics are fine. Um second it's going to enter um [2:26] like a staging stage where you can kind of like test what it's going to look like on production. [2:31] And if the metric looks good, then you can roll it out uh and uh finally like report [2:36] some efficiency savings. Uh so let's dive into the the first uh the first part here. [2:44] So while building this, um I think the first challenge is the integration. Uh so [2:50] one investigation uh for an efficiency opportunity may need like uh production profiles, source code, [2:58] um whoever is coding that specific code path, um similar past optimizations maybe. Um and if [3:05] you use a direct integration model, like every workflow every optimizer optimization workflow [3:10] that you're going to build um is going to have to understand every back end, every authentication, [3:16] queries, uh and response formats. And that grows like very quickly. And so that's why you want to [3:22] you want to choose what I call a shared access layer instead. Um so each back end gets one [3:29] adapter uh behind um a stable type contract. And so that workflows only depend on the contract [3:36] and not on the back end API. Um and so that when you do like back end changes, like um [3:42] one adapter like um so a back end change updates uh one adapter instead of many workflows. [3:49] Um so that's for integrating the agent to getting like the evidence. Um [3:57] and if you look at the second stage of this, like for now you only have like the data set of things, [4:03] but you don't have um the actual uh judgments. Um and so, this is where uh [4:10] you want to you want to use like a combination of tools and skills. Um so, tools, they're going to [4:15] increment the access layer, they retrieve a hot function query, it's pretty profile [4:21] or like find whoever's calling them. And skill, I think this is the most important part here, [4:26] is going to contain the engineering judgment. Um so, the knowledge that used to live in some [4:32] like specialized capacity engineers going to be written down into the skills. Um so, that each uh [4:40] that they would be applied to each optimization type. Uh for example, like the caching skill [4:46] uh ask when a value becomes stale, uh a skill for optimizing like a numerical precision calculation [4:53] in PyTorch uh will ask how much error is acceptable. Um so, to sum up, like tools tell us [5:01] I like tools, they don't give you any thinking, they just allow the agent to retrieve data or [5:06] information, and the skill is what's going to tell the agent what to do. [5:12] Okay. And so, when you put those two together, um this is where you get like the resolution flow [5:17] for the efficiency optimization. Um so, the tools going to gather like the different the [5:23] all the relevant relevant code and production evidence. And the skill for that optimization [5:28] pattern is going to apply its rule uh and say what the state, what behavior must uh like the [5:35] the skill would tell the agent exact exactly what the performance engineer would have done before. [5:41] Uh and only then the the like the system can propose like a change that an engineer can review. [5:47] And so, if we can like take this into like a a more concrete example, [5:51] um so, here's a simple like memorization example. Um you know, suppose you have like [5:57] a function that's uh whose job is to like rank stories, and that function takes the viewer ID. [6:03] Uh and like runs in a hot path. Like uh a dummy like agent could just go and cache it. [6:09] Uh but and that that will actually like result in like some efficiency optimization, [6:14] but the issue here is that uh if there in that case like the viewer ID would was missing, then [6:20] what will happen is that although you did do an efficiency optimization, uh the product behavior [6:25] will actually change, and that's really bad. So, in that example like you could end up like [6:29] receiving um stories recommendation that would be for someone else and not tailored to you. [6:36] Uh and this is where like the skill matters. Like what the model um like the cache like [6:41] a performance expert in caching will actually write uh to check whether the key's complete, uh [6:47] whether like the value is stale, and other like a bunch of other rules that they would know. [6:55] And so, yeah, that expert judgment would be applied uh consistently to every like memorization [7:01] like optimization in that case. Uh but then like how what do you do when you want to expand that [7:05] to other um other type of optimization? Yeah, so that's why uh I built this uh [7:13] using like a shared resolution workflow. Um like like the previous memorization example [7:19] there you have was just one example in one of the possible configuration, but other configuration [7:24] could be handling uh data pipelines, uh model serving parameters, uh numerical precisions, um [7:31] and so like the possibilities are infinite, and they're just up to like whoever uh [7:37] capacity engineer can like onboard into the agent. And so, suppose you add a new [7:43] optimization type usually means adding a new just a new configuration and new skill for new domain. [7:54] And yeah, so we actually tried to like have only one single efficiency agent at the beginning. [8:00] It just wouldn't work. So now like each optimization type has its own skill [8:05] that's all that offered by other main experts that's version that's tested [8:10] against good and bad examples and this is what produces like better optimization candidates. [8:19] And so that brings us to the [8:22] like last step of this process which is around like production validation. [8:29] The the change like you have so at this stage I change have passed like [8:35] like reviews and offline checks and now we just have to compare it to [8:41] the production data and see if actually like saves on compute. [8:46] And if the result in the like in that case it's multiple scenario like you could either pass [8:51] or if it's unclear like an engineer could review and then if the face it and land any optimization [8:57] then we just write it back. And so yeah, that that last result kind of like closes the loop. [9:06] When an optimization is created there's some successes, there's some like failures. [9:13] They they they both use for like successes become positive evaluation cases. [9:18] Repeated failures like make sure that the detector like the skill is not very well suited [9:24] or is has to be updated and this is when like the iteration process kind of like happens and [9:31] engineers turn that evidence into like new test or like new version of the scale. [9:40] Um just yeah, quick a quick question for the audience. Who here has received more PR [9:47] that they could just review and just get overwhelmed by AI slope? [9:52] Yeah, I feel like most engineers would relate to that. Um and so yeah, I think I feel like here um [9:59] this is where I like to emphasize one of the I I like to emphasize one of the um [10:07] core principles for this system is uh like and as the person in the presentation said, [10:13] like trust now is becoming more and more important in these kind of systems. And that's why while [10:18] building this, you want to like have clearly tested and versioned skills that are built by [10:23] the performance engineers. Um and you want to [clears throat] optimize. So, I chose to [10:28] optimize for precision. So, meaning like the percentage of fixes that were shipped have any [10:34] error eventually accepted. Uh so that you build a system that eventually is trusted by engineers. [10:44] And so, what this did this system uh result in practice? So, it would like performance [10:51] engineers would spend hours kind of like you know, gathering the different profile signals, [10:57] digging into the code, trying to see whether the fixes made made sense. This used to take hours and [11:03] only 6 minutes now. Our robot We're able to save like tons of megawatts with this uh system. And [11:09] most importantly, I think what you realize is like I think people get bored at doing like repetitive [11:15] tasks. And so, it's once an optimization had been proven and was able to be automat- uh automatized, [11:22] then this is where like yeah, the the the the big- the biggest value I would say um came. [11:32] And so yeah, that's um efficiency um AI chunks for efficiency um at global scale.