Tony Bai - 一个程序员的心路历程

Google 开源 AX 与 Agent Substrate：构建以 Agent 为核心的云原生计算底座

五月 23, 2026
0 条评论

本文永久链接 – https://tonybai.com/2026/05/23/google-open-sources-ax-and-agent-substrate-agent-centric-cloud-native-foundation

大家好，我是Tony Bai。

随着大语言模型（LLM）与应用场景的深度融合，AI 正在从单纯的“聊天对话框”快速演进为具备长期运行、自主工具调用和复杂任务编排能力的 AI Agent（智能体）。

在生产环境中，这些 Agent 展现出与传统微服务截然不同的负载特征：它们是高度非线性的、需要频繁执行不可信代码（如动态生成的 Python 脚本）、在等待人类确认（HITL，人类在环）时长期处于闲置状态，同时又会在瞬时产生极其高频的子秒级（Sub-second）工具调用。

传统的容器和虚拟机调度架构（如标准的 Kubernetes）面对这种数以百万计、高密度、长生命周期但又极度高并发的“智能体负载（Agentic Workflows）”时，在隔离安全性、调度时延与算力浪费上面临严重的物理局限。

针对这一工程痛点，Google 在 Google I/O ’26 大会上给出了其深思熟虑的系统级回应。这并非一个单一工具的发布，而是一套分层解耦的云原生 Agent 堆栈的整体亮相。

Google 定义的“三层 Agent 堆栈”，其中包含了：

应用运行时（Agent Runtime）：开源项目 Agent Executor（AX），专注于可靠的状态编排、连接恢复与执行审计。
高密度计算与调度层（Compute Plane）：开源项目 Agent Substrate，专注于海量闲置 Agent 的极速挂起/恢复与去中心化控制平面调度。
安全隔离层（Sandbox Layer）：已正式商用的 GKE Agent Sandbox，基于 gVisor/MicroVM 技术，提供低时延、强隔离的运行沙箱。

本文将拆解这一套以 Agent 为负载单元的新型云原生抽象层，揭示 Google 是如何重新定义大模型时代的分布式系统底座的。

架构解密：从基础设施到应用层的“三层 Agent 堆栈”

要理解这一套复杂的系统，我们需要像拆解传统 TCP/IP 协议栈一样，将其自底向上划分为四个物理层级：

这种分层解耦的系统设计，标志着 AI 应用开发正式告别了“框架包揽一切”的单体混沌状态，进入了精细化、高可用的系统工程时代。

底层解局：Agent Substrate 与 Sandbox 是如何解决物理局限的？

传统的 Kubernetes 是为了支撑长期运行、状态相对稳定的“微服务（Microservices）”而设计的。如果直接将数百万个 Agent 部署为普通的 K8s Pod，系统会迅速面临崩溃：

内存与算力浪费：许多 Agent 处于非激活状态（等待人类输入或调度触发），如果让它们的 Pod 持续在线，会产生天文数字的算力账单。
控制面过载：数百万个 Agent 产生的子秒级内部工具调用，如果全部经过传统的 K8s API Server 进行调度和授权，会直接导致 K8s 控制平面瘫痪。
安全防线脆弱：Agent 具有动态执行解释型代码（如本地运行一段临时生成的 Python 来计算数据）的本能，一旦逃逸，将危害宿主机安全。

为此，Google 联合 GKE 团队和 Kubernetes 社区，推出了 Agent Substrate 与 Agent Sandbox：

1. 基于 gVisor 的强物理隔离（Ironclad Security）

GKE Agent Sandbox 默认集成了开源的安全容器沙箱 gVisor。

它在不可信的 Agent 应用代码与 Linux 内核之间插入了一个名为 Sentry 的用户态内核。所有 Agent 试图执行的系统调用（Syscalls）都会在用户态被拦截、审计并安全执行。这确保了即便 Agent 生成的代码带有恶意，也绝无可能穿透容器逃逸到宿主机上，实现了生产级的“Secure-by-design”。

2. Pod 快照技术与冷启动消除（Reduce Idle Compute & Low Latency）

为了消灭 Agent 闲置时的算力浪费，Agent Substrate 引入了 Pod 快照技术（Pod Snapshots）：

主动挂起（Suspend）：当一个 Agent 进入休眠或长时等待状态时，Agent Substrate 捕获其完整的运行状态并制作快照，释放其占用的物理 CPU 与内存资源。
瞬时恢复（Resume）：当事件触发或用户响应时，系统通过集成的 温水池（Warm Pool） 技术，利用快照快速恢复运行。

根据 Google Cloud 的官方测评，GKE Agent Sandbox 能够在每秒启动 300 个沙箱的高并发压力下，保证 90% 的分配在 200 毫秒内完成。这几乎抹平了传统安全容器长达数秒的冷启动时延，真正做到了“随用随起，用完即挂”。

