2026 企业 AI 的真正风险：代理之间的复杂性，而非代理本身

代理复杂性是企业内部正在蔓延的阴影。因为企业不会只部署一个代理然后看着它跑——它们部署的是代理集群，每个都在调 API、调其他代理、伸进从未为机器决策者设计过的应用。这才是该让你夜不能寐的失败模式：一个没人能看清、也就没人能治理的蜿蜒复杂系统。但为什么这么快就变得这么不透明？加第二个代理，你加了一条连接。加第十个，你加的不是十条连接——而是可能几十条，因为现在任何代理都可能调用任何其他代理，而每一次调用都可能触发别处的调用。复杂性不是随代理数量爬升的，它是随代理之间路径数量复合增长的——而画这张图不是任何人的工作。

1. 复杂性随路径复合增长

一张曾经只碰一个系统的支持工单，现在可能在人类看到之前穿过四个代理，而每一次交接都是一个没人批准过的决策点。大多数企业 AI 项目在负责人失去线索时停滞。问安全团队一个简单问题：哪些代理能触达哪些系统？等着沉默。问哪个代理在三跳之前触发了哪个下游动作？更沉默。直觉是把这当清单处理：批准代理、记录代理、继续前进。我认为这是错误的直觉。清单检查的是单一时间点；复杂性横跨整条链，你没法用一堆一次性审批来治理一条链——就像你不能因为吃过一次蔬菜就说节食成功。

// Why complexity compounds: add a second agent and you
// have one connection. Add a tenth and you have dozens,
// because any agent might call any other, and each call can
// trigger a call somewhere else.
function maxPairs(n: number): number {
  return (n * (n - 1)) / 2;
}
maxPairs(2);  // 1
maxPairs(10); // 45 — and that is only pairwise paths
// Nobody's job is to draw that graph. That is the risk.

2. 它在哪一环断掉：权限蔓延

权限蔓延是第一个断点。有人建了一个总结支持工单的代理，因为精确划定权限要多花一个 sprint，就给了它宽泛的 API 访问权，然后忘了它。六个月后，同一个代理有了通往支付系统的路径。没人记得批准过这件事——因为根本没人批准过。这是「没人记得签字」的经典形态：范围太宽是为了赶工，而代理不会自己缩小权限。每个宽范围授权都是一个潜伏的路径，等某个下游系统被纳入它的可达范围。

// Agent identity: every agent exists as its own entity, not
// a shadow permission borrowed from whoever deployed it.
type Agent = {
  id: string;            // its own name in the register
  sponsor: string;       // a named human who answers for it
  scopes: string[];      // scoped authority, granted not inherited
  register: "active" | "revoked";
};
const ticketSummarizer: Agent = {
  id: "agent:support-ticket-summarizer",
  sponsor: "alice@corp",
  scopes: ["tickets:read", "triage:write"],
  register: "active",
};
// Six months later it must NOT have a path to payments.

3. 所有权随链条稀释

所有权则随着链条延伸而变薄。五个代理碰一个工作流，第四步出了故障，然后你问：谁为这条从没人被指派去拥有的链路负责？组织结构图停在「部署代理」，从没到「指定一个为它负责的人」。当链条上每一个环节都有人签字、有人回答，故障才有人负责；而今天的现实是，链条越长，负责人越模糊。治理基础设施没有跟上代理的真实行为：互联、级联、增长速度超过追踪它们的流程。

// Enforcement before execution: a system that STOPS an
// out-of-policy call before it executes is governance. A
// dashboard that shows you a breach five minutes after it
// happened is only monitoring.
async function guardedCall<T>(agent: Agent, call: Call): Promise<T> {
  const decision = await policyEngine.evaluate({
    agent: agent.id,
    action: call.action,
    target: call.target,
    chain: trace.getAncestors(call), // 3 hops back
  });
  if (decision !== "allow") {
    audit.log({ agent: agent.id, call, decision, at: Date.now() });
    throw new PolicyBlocked(decision);
  }
  return execute(call);
}
// Monitoring tells you what happened. Enforcement is the
// piece most programs skip.

4. 修复从身份开始——但身份远远不够

修复集群从身份开始。每个代理必须作为独立实体存在，而不是从部署它的人那里借来的影子权限。它自己的注册名、自己的限定权限、一个为它的行为负责的具名人类赞助人。这部分是必须的。但远远不够。更难的部分是跨整条链的监督——你要实时看到代理做了什么、它在下游触发了什么、这条轨迹在哪里结束，而不是某个季度才有人拼出来的报告。只把代理级身份做对就停手，你得到的是一柜子记录完美的代理，运行在一个没人能真正解释的系统里。

5. 监督只告诉你发生过什么

监督本身只告诉你已经发生的事。看一条链不等于控制它。强制执行是大多数项目跳过的一块：在越权调用执行之前就阻止它，而不是记录它让某人三周后在审查里发现。一个五分钟前显示代理越界的仪表盘是监控工具；一个从一开始就阻止越界的系统才是治理。认真对待代理问责的企业两者都需要——而大多数只建了第一个。安全团队问不出「哪些代理能触达哪些系统」的那一刻，你就已经落后了。

// Ownership that doesn't thin out: name the human who
// answers for every LINK, not just every agent. The org
// chart stops at "deploy the agent" — push it further.
type Link = {
  from: AgentId;
  to: AgentId;
  owner: HumanId;      // answers when step four breaks
  approvedBy: HumanId; // and who signed off
  approvedAt: string;
};
const links: Link[] = registry.getAllLinks();
// Ask "which agent triggered which downstream action three
// hops ago" and the silence comes from missing Link rows.

6. 解法：Human-Agent Harmony

复杂性不是踩刹车的理由。做对的企业没有减速，它们在构建 Human-Agent Harmony——规模与问责一起增长，而不是相互交易。真正的风险从来不是一个代理做了它被造出来该做的事；而是一百个代理同时做了它们被造出来该做的事，以没人设计过的组合互相作用。正是这种乘法让企业 AI 永远困在试点里，进不了生产。为复杂性而设计——身份、链级监督、执行前强制——自主就不再是反派，它成了全部意义。回答一个问题：这个系统现在在做什么，谁为它负责？

// Chain-level oversight: you need to see what an agent did,
// what it set off downstream, and where the trail ends — in
// real time, not in a quarterly report.
async function traceChain(start: AgentId, depth = 3) {
  const trail = [];
  let current = start;
  for (let i = 0; i < depth; i++) {
    const step = await telemetry.getStep(current);
    trail.push({ agent: step.agent, action: step.action,
                 target: step.target, at: step.at });
    current = step.next ?? break;
  }
  return trail;
}
// A filing cabinet of perfectly documented agents operating
// inside a system nobody can explain is not governance.