A few months ago, I stumbled upon kagent, a CNCF project that immediately caught my attention.
Its declarative approach really resonated with me: you focus on defining what your agents are, which tools they need and how they collaborate, rather than getting lost in orchestration glue code. On top of that, kagent makes composing multiple agents toward a single goal almost trivial, thanks to the A2A (Agent-to-Agent) protocol.

Simple. Explicit. Cloud-native by design.

From curiosity to practice

In January, I had the chance to share my early experience with kagent at the Cloud Native Belgiummeetup. That talk was mostly about discovering the framework, understanding its building blocks, and seeing how agent collaboration works in practice.  

I had a lot of fun putting together a bunch of agents that collaborate to produce meaningful Azure Kubernetes Service (AKS) reports without writing (almost) a single line of code..  well, except for the MCP part. In the end, this is the setup I landed on.

Naturally, that raised the obvious question for me: what would it look like to go one step further and build my own agent, with full control over its logic? Kagent embraces a Bring Your Own Agent approach, allowing you to integrate your own agents offering native support for popular Python frameworks like LangGraph, CrewAI, OpenAI, and ADK. 

That’s great, but my Python skills are… basically nonexistent. So here we go: dusting off my C# skills and creating an example of a KAgent integration using the Microsoft Agents Framework.

Building a MAF agent

In this repo https://github.com/MassimoC/kagent-dotnet you can find an end-to-end example on how to build a HelloWorld custom agent in dotnet and integrate it with kagent. The repo contains:

  • a core library to interface with the kagent backend.
  • a kagentapp that exposes the A2A endpoints and integrates a Microsoft.Agents.AI agent directly. kagent allows you to bring your own agent implementation, as long as it speaks the A2A protocol.
  • a hello-world agent we can use to test the end-to-end scenario. The sample agent, answer to any questions by adding some jokes, it uses AzureOpenAI model as the underlying LLM provider.

Pick, pack, ship

Clone the code repository,  build the custom agent image and push it to your preferred registry. 

Create a BYO agent resource

With the image available, you can now register your custom agent in kagent by creating a BYO agent resource.

Before doing that, you’ll need to create a Kubernetes secret containing the API key used to access your LLM provider (Azure OpenAI in this case). Once the secret exists, the BYO agent definition simply references the container image, the LLM inference endpoint and the required secrets. At this point, your .NET agent is officially part of the kagent ecosystem.

Test your agent

You can invoke the agent in several ways, including the:

  • kagent dashboard
  • kagent CLI (kagent invoke command)
  • and the A2A inspector
  • trigger a [local test without a kagent installation](https://You can invoke the agent in several ways, including the kagent dashboard, kagent CLI, and the A2A host CLI.)

Join the multi-agent party

Real-world problems need specialists working together, so let’s add our brand new ironic helloworld agent to the multi-agent scenario described above so we can have many minds collaborating on one goal: create a health report with a touch of fun.

The steps here are simple and intuitive. I updated the supervisor agent so it is aware of the new agent, its role, and its capabilities, and I adjusted the supervisor’s instructions to explicitly allow (and encourage) delegating parts of the final narrative to this agent. From that point on, nothing else had to change: the supervisor naturally started routing the “make this more engaging” or “add some personality” tasks to the ironic agent, while the other agents continued focusing on data collection and analysis. 

Conclusion

In the end, what really stood out to me is how kagent makes multi-agent systems feel practical: agents are explicit, interactions are observable, and everything fits naturally into a Kubernetes-native, declarative model. By bringing my own .NET agent into the mix, I was able to validate that kagent is not tied to a single language or framework, but instead provides a solid, open foundation for heterogeneous agent ecosystems.