图：GKE 引入的高性能温水池与 Pod 快照技术

应用层编排：Google AX 如何行使“指挥官”职责？

在底层的 Agent Substrate 提供了极致的物理隔离与快速调度能力后，位于上层的 Agent Executor (AX) 运行时则真正扮演起了“状态与业务编排指挥官”的角色。

AX 的核心设计并不是去触碰模型细节，而是通过 Single-Writer 架构 和 Durable Execution（持久化执行） 来保障 Agentic 循环的绝对可靠：

1. 轨迹分支（Trajectory Branching）与分支克隆（Forking）

在复杂决策中，开发者往往希望 Agent 能像写代码一样，在某个关键节点“分叉（Fork）”去尝试多条不同的规划路径，在评估各路径的优劣后再做最终合并。

由于 AX 底层维护了强一致性的持久化事件日志，它原生提供了 ax fork 功能：

ax fork \
  --src-conversation 38460323-9a78-41cb-8991-022b0ff2c19c \
  --dest-conversation e5e26e38-53a2-4f22-b1cb-ae867357df83 \
  --src-seq 12

开发者可以直接在指定的事件序列号（–src-seq 12）处，克隆出一条全新的、独立的执行轨迹（Trajectory）。这让 AI 在多路径探索、蒙特卡洛树搜索（MCTS）等高级推理算法中的应用变得异常简单和标准。

2. 会话一致性（Session Consistency）

在多客户端并发控制或分布式协作中，多个进程可能同时试图更新同一个 Agent 的会话状态。AX 的单写入者（Single-Writer）架构通过统一的序列号控制机制，彻底避免了因并发竞争（Race Conditions）导致的状态脏写与损坏。

统一的工程视角：Go 的系统级胶水作用

如果我们仔细观察这套三层架构，会发现一个极具工程美学的现象：

最底层的 Kubernetes 与 GKE Sandbox：由 Go 语言统治。
中间层的 Agent Substrate 与 AX：同样是由 Go 语言构建（github.com/google/ax 和 github.com/agent-substrate/substrate）。
最上层的 Agent 应用与框架：则可以使用 Python（如 LangChain、ADK）来尽情发挥，当然如果你依然要使用Go，比如adk-go，来开发Agent应用也是非常棒的选择。

这一架构再次印证了我们在 AI 系统工程中的理性认知：运行时底层是系统级工程（System Engineering），应用层是模型算法工程（Algorithm Engineering）。

Go 语言在这里扮演了不可替代的“系统级胶水”角色：它将高密度调度、gRPC 双向流、持久化快照以及隔离沙箱等硬核的系统级原语，封装成极其简单易用的 CLI 和 API，让上层的应用开发者能够专注在 Prompt 与模型逻辑上。

小结

在看完 Google 发布的这一套以 Agent 为第一公民的云原生计算底座后，作为软件工程师，我们应该感到无比的兴奋。

大模型确实降低了写业务逻辑代码的门槛，甚至让“AI 自动编程”成为可能。但正如 Google 资深软件工程师 Tim Hockin（Kubernetes 的共同创始人之一）和 Brandon Royal 的联手探索所展示的那样：如何在大规模、高密度、异构的物理硬件集群中，保障这些 AI 智能体安全、高效、廉价地运转，是一个极其深邃、且刚刚拉开序幕的分布式系统课题。

谁来设计高密度的内存挂起与快照算法？
谁来在网络边界保障 gVisor 沙箱的安全网络策略？
谁来在 AX 层面设计多 Agent 协作时的数据一致性协议？

这些问题，AI 无法自己解决，它需要那些真正懂得底层计算机制、网络协议和系统调度的优秀工程师。

随着大模型和 Agent 的普及，软件工程正在经历一场从“单机时代”迈向“网格化 Agent 集群时代”的伟大战役。掌握这一套新型基础设施设计哲学与开发范式的架构师们，正在迎来属于他们的、前所未有的黄金时代。

资料链接：

https://x.com/rakyll/status/2057129537553785093
https://cloud.google.com/blog/products/containers-kubernetes/bringing-you-agent-sandbox-on-gke-and-agent-substrate
https://cloud.google.com/blog/products/ai-machine-learning/agent-executor-googles-distributed-agent-runtime
https://github.com/agent-substrate/substrate
https://github.com/google/ax
https://github.com/kubernetes-sigs/agent-sandbox

✍️ 今日的深度思考题：

当底层的 GKE Sandbox 能够将 Agent 启动时延压低至 200 毫秒以内、且支持自动挂起时，你会如何重新设计你的多 Agent 编排逻辑？这会给你的服务器算力账单带来怎样的改变？

欢迎在评论区留下你对这一套“Agent 时代 K8s 抽象层”的看法，我们共同探讨云原生的未来！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
构建坚不可摧的 Safety Middleware 与飞书人工审批防线
在底层实现 Token 成本审计、链路追踪与自动化跑分评估
从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

