Meta Deploys AI Agent Swarms to Cut Network Design Time

@Scale

Deterministic grounding rules and multi-agent coordination reduce network topology drafting times from six weeks to minutes while keeping human architects in the loop for final approval.

AI-assisted summary of Lightning Talk: 10x Network Design Engineer | Maaz Mohiuddin, Meta — original source. Check the original for full context.

Source published: 2026-09-13

Detailed notes

## Background Published by @Scale on YouTube on August 27, 2026, this video features a lightning talk by Maaz Mohiuddin from Meta. According to the page description, the presentation explores how network design engineering is evolving from a fragile, judgment-heavy manual process into an agent-assisted workflow, shifting the engineer's role from author to approver.

## TL;DR Maaz Mohiuddin breaks down why traditional, sequential network design handoffs lead to silent errors and how generic LLMs fail without strict grounding in deterministic network rules. To solve this, Meta utilizes a swarm of specialized AI agents—ranging from code search to config rendering—backed by RAG and strict validation layers. This architecture accelerates tasks like network sizing from six weeks down to minutes while handling low-level IP addressing and complex dynamic scenario planning. Ultimately, while human architects remain essential for final approval, AI automation is driving a 10x to 20x productivity boost with the long-term goal of 100x end-to-end orchestration.

## Atmosphere & style The presentation carries a pragmatic, focused, and forward-looking technical energy typical of a high-level engineering conference. Maaz delivers a realistic assessment of complex network architecture, balancing a candid acknowledgment of past operational headaches with compelling enthusiasm for multi-agent workflows. Watching the talk feels like a sharp, efficient deep-dive into the practical future of datacenter engineering, demystifying AI hype with concrete architectural realities.

## Key takeaways - [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) Designing datacenter network infrastructure requires translating business requirements into physical topologies, low-level IP addressing, and a bill of materials. - [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) Traditional network engineering handoffs suffer from uncodified tribal knowledge, slow serial execution, and silent errors that propagate into turn-up failures. - [01:52](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=112s) Generic coding LLMs fail at network architecture because networking demands absolute correctness and global connectedness across the entire bill of materials. - [01:52](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=112s) Grounding AI models with deterministic platform constraints, historical RAG retrieval, natural language intent, and continuous validation eliminates hallucinations. - [04:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=267s) A specialized agent swarm—spanning code search, config rendering, wiki reading, and diagram digestion—handles modular tasks to draft unified designs. - [06:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=387s) Automated network sizing reduces the cycle time for transforming capacity demands into validated topologies from six weeks to a matter of minutes. - [06:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=387s) AI agents manage low-level deterministic addressing and execute complex dynamic 'what-if' forecasting scenarios across datacenter rack expansions. - [08:39](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=519s) AI shifts the network engineer's role from manual draft author to strategic reviewer, driving a 10x to 20x speedup with a 100x end-to-end orchestration target.

## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) From High-Stakes Blueprints to Fragile Handoffs

Maaz Mohiuddin introduces the reality of network architecture: taking a high-level plan and transforming it into a complete, build-ready design artifact. While being a network architect looks glamorous on the surface—drawing diagrams that turn into hundreds of millions of dollars in physical hardware handling real-world traffic—the actual underlying engineering process is a vulnerable chain of sequential handoffs. A business requirement is sized into a capacity demand, which translates into a network topology, undergoes low-level design (such as IP addressing), produces a detailed bill of materials (BOM) specifying what, where, and when to ship, and finally culminates in on-site physical rack-and-stack, cabling, and configuration.

Every arrow in this workflow represents a handoff, and every handoff is fundamentally fragile due to three critical structural problems:

* **Tribal Knowledge:** The core rules governing network correctness remain uncodified, living inside engineers' heads or scattered across disparate wiki pages rather than in executable code. * **Serial Execution:** The sequential nature of the process makes it exceptionally slow, preventing any meaningful parallelization across stages. * **Silent Error Propagation:** Mistakes introduced in the earliest design steps often remain hidden until final turn-up on site, resulting in catastrophic network outages or weeks of delayed capacity delivery.

[01:52](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=112s) Why Generic LLMs Fail and the Power of Grounding

Generic or off-the-shelf coding LLMs cannot solve network architecture out of the box because networking is not traditional code. In software development, code is often "close enough," backed by unit tests that catch errors during compilation or build cycles. In network engineering, however, there is a strict correctness bar alongside complex global connectedness criteria—modifying a single port or role can trigger a ripple effect across the entire bill of materials. The solution lies in grounding LLMs using deterministic rules (like port budgets, routing aggregation logic, and hardware platform limits) that act as strict integration tests.

To ground AI agents in reality and eliminate hallucinations, the engineering framework relies on four core pillars:

* **Domain Context & Codified Rules:** Explicitly defining platform constraints into the models (e.g., establishing that a specific 4RU switch strictly has 128 ports). * **Historical Design Retrieval (RAG):** Indexing hundreds of battle-tested prior designs into a high-performance database so agents can retrieve proven patterns without performance penalties. * **Natural Language Intent:** Enabling engineers to converse naturally with the system during design, keeping creative flow intact rather than losing momentum writing manual documentation. * **Validation Layer:** Enforcing a rigorous verification step with concrete rules to catch omissions or structural errors automatically.

[04:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=267s) The Multi-Agent Ecosystem and Institutional Memory

To navigate network design under the hood, institutional memory is explicitly structured into modular scopes and formal naming conventions. Network domains are compartmentalized into aggregation layers (with fabric cross-connects), edge connections to the backbone, backbone planes, mesh groups, and standardized rack specifications. Core variables are explicitly typed—device names follow a structured `[Prefix]-[Plane]-[Index]-[Site]` format, circuit roles map A-endpoints to Z-endpoints, and IP addressing schemes strictly adhere to block, prefix, region, metro, and plane rules.

``` [ Engineer Intent / Natural Language ] │ ▼ ┌─────────────────────────────────┐ │ Specialized Agent Swarm │ ├────────────────├────────────────┤ │ Deep Tech / │ Config Render │ │ Repo Search │ │ ├────────────────├────────────────┤ │ Wiki Reader │ PDF / Diagram │ │ │ Digest │ └────────────────┴────────────────┘ │ ▼ ┌─────────────────────────────────┐ │ Grounding & RAG Retrieval │ │ (Historical Designs & Rules) │ └────────────────┴────────────────┘ │ ▼ ┌─────────────────────────────────┐ │ Validation Engine │ │ (Deterministic Integration Test)│ └────────────────┴────────────────┘ │ ▼ [ Human Architect: Review & Approve ] ```

