From OpenAPI to Komodor agent: Automated agent generation with A2A, SLIM, and LangGraph

AI code generation, disruptive as it’s been to software development, is quickly becoming a mere stepping stone towards the transformative potential of re-architecting how we build, deploy, evaluate, and scale AI agents across enterprise development environments. 

Outshift by Cisco’s Platform Engineering team recently launched an open-source, fully-automated agentic workflow. This workflow transforms any OpenAPI specification into a production-ready LangGraph ReAct agent, complete with an Agent-to-Agent (A2A) protocol server, a comprehensive Model Context Protocol (MCP) toolset, and a complete evaluation of the observability suite. 

By using the Community AI Platform Engineering (CAIPE) framework supported by the CNOE (Cloud Native Operational Excellence) forum, we've created a blueprint that reduces agent development time from weeks to hours while maintaining enterprise-grade reliability, security, and observability. 

Why Komodor’s Kubernetes API was chosen to test automated multi-agent generation

Komodor's Kubernetes troubleshooting platform is already a powerful tool. It has its own AI assistant, Klaudia, specialized in root-cause analysis (RCA). The platform's public API made it an ideal candidate for testing our automated agent generation approach. The team saw the following key opportunities: 

• Expose Komodor’s public API to other agents through the A2A protocol, enabling seamless inter-agent communication.
• Keep implementation costs close to zero, as automation should eliminate manual coding, not create new bottlenecks.
• Remain aligned with CAIPE’s modular, best-practice-driven philosophy.
• Integrate advanced features like AGNTCY’s Secure Low-latency Interactive Messaging (SLIM) and comprehensive tracing and evaluation with Langfuse. 

The choice of Komodor also reflected a strategic decision to work with real-world complexity. Kubernetes troubleshooting involves intricate data relationships and time-sensitive operations, so the team had the perfect conditions for stress-testing our automated generation pipeline. 

Architecture overview: From specification to intelligence

The core innovation is a streamlined architecture that transforms an OpenAPI specification into a functional, interoperable, and observable agent. The process begins with Komodor's OpenAPI specification. With a single command, this generates a complete ecosystem. 

1. The openapi-mcp-codegen tool processes the OpenAPI specification, generating a complete MCP server built on FastAPI with rich Pydantic models and automatically configured tools.
2. With the --generate-agent flag, the generator produces a fully functional LangGraph ReAct agent, including its graph structure and A2A server bindings.
3. The --generate-eval flag creates an entire evaluation harness to build a golden dataset and run automated tests, with results uploaded to Langfuse for deep tracing and analysis.
4. The optional --enable-slim flag integrates the SLIM transport from AGNTCY, providing a bridge for secure, low-latency interactive messaging. 

The resulting agent can communicate with downstream multi-agent systems (MAS) clients through the A2A protocol or SLIM, creating a network of interconnected AI agents capable of complex collaborative workflows.  

The core engine: LangGraph, A2A, MCP, and SLIM 

The Komodor agent's reasoning loop implements LangGraph's ReAct pattern, where each thought-action-observation cycle is exposed over the A2A protocol. This design enables other agents or human operators to stream-subscribe to tool calls and partial thoughts, creating unprecedented transparency. 