img{512x368}

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

十年难题终获突破：揭秘 Go 1.27 接口逃逸分析优化

五月 22, 2026
0 条评论

本文永久链接 – https://tonybai.com/2026/05/22/go-1-27-interface-escape-analysis-optimization-breakthrough

大家好，我是Tony Bai。

在日常的 Go 语言开发中，有这样一段极其普通、普通到闭着眼睛都能敲出来的代码：

val := 1000
fmt.Sprintf("Result: %d", val)

如果我告诉你，这短短两行代码，就是导致你高并发服务 CPU 飙升、GC（垃圾回收）频繁卡顿的元凶之一，你会不会觉得我在危言耸听？

这并非危言耸听。在 Go 的世界里，存在一个困扰了全球开发者整整 10 多年的“幽灵 Bug”：只要你的参数被传递给 interface{}（比如 fmt 系列函数），哪怕你传入的只是一个简单的整数或一个局部变量，一旦它进入了 any（interface{}）的大门，编译器通常就会由于“看不透”后续的操作，而保守地判定该变量“逃逸（Escape）”，从而强制将其分配在堆（Heap）上。

这个痛点，最早可以追溯到 2014 年由 Go 核心团队成员 Keith Randall 提出的 Issue #8618，Rob Pike 亲自将 Issue #8618（不逃逸的 interface{} 转换不应分配内存）标记为 Accepted，并等待有人来解决。

谁能想到，这一等，就是十余年。 这期间，Go 核心团队一直在试图彻底拔掉这根刺。

直到最近，随着 Go 1.27 路线图中 Issue #62653 以及核心补丁 CL 743200 、CL 743240等的提交，这场跨越十余年的技术长跑终于迎来了突破性的进展。

今天，我们就来深度拆解这个“核弹级”优化背后的底层逻辑，看看 Go 编译器和运行时团队是如何在不改变一行业务代码的情况下，让我们在未来实现“白嫖性能”的！

困局：为什么接口转换成了“性能黑洞”？

要理解这个优化的意义，我们要看看编译器在过去十年里到底在“怕”什么，首先要直面日常开发中的痛点。

在 Go 中，逃逸分析（Escape Analysis）决定了一个变量是待在轻量、快速的栈（Stack）上，还是被迫流浪到沉重的堆（Heap）中。

然而，Go 将一个具体类型（比如 int 或者一个 struct）赋值给 interface{} 时，底层需要构造一个包含类型信息和数据指针的结构（eface 或 iface）。注意接口里的数据字段是个指针。

当你执行 Print(val)，其中 val 被转换成接口时，编译器面临一个巨大的“不确定性”。请看这个经典的例子：

func Print(input any) {
    if v, ok := input.(Stringer); ok {
       println(v.String()) // 这里是罪魁祸首
    }
}

当我们调用 v.String() 的时候，编译器彻底懵了。因为 v 可能是一个“好市民（Nice）”，也可能是一个“内鬼（Leaking）”。

什么是内鬼？

var global any
type Leaking struct {a, b int}
// String() 偷偷把接收器 l 泄露给了全局变量！
func (l *Leaking) String() string { global = l; return "" }

什么是好市民？

type Nice struct {a, b int}
// 只是单纯返回字符串，啥也没泄露
func (n Nice) String() string { return "something" }

这样一来，编译器在看到 Print(n) 时，它不知道 input 到底会不会被传入像 Leaking 这样恶意的 String() 方法中。为了绝对的安全，只要变量变成了接口，并且后续可能发生接口方法调用，编译器就直接投降：“我算不清楚，全部逃逸到堆上吧！”

这就导致了一个灾难性的后果：极其高频的日志和格式化场景，成了分配内存的重灾区。

看看我们在业务里写的最多的代码：

log.Printf(“user %s logged in at %v”, username, time.Now())
json.Marshal(myStruct)

这些 API 的入参无一例外都是 any（即 interface{}）。由于逃逸分析的短视，即使这些参数在函数执行完毕后就不再使用了（本该在栈 Stack 上廉价地分配和销毁），它们依然会引发海量的 Heap Allocations（堆分配），进而给 GC 带来巨大的压力。

在 Issue #8618 的讨论中，无数开发者大吐苦水。有人为了避开这个坑，甚至被迫手写了一套恶心至极的零分配格式化库（比如用链式调用 .S(“hello “).D(1) 来代替 Sprintf）；还有人寄希望于 Go 1.18 的泛型，试图用 [T any] 展开具体类型来绕过接口逃逸。

这就好比为了喝一口水，你不得不自己造一个水库。这就是这十多年间，追求极致性能的 Go 开发者的真实写照。

破局：CL 743200 带来的“背景调查”机制