Instead of relying on a single monolithic model, the system uses a coordinated swarm of specialized agents: * A **Deep Tech Agent** to search internal code repositories. * A **Config Rendering Agent** to generate final device configurations. * A **Wiki Reading Agent** to extract context from internal documentation. * A **Document Digest Agent** to parse large technical PDFs and diagrams into structured data. * A **Visualization Agent** to render network topologies, dashboards, and visual artifacts.

Working together, these agents take intent, retrieve grounded data, draft a design, validate constraints, and present the final proposal to a human engineer. This workflow transforms the engineer's role from manual author to strategic approver, yielding a **10x productivity speedup** by turning an hour of manual drafting into a two-minute review.

[06:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=387s) Production Wins: Sizing, Addressing, and Scenario Planning

The framework's primary production use case is autonomous network sizing. Previously, translating business demands into a verified topology was a chaotic web of manual scripts and spreadsheets taking up to **6 weeks**. With AI agents driving underlying mathematical capacity models via natural language queries, engineers can generate complete, production-grade fabric topologies in just minutes. Over a six-month period, hundreds of these automated capacity analyses were successfully executed and validated in real production environments.

Beyond high-level sizing, the agents excel at deterministic low-level design tasks and complex dynamic forecasting:

* **Deterministic Addressing:** Automatically allocating subnets, device IPs, and interface prefixes across regions, metros, and planes in strict compliance with top-level IP hierarchy rules. * **Complex "What-If" Analysis:** Evaluating major structural modifications—such as calculating the operational, stack, and tooling trade-offs required to expand data center network rows from 38 to 44 racks.

[08:39](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=519s) The Road Ahead: From 10x Drafting to 100x End-to-End Orchestration

AI-driven network design is currently in the second phase of its technological maturity: six months ago it could only assist; today it can draft complete designs. However, full end-to-end autonomous validation remains an unsolved challenge. Because the real-world cost of network failure is exceptionally high, human engineers must remain directly in the loop to review and validate outputs.

Despite this limitation, replacing manual toil with AI-driven retrieval, draft generation, and automated analysis has delivered a **10x to 20x speedup** across key design tasks, freeing engineers to focus on high-level strategic decisions. The ultimate goal is unlocking automated end-to-end checking and orchestration—moving network design from a drafting tool to an autonomous conversational partner that will ultimately yield a **100x productivity boost**.

## Notable quotes > [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) drawing diagrams that turn into hundreds of millions of dollars in physical hardware handling real-world traffic — Maaz Mohiuddin

> [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) vulnerable chain of sequential handoffs — Maaz Mohiuddin

> [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) Tribal Knowledge: The core rules governing network correctness remain uncodified, living inside engineers' heads or scattered across disparate wiki pages rather than in executable code. — Maaz Mohiuddin

> [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) Serial Execution: The sequential nature of the process makes it exceptionally slow, preventing any meaningful parallelization across stages. — Maaz Mohiuddin

> [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) Silent Error Propagation: Mistakes introduced in the earliest design steps often remain hidden until final turn-up on site, resulting in catastrophic network outages or weeks of delayed capacity delivery. — Maaz Mohiuddin

> [01:52](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=112s) networking is not traditional code — Maaz Mohiuddin

> [01:52](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=112s) modifying a single port or role can trigger a ripple effect across the entire bill of materials — Maaz Mohiuddin

> [01:52](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=112s) keeping creative flow intact rather than losing momentum writing manual documentation — Maaz Mohiuddin

> [04:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=267s) transforms the engineer's role from manual author to strategic approver, yielding a 10x productivity speedup by turning an hour of manual drafting into a two-minute review. — Maaz Mohiuddin

> [06:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=387s) 6 weeks — Maaz Mohiuddin

> [08:39](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=519s) six months ago it could only assist; today it can draft complete designs. — Maaz Mohiuddin

> [08:39](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=519s) 10x to 20x speedup — Maaz Mohiuddin

> [08:39](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=519s) 100x productivity boost — Maaz Mohiuddin

## Mentioned Maaz Mohiuddin, Meta, @Scale

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

中文简报

Meta部署AI智能体集群缩短网络设计时间确定性基础规则与多智能体协同将网络拓扑起草时间从六周缩短至数分钟，同时保留人工架构师负责最终审批。 Maaz Mohiuddin剖析了传统串行网络设计交接为何会导致隐性错误，以及通用大模型在缺乏确定性网络规则严格约束下为何难以奏效。为解决此问题，Meta采用了一套涵盖从代码搜索到配置渲染的专用AI智能体集群，并辅以RAG及严格的验证层。该架构在处理底层IP编址与复杂动态场景规划的同时，将网络规模评估等任务耗时从六周大幅缩减至数分钟。最终，尽管人工架构师对最终审批仍不可或缺，AI自动化已带来10到20倍的生产力提升，其长期目标则是实现100倍的端到端编排效率。传统数据中心网络设计因依赖未代码化的经验规则与串行交接而极易出错，且通用代码 LLM 难以满足网络架构对绝对正确性与全局连通性的严格要求。 (0:04) 通过结合确定性平台规则、历史设计 RAG 检索及严格验证层，Meta 构建了涵盖代码搜索、配置渲染与文档解析的多 Agent 协作生态，有效杜绝了模型幻觉。 (4:27) 自动化方案将容量需求转化为有效拓扑的周期从 6 周缩短至数分钟，并能自主处理确定性 IP 寻址及机架扩容等复杂的动态“假设”（what-if）场景分析。 (6:27) AI 推动网络工程师的角色从手动制图者转向战略审批者，目前已带来 10 到 20 倍的效率提升，其长远目标是实现 100 倍提速的端到端全自动编排。 (8:39)

Reading summary

