In my talk at Container days Hamburg last month, I presented Kagent: the OSS platform that makes creating and managing Cloud Native AI Agents easy and scalable.

While there was a lot of interest in the topic and the platform, many questions clearly voiced the engineers’ very valid concerns over the security and reliability of existing agentic frameworks and workflows:

• How long will it take until the agent erases my whole cluster?
• How do I know which of the tools available to agents are potentially destructive?

The hype around agentic AI is still peaking, but underneath it, many of us are already asking a harder question: what’s the real cost of giving AI this kind of agency?

In behavioral economics, the “cost of agency” refers to the tension that exists in any relationship where one party acts on behalf of another; questions of trust, control, and accountability arise. That same tension now applies to AI systems that make decisions or take actions for us.

The Principal-Agent Problem

To really understand what “cost of agency” means, we need to go back to the theory it comes from: the principal–agent problem.

Before we go further, let’s get the terms straight:

• Agency relationship: a dynamic between two parties — a principal and an agent.
• Principal: the party that delegates authority.
• Agent: the party empowered to act on behalf of the principal.
• Principal–agent problem: arises when the principal and agent have different incentives, and the agent acts in their own interest rather than the principal’s.
• Cost of agency: the total of direct and indirect costs involved in reducing conflicts of interest and misalignment between a principal and an agent.

These ideas might sound abstract, but they map surprisingly well onto how AI systems behave.

Now, how does this apply to AI?

In short—completely. While an LLM isn’t supposed to have personal interests, we all know that’s not quite true in practice. Commercial models have repeatedly shown bias and built-in preferences. Even open-source ones will confidently fabricate facts if it helps them appear helpful or correct.

Take a recent example: during a rebase attempt, I asked an LLM to resolve merge conflicts for me. It eagerly overwrote all the changes from the main branch… breaking the API entirely. That might be tolerable for a chat-based assistant with a human in the loop, but it’s a shaky foundation for an autonomous agent I’m supposed to trust with real decisions.

In this demo of Khook, the event-driven agent controller I built for Kagent, you can watch an agent attempt to “fix” a failing Kubernetes pod…though not in the way I’d hoped.

Moments like this make me chuckle when in isolation, but they hint at something bigger: it’s easy to imagine far more serious consequences once we start letting agents act autonomously in live environments.

Which brings me to:

The Cost of AI Agency

Every time we give an agent more freedom, we’re also taking on a bit more risk. And that risk comes with a price tag.

In practice, the cost of agency usually shows up in three places:

1. The cost of building and maintaining the supporting infrastructure.
2. The cost of creating and maintaining the observability and guardrails that will prevent the agents from wreaking havoc on our infrastructure, data or application behavior.
3. The cost of changing the organizational behaviour to adapt to the agentic mode of operation.

Now let’s break down how each of these costs is getting paid today and what is still missing.

Agentic Infrastructure

Most teams handle this either ad hoc or, ideally, by integrating one or more of the new open-source frameworks. A good example in the cloud-native ecosystem is Kagent, a platform for declarative creation, deployment, and management of AI agents in Kubernetes. It also includes kmcp, a tool for building and deploying stdio MCP servers, and Khook, a reactive agent invocation controller.

Of course, Kagent and similar tools rely on agentic protocols that are still evolving, like MCP, A2A, and their various implementations.

To be clear, this isn’t about the training or inference infrastructure for the LLMs that agents are built on. Those are often handled by third-party providers. But if you’re running those processes in-house, you’ll want to look at related frameworks such as Kaito, Ollama, or llm-d.

Observability and Guardrails

All critical software needs observability, security, and governance. But agentic systems push those requirements further, and they force us to rethink how authentication, authorization, and governance even work.

A lot of work is already happening in the cloud-native ecosystem to tackle this. One example is agentgateway, a project adjacent to Kagent that reimagines network gateways and proxies for the agentic age.

Organizational Behaviour

This might be the most hidden cost of AI agency so far. To be honest, we still don’t fully know what it is. The processes are taking shape in real time.

We’re seeing clear productivity gains at the individual level, but the impact at the organizational level is still unclear. The latest DORA report on AI-assisted software development points out that the biggest returns come “not from the tools themselves, but from investing in the underlying organizational system.”

As the tools continue to evolve, so will the organizational practices needed to unlock their full value.

Summing it Up

The cost of agency in modern agentic systems is real, and it needs to be understood and managed if enterprises want to see real value from AI transformation.

A growing number of CNCF projects are tackling this head-on, building cloud-native tools for smarter, API-driven management of agentic software.

The key to getting it right? Start with the best practices we already know from the cloud-native world…then adapt them to fit the messy, evolving reality of agentic systems.

KubeCon + CloudNativeCon North America 2025 is taking place in Atlanta, Georgia, from November 10 to 13. Register now.