An Introduction to Kagent: The Open-Source Framework for AI Agents on Kubernetes

Based on the video with: Lin Sun, Head of Open Source at solo.io & CNCF TOC Member

Managing complex cloud-native systems on Kubernetes requires deep expertise. Kagent is an open-source project that solves this by bringing agentic AI to the cloud-native ecosystem, packaging expert knowledge into an intelligent, automated assistant. In a recent livestream, lead maintainer Lin Sun demonstrated Kagent's powerful capabilities for solving real-world problems, which we will explore in this post.

The Spark of an Idea: From Crisis to Code

Every great project starts with a problem. For Kagent, that problem became crystal clear during a hurricane. An insurance provider, a customer of Solo.io, saw their production environment go down over a weekend as they were inundated with claims. Key engineers had to jump in to troubleshoot, highlighting a major scalability issue: a company's deepest expertise is often concentrated in a small group of experts.

This incident sparked the idea for Kagent. The vision was to create a tool that could act as an expert sitting next to support engineers, development teams, or anyone operating cloud-native infrastructure, providing a first or second level of defense without needing to escalate to the core developers. The project was started late last year/early this year, prototyped internally at Solo, and then open-sourced in March to foster community collaboration.

Under the Hood: The Architecture of Kagent

Kagent is more than just a single tool; it's a comprehensive framework for building and running AI agents on Kubernetes. Its architecture is designed for flexibility, power, and ease of use.

Here are the core components:

• Declarative Framework: Kagent provides a controller and a declarative API for managing agents. This means you can define your agents, their tools, and their instructions in YAML files. This makes agents portable and easy to share. If a community member creates a useful agent, you can take their YAML definition and deploy it directly into your own cluster.

  
  

• Agents and Tools: At its heart, an agent is composed of a system prompt (its instructions and "brain"), a Large Language Model (LLM), and a set of tools. Tools are critical because they allow an agent to perform specific tasks that an LLM can't do on its own, like interacting with the GitHub API to create a pull request or querying a Prometheus instance.

  
  

• Model Context Protocol (MCP): To solve the "spawn of tools" problem, Kagent uses the Model Context Protocol (MCP). Think of MCP as a universal adapter, like a USB-C port, that allows an agent to connect to and use various "tool servers". For example, by connecting to the official GitHub MCP server, an agent instantly gains the ability to create issues, branches, and pull requests.

  
  

• Agent-to-Agent (A2A) Protocol: Modern AI solutions often involve multiple specialized agents collaborating. Kagent embraces this by supporting the A2A protocol, which standardizes how agents communicate with each other.

  
  

Kagent in Action: A Real-World Troubleshooting Demo

Lin demonstrated Kagent's power by solving a common and frustrating issue: a misconfigured service in Kubernetes.

The Scenario: A demo application was deployed using Argo CD on a Kubernetes cluster running Istio's sidecar-less Ambient Mesh. The application was supposed to be accessible through an Istio Ingress Gateway, but attempts to reach it failed.

Kagent to the Rescue:

1. Initiating the Chat: The user started a chat with a pre-configured troubleshooting agent, describing the problem: "the demo service in the default namespace cannot be reached from the ingress gateway can you debug for me".

   
   

2. Investigation: The agent immediately began executing its plan, which was defined in its system prompt. It used its Kubernetes tools to gather information about services, pods, and routing configurations in the cluster.

   
   

3. Identifying the Problem: The agent correctly identified that the routing was misconfigured. The Kubernetes Gateway API

   HTTPRoute was trying to send traffic to port 8080, but the actual demo service was listening on port 80.

   
   

4. Automated Fix: Instead of just reporting the problem, the agent asked for permission to fix it. Upon approval, it used its GitHub tools (via the MCP server) to:

   
   

   • Locate the correct Git repository from the Argo CD application definition.

     
     

   • Create a new branch.

     
     

   • Modify the HTTPRoute YAML file to use the correct port (80).

     
     

   • Commit the change and create a pull request with a descriptive title and summary.

After the PR was merged and Argo CD synced the changes, the application was immediately accessible. The entire process was faster, more systematic, and less error-prone than a manual investigation.

The Road Ahead: What's Next for Kagent?

The project is moving fast, with an exciting roadmap focused on expanding the ecosystem and enhancing interoperability.

• Multi-Framework Support: Kagent is adding built-in integration for Google's Agent Development Kit (ADK), and plans to allow users to bring their own agent frameworks, such as LangGraph or CrewAI.

  
  

• Bring Your Own MCP: The team is making it even easier to bootstrap your own MCP server or consume existing ones, allowing developers to quickly tool-enable their agents for any custom task.

  
  

• Agent Gateway: A related and highly anticipated project is Agent Gateway. This is a new, high-performance proxy built from the ground up in Rust to specifically handle AI agent traffic. It will sit in the middle of agent communications (agent-to-LLM, agent-to-tool, agent-to-agent) to provide crucial security, governance, and observability—an essential piece for running agentic systems in production.

  
  

Get Involved!

Kagent is more than just a tool; it's a new paradigm for managing cloud-native complexity. By encoding expert knowledge into reusable, declarative AI agents, it empowers teams to operate more efficiently and solve problems faster.

The project is community-driven and welcomes new contributors and users. If you're interested in the future of AI in operations, check out the Kagent project and consider joining one of their weekly community meetings.