Meta's Maaz Mohiuddin argues that traditional network design is bottlenecked by uncodified institutional knowledge and fragile sequential handoffs, but grounding multi-agent AI systems in deterministic rules can reduce design turnaround from weeks to minutes. Structural Fragility in Traditional Network Design (0:04) Network architecture requires translating business capacity demands into physical topologies, low-level addressing schemes, bills of materials (BOM), and on-site cabling. Mohiuddin observes that while the role controls hundreds of millions of dollars in infrastructure, the underlying delivery pipeline suffers from three structural flaws: uncodified tribal knowledge stored in personal notes or disparate wikis, slow serial execution across teams, and silent error propagation where early mistakes remain undetected until physical turn-up. Why Generic LLMs Fail Network Correctness (1:52) Off-the-shelf code-generation LLMs fail in network architecture because networking demands global connectedness and strict correctness rather than standard approximate code. In hardware networks, altering a single port or role can trigger cascading errors across the entire BOM. To eliminate hallucinations, the engineering framework grounds language models against four pillars: explicit platform constraints (such as strict 128-port limits on a 4RU switch), retrieval-augmented generation (RAG) indexing hundreds of historical designs, natural language intent translation, and a deterministic validation layer functioning as an integration test. Multi-Agent Coordination and Institutional Memory (4:27) To systematize design knowledge, Meta organizes infrastructure data into formal typing schemes—such as explicit device naming formats (`[Prefix]-[Plane]-[Index]-[Site]`), typed circuit roles, and rigid IP hierarchy blocks. Operationally, the system distributes design labor across a coordinated swarm of specialized agents, including Deep Tech agents for internal code search, Config Rendering agents, Wiki Reading agents, Document Digest agents for PDFs and diagrams, and Visualization agents. This division of labor allows the system to parse engineering intent, retrieve historical templates, draft configurations, and validate constraints automatically. The human architect shifts from manually writing artifacts to reviewing and approving validated drafts, turning an hour of drafting into a two-minute review. Production Deployment and Scenario Forecasting (6:27) The framework's primary production use case is autonomous network sizing. Translating demand into verified topologies previously required up to six weeks of spreadsheets and bespoke scripts; AI agents executing mathematical capacity models now generate production-grade fabric topologies in minutes. Over a six-month period, Meta executed hundreds of automated capacity analyses in live production. Beyond high-level capacity sizing, the models automate deterministic low-level design tasks, including hierarchical IP and subnet allocations across regions and metros. They also perform complex 'what-if' analyses, such as evaluating the tooling, software stack, and operational trade-offs of expanding data center rows from 38 to 44 racks. Mohiuddin emphasizes that full end-to-end autonomous validation remains an unsolved challenge because the real-world cost of network failure requires human engineers to remain in the loop for final approval. While the current phase delivers a 10x to 20x speedup by automating retrieval, drafting, and analysis, he projects that developing complete end-to-end automated orchestration will eventually yield a 100x productivity gain.

精炼阅读摘要

Meta 的 Maaz Mohiuddin 指出，传统网络设计长期受制于分散的非代码化经验、缓慢的串行流程与隐性错误传播；通过将确定性规则、历史设计检索与专业化多智能体集群相结合，工程团队正将网络工程师从手动制图者转变为战略审批者，实现了关键设计环节 10 到 20 倍的效率飞跃。传统网络设计的串行交接与隐性错误困境 (0:04) 在传统网络架构实践中，将高层业务需求转化为可落地的工程成果是一条漫长而脆弱的串行交接链条。整个生命周期始于将业务需求换算为容量规划，随后依次转化为网络拓扑结构、完成低阶设计（如 IP 寻址分配）、生成精确标明设备发货详情的物料清单（BOM），最终在现场完成物理机架安装、布线与配置上线。这种看似蓝图宏大的工作，实际在每个交付环节都潜藏着严重的结构性断层。 Mohiuddin 总结了制约该流程的三大核心症结：首先是“部落知识”（Tribal Knowledge），保障网络正确运行的关键规则未被固化为可执行代码，而是散落在工程师个人记忆或零散的内部 Wiki 页面中；其次是完全串行的执行模式，各阶段之间缺乏有效的并行协作可能，极大地拖慢了交付节奏；最后是隐性错误传播（Silent Error Propagation），前期设计阶段引入的细微疏漏往往潜伏数周，直到现场最终上电激活时才爆发，导致灾难性的网络瘫痪或重大容量延期交付。通用模型局限与确定性规则锚定框架 (1:52) 针对网络架构设计，开箱即用的通用大语言模型或常规代码生成模型难以直接胜任。与允许“大致可用”并通过单元测试逐步排除编译错误的通用软件开发不同，网络工程具有极高的准确性门槛和全局强连通约束——任何单一端口或设备角色的细微修改，都可能在整张物料清单与全网拓扑中引发连锁震荡。因此，将大语言模型与确定性规则相结合，成为构建可靠设计集成测试的关键。为消除幻觉并确保输出符合物理与逻辑现实，该工程框架建立在四大支柱之上：第一是领域上下文与规则代码化，将硬性平台限制（例如明确特定 4RU 规格交换机严格限定为 128 个端口）编码为不可违背的模型约束；第二是基于历史设计的检索增强生成（RAG），将数百套经过实战检验的历史成熟设计索引至高性能数据库中，供系统零损耗复用；第三是自然语言意图接口，允许工程师在设计过程中通过自然语言进行交互，避免因繁琐的手动文档编写而打断思路；第四是确定性验证层，通过严苛的集成测试规则自动拦截结构性缺陷与遗漏。结构化制度记忆与多智能体协同生态 (4:27) 为了让系统精准理解复杂的网络体系，工程团队对机构制度记忆进行了模块化梳理。网络架构被划分为聚合层（含光纤交叉互连）、骨干网边缘连接、骨干网平面、网状群组以及标准化机架规范等不同作用域；同时对核心变量实施了严格的形式化命名与强类型约束，例如设备名称统一遵循“[前缀]-[平面]-[索引]-[站点]”格式，链路角色明确映射端到端对应关系，IP 编址策略亦严格遵循块、前缀、区域、大都市区及平面的层次化划分。在底层实现上，系统摒弃了单一全能模型方案，转向专业化多智能体集群协同作战：Deep Tech Agent 负责检索内部代码库，Config Rendering Agent 负责生成最终的设备配置，Wiki Reading Agent 负责解析内部文档上下文，Document Digest Agent 负责将技术 PDF 与设计图纸转化为结构化数据，Visualization Agent 则用于渲染拓扑图与交互式仪表盘。这套协同体系将工程师的角色从底层手稿作者彻底转变为高层审批者，原本需要手动耗时一小时的草图编制工作，缩短为两分钟的评审与核准，带来了高达 10 倍的生产力提升。生产验证成效：容量规划、编址与假设推演 (6:27) 该系统在生产环境中最显著的落地成果体现在网络容量的自动化规划。过去，将业务需求转化为经过验证的拓扑方案，往往依赖复杂的自定义脚本和混乱的电子表格，整个流程可能耗费长达 6 周时间；而在智能体根据自然语言指令驱动底层数学容量模型后，工程师仅需数分钟即可生成完整的生产级网络拓扑结构。在长达六个月的周期内，生产系统已成功执行并验证了数百次此类自动化容量分析。除了宏观层面的容量规划，智能体还在确定性低阶设计与复杂情景推演中表现优异。在低阶设计方面，系统能严格依据高层 IP 层次化规范，自动化分配跨区域、大都市区与网络平面的子网、设备 IP 及接口前缀。在假设情景分析（What-If Analysis）中，系统能够迅速评估重大架构调整带来的连锁影响，例如精准计算将数据中心每排机架从 38 个扩容至 44 个时，在运维操作、技术堆栈以及配套工具链方面所必须付出的工程权衡代价。 Mohiuddin 总结认为，AI 驱动的网络设计目前处于技术成熟度的第二阶段，即从半年前的辅助提示演进到了当前的全量设计草案生成。然而，鉴于网络物理故障的代价极高，全流程端到端自主验证在当前仍未完全解决，必须始终保持人类工程师在回路中负责最终把关。尽管如此，现有方案已在核心设计任务中实现了 10 到 20 倍的提速；Meta 团队的未来目标是攻克全链路自主校验与编排难题，推动网络工程从辅助绘图工具向完全自主的协同设计平台演进，最终释放 100 倍的生产力飞跃。

