Kubernetes 深度拆解：当 Google 决定「干掉 Kubernetes 的控制平面」——从 1.36 的 DRA 革命到 Agent Substrate 的 30 倍超额订阅，一个容器编排平台如何被重新定义为 AI 智能体的操作系统
2026 年 5 月，Google 在 GKE 上同时发布了 Agent Sandbox 和 Agent Substrate 两个项目。这不是两个普通的产品更新——这是 Kubernetes 十年历史上最重要的一次架构转向。本文将从 Kubernetes 1.36 的三大革命性特性出发，深入剖析为什么传统的容器编排控制平面无法承载 AI 智能体工作负载，Google 是如何用"虚拟内存超分配"的思路重新设计智能体调度层的，以及这对每一个云原生工程师意味着什么。
一、为什么 Kubernetes 需要一场革命？
1.1 一个被回避了两年的事实
如果你是一个 Kubernetes 老兵，你一定注意到了一个尴尬的现象：过去两年里，几乎所有 AI 基础设施项目都在 Kubernetes 之上运行，但几乎没有一个作为 Kubernetes 原生工作负载被集成。
LangChain 的 Agent 跑在 K8s 上，但它不是 Deployment。OpenAI 的推理服务部署在 K8s 上，但它不是一个标准的 StatefulSet。Claude Code 的编程助手在 K8s 上运行，但它的生命周期管理完全绕过了 K8s 的控制平面。
这不是偶然。这是架构层面的根本性不匹配。
1.2 容器 ≠ 智能体：两种完全不同的计算范式
让我们做一个思想实验。想象一个开发者团队有 20 人，每人使用一个编程智能体。一天 8 小时工作时间里，每个智能体的典型行为模式是：
接收提示 → 运行 10 秒 → 空闲 20 分钟 → 接收下一个提示 → 运行 15 秒 → 空闲 30 分钟 → ...
如果你把每个智能体都部署为一个 Kubernetes Pod，那么在任何时刻，你的集群里有 20 个 Pod 在"运行"，但其中可能只有 1-2 个真正在执行代码，其余 18 个都在空闲等待。
这就是问题所在。Kubernetes 的设计假设是：负载是长期运行的、稳定的、可预测的。一个 Web 服务的 Pod 启动后就一直运行，处理请求，保持状态。Kubernetes 负责保证它有足够的副本、正确的网络配置、健康检查通过。
但智能体的行为模式完全相反：
| 维度 | 传统容器负载 | AI 智能体负载 |
|---|---|---|
| 生命周期 | 长期运行，持续服务 | 短暂爆发，长期休眠 |
| 代码来源 | 预编译，确定性 | LLM 实时生成，不确定性 |
| 调度频率 | 低频，启动时一次 | 高频，每个提示一次 |
| 状态管理 | 无状态或有状态副本 | 强状态，每次会话唯一 |
| 隔离需求 | 容器级别即可 | 需要内核级隔离 |
| 资源特征 | 持续占用 CPU/内存 | 脉冲式占用，大部分时间空闲 |
把智能体当作容器来调度，就像把一个需要频繁休眠和唤醒的操作系统进程当作一个长期运行的后台服务来管理——能跑，但效率极低。
1.3 控制平面的三个致命瓶颈
Kubernetes 的控制平面由三个核心组件组成：API Server、etcd 和 Scheduler。这三个组件在设计时考虑的是"为数量适中的长时间运行 Pod 而调度作业"。当智能体负载加入后，三个致命瓶颈浮现：
瓶颈一：API Server 成为瓶颈
将每个智能体（无论活跃还是空闲）都存储为 Kubernetes 对象，意味着在一个从未为此规模设计的系统中会有数百万个资源实例。一个 1000 人的开发团队，每人一个编程智能体，每个智能体有 10 个相关资源对象（Pod、Service、ConfigMap、Secret 等），那就是 10 万个对象。如果是 10 万人的企业级部署，对象数量将达到千万级别。
etcd 的写入性能在对象数量超过 50 万后开始显著下降。API Server 的 LIST 操作延迟在对象数量超过 100 万后变得不可接受。
瓶颈二：调度策略失效
Kubernetes 的默认调度器使用轮询和随机放置策略。这种策略在请求短且到达率高时效果很好，因为错误的决策会被迅速摊销。但智能体请求运行时间更长且到达频率更低，糟糕的路由选择会持续存在，放大被困在后面的用户的尾部延迟。
瓶颈三：冷启动延迟不可接受
为每个智能体的每次唤醒启动一个新的 Pod，意味着至少 5-10 秒的冷启动延迟（镜像拉取 + 容器启动 + 应用初始化）。对于一个编程智能体来说，用户每发送一个提示就要等待 10 秒，体验是灾难性的。
二、Kubernetes 1.36：三大革命性特性深度解析
2026 年 7 月，Kubernetes 1.36 正式发布。这个版本被社区称为"AI 原生版本"，带来了三个足以改变游戏规则的特性。
2.1 动态资源分配（DRA）正式 GA：AI 算力调度的新标准
DRA（Dynamic Resource Allocation）是 Kubernetes 处理硬件加速器（GPU/TPU）的全新方式。在此之前，GPU 资源通过设备插件（Device Plugin）管理，这种方式存在三个根本问题：
- 粒度太粗：一个 Pod 要么占用整张 GPU，要么不占用。无法实现 GPU 分片（MIG）。
- 声明不精确：无法指定需要的 GPU 型号、显存大小、计算能力。
- 共享困难：多个 Pod 无法共享同一张 GPU。
DRA 通过两个新的 API 对象彻底解决了这些问题：
# ResourceClass 定义：GPU 资源的抽象描述
apiVersion: resource.k8s.io/v1alpha2
kind: ResourceClass
metadata:
name: nvidia-gpu
driverName: gpu.nvidia.com
parameters:
driver: nvidia
version: "560.35.03"
---
# ResourceClaim 声明：精确描述工作负载需要的 GPU 资源
apiVersion: resource.k8s.io/v1alpha2
kind: ResourceClaim
metadata:
name: llm-inference-gpu
spec:
resourceClassName: nvidia-gpu
parameters:
gpuMemory: 80Gi # 精确指定显存需求
computeCapability: "8.0" # 要求特定算力架构
multiInstanceGPU: true # 启用 MIG 分片
count: 2 # 需要 2 个 GPU 分片
实战案例：某 AI 公司的大模型推理集群使用 DRA 后，GPU 利用率从 58% 提升至 89%，推理延迟降低 42%，硬件成本节省 37%。关键改进在于：
- MIG 分片让一张 A100 80GB 可以同时服务 3 个小模型推理请求
- 精确的资源声明避免了"大材小用"——7B 模型不再需要整张 A100
- 声明式管理让 GPU 资源可以像 CPU 一样参与调度决策
# 实际部署：7B 推理模型使用 DRA 声明 GPU 资源
apiVersion: apps/v1
kind: Deployment
metadata:
name: qwen-7b-inference
spec:
replicas: 3
selector:
matchLabels:
app: qwen-7b
template:
spec:
resourceClaims:
- name: gpu-claim
source:
resourceClaimName: qwen-7b-gpu
containers:
- name: inference
image: vllm/vllm-openai:latest
resources:
claims:
- name: gpu-claim
2.2 用户命名空间（User Namespaces）GA：容器安全的终极防线
这是 Kubernetes 安全领域等待了 5 年的特性。用户命名空间实现了容器内 root 用户到主机非特权用户的自动映射。
在没有用户命名空间之前，容器安全有一个根本性的弱点：如果攻击者利用漏洞获得了容器内的 root 权限，那么在很多配置下，他们实际上也获得了主机的 root 权限（特别是当容器以 privileged 模式运行或使用了 hostPID 等主机命名空间时）。
用户命名空间的工作原理：
容器内部视角：
uid=0(root) gid=0(root)
主机实际映射：
uid=1000650000 gid=1000650000
即使容器逃逸，攻击者也只能获得主机上的非特权用户身份。
启用配置：
# kubelet 配置
--feature-gates=UserNamespacesStatelessPodsSupport=true
# 强制 Pod 安全标准
--pod-security-standards=restricted
# 验证映射
kubectl exec -it my-pod -- id
# 输出：uid=0(root) gid=0(root) groups=0(root)
# 在主机上验证
ps -eo pid,user,comm | grep <container-process>
# 输出：实际运行在非特权用户下
对 AI 工作负载的意义：AI Agent 执行的代码由 LLM 生成，是不可信代码。传统容器假设工作负载是"善意的"，但 AI Agent 的代码可能执行任何操作。用户命名容器提供了最后一道防线——即使 Agent 代码突破了容器边界，也无法获得主机的管理权限。
2.3 PodGroup API 与负载感知调度 2.0：分布式训练的调度革命
v1.36 引入了 PodGroup API，实现了调度状态与工作负载定义的解耦。这解决了 AI 领域一个长期存在的问题：Gang Scheduling（组调度）。
在分布式训练中，一个训练任务通常需要多个 Pod 同时运行。例如，一个 8 卡 A100 的 PyTorch 分布式训练任务需要 8 个 Pod 同时被调度到节点上。如果只有 7 个 Pod 被调度，第 8 个 Pod 需要等待，而前 7 个 Pod 占着 GPU 资源空转，造成资源浪费。
PodGroup API 通过声明式的方式解决了这个问题：
apiVersion: scheduling.k8s.io/v1alpha1
kind: PodGroup
metadata:
name: pytorch-distributed-training
spec:
minMember: 8 # 至少需要 8 个 Pod
scheduleTimeoutSeconds: 300 # 5 分钟超时
priorityClassName: ai-training # AI 训练专用优先级
affinity:
topologyKey: kubernetes.io/hostname # 尽量调度到同一节点
maxSkew: 1 # 跨节点时最大偏差为 1
与传统的 scheduler.alpha.kubernetes.io/pod-group 注解不同，PodGroup 是一个独立的 API 对象，可以独立管理、监控和调试。这使得调度器可以做出更智能的决策：
- 全局视野：调度器可以看到所有 PodGroup 的需求，而不是逐个 Pod 调度
- 超时回滚：如果 PodGroup 在超时时间内无法满足
minMember，可以回滚已分配的资源 - 优先级队列：AI 训练任务可以设置比 Web 服务更高的优先级，确保 GPU 资源优先分配给训练
# 完整的 PyTorch 分布式训练配置
apiVersion: kubeflow.org/v1
kind: PyTorchJob
metadata:
name: llama-finetune
spec:
pytorchReplicaSpecs:
Master:
replicas: 1
template:
spec:
podGroup: pytorch-distributed-training
containers:
- name: pytorch
image: pytorch/pytorch:2.4.0-cuda12.4-cudnn9-runtime
resources:
claims:
- name: gpu-claim
Worker:
replicas: 7
template:
spec:
podGroup: pytorch-distributed-training
containers:
- name: pytorch
image: pytorch/pytorch:2.4.0-cuda12.4-cudnn9-runtime
resources:
claims:
- name: gpu-claim
三、Google Agent Sandbox：为不可信代码打造的安全牢笼
3.1 为什么需要一个新的沙箱？
传统容器（基于 namespace + cgroups）的安全模型假设工作负载是"善意的"。它提供的是"隔离"而非"防御"。容器共享宿主机内核，一个内核漏洞就可能导致容器逃逸。
对于 AI Agent 来说，这个假设完全不成立。Agent 执行的代码由 LLM 在运行时生成，可能是任何东西——包括恶意代码、危险的系统调用、或者意外的资源消耗。运行宿主必须默认将其视为不可信的负载。
Agent Sandbox 的设计思路是将隔离责任从容器边界转移到了内核边界：
传统容器：
应用代码 → 容器 runtime → 宿主内核（共享）
Agent Sandbox：
Agent 代码 → gVisor → Sentry（用户态内核） → 宿主内核（隔离）
3.2 gVisor：用户态内核的工程实现
gVisor 是 Google 开源的应用内核，它在用户空间实现了一个 Linux 内核的子集。Agent 代码的所有系统调用都被 gVisor 拦截和处理，而不是直接传递给宿主内核。
Agent 代码执行 write() 系统调用：
1. gVisor 的 Sentry 拦截系统调用
2. Sentry 验证调用的合法性（权限检查、资源限制）
3. Sentry 使用 Go 语言重新实现系统调用逻辑
4. 只有必要的底层操作才传递给宿主内核
这意味着即使 Agent 代码尝试利用内核漏洞，攻击面也被大幅缩小——它只能接触到 gVisor 的 Go 代码实现，而不是真正的 Linux 内核。
3.3 预热池：解决冷启动的工程方案
Agent Sandbox 的一个关键创新是预热池（Warm Pool）机制。每个集群维护一组预配置的 Sandbox 副本，当 Agent 需要执行代码时，直接从预热池分配，而不是从零启动。
# Agent Sandbox 配置
apiVersion: sandbox.gke.io/v1
kind: SandboxPool
metadata:
name: agent-pool
spec:
replicas: 50 # 预热 50 个 Sandbox
template:
runtimeClass: gvisor # 使用 gVisor 运行时
resources:
limits:
cpu: "2"
memory: 4Gi
securityContext:
runAsNonRoot: true
readOnlyRootFilesystem: true
allowPrivilegeEscalation: false
autoscaling:
minReplicas: 20
maxReplicas: 200
targetUtilization: 70
性能数据（来自 Google 官方报告）：
| 指标 | 传统 Pod | Agent Sandbox |
|---|---|---|
| 冷启动时间 | 8-15 秒 | 200 毫秒（预热池分配） |
| 每秒分配量 | ~10 | ~300 |
| 内存开销 | 100% | ~30%（gVisor 优化） |
| 隔离级别 | 容器级 | 内核级 |
3.4 Pod 快照：空闲会话的内存置换
Agent Sandbox 的另一个核心能力是 Pod 快照（Pod Snapshot）。当 Agent 进入空闲状态时，其完整的运行时状态（包括内存、文件系统、网络连接）被序列化并持久化到存储中，底层计算资源被释放。
Agent 活跃状态：
[CPU: 2核] [内存: 4GB] [GPU: 1x A100] ← 占用资源
Agent 进入空闲：
执行 Pod Snapshot → 状态写入 S3/GCS
释放 CPU、内存、GPU 资源 ← 资源回收
Agent 被唤醒：
从存储恢复状态 → 200ms 内恢复到快照时的状态
这就像操作系统的虚拟内存机制——把不活跃的内存页交换到磁盘，为活跃进程腾出空间。不同的是，这里交换的是整个 AI Agent 的运行时状态。
四、Google Agent Substrate：重新定义智能体调度层
4.1 核心思路：虚拟内存超分配
Agent Substrate 是 Google 提出的智能体运行时调度层。它的核心设计灵感来自操作系统的虚拟内存机制。
操作系统的虚拟内存允许程序寻址远超机器物理内存的内存空间，方法是将冷页分页到磁盘。Agent Substrate 对智能体会话采用同类思路：
物理内存模型（传统 K8s）：
100 个 Pod × 4GB = 400GB 内存
实际使用率：10%（大部分 Pod 空闲）
虚拟内存模型（Agent Substrate）：
1000 个 Agent 会话
实际运行的 Pod：50 个 × 4GB = 200GB
空闲会话：950 个 → 快照到存储
超额订阅率：20x
4.2 架构：旁路 Kubernetes 控制平面
Agent Substrate 的关键设计决策是不替代 Kubernetes，而是在旁边运行。它使用 K8s 的 Pod 和自动扩缩容来管理底层节点资源，但在上层叠加自己的调度器。
┌─────────────────────────────────────────┐
│ Agent Substrate 控制平面 │
│ ┌──────────┐ ┌──────────┐ ┌────────┐ │
│ │ 调度器 │ │ 状态管理 │ │ 路由层 │ │
│ └────┬─────┘ └────┬─────┘ └───┬────┘ │
│ │ │ │ │
│ ┌────▼──────────────▼────────────▼────┐ │
│ │ Worker Pool (预热 Pod) │ │
│ │ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │ │
│ │ │Pod 1│ │Pod 2│ │Pod 3│ │Pod N│ │ │
│ │ └─────┘ └─────┘ └─────┘ └─────┘ │ │
│ └────────────────────────────────────┘ │
└─────────────────┬───────────────────────┘
│ 使用 K8s API 管理节点
┌─────────────────▼───────────────────────┐
│ Kubernetes 控制平面 │
│ (配置节点、网络、存储，但不参与调度) │
└─────────────────────────────────────────┘
为什么不直接用 K8s 调度器？
Agent Substrate 的架构文档对此直言不讳：
"标准控制平面没有巧妙的方法能容纳数百万个对象。Kubernetes 调度器的设计假设调度决策发生频次低且决策时持久的。智能体通过生成持续不断的细粒度调度事件打破了这一假设。"
解决方案是将智能体调度从 K8s 控制平面的关键路径上移除：
- 路由层使用专用网络直接将请求发送到正确的会话
- 状态管理将空闲会话的快照存储在独立的存储系统中
- 调度器在 Worker Pool 中做调度决策，而不是通过 K8s Scheduler
4.3 自定义资源：WorkerPool 和 ActorTemplate
Agent Substrate 定义了两个核心的自定义资源：
# WorkerPool：定义计算资源池
apiVersion: substrate.agent.google.com/v1
kind: WorkerPool
metadata:
name: coding-agent-pool
spec:
replicas: 100
template:
spec:
containers:
- name: agent-worker
image: gcr.io/agent-substrate/worker:latest
resources:
limits:
cpu: "4"
memory: 8Gi
runtimeClass: gvisor
autoscaling:
minReplicas: 20
maxReplicas: 500
targetUtilization: 60
warmPool:
readyReplicas: 50
snapshotStorage: gs://my-bucket/agent-snapshots
---
# ActorTemplate：定义智能体模板
apiVersion: substrate.agent.google.com/v1
kind: ActorTemplate
metadata:
name: claude-code-agent
spec:
framework: claude-code
container:
image: anthropic/claude-code:latest
env:
- name: ANTHROPIC_API_KEY
valueFrom:
secretKeyRef:
name: api-keys
key: anthropic
stateManagement:
snapshotInterval: 60s
maxIdleTime: 300s
snapshotStorage: gs://my-bucket/claude-snapshots
isolation:
runtimeClass: gvisor
networkPolicy: default-deny
maxCpu: "2"
maxMemory: 4Gi
4.4 性能基准：30 倍超额订阅的实现
Agent Substrate 的性能数据令人印象深刻：
| 指标 | 传统 K8s 部署 | Agent Substrate |
|---|---|---|
| 并发 Agent 数 | ~100（受 Pod 数量限制） | ~3000（超额订阅 30x） |
| 冷启动延迟 | 8-15 秒 | <1 秒（预热池） |
| 空闲资源浪费 | ~90% | <5% |
| 每 Agent 成本 | $0.50/小时 | $0.02/小时 |
| 激活延迟 | 5-10 秒 | <500 毫秒 |
实现 30 倍超额订阅的关键技术：
- 预热池：Worker Pool 中始终保持一定数量的"热" Pod，随时可以接收新会话
- 快照恢复：空闲会话的状态快照可以在 200 毫秒内恢复
- 直连路由：请求通过专用网络层直接发送到目标 Pod，绕过 K8s Service
- 状态分离：会话状态存储在独立的存储系统中，不依赖 etcd
五、实战：如何部署 AI 原生 Kubernetes 集群
5.1 基础设施规划
# 1. 创建启用 DRA 的 GKE 集群
gcloud container clusters create ai-cluster \
--zone us-central1-a \
--num-nodes 10 \
--machine-type n1-standard-8 \
--enable-dynamic-workload-scheduling \
--enable-user-namespaces \
--release-channel rapid \
--cluster-version 1.36
# 2. 添加 GPU 节点池（带 DRA 支持）
gcloud container node-pools create gpu-pool \
--cluster ai-cluster \
--zone us-central1-a \
--num-nodes 4 \
--machine-type a2-highgpu-1g \
--accelerator type=nvidia-a100-80gb,count=1 \
--enable-driver-installation
# 3. 安装 Agent Sandbox
kubectl apply -f https://storage.googleapis.com/agent-sandbox/release/manifests/sandbox-operator.yaml
# 4. 安装 Agent Substrate
kubectl apply -f https://storage.googleapis.com/agent-substrate/release/manifests/substrate-operator.yaml
5.2 部署编程智能体集群
# agent-deployment.yaml
apiVersion: substrate.agent.google.com/v1
kind: WorkerPool
metadata:
name: coding-agents
namespace: ai-agents
spec:
replicas: 200
template:
spec:
runtimeClass: gvisor
containers:
- name: agent
image: anthropic/claude-code:latest
resources:
limits:
cpu: "4"
memory: 8Gi
env:
- name: ANTHROPIC_API_KEY
valueFrom:
secretKeyRef:
name: agent-secrets
key: anthropic-key
resourceClaims:
- name: agent-gpu
source:
resourceClaimName: coding-gpu
warmPool:
readyReplicas: 50
autoscaling:
minReplicas: 50
maxReplicas: 500
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 60
---
# GPU 资源声明
apiVersion: resource.k8s.io/v1alpha2
kind: ResourceClaim
metadata:
name: coding-gpu
namespace: ai-agents
spec:
resourceClassName: nvidia-gpu
parameters:
gpuMemory: 40Gi
multiInstanceGPU: true
count: 2
5.3 监控与可观测性
# 部署 Prometheus + Grafana 监控
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
name: agent-substrate-alerts
spec:
groups:
- name: agent-substrate
rules:
- alert: AgentColdStartLatencyHigh
expr: |
histogram_quantile(0.99,
rate(agent_substrate_cold_start_duration_seconds_bucket[5m])
) > 2
for: 5m
labels:
severity: warning
annotations:
summary: "Agent cold start latency > 2s"
- alert: WarmPoolExhausted
expr: |
agent_substrate_warm_pool_ready < 5
for: 2m
labels:
severity: critical
annotations:
summary: "Warm pool nearly exhausted"
- alert: GPUMemoryFragmentation
expr: |
agent_substrate_gpu_memory_fragmented /
agent_substrate_gpu_memory_total > 0.3
for: 10m
labels:
severity: warning
annotations:
summary: "GPU memory fragmentation > 30%"
5.4 成本优化策略
# cost_optimizer.py - 基于历史数据的智能扩缩容
import json
from datetime import datetime, timedelta
class AgentCostOptimizer:
def __init__(self, cluster_client):
self.cluster = cluster_client
def analyze_usage_pattern(self, agent_type, days=7):
"""分析智能体使用模式，优化预热池大小"""
metrics = self.cluster.get_metrics(
agent_type=agent_type,
period=timedelta(days=days)
)
# 计算峰值和谷值
hourly_usage = self._aggregate_hourly(metrics)
peak_hours = [h for h, v in hourly_usage.items() if v > 0.8 * max(hourly_usage.values())]
valley_hours = [h for h, v in hourly_usage.items() if v < 0.2 * max(hourly_usage.values())]
return {
"peak_hours": peak_hours,
"valley_hours": valley_hours,
"avg_utilization": sum(hourly_usage.values()) / len(hourly_usage),
"recommended_warm_pool": self._calculate_optimal_pool(hourly_usage),
"estimated_monthly_cost": self._estimate_cost(hourly_usage)
}
def _calculate_optimal_pool(self, hourly_usage):
"""基于使用模式计算最优预热池大小"""
# 谷值时段保持最小预热池
min_pool = max(10, int(0.1 * max(hourly_usage.values())))
# 峰值时段按 1.5x 冗余
max_pool = int(1.5 * max(hourly_usage.values()))
# 工作日 9-18 点使用峰值配置
return {"min": min_pool, "max": max_pool}
六、Google Agent Substrate vs 传统方案对比
6.1 与 Knative 的对比
Knative 是 Kubernetes 上最流行的 Serverless 框架。但它为 AI Agent 工作负载提供了三个关键缺陷：
| 维度 | Knative | Agent Substrate |
|---|---|---|
| 冷启动 | 1-5 秒 | <200 毫秒 |
| 状态管理 | 无状态（每次调用独立） | 有状态会话（跨调用保持） |
| 会话持久化 | 不支持 | Pod 快照，持久化整个运行时 |
| 隔离级别 | 容器级 | 内核级（gVisor） |
| 超额订阅 | 有限（基于并发请求数） | 30x+（基于会话数） |
6.2 与 Volcano 的对比
Volcano 是 Kubernetes 上的批量调度框架，常用于 AI 训练任务。但它专注于"批处理"调度，不适合"交互式"智能体：
| 维度 | Volcano | Agent Substrate |
|---|---|---|
| 适用场景 | 批量训练任务 | 交互式智能体 |
| 调度模型 | Gang Scheduling | 会话级调度 |
| 状态管理 | 无状态（任务完成后释放） | 有状态（会话持续存在） |
| 空闲处理 | 无（任务完成即释放） | 快照挂起，按需恢复 |
| 延迟要求 | 容忍分钟级 | 要求毫秒级 |
七、社区生态与未来展望
7.1 kagent：统一的智能体管理界面
Solo.io 已经将 Agent Substrate 集成到 kagent 中，提供了一个统一的 UI 来管理 AI 智能体。通过 kagent，你可以：
- 在一个界面查看所有智能体的状态（活跃/空闲/错误）
- 配置智能体模板和资源池
- 监控智能体的性能指标和成本
- 一键部署新的智能体框架
# 安装 kagent
helm repo add kagent https://kagent.dev/charts
helm install kagent kagent/kagent \
--namespace kagent-system \
--set substrate.enabled=true \
--set sandbox.enabled=true
7.2 悬而未决的问题
问题一：谁会主导这一层？
Agent Substrate 目前处于早期阶段，kagent 也处于早期阶段。随着空闲智能体的成本成为平台团队无法忽视的开支项目，竞争对手的运行时也将陆续面世。这个智能体控制平面能否像当年容器编排赛道最终收敛到 Kubernetes 一样收敛成一个单一的开源项目？
问题二：多云场景下的兼容性
如果每个云厂商都推出自己的 Agent 运行时，智能体原本想要摆脱的生态割裂问题会向上转移到这一层基础设施再度出现。
问题三：安全模型的演进
Agent 执行的代码是 LLM 生成的不可信代码。当前的安全模型（gVisor + 网络策略）是否足够？未来是否需要更细粒度的系统调用过滤和资源限制？
7.3 2026-2028 技术趋势预测
Agent Runtime 成为独立基础设施层：就像容器运行时（containerd/CRI-O）从 Docker 中独立出来一样，Agent Runtime 将成为独立的基础设施组件。
Kubernetes 原生支持 Agent 工作负载：预计在 K8s 1.38 或 1.39 中，PodGroup API 将 GA，Pod 快照将成为原生特性。
GPU 虚拟化成为标配：MIG、vGPU、Time-slicing 等技术将标准化，GPU 资源将像 CPU 一样被灵活分配。
边缘 AI 推理与 K8s 深度整合：K3s/K0s 等轻量级 K8s 发行版将原生支持 AI 推理工作负载，实现"万物皆容器"的愿景。
八、总结：从容器编排到智能体编排的范式革命
Kubernetes 在过去十年里统治了容器时代。但 AI 智能体的崛起暴露了它在架构层面的根本局限。Google 的 Agent Sandbox 和 Agent Substrate 代表了一种新的设计哲学：
不是在 Kubernetes 之上修补，而是在旁边重建一个为智能体设计的调度层。
这个新层的核心思想是借鉴操作系统的经典机制——虚拟内存超分配、进程调度、内存页置换——来解决智能体工作负载的独特挑战。
对于每一个云原生工程师来说，这意味着：
- 学习新的思维模型：从"容器是进程"转变为"智能体是操作系统进程"
- 掌握新的工具链：DRA、User Namespaces、PodGroup、Agent Sandbox、Agent Substrate
- 重新思考成本模型：从"按 Pod 计费"转变为"按活跃时间计费"
- 关注安全新维度：从"容器逃逸防护"转变为"LLM 生成代码的内核级隔离"
Kubernetes 不会被取代。它仍然是底层的基础设施操作系统。但在它之上，一个新的调度层正在被重建——一个为 AI 智能体量身定制的调度层。
下一个十年，不是"Kubernetes vs AI"的故事，而是"Kubernetes + AI 原生调度层"共同演进的故事。而这个故事，才刚刚开始。
参考资源：
- Kubernetes 1.36 Release Notes: https://kubernetes.io/blog/2026/07/kubernetes-1-36-release/
- Google Agent Sandbox: https://cloud.google.com/agent-sandbox
- Google Agent Substrate: https://cloud.google.com/agent-substrate
- kagent (Solo.io): https://kagent.dev
- DRA Enhancement Proposal: https://github.com/kubernetes/enhancements/tree/master/keps/sig-scheduling/4381-dra
- PodGroup API: https://github.com/kubernetes/enhancements/tree/master/keps/sig-scheduling/626-pod-group