kagent: Running AI Agents the Kubernetes Way

TL;DR - kagent is an open-source framework that brings agentic AI into Kubernetes. Instead of running an agent runtime as an external service bolted onto your cluster, kagent models agents, sessions, and tools as Kubernetes CRDs - reconciled by an operator, governed by GitOps, RBAC, and admission control. It speaks MCP, Agent-to-Agent (A2A), and OpenAI-compatible APIs to avoid lock-in. A CNCF Sandbox project since May 2025, it hit 100 contributors in its first 100 days - one of the clearest signals of where cloud-native AI is heading.

---

There is a quiet architectural question underneath the entire "AI agents in production" conversation: where does the agent actually run, and who governs what it is allowed to do? Most frameworks answer by adding a new runtime - a service you deploy, monitor, and secure separately from everything else. kagent answers differently, and the difference is the whole point.

Kubernetes-native, all the way down#

kagent's design principle is that the agent should not be a black box running beside your cluster - it should be a first-class Kubernetes object inside it. Agents, sessions, and tools are defined as Custom Resource Definitions (CRDs), and a controller (a standard Kubernetes operator) reconciles them the way any operator reconciles desired state.

That single decision cascades into everything platform teams care about:

• The agent's definition lives in Git. It ships through your existing CD pipeline, gets code-reviewed, and has a version history. An agent becomes a reviewable, auditable, declarative resource instead of an opaque process.
• RBAC governs what it can do. The same role-based access control that constrains every other Kubernetes workload constrains your agents - who can deploy them, what they can touch.
• Admission control can gate it. Policy engines you already run can inspect and permit or reject agent definitions before they ever execute.

In other words, kagent reuses the entire trust apparatus platform teams have spent a decade building - kubectl, GitOps, RBAC, admission control - rather than asking you to invent a parallel one for AI agents. For anyone who has watched a shadow AI stack grow up ungoverned next to a carefully-run cluster, the appeal is immediate.

What it looks like#

At the core is a small set of CRDs and a controller:

• An Agent resource defines an agent - its model, its instructions, the tools it can call.
• Tool resources define what the agent can act on, exposed over MCP (Model Context Protocol) or A2A (Agent-to-Agent).
• A Session tracks a running interaction.
• The kagent controller reconciles all of it, applying RBAC, admission control, and GitOps the way an operator applies desired state.

Crucially, kagent is deliberately unopinionated about the AI layer: any LLM, any framework, any tool. Its native MCP, A2A, and OpenAI-compatible endpoints mean you are not locked into one model vendor or one agent framework - it is the cloud-native plumbing, not the intelligence. In practice it already ships agents that integrate with the tools cloud-native operators live in: Kubernetes itself, Argo, Istio, Prometheus, Grafana, and Helm - so the agents can actually do platform work, not just talk about it.

Why it matters#

kagent sits at the exact seam between two worlds that are rapidly merging: cloud-native infrastructure and agentic AI. It bridges the CNCF ecosystem and the agent-protocol world of the Agentic AI Foundation through native MCP support (for how those protocols differ, see MCP vs A2A). It is, in a real sense, the answer to "how do we run agents in production without abandoning everything we know about running production."

It is also young, and that is part of the story. Accepted to CNCF Sandbox in May 2025, kagent reached 100 contributors (over 85% from outside its originating company) and 1,000+ GitHub stars within 100 days - unusually fast, and a signal that the Kubernetes-native framing resonated with the people who actually operate clusters. As a Sandbox project it moves fast and expects breaking changes, so pin your versions; but weekly releases and maintainers who answer on Discord in hours make it an unusually approachable project to learn from or contribute to.

For a platform team, kagent is worth watching for a simple reason: if agents are going to run in production, they will need to be governed like everything else that runs in production. kagent is a serious attempt to make that true by construction.

Further reading#

• kagent.dev and the kagent docs
• kagent on CNCF
• Celebrating 100 days of kagent
• kagent repository