Detailed notes — zh

## Background 该视频由 @Scale 频道于 2026 年 9 月 3 日在 YouTube 平台发布，主讲人为来自 Meta 的网络工程师 Maaz Mohiuddin。视频简介指出，数据中心网络设计历来高度依赖人工专业判断且极难被自动化，演讲展示了 Meta 如何利用 AI 智能体逐步承接容量规划、拓扑推导与变更分析等离散任务，并揭示了网络工程师从方案绘制者向终审决策者转变的演进路径。 ## TL;DR 传统数据中心网络设计依赖高度串行的流程与散落的隐性经验，微小的早期误差极易在上线通电时酿成严重故障，通用代码大模型亦难以满足严苛的连通性与确定性指标。Meta 通过将物理世界硬性约束与制度记忆深度编码化，结合 RAG 检索、自然语言交互与确定性规则校验层，构建起分工明确的多专家 Agent 协作体系。该方案已在生产环境中成功将长达 6 周的容量评估与拓扑生成压缩至数分钟，并实现了高效的 IP 自动化编址与复杂 What-If 场景推演。尽管由于端到端闭环验证的挑战仍需保持人类在环（Human-in-the-loop），但该系统已实现 10 到 20 倍的效能提升，并正迈向端到端完全编排的 100 倍生产力飞跃。 ## Atmosphere & style 整场演讲风格利落干练、充满硬核工业实战底色，主讲人以超大规模数据中心一线老兵的务实视角直击痛点，毫无泛泛而谈的 AI 营销泡沫。叙述中交织着摆脱低级手工文档与 Excel 泥潭的技术释然，以及面对硬件事故高昂代价时始终恪守的严密与克制。紧凑的架构拆解与清晰的演进逻辑，带给观众一种见证经典网络工程体系被智能化深度重构的扎气质感。 ## Bulletin - [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) 通用代码大模型因无法满足网络工程对严格正确性与连通性准则的严苛要求，难以直接接管传统脆弱串行链条中的网络物理设计任务。 - [02:20](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=140s) Meta 通过将工程师经验黑盒代码化、构建 RAG 检索资产并配合确定性规则校验层，实现物理约束的知识对齐（Grounding）。 - [06:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=387s) 生产落地的自主容量评估引擎将以往需要 6 周的拓扑规划缩短至数分钟内完成，在真实环境中已成功推导数百次复杂设计。 - [08:39](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=519s) AI 辅助已为 Meta 带来 10 至 20 倍效率提升，网络工程师角色正从繁琐画图的撰写者转变为核心决策的审批者，未来攻克端到端自主验证后有望实现 100 倍跃迁。 ## Key takeaways - [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) 传统数据中心网络设计是一条串行且脆弱的交接链条，涵盖容量规划、拓扑生成、寻址、BOM 清单及现场部署上线。 - [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) 经验黑盒未结构化固化、严格串行执行导致低效，以及早期微小错误在通电点亮时才暴露的隐蔽传导，是传统网络设计的核心痛点。 - [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) 通用代码模型擅长软件层面的“大致正确”，但无法应对网络拓扑与物理硬件中由于单点改动引发剧烈连锁反应的严苛连通性要求。 - [02:20](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=140s) 破解网络自动化瓶颈的核心在于“知识对齐与锚定”（Grounding），即向成熟模型注入物理世界的底层硬件规则与连通性硬约束。 - [02:20](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=140s) 实现网络架构智能体需协同运行四大支柱：领域上下文代码化、历史工程资产 RAG 检索引擎、自然语言意图交互与确定性规则校验层。 - [04:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=267s) Meta 将制度记忆（Institutional Memory）进行了模块化与结构化建模，涵盖交换机端口配额、机柜规格、设备命名规范与级联 IP 编址体系。 - [04:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=267s) 系统底层采用由代码库检索、文档 PDF 解析、配置渲染及拓扑看板可视化组成的专业多 Agent 集群协同工作。 - [04:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=267s) 智能体系统重塑了工程师职责，网络工程师从耗费数小时逐行撰写的“撰写者”（Author）转变为仅需数分钟复核评估的“审批者”（Approver）。 - [06:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=387s) 自主容量评估与选型（Autonomous Sizing）成为首个生产落地用例，利用数学模型与自然语言交互将以往 6 周的苦工压缩到数分钟。 - [06:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=387s) 该容量平台在过去 6 个月内于生产环境中完成数百次复杂拓扑推导与生成，每份方案均通过自动化规则校验。 - [06:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=387s) 智能体还能高效处理确定性分层 IP 编址及复杂的假设推演（What-If Analysis），评估扩展排柜等变动对硬件和全栈工具链的联动影响。 - [08:39](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=519s) 当前系统在设计检索、图纸生成与方案分析等环节已为 Meta 实现 10 到 20 倍的生产力提速。 - [08:39](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=519s) 全流程端到端自主验证（End-to-End Validation）尚未完全攻克，高昂的故障风险决定了人类专家必须留在控制环路（Human-in-the-loop）中。 - [08:39](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=519s) 网络设计 AI 经历了从初级局部辅助（Assist）到高质量方案草拟（Draft）的演进，未来实现端到端编排（End-to-End Orchestration）后将带来 100 倍生产力飞跃。 ## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) 传统网络架构的脆弱链路与通用大模型的局限在数据中心网络建设中，将容量规划转化为可实际交付的施工级设计工件，一直以来都是最具技术判断力且难以自动化的环节。网络架构师的工作在外界看来光鲜亮丽——“在图纸上信手一画，就能直接转化为价值数亿美元、承载真实海量流量的实体硬件设备”；然而掀开光鲜的表象，实际操作流程是一条漫长而脆弱的串行传递链。业务需求首先被折算为带宽与容量指标，容量转化为拓扑结构，拓扑再经过详细寻址等底层设计；一旦方案通过可行性验证，便生成物料清单（BOM），指引采购与物流系统明确设备发往何处、何时到料，最终交由现场团队进行机架安装、堆叠、走线和配置上线。在这条链条中，每一次箭头流转都是一次极度脆弱的团队交接。导致这种脆弱性的核心症结有三个： - **组织内部的经验黑盒（Tribal Knowledge）**：决定网络设计正确与否的关键规则散落在工程师的脑海中或维基（Wiki）文档里，既未形成代码规范，也未结构化固化。 - **严格的串行执行（Serial Execution）**：整个链条只能按部就班推进，没有任何步骤能够并行处理，导致整体进度极度缓慢。 - **隐蔽的错误传导（Silent Error Propagation）**：在初期阶段哪怕引入微小的细微误差，往往要等到数周后网络通电点亮的阶段才会彻底暴露，而在网络工程中，这直接意味着突发宕机或长达数周的算力交付延误。正是由于这些硬性约束，通用的代码生成大语言模型（Coding LLM）根本无法直接接管网络设计任务。对于普通软件代码，逻辑“大致正确”（Close enough）往往就足够应付，开发者还可以借助完善的单元测试定位偏差；但网络架构对正确性（Correctness）以及全网连通性准则（Connectedness Criteria）有着苛刻的门槛——在底层哪怕仅仅微调一个交换机角色，都会在整个物料清单和拓扑链路上引发剧烈的连锁反应。 ```mermaid flowchart TD accTitle: 传统网络设计链路与三大瓶颈 accDescr: 展示从业务需求转化为上线交付的脆弱串行链条及核心挑战 subgraph DesignChain["传统串行交付链路"] A["业务需求与容量规划"] --> B["网络拓扑生成"] B --> C["底层设计与 IP 寻址"] C --> D["物料清单 (BOM) 生成"] D --> E["现场上架、布线与配置上线"] end subgraph FragilityFactors["三大固有脆弱根源"] F["经验黑盒<br/>规则散落在人脑与 Wiki"] G["串行执行<br/>无法并行推进且效率低下"] H["隐蔽传导<br/>早期微小错误在点亮时导致宕机"] end DesignChain -.-> FragilityFactors ``` --- ### [02:20](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=140s) 核心破局点：基于真实约束的“知识对齐与锚定”（Grounding）突破自动化困局的关键不在于盲目堆砌更大的通用模型，而在于“知识对齐与锚定”（Grounding）——即通过向成熟模型注入物理世界的底层真实约束，教会它区分什么是可行的现实、什么是虚幻的幻觉。网络物理设计虽然复杂，却天然存在明确的硬性规则：每台硬件设备的端口配额、路由聚合逻辑以及特定平台的芯片性能极限。只要将这些物理规则转译给 AI，并配备确定性的验证代码进行集成测试，整个工程范式就会迎来根本性转变。实现这一架构需要协同运行四大支柱： - **领域上下文编码化**：将工程师头脑中的隐性经验转化为严格代码。例如在数据中心设计规范中，“一台 4RU 的交换机拥有 128 个端口”，这是一条绝不容许大模型自行突破的铁律。 - **历史工程资产的检索引擎（RAG）**：企业内部沉淀了数百份历经验证的成功方案。通过将这些优质拓扑导入高性能数据库，构建起无损性能的检索增强系统，让 Agent 随时掌握“优秀设计的标准形态”。 - **自然语言意图交互**：以自然对话代替机械繁杂的手工文档录入。架构师的工作常被淹没在冗长文档的编写中，从而扼杀了创造性；而与智能体交互如同与资深同事头脑风暴，能最大化激活创意思维。 - **确定性规则校验层**：构建端到端校验关卡，对生成方案施加严格约束检查，确保任何遗漏、超限或不合规参数在出库前被当场拦截。 --- ### [04:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=267s) 制度记忆的代码化与多专家 Agent 协作体系为了让大型模型真正理解复杂的超大规模网络，Meta 将制度记忆（Institutional Memory）进行了模块化与结构化建模。网络被精细拆解为多个独立作用域（Scopes）：汇聚层被规范为网络 Fabric 的交叉互联模块，边缘层专门承接向骨干网的打通，骨干网内部严格定义平面（Planes）与网状组（Mesh Groups），而部署在现场的机柜则绑定了模块化机柜规格说明书（Rack Specs），明确规定每一台网络机架内的设备填充准则。这一代码化逻辑深入到了网络工程的细枝末节： - **设备命名规范**：拆解为标准前缀、平面归属、设备索引号与站点标识，AI 生成设备时必须精准补齐这些核心元数据。 - **电路角色结构**：固化为统一格式规范，明确包含电路名称、A 端（A-endpoint）与 Z 端（Z-endpoint）映射。 - **IP 编址方案**：按地址块、网络前缀、地理大区（Region）、城域（Metro）与网络平面（Plane）逐层级联。 ```mermaid flowchart LR accTitle: 多专家智能体协同与交付工作流 accDescr: 展示专业 Agent 集群分工处理并经由验证层呈交人类审批的完整流程 subgraph Agents["专业 Agent 专家集群"] A1["代码库深度检索 Agent"] A2["文档与长 PDF 解析 Agent"] A3["配置渲染与配置生成 Agent"] A4["拓扑绘制与看板可视化 Agent"] end UserIntent["自然语言设计意图"] --> Agents Agents --> Synthesis["生成候选草案"] Synthesis --> ValidationGate["确定性规则校验层"] ValidationGate --> Review{"人类架构师审批"} Review -- 确认批准 --> BuildReady["交付投产物料与配置"] ``` 在系统底层，执行任务的并非单一全能模型，而是一组分工明确的专家级智能体集群：有专门深挖内部代码仓库的深度技术 Agent、负责阅读 Wiki 的知识 Agent、能够消化厚重复杂架构 PDF 及拓扑图示的解析 Agent、专门在底层渲染最终网络配置文件的配置 Agent，以及最终生成直观仪表盘与高保真拓扑图的可视化 Agent。整个工作流闭环运转：智能体集群接收工程师的自然语言意图，从真实数据基座中检索历史参照，推导并生成设计草案，经过底层物理规则的严格约束验证，最终呈交给人类专家审批。原本需要耗费数小时逐行撰写、校验的低级设计任务，现在人类架构师只需两三分钟即可完成评估复核。网络工程师的角色由此发生了颠覆性的转变——“从繁杂图纸的撰写者（Author），全面进阶为核心方案的审批者（Approver）”。 --- ### [06:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=387s) 生产落地实践：自主容量评估与复杂情景分析这套系统在真实生产环境中的首个落地用例是**自主容量评估与选型（Autonomous Sizing）**。以往将一项宏观业务需求转化为能够完全满足流量要求的网络拓扑，是一场充斥着混乱脚本和繁重 Excel 表格的“苦工泥潭”，通常需要耗费资深团队整整 6 周的反复调整才能交付；而现在，只需向 AI 驱动的容量引擎输入一条简练的自然语言指令，几分钟之内就能输出可行方案。该容量引擎底层由一系列严格的数学模型驱动，AI Agent 的核心职责在于从工程师的自然语言输入中准确提取核心参数——例如“设计一个能够承载 X 数量客户端、具备特定超分比（Over-subscription）、并满足特定业务吞吐需求的网络拓扑”。系统会自动调取历史最优架构，将其转化为底层数学输入触发算力模型，最终直接输出一个可在数据中心真实部署的 Fabric 拓扑架构，而非仅供 PPT 展示的示意图。在过去 6 个月内，该平台已在生产环境中完成了数百次此类复杂的容量推导与分析，每一份设计均经受住了自动化校验引擎的严苛考验。除了容量规划，智能体还承担了多项传统网络工程师的繁重日常事务： - **确定性 IP 编址**：严格遵循分层规则，智能体能迅速将上层分配的大网段前缀自动解构成对应大区、城域、平面直至单台设备所需的全部细粒度底层地址。 - **复杂假设推演（What-If Analysis）**：当遇到“如果将网络排柜长度从 38 个机架扩展到 44 个机架会发生什么”这类非平庸的工程难题时，智能体能够全面权衡硬件极限与走线利弊，给出清晰的权衡方案，并明确指出运营工具链与底层技术栈必须做出哪些协同修改才能落地实施。 --- ### [08:39](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=519s) 从“起草者”到“端到端编排”：迈向 100 倍生产力飞跃目前该系统在设计检索、可视化图纸生成与复杂方案分析等工程任务上，已经为 Meta 带来了 10 到 20 倍的生产力提速，彻底清除了设计阶段中机械单调的琐碎苦工，使工程师能够将精力全额聚焦于战略层面的决策权衡。然而，当前的系统依然存在关键挑战：全流程的**端到端自主验证（End-to-End Validation）**仍未彻底解决。正因如此，“人类必须留在控制环路之中（Human-in-the-loop）”，这绝非权宜之计，而是在高可用网络领域的必然选择，因为在超大规模数据中心中，任何一次设计疏漏造成的事故成本都极其高昂，容不得丝毫侥幸。从技术成熟度的演进路径来看，AI 在网络工程设计领域经历了清晰的三步走阶段： - **半年前的第一阶段**：AI 仅能扮演初级辅助（Assist）的角色，完成一些局部的文本总结与脚本片段编写。 - **当前的第二阶段**：AI 已经能够胜任高质量的方案草拟（Draft），但尚不具备自主校验（Check）整套网络的能力；也正因为欠缺闭环的校验能力，它无法独立承担端到端的设计编排并对最终交付成果全权负责。 - **未来的第三阶段**：一旦攻克自动化验证与全链路端到端编排（End-to-End Orchestration）的技术高地，网络设计将彻底转变为工程师与 AI 之间自然高效的智力对话。届时，智能体集群将把网络设计的交付效率从如今的 10 倍推向惊人的 100 倍生产力跃迁。 ## Notable quotes > [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) 在图纸上信手一画，就能直接转化为价值数亿美元、承载真实海量流量的实体硬件设备 — Maaz Mohiuddin > [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) 组织内部的经验黑盒（Tribal Knowledge） — Maaz Mohiuddin > [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) 严格的串行执行（Serial Execution） — Maaz Mohiuddin > [00:04](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=4s) 隐蔽的错误传导（Silent Error Propagation） — Maaz Mohiuddin > [02:20](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=140s) 知识对齐与锚定（Grounding） — Maaz Mohiuddin > [02:20](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=140s) 一台 4RU 的交换机拥有 128 个端口 — Maaz Mohiuddin > [04:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=267s) 从繁杂图纸的撰写者（Author），全面进阶为核心方案的审批者（Approver） — Maaz Mohiuddin > [06:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=387s) 自主容量评估与选型（Autonomous Sizing） — Maaz Mohiuddin > [06:27](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=387s) 如果将网络排柜长度从 38 个机架扩展到 44 个机架会发生什么 — Maaz Mohiuddin > [08:39](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=519s) 端到端自主验证（End-to-End Validation） — Maaz Mohiuddin > [08:39](https://www.youtube.com/watch?v=dNssrB_-Wxk&t=519s) 人类必须留在控制环路之中（Human-in-the-loop） — Maaz Mohiuddin ## Mentioned Maaz Mohiuddin, Meta, @Scale, RAG, BOM (物料清单), Fabric, Coding LLM ## Video description Designing a datacenter network is where a capacity requirement becomes a blueprint: assigning device roles, wiring the interconnect, laying out addressing and failure domains, and producing the bill of materials — all while keeping the design constrained, connected, and correct. It is some of the most judgment-heavy work in network engineering, and until recently it resisted automation. This talk walks through how that is starting to change. Today, agents assist with discrete steps — sizing a fabric, proposing a topology, analyzing a change — but the trajectory points toward a single agent that can own the design end-to-end. Drawing on real waypoints from Meta's fabrics, Maaz shows what already works, where the hard problems remain (validation, above all), and how the engineer's role shifts from author to approver. The through-line: humans still make the call — they just no longer have to draw every line. Learn more about the @Scale conferences here: atscaleconference.com [Source](https://www.youtube.com/watch?v=dNssrB_-Wxk)

