Kagenti is a Cloud-native middleware providing a framework-neutral, scalable and secure platform for deploying and orchestrating AI agents through a standardized REST API. It includes key services such as:
- Authentication and Authorization
- Trusted identity
- Deployment
- Configuration
- Scaling
- Fault-tolerance
- Checkpointing
- Discovery of agents and tools
- Persistence
Despite the extensive variety of frameworks available for developing agent-based applications, there is a distinct lack of standardized methods for deploying and operating agent code in production environments, as well as for exposing it through a standardized API. Agents are adept at reasoning, planning, and interacting with various tools, but their full potential can be limited by these deployment challenges. Kagenti addresses this gap by enhancing existing agent frameworks with the following key components:
-
Kubernetes Platform Operator: Facilitates the deployment and configuration of agents along with infrastructure dependencies on Kubernetes. It enables scaling and updating configurations seamlessly.
-
Agent and Tool Authorization Pattern: This pattern replaces static credentials with dynamic SPIRE-managed identities, enforcing least privilege and continuous authentication. Secure token exchanges ensure end-to-end security principles enforcement across agentic workflows.
In the open-source community, several frameworks are emerging for developing agent-based applications. These include LangGraph, CrewAI, AG2, Llama Stack, and BeeAI. The selection of a specific framework is often driven by the use case requirements. For scenarios requiring complex orchestration with a high degree of control over the agent workflow, frameworks like LangGraph are usually a better fit. They allow explicit graph creation where nodes perform LLM model inference and tool calls, with routing that can be either predefined or dynamically influenced by LLM decisions. On the other hand, frameworks such as CrewAI are designed to assign roles and tasks to agents, enabling them to autonomously work towards achieving predefined goals. Llama Stack agents are primarily pre-built state machines focused on ReAct-style patterns. Users configure the system’s prompts, tools, models, and then simply input data and prompts, allowing the agent to execute without the need for backend code development.
Kagenti provides a unified platform to deploy, scale, configure, and orchestrate agents created across these various frameworks by supporting APIs based on emerging standards such as A2A.
Deploying agents in production involves addressing typical challenges associated with managing complex microservices-based applications, including managing infrastructure services such as key-value store databases, caches, queuing systems and deployment, configuration management and scaling of API servers, and workers. The Kubernetes operator facilitates the deployment of new framework instances, supports the registration and scaling of multi-framework agents, and assists in setting up and configuring identity management and agents' authorizations.
The Agent and Tool Authorization Pattern for the Agentic Platform ensures that both human and machine identities are continuously authenticated and authorized, minimizing implicit trust at every stage of interaction. Traditional static credentials, such as API keys or client secrets, risk privilege escalation and credential leaks, and therefore are replaced with dynamic, short-lived identity-based tokens, managed through SPIRE and integrated with Keycloak for access control.
This approach enforces least privilege access by ensuring that identities — whether users, tools, or external services — only receive the minimum permissions necessary. The authentication and authorization flow follows a structured token exchange mechanism, where a user's identity propagates securely through the system, from initial authentication to tool interactions and external service access. By leveraging SPIFFE/SPIRE for workload identity and OAuth2 transaction tokens for controlled delegation, the platform prevents credential misuse, reduces attack surfaces, and ensures real-time policy enforcement.
In practice, the Authorization Pattern within the Agentic Platform enables:
- Machine Identity Management – replacing static credentials with SPIRE-issued JWTs.
- Secure Delegation – enforcing token exchange to propagate identity across services without excessive permissions.
- Continuous Verification – ensuring authentication and authorization at each step, preventing privilege escalation.
More detailed overview of the identity concepts are covered in the Kagenti Identity PDF document.
This end-to-end approach aligns agentic workflows with security best practice principles, making them secure, scalable, and eventually production-ready.
To achieve the objectives outlined above, we are developing this technology through a series of demos, each targeting specific aspects of our goals. Our aim is to refine these demos into an initial Minimum Viable Product (MVP) architecture.
These demos are built on the following core technologies:
- Cloud-native infrastructure including Kubernetes Gateway API, Istio Ambient Mesh, and Kiali.
- Kagenti Operator: an operator for building agents and tools from source, managing their lifecycle, and coordinating platform components.
- Tool-side communication via Model Context Protocol (MCP)
- Agent-side communication via A2A
For running the local demos (and the preload-file Makefile target) you should have the following tools installed and available in your PATH:
kubectl— used to query the cluster for pods and images.jq— used to parse and filter JSON output fromkubectl.
On macOS you can install them with Homebrew, for example:
brew install kubectl jq
If these tools are missing, the preload-file target will now fail with a clear message explaining which tool is absent and how to install it.
We provide a quick way to deploy various relevant open source technologies to set up an agentic platform on your local cluster. This demonstrates how agents, tools, and protocols interoperate to fulfill end-to-end application flows in cloud-native environments.
See the Demo Documentation for deploying a Cloud-Native Agent Platform with A2A Multi-Framework Agents.
We regularly publish articles at the intersection of cloud-native architecture, AI agents, and platform security.
Some recent posts include:
- Introducing MCP-Gateway in Kagenti: A Unified Front Door for Your MCP Servers
- Hands-On Introduction to Agentic AI Concepts with Kagenti
- Toward a Cloud-Native Platform for AI Agents
- Security in and around MCP
- Identity in Agentic Platforms: Enabling Secure, Least-Privilege Access
Explore more on our Kagenti Medium publication.
This QR Code links to http://kagenti.io
