The Cloud Native Computing Foundation (CNCF) – the foundation under whose umbrella, among other things, Kubernetes is maintained – has placed several projects under its stewardship at KubeCon + CloudNativeCon NA. The stated goal: to advance the secure operation of AI agents and improve their efficiency.
The announcement itself is brief, but the signal behind it is clear. When a foundation that manages the de facto standard for container orchestration takes on projects around AI agents, the topic shifts from experimental operation towards infrastructure. And infrastructure means: operations, responsibilities, security architecture.
Why the topic is coming up right now
AI agents are software components that, based on a language model, not only generate text but independently execute actions – such as calling interfaces, reading data or triggering process steps. In a prototype this is manageable: a developer machine, a test dataset, a tightly scoped scenario.
As soon as an agent is allowed into production systems that hold real customer data, orders or invoices, the risk situation changes fundamentally. From a security architecture perspective, an agent that can call tools is no longer a chat window but another acting entity in the system – with permissions, network access and potential for error.
This is precisely where the cloud-native world traditionally starts: with standardisation, traceable operations and tools that not every team has to build from scratch.
The questions that should be clarified before going into production
Regardless of which specific tools prevail, the problem areas can be clearly named. Anyone letting agents into business-critical systems should have an answer to the following points:
- Identity and permissions: Under which identity does the agent act? Does it have its own, tightly limited rights – or does it inherit the far-reaching rights of a shared technical account?
- Tool access: Which interfaces may the agent call, which may it not? Is there an allowlist, or does the model effectively decide for itself?
- Traceability: Can it be reconstructed afterwards which agent triggered which action and when, and on what data basis?
- Limits and abort criteria: What happens with infinite loops, with contradictory instructions, with unexpected input from external sources?
- Costs and resources: Agents cause load – through model calls, through repeated loops, through parallel instances. Without limits, consumption is hard to plan.
The efficiency question that the CNCF explicitly addresses is not a side issue here. Agentic workflows tend to process the same context multiple times. What costs a few cents in testing scales linearly with volume in production.
What acceptance into the CNCF means in practice
Acceptance under the foundation's umbrella is first and foremost an organisational decision: projects receive a neutral framework, open governance and visibility in an ecosystem that many companies use anyway. It is not a seal of quality, nor a guarantee that a project will endure in the long term.
For practice, however, the effect is still relevant. The CNCF has shown in the past that it can bundle topics – container runtimes, observability, supply-chain security. If agent operations are negotiated there, the likelihood increases that shared terms, interfaces and operational patterns will emerge, rather than each platform imposing its own proprietary model.
For decision-makers, this is above all planning information: standardisation is underway but not complete. Commitments to a single platform should remain reversible for now.
A pragmatic approach to uncertainty
Between "we wait until something prevails" and "we give agents access to the ERP" there is a lot of room. A workable middle path usually looks like this:
- Initially deploy agents in read-only scenarios – research, summarisation, preparation of decisions.
- Route write actions through clearly defined, tightly scoped interfaces, not through direct database access.
- Log every action before the first agent goes into production – not afterwards.
- Provide for human approval for critical steps and only remove it once data on the error rate is available.
- Measure operating costs from the outset and set a limit.
These points are valid regardless of specific tools. They can be implemented with existing means and remain viable even if the ecosystem continues to sort itself out in the coming months.
Assessment for web and software projects
For ongoing projects, this above all means: agents should be treated early on as regular system components – with their own identity, limited rights and complete logging, not as a feature that is secured retroactively. Anyone building integrations today is already laying the foundation with cleanly scoped interfaces and clear permission boundaries so that an agent can later dock on in a controlled way.
And as long as the standards are still taking shape, every architectural decision that keeps the exchange of individual components open pays off.
Sources
- KubeCon 2026: The CNCF wants to make AI agents safer and more efficient — heise developer News