Source quotes

[0:04] Maaz Mohiuddin: 在图纸上信手一画，就能直接转化为价值数亿美元、承载真实海量流量的实体硬件设备 [0:04] Maaz Mohiuddin: 组织内部的经验黑盒（Tribal Knowledge） [0:04] Maaz Mohiuddin: 严格的串行执行（Serial Execution） [0:04] Maaz Mohiuddin: 隐蔽的错误传导（Silent Error Propagation） [2:20] Maaz Mohiuddin: 知识对齐与锚定（Grounding） [2:20] Maaz Mohiuddin: 一台 4RU 的交换机拥有 128 个端口 [4:27] Maaz Mohiuddin: 从繁杂图纸的撰写者（Author），全面进阶为核心方案的审批者（Approver） [6:27] Maaz Mohiuddin: 自主容量评估与选型（Autonomous Sizing） [6:27] Maaz Mohiuddin: 如果将网络排柜长度从 38 个机架扩展到 44 个机架会发生什么 [8:39] Maaz Mohiuddin: 端到端自主验证（End-to-End Validation） [8:39] Maaz Mohiuddin: 人类必须留在控制环路之中（Human-in-the-loop）

Source quotes

[0:04] Maaz Mohiuddin: drawing diagrams that turn into hundreds of millions of dollars in physical hardware handling real-world traffic [0:04] Maaz Mohiuddin: vulnerable chain of sequential handoffs [0:04] Maaz Mohiuddin: Tribal Knowledge: The core rules governing network correctness remain uncodified, living inside engineers' heads or scattered across disparate wiki pages rather than in executable code. [0:04] Maaz Mohiuddin: Serial Execution: The sequential nature of the process makes it exceptionally slow, preventing any meaningful parallelization across stages. [0:04] Maaz Mohiuddin: Silent Error Propagation: Mistakes introduced in the earliest design steps often remain hidden until final turn-up on site, resulting in catastrophic network outages or weeks of delayed capacity delivery. [1:52] Maaz Mohiuddin: networking is not traditional code [1:52] Maaz Mohiuddin: modifying a single port or role can trigger a ripple effect across the entire bill of materials [1:52] Maaz Mohiuddin: keeping creative flow intact rather than losing momentum writing manual documentation [4:27] Maaz Mohiuddin: transforms the engineer's role from manual author to strategic approver, yielding a 10x productivity speedup by turning an hour of manual drafting into a two-minute review. [6:27] Maaz Mohiuddin: 6 weeks [8:39] Maaz Mohiuddin: six months ago it could only assist; today it can draft complete designs. [8:39] Maaz Mohiuddin: 10x to 20x speedup [8:39] Maaz Mohiuddin: 100x productivity boost