既然难题在于“看不透”，那么解决之道就在于“精准画像”。

在最新的 CL 743200 中，开发者 thepudds 和 Go 编译器大牛 mdempsky 引入了一套极其精妙的追踪机制。我将其形象地称为：对具体类型的“背景调查”回流。

1. 核心武器：ifaceRecvLoc 虚拟位置

编译器引入了一个全新的伪位置属性——ifaceRecvLoc。

以前，编译器看到接口转换，直接就把变量引向堆（Heap）。现在，它会先给这个转换点打上一个 ifaceRecvLoc 的标记。

2. 逆向溯源：OCONVIFACE 节点的觉醒

当编译器处理到 OCONVIFACE（即具体类型转接口的代码节点）时，它不再盲目投降。它会回过头去，审查这个具体类型（Concrete Type）的所有方法。

如果编译器通过分析发现：这个具体类型实现的 String() 方法（或者其他接口方法）非常“守规矩”，并没有将接收者指针存入全局变量或返回给外部，那么这个 ifaceRecvLoc 的逃逸标记就会被撤销。

本质上，这是一种“按需定制”的逃逸分析：

如果你传入的是 Leaking 类型，编译器依然让它逃逸（保证安全）；
如果你传入的是 Nice 类型，编译器现在能证明它是安全的，从而让它留在栈上（榨干性能）。

算法优化：用 SCC 解决“循环依赖”迷宫

你可能会问：既然思路这么清晰，为什么 Go 团队用了十年才逼近搞定？

答案是：现实中的调用链远比示例复杂，甚至存在“递归死循环”。

在大型 Go 项目中，函数调用关系构成了一个复杂的有向图。如果函数 A 调用了接口方法，而该接口方法的某个实现又反过来调用了函数 A，或者涉及复杂的跨包依赖，逃逸分析就会陷入死循环。

为了解决这个问题，CL 743240重写了编译器的访问逻辑。它引入了图论中的 SCC（Strongly Connected Components，强连通分量） 算法：

自底向上遍历（Bottom-Up）： 编译器先分析那些不依赖别人的函数，确定它们的逃逸行为。
处理循环： 将互相依赖的函数归为一个“组（Group）”。
合并策略： 新版本编译器会执行两次遍历，将“函数调用图”和“类型-接口转换图”进行合并分析。

根据测试结果，这种算法目前在 99.85% 的标准库场景中都能完美收敛。即便是像 Kubernetes 这样拥有数百万行代码、接口调用深不见底的项目，新算法依然能保持极高的编译速度，同时大幅提升逃逸分析的准确度。

开发者能白嫖到什么？

这次优化的落地，对 Go 开发者来说是一次无需改动代码的“性能大礼包”。

1. fmt 和 log 系列的全面瘦身

在资料中，thepudds 明确展示：在应用了这些 Patch 后，类似 fmt.Sprintf(“%v”, p) 这种调用，如果 p 是一个简单的结构体（如 Point{x, y int}），它将不再产生堆分配。

对于那些每秒产生数万条日志的高并发系统，这意味着内存带宽的巨大释放。

2. 反射（Reflect）性能的连带提升

虽然这个优化集中在接口逃逸，但它也顺带解决了 reflect.Value.Interface() 在某些场景下的强制逃逸问题。作为很多框架（如 JSON 编解码、ORM）的底层基石，这种连锁反应将带来整体性能的连带提升。

3. 架构设计的解放

以前，资深 Go 开发者为了避免逃逸，往往会刻意避开使用接口，甚至写出极其晦涩的“泛型展开”代码。

现在，你可以重新拥抱接口了。 Go 编译器终于变得足够聪明，能够理解你的意图，并在幕后默默地为你进行最优化的内存调度。

小结：十余年的坚持与务实

Issue #8618 从 2014 年挂载至今，期间经历了 Go 1.0 时代的稚嫩，到 2.0 提案的讨论，再到泛型的落地。Go 团队之所以迟迟没有合并早期的简单补丁，是因为他们一直在追求一种“不产生副作用的完美解法”——既要解决逃逸，又不能让编译速度变慢，更不能引入不稳定的 Bug。

这种“宁缺毋滥”的工程态度，正是 Go 语言能够成为云原生基石的原因。

虽然目前的 Milestone 定在 Go 1.27，虽然中间可能还会有反复，但 CL 743200 的出现标志着技术方案已经趋于彻底闭环。

十年一剑，利刃出鞘。 当 Go 1.27 发布的那一天，我们或许终于可以对着那句经典的 fmt.Printf 说一声：“感谢你，终于不再让我的变量到处流浪。”

注：issue 62653曾多次跳票，从Go 1.25到Go 1.27，至于究竟是否能在Go 1.27落地，还得拭目以待！但Go 核心团队解决这个问题的决心是值得肯定的^_^。