企业 AI 的真正风险不是自主 Agent，而是它们之间的复杂性

由 Gravitee 呈现

Agent 复杂性正是如今潜伏在企业内部、亟待被揭示的隐性风险。

这是因为，企业不会只部署一个 Agent 然后看着它运行；它们部署的是成群的 Agent，每个 Agent 都会调用 API、调用其他 Agent，并访问那些从未为机器决策者而构建的应用程序。这才是真正会让你夜不能寐的失效模式：一个错综复杂、不断延伸的系统，没有人能看得足够清楚，更谈不上治理。但为什么它会如此迅速地变得不透明？

在系统中加入第二个 Agent，你增加了一条连接。加入第十个 Agent 时，你增加的并不只是十条连接，而可能是数十条，因为现在任意 Agent 都可能调用其他任意 Agent，而每一次调用又可能触发对其他地方的调用。复杂性不会随着 Agent 数量线性增长，而是会随着 Agent 之间路径数量增加而复合增长；却没有人的职责是把这张关系图画出来。过去只需触及一个系统的支持工单，如今可能在人工首次看到之前已经经过四个 Agent，而每一次交接都是一个从未获得审批的决策点。

大多数企业 AI 项目停滞不前，都是因为负责这些 Agent 的人已经失去了对整个系统脉络的掌握。向安全团队提出一个简单问题：哪些 Agent 可以访问哪些系统？你会看到一片沉默。再问，三跳之前是哪个 Agent 触发了哪项下游操作？依然是一片沉默。

人们本能地会把这当作一份检查清单来处理：审批 Agent，记录 Agent，然后继续推进。我认为这是错误的本能。检查清单只能核验某一个时间点。复杂性贯穿整个链条，而你无法靠一叠一次性审批来治理一条链，就像你不能因为曾经吃过一次蔬菜，就认定节食已经成功。

那么，问题究竟会在哪里真正失控？

首先是权限蔓延。有人构建了一个用于汇总支持工单的 Agent，因为正确限定其权限范围还需要额外一个 Sprint，于是给了它宽泛的 API 访问权限，然后就忘了这件事。六个月后，同一个 Agent 已经拥有通往支付系统的路径。没有人记得曾经批准过这一点。事实上，也从未有人批准过。

随着链条不断延伸，责任归属也会越来越稀薄。五个 Agent 触及同一个工作流，第四步出了问题，这时你开始追问谁应对某个链路负责；但这个链路从未被分配给任何人负责，因为组织架构止步于“部署 Agent”，却从未走到“指定为它承担责任的人”。

这是一个关于治理基础设施未能跟上 Agent 实际行为方式的故事：它们彼此连接、层层级联，并以快于现有跟踪流程的速度不断增加。

解决这一混乱局面的起点是身份。每个 Agent 都需要作为独立实体存在，而不是借用部署者的影子权限。它应在登记册中拥有自己的名称，拥有范围明确的权限，并有一名具名的人类负责人，为它的行为承担责任。这一部分是必要的。

但这还远远不够。

更难的部分，是建立贯穿整条链路的监督机制，而不只是监督其中每一个独立环节。你需要实时看到一个 Agent 做了什么、它在下游触发了什么，以及这条轨迹最终在何处结束，而不是等到有人每季度汇总一次报告。即使你正确建立了 Agent 级别的身份体系，却止步于此，最终也只会得到一个档案柜，里面装满了文档完美齐全的 Agent，但没有人真正能解释它们所在的整个系统。

而监督本身只能告诉你已经发生了什么。观察一条链并不等同于控制它。执行是大多数项目跳过的一环：在不符合策略的调用执行之前将其阻止，而不只是记录下来，等某人在三周后的审查中发现它。一个向你展示某个 Agent 五分钟前越权的仪表板，只是一个监控工具；一个从源头上阻止违规发生的系统，才是治理。认真对待Agent 问责的企业需要同时具备两者，而大多数企业只建立了前者。

我们都在以惊人的速度前进，确保自己不会在这场突然置身其中的竞赛里落后；我们也都十分清楚，放慢速度会付出代价。每一家认真发展 Agentic AI 的企业，最终都会撞上复杂性之墙。那些能够跨越它的企业，都是因为构建了足够的可见性和问责机制，使其 Agent 集群能够持续增长，同时又不失去回答一个问题的能力：这个系统此刻正在做什么，谁对此负责？

但不要错过重点。复杂性并不是踩下刹车的理由。真正把这件事做对的企业并没有放慢脚步。它们正在迈向人机 Agent 协同（Human-Agent Harmony），让规模与问责能力共同增长，而不是彼此取舍。