Original transcript

[0:04] Hi, I'm Marz. Benalis covered plan. I'm [0:09] going to show you what happens next. How [0:11] do we take a plan and convert it into a [0:14] build ready design artifact and how [0:17] we've handed most of that job to AI and [0:20] in the process gotten a 10x productivity [0:23] speed up. For years, this was my job. It [0:28] looks glamorous as a network architect. [0:30] You draw a picture and it gets [0:32] translated to hundreds of millions of [0:34] dollars of real hardware moving real [0:36] traffic. But let's take a look at what's [0:38] happening here. It's a chain of multiple [0:40] actions. A business need gets sized into [0:43] a demand. A demand turns into a [0:44] topology. Topology goes through a [0:47] low-level design like addressing. And [0:49] once that is known to work, we get a [0:51] bomb that tells us what to ship, where [0:53] to ship, and when to ship. And once that [0:55] lands on site, we rack, stack, cable and [0:58] configure. This chain has handoffs. [1:02] Every arrow there is a handoff. And [1:05] every handoff is fragile. There are [1:07] three specific things that make it [1:09] fragile. One is tribal knowledge. The [1:11] rules that make a network design correct [1:14] live in people's heads in scattered [1:16] across wikis. They are not qualified. [1:19] They're not code. This is serial [1:21] execution. It's slow and nothing here is [1:24] paralyzable. [1:26] There's silent error propagation. An [1:28] error that is introduced in the first [1:30] half or the first step of the chain only [1:34] announces itself towards the end when [1:36] the network is being turned up. And in [1:38] networking that can mean either an [1:40] outage or weeks of capacity delivery [1:42] delay. Remember these three things [1:45] tribal knowledge, serial execution, [1:47] silent propagation because we'll come [1:49] back to them. It's these reasons that's [1:52] why a generic LLM cannot directly solve [1:56] this problem. By a generic LLM, I mean a [1:58] coding LLM because network is not really [2:00] code. For code, close enough is usually [2:04] sufficient. You have good unit tests [2:06] that tell you when you're going wrong. [2:08] For network, there is a very high [2:10] correctness bar. There's also [2:13] connectedness criteria. If you change [2:15] one role, that can cause a ripple effect [2:18] in the entire poem. But here's the [2:20] opening. The problem has some rules. [2:23] Port budgets on devices, aggregation [2:26] logic and routing, hardware limits on [2:28] platforms. If you can teach these things [2:30] to AI and teach it how to check this [2:34] using deterministic code, kind of like [2:37] integration tests, then the whole thing [2:40] changes. By the end of this talk, I'll [2:43] show you how we do this with a secret [2:45] source that is grounding. grounding [2:48] these agents in reality so that they [2:50] don't hallucinate. [2:53] In this talk, we're going to make three [2:54] quick stops. How the sausage is made, [2:57] some quick wins from production [2:59] experiences, and what's in store for the [3:01] future. [3:04] As I mentioned earlier, the solution is [3:06] grounding. It's not just a bigger model. [3:08] It is to take the existing model and [3:11] teach it what is real and what is not. [3:14] First, we provided domain context. We [3:16] take these rules that are tribal [3:18] knowledge and we codify them. For [3:20] example, in data center design, a 4RU [3:24] switch has 128 ports. That is a rule [3:27] that should not be violated. Second, our [3:30] historical designs. We have hundreds of [3:32] previous designs. So, we know what good [3:34] looks like. We take these designs and [3:37] translate them through a high [3:38] performance database and make them [3:41] available to the agent kind of like a [3:43] rag. and then the agents can retrieve [3:46] them without a penalty in in the [3:50] performance. [3:51] Third is we use natural language intent [3:54] to talk to the agent because when you [3:57] talk is really where the creative juices [4:00] get flowing. The hard one of the hard [4:02] parts of my job is writing down [4:04] everything and and losing the creative [4:07] flow in doing that. Talking is like [4:09] brainstorming working with a colleague. [4:12] And fourth is a validation layer with [4:14] concrete rules that tell us when [4:18] something is being missed, something [4:22] erroneous that can be caught. That's how [4:24] we solve the problem. Here is an example [4:27] of how institutional memory is injected [4:30] into the model. For example, we define [4:33] scopes to modularize the network design. [4:36] Aggregation layers has fabric cross [4:38] connect. Then it has an edge that [4:41] connects to the backbone. Backbone has [4:43] planes, mesh groups and our racks that [4:46] we deploy in the network have modular [4:49] rack specs. A rack spec describes what [4:51] goes in a network rack. There's also [4:54] other aspects of network engineering [4:56] that are codified. For example, a device [4:58] name has a prefix, has a plane, has an [5:01] index, and has a site. So AI then knows [5:03] when it's generating a design for a [5:06] device name. Those are the key things it [5:07] has to fill and fix. Circuit roles have [5:10] a particular format name A endpoint and [5:13] Z endpoint. IP addressing schemes again [5:16] have blocks prefix region metro plane. [5:19] These are the insights that we have [5:21] codified. So our agent, our design agent [5:23] now knows what to how to navigate the [5:27] space under the hood. It's not one [5:29] agent. It's a bunch of specialists all [5:32] working together. Each agent married to [5:35] the right task. We have a deep tech [5:37] agent that searches our code [5:38] repositories. We have one that renders [5:40] config at the end. We have one that [5:43] reads wikis and we have one can that can [5:45] digest large PDFs and diagrams into [5:48] something that's usable by the other [5:49] agents. And then we have one that [5:51] generates pretty pictures and dashboards [5:54] and the final topology, the final [5:55] artifact. [5:57] These agents work in harmony. They take [6:00] intent. They retrieve it in grounded [6:02] data. They propose a draft. They [6:04] validate the constraints and once [6:07] they're happy with this, they present it [6:09] to the human for approval. And that's [6:11] where the 10x speed up comes from. [6:14] Typically, what takes an hour to write [6:17] takes only a couple of minutes to [6:18] review. The role of engineer, a network [6:21] architect is now changed from an author [6:25] to an approver. [6:27] What did this actually do for us? Our [6:29] first production use case is autonomous [6:31] sizing. This one still impresses me. How [6:34] we can take a business requirement and [6:37] translate it into a network topology [6:40] that satisfies a network demand in just [6:42] a few minutes. Prior to this, this [6:45] exercise was a chaotic web of scripts [6:48] and Excel sheets that took us 6 weeks to [6:51] get right. Now it is as simple as a [6:54] natural language query to our capacity [6:56] engine which is driven by AI. The engine [7:00] is a bunch of mathematical models and AI [7:03] agents trigger those models with the [7:05] right set of inputs that are derived [7:08] from the natural language query. For [7:10] example, write for me a network topology [7:15] that has X clients and has some level of [7:18] over subscription and meet certain level [7:20] of demand. It reaches for past designs, [7:25] translates those inputs and then inputs [7:28] them into the capacity agent that [7:29] produces a real working topology. Not [7:32] just a slide, a real fabric that we've [7:34] deployed in a network. Over the past 6 [7:37] months, we have done hundreds of these [7:39] analysis and each of those is well [7:42] tested through our validation engine. [7:44] Our LLMs can also do what network [7:48] engineers have been doing for a long [7:49] time just much faster. This is [7:53] deterministic addressing. For example, [7:55] in this case, given a certain rules of [7:57] IP address hierarchy, it can take a [8:00] prefix and find low-level addresses for [8:03] devices through region, metro, plane, [8:07] and all meeting the top level rules that [8:10] the engineer said. [8:13] Sometimes I give it a complex analysis, [8:15] a what if. What happens if you want to [8:17] extend our network rows from 38 racks to [8:21] 44 racks. It's not a trivial exercise. [8:24] It can do a bunch of what if analysis [8:27] for me, give tradeoffs and tell me how [8:30] we can actually implement it. What needs [8:32] to change in our stack in our operations [8:34] tooling to actually realize the [8:36] solution. [8:39] Today it can draft and scope. The [8:42] challenge yet is with end to end [8:44] validation. [8:46] A human still needs to be in the loop. [8:48] That's on purpose because in this domain [8:50] the cost of getting something wrong is [8:52] too high. And today we cannot skip that. [8:56] We have transformed information search, [8:58] visual artifact generation, complex [9:01] analysis into a 10 to 20x speed up on [9:05] most engineering tasks in design. The [9:08] mechanical toil is eradicated. The [9:11] engineers are used for strategic [9:12] decisions. [9:15] AI today in design is in second stage of [9:18] its maturity. 6 months ago it could [9:20] assist. Today it can draft. It cannot [9:24] check and because it cannot check it [9:27] cannot do an end to end orchestration of [9:29] a design and own the entire outcome. A [9:32] human still needs to be in the loop. [9:34] What this work has taught us is that [9:38] network design is becoming a [9:40] conversation like you would have with [9:42] your colleague. We have 10x the [9:44] productivity once we unlock check and [9:48] end to orchestration. [9:50] Agents can give us 100x productivity [9:54] boosts. That's the future we're building [9:56] and it makes me super excited. Thank you [9:59] so much.