Every Komodor REST endpoint is transformed into a first-class MCP tool (mcp_komodor/tools/*.py), which can be executed locally by the LangGraph node or remotely by another A2A consumer. For scenarios demanding higher security and performance, the agent can communicate over SLIM from the AGNTCY project. 

The automation pipeline in action: A quick start guide 

This entire process is fully automated. Let's walk through how to generate, run, and evaluate the Komodor agent from scratch. 

Prerequisites: 

• uv installed (docs)
• yq installed (docs)
• LLM provider credentials (OpenAI, Azure OpenAI, etc.)
• Docker
• Optional: Langfuse deployed locally or accessible remotely 

1. Generate the agent 

First, create a directory, fetch the Komodor OpenAPI spec, and run the generator. 

mkdir komodor_agent
cd komodor_agent
# Configure the Komodor client auth headers
echo "headers:\n  X-API-KEY: \"{token}\"" >> config.yaml
# Get the Komodor OpenAPI spec and set the title
curl -s https://api.komodor.com/api/docs/doc.json | yq '.info.title = "komodor"' > komodor_api.yaml
# Generate the agent, eval code, and SLIM bindings
uvx --from git+https://github.com/cnoe-io/openapi-mcp-codegen.git openapi_mcp_codegen \
  --spec-file komodor_api.yaml \
  --output-dir . \
  --generate-agent \
  --generate-eval \
  --enable-slim

This single command generates the MCP server, tools, A2A/SLIM bindings, a LangGraph agent skeleton, and a complete evaluation suite.

2. Configure your environment 

Create a .env file with your Komodor, large language model (LLM), and optional Langfuse credentials. 

cat > .env << 'EOF'
# Komodor API
KOMODOR_API_URL=https://api.komodor.com
KOMODOR_TOKEN=<your-komodor-api-key>
 
# LLM provider (configure for your provider)
LLM_PROVIDER=openai
OPENAI_API_KEY=<your-openai-api-key>
OPENAI_MODEL_NAME=gpt-4-turbo
 
# Langfuse (optional)
LANGFUSE_HOST=http://localhost:3000
LANGFUSE_PUBLIC_KEY=<your-langfuse-public-key>
LANGFUSE_SECRET_KEY=<your-langfuse-secret-key>
EOF
 
# Export the variables into your shell
export $(grep -v '^#' .env | xargs)

3. Run the agent and client 

In one terminal, start the A2A agent server: 

make run-a2a

In a second terminal, run the interactive client:

make run-a2a-client

You can now interact with your agent! Ask it a question like, "What clusters do I have?" 

Beyond generation: A new era of agent evaluation 

An agent is only as good as its performance. Our workflow introduces a revolutionary, auto-generated evaluation pipeline to ensure reliability and prevent regressions. 

Step 1: Build a golden dataset with eval-mode 

Eval-mode helps you curate a set of canonical prompts and expected tool trajectories for common scenarios.

Run the agent in evaluation mode: 

make run-a2a-eval-mode

The tool interactively guides you to enter queries, review the agent's reasoning (tool calls), and approve the final output. This process builds a "golden dataset" of expected behaviors, which is stored in eval/dataset.yaml. 

Step 2: Run automated evaluation and upload to Langfuse

Once your dataset is ready, run the automated LLM-as-judge evaluation. 

Simply run: 

make eval 

This command executes each test case against the agent, scores it for correctness and hallucination, and uploads all traces, metrics, and results directly to your Langfuse instance for deep analysis and continuous monitoring. 

Advanced: Secure, Low-Latency Messaging with SLIM 

For use cases requiring high performance and security, you can run the agent over the SLIM transport. Since you generated the code with --enable-slim, the bindings are already there. 

Start the complete SLIM stack (this also builds the required containers): 

make run-a2a-and-slim

In a separate terminal, connect using the SLIM client: 

make run-slim-client

You now have an interactive session with the agent over a secure, low-latency message bus. 

Transform any OpenAPI spec into an enterprise-grade AI agent 

By combining openapi-mcp-codegen, LangGraph, Langfuse, and the CAIPE component ecosystem, Outshift by Cisco has built a production-grade, fully observable Komodor agent in a matter of hours, not weeks. 

The true power of this workflow is its versatility. It can be applied to any SaaS application with an OpenAPI specification, paving the way for a collaborative environment of interoperable, streaming, and continuously validated AI agents.

You can start using CAIPE today! Point the generator at your favorite API spec, add the --generate-agent and --generate-eval flags, and you'll have an MCP server, tools, and an A2A-capable LangGraph agent with a full evaluation suite before your coffee even gets cold.  

The future of agent development is here. It's automated, integrated, and ready to scale.  

OpenAPI to MCP Server Code Generator is on GitHub.