真正的风险从来不是某一个 Agent 精确完成它被设计去做的事情，而是一百个 Agent 同时精确完成各自被设计去做的事情，并以从未有人设计过的组合方式彼此交互。这种乘法式增长，才是让企业 AI 永远停留在试点阶段、无法进入生产环境的原因。

解决复杂性问题，自主性就不再是反派。它将成为这一切的真正意义所在。

Rory Blundell 是 Gravitee 的 CEO。

赞助文章是由为文章付费或与 VentureBeat 存在商业关系的公司制作的内容，且始终会被明确标注。如需了解更多信息，请联系 sales@venturebeat.com 。

Presented by Gravitee

Agent complexity is the insidious shadow lurking inside enterprises right now that needs a light shone on it.

That’s because enterprises don't deploy a single agent and watch it run, they deploy fleets, each one calling APIs, calling other agents, reaching into applications that were never built with a machine decision-maker in mind. That's the failure mode that should keep you up at night: a windy, complicated system nobody can see clearly enough to govern. But why do things get so opaque so quickly?

Add a second agent to a system, and you've added one connection. Add a tenth, and you haven't added ten connections, you've potentially added dozens, because now any agent might call any other, and each of those calls can trigger a call somewhere else. Complexity doesn't creep up with agent headcount. It compounds with the number of paths between agents, and nobody's job is to draw that graph. A support ticket that used to touch one system might now pass through four agents before a human ever lays eyes on it, and every one of those handoffs is a decision point nobody approved.

Most enterprise AI programs stall when the humans responsible for their agents lose the thread. Ask a security team a simple question: which agents can reach which systems, and watch the silence. Ask which agent triggered which downstream action three hops ago. More silence.

The instinct is to treat this like a checklist. Approve the agent. Log the agent. Move on. I'd argue this is the wrong instinct. A checklist checks a single point in time. Complexity runs across a chain, and you can't govern a chain with a stack of one-time approvals any more than you can call a diet successful because you had a vegetable once.

So where does it actually break down?

Permissions creep first. Somebody builds an agent to summarize support tickets, grants it broad API access because scoping it properly would've taken another sprint, and forgets about it. Six months later, that same agent has a path into the payments system. Nobody remembers signing off on that. Nobody did.

And ownership thins out the further the chain runs. Five agents touch one workflow, something breaks at step four, and now you're asking who's responsible for a link nobody was ever assigned to own, because the org chart stopped at "deploy the agent" and never got to "name the human who answers for it."

This is a story about governance infrastructure that hasn't caught up with how agents actually behave: interconnected, cascading, multiplying faster than the processes built to track them.

Fixing the cluster starts with identity. Every agent needs to exist as its own entity, not a shadow permission borrowed from whoever deployed it. Its own name in the register. Its own scoped authority. A named human sponsor who answers for what it does. That part is necessary.

But it is nowhere near sufficient.

The harder piece is the oversight that holds across the entire chain, not just at each individual link in it. You need to see what an agent did, what it set off downstream, and where that trail ends in real time, not in a report someone pulls together once a quarter. Get agent-level identity right and stop there, and you end up with a filing cabinet full of perfectly documented agents operating inside a system nobody can actually explain.

And oversight by itself only tells you what already happened. Watching a chain isn't the same as controlling it. Enforcement is the piece most programs skip: the ability to stop an out-of-policy call before it executes, not just log it for someone to find in a review three weeks later. A dashboard that shows you an agent breached its scope five minutes ago is a monitoring tool. A system that stops the breach from happening in the first place is governance. Enterprises serious about agent accountability need both, and most have only built the first.

We're all running at blazing speed to ensure we're not the ones left behind in the race we've found ourselves in, and we're all too aware that there's a cost to slowing down. Every enterprise serious about agentic AI hits the complexity wall eventually. The ones that get past it are the ones who built enough visibility and accountability, so their fleet can keep growing without anyone losing the ability to answer one question: what is this system doing right now, and who's responsible for it.

But don't miss the point. Complexity isn't a reason to pump the brakes. The enterprises getting this right aren't slowing down. They're building toward Human-Agent Harmony, where scale and accountability grow together instead of trading off against each other.

The real risk was never a single agent doing exactly what it was built to do. It's a hundred of them doing exactly that, all at once, interacting in combinations nobody designed for. That kind of multiplication is what keeps enterprise AI stuck running pilots forever instead of running production.

Solve for complexity and autonomy stops being the villain. It starts being the whole point.

Rory Blundell is CEO at Gravitee.

Sponsored articles are content produced by a company that is either paying for the post or has a business relationship with VentureBeat, and they’re always clearly marked. For more information, contact sales@venturebeat.com .