🤖 CAIPE: Community AI Platform Engineering Multi-Agent System

Agentic AI SIG Community

🚀 Getting Started | 🎥 Meeting Recordings | 🏛️ Governance | 🗺️ Roadmap

🗓️ Weekly Meetings

• Every Monday
  • 🕕 19:00–20:00 CET | 🕔 18:00–19:00 GMT (London) | 🕘 10:00–11:00 PST
• 🔗 Webex Meeting | 📅 Google Calendar | 📥 .ics Download

💬 Slack

• Not in CNCF Slack? Join here first
• Join #cnoe-sig-agentic-ai channel

Note: Use latest docs to get started

What is AI Platform Engineering?

As Platform Engineering, SRE, and DevOps environments grow in complexity, traditional approaches often lead to delays, increased operational overhead, and developer frustration. By adopting Multi-Agentic Systems and Agentic AI, Platform Engineering teams can move from manual, task-driven processes to more adaptive and automated operations, better supporting development and business goals.

Community AI Platform Engineering (CAIPE) (pronounced as cape) is an open-source, Multi-Agentic AI System (MAS) championed by the CNOE (Cloud Native Operational Excellence) forum. CAIPE provides a secure, scalable, persona-driven reference implementation with built-in knowledge base retrieval that streamlines platform operations, accelerates workflows, and fosters innovation for modern engineering teams. It integrates seamlessly with Internal Developer Portals like Backstage and developer environments such as VS Code, enabling frictionless adoption and extensibility.

CAIPE is empowered by a set of specialized sub-agents that integrate seamlessly with essential engineering tools. Below are some common platform agents leveraged by the MAS agent:

• 🚀 ArgoCD Agent for continuous deployment
• 🚨 PagerDuty Agent for incident management
• 🐙 GitHub Agent for version control
• 🗂️ Jira/Confluence Agent for project management
• 💬 Slack/Webex Agents for team communication

...and many more platform agents are available for additional tools and use cases.

Together, these sub-agents enable users to perform complex operations using agentic workflows by invoking relavant APIs using MCP tools. The system also includes:

• A curated prompt library: A carefully evaluated collection of prompts designed for high accuracy and optimal workflow performance in multi-agent systems. These prompts guide persona agents (such as "Platform Engineer" or "Incident Engineer") using standardized instructions and questions, ensuring effective collaboration, incident response, platform operations, and knowledge sharing.
• Multiple End-user interfaces: Easily invoke agentic workflows programmatically using standard A2A protocol or through intuitive UIs, enabling seamless integration with existing systems like Backstage (Internal Developer Portals).
• End-to-end security: Secure agentic communication and task execution across all agents, ensuring API RBACs to meet enterprise requirements.
• Enterprise-ready cloud deployment architecture: Reference deployment patterns for scalable, secure, and resilient multi-agent systems in cloud and hybrid environments

For detailed information on project goals and our community, head to our documentation site.

💡 Examples

AI Platform Engineer can handle a wide range of operational requests. Here are some sample prompts you can try:

• 🚨 Acknowledge the PagerDuty incident with ID 12345
• 🚨 List all on-call schedules for the DevOps team
• 🐙 Create a new GitHub repository named 'my-repo'
• 🐙 Merge the pull request #42 in the ‘backend’ repository
• 🗂️ Create a new Jira ticket for the ‘AI Project’
• 🗂️ Assign ticket 'PE-456' to user 'john.doe'
• 💬 Send a message to the ‘devops’ Slack channel
• 💬 Create a new Slack channel named ‘project-updates’
• 🚀 Sync the ‘production’ ArgoCD application to the latest commit
• 🚀 Get the status of the 'frontend' ArgoCD application

🚀 Quick Start with Docker Compose

Run CAIPE locally with the OSS all-in-one stack:

# Clone the repository
git clone https://github.com/cnoe-io/ai-platform-engineering.git
cd ai-platform-engineering

# Copy and configure environment variables
cp .env.example .env
# Edit .env with your LLM API key or local OpenAI-compatible endpoint.

# Run the stack described by .env.example
docker compose up

Access the UI at http://localhost:3000 and the supervisor API at http://localhost:8000.

The default .env.example uses image tag 0.5.16 and enables this profile set:

COMPOSE_PROFILES=mcp-servers,caipe-ui-prod,rbac,caipe-supervisor,dynamic-agents,rag,caipe-mongodb

That starts the supervisor in all-in-one mode, the MCP server containers, production UI, dynamic agents, local Keycloak/OpenFGA/AgentGateway RBAC, MongoDB, and RAG. Remote A2A sub-agent containers are not started by default.

Add web_ingestor when you want the web ingestion worker. Add slack-bot or webex-bot only when you want those bot integrations.

Optional Profiles

Enable additional features with profiles:

# With tracing (Langfuse)
docker compose --profile tracing up

# With Graph RAG (adds Neo4j and ontology services)
docker compose --profile graph_rag up

# With web ingestion worker
docker compose --profile web_ingestor up

# Development mode (build from source)
docker compose -f docker-compose.dev.yaml up --build

Deployment Modes

CAIPE supports all-in-one, distributed, and hybrid supervisor modes:

Mode	Description	Use Case
All-in-one (default)	Supervisor runs agents in-process and connects to MCP server containers	OSS local deployments, VM deployments, demos
Distributed	Supervisor orchestrates remote sub-agent containers via A2A	Scale-out testing and specialized deployments
Hybrid	Only selected agents run remotely	Gradual migration or debugging

All-in-One Mode

All-in-one mode leaves DISTRIBUTED_AGENTS empty and starts MCP servers instead of sub-agent containers:

# Image-based stack
docker compose up

# Development mode — all-in-one (build from source)
docker compose -f docker-compose.dev.yaml up --build

# Development mode — fully distributed (all agents as separate A2A containers)
DISTRIBUTED_AGENTS=all docker compose -f docker-compose.dev.yaml --profile all-agents up --build

# Development mode — hybrid (only specific agents distributed)
DISTRIBUTED_AGENTS=argocd,github docker compose -f docker-compose.dev.yaml --profile argocd --profile github up --build

The supervisor mode is controlled by the DISTRIBUTED_AGENTS environment variable:

• Empty (default): all agents run in-process via MCP (all-in-one)
• all: all agents run as remote A2A containers (fully distributed)
• Comma-separated list (e.g., argocd,github): only listed agents are remote (hybrid)

All-in-One with RAG (Knowledge Base)

RAG is included in the default profile set. Use graph_rag only when you also want Neo4j-backed graph relationships:

# Vector RAG, included by default
docker compose up

# All-in-one with full Graph RAG (includes Neo4j)
docker compose --profile graph_rag up

RAG Profiles:

Profile	Services Included	Use Case
rag	rag-server, milvus, redis	Vector search without graph relationships
web_ingestor / web-ingestor	web-ingestor	Web datasource ingestion worker
graph_rag	All rag services + Neo4j, agent_ontology	Full knowledge graph with entity relationships

Ingesting Content:

Once RAG services are running, you can ingest web content via the RAG server API:

# Ingest a website (uses sitemap if available)
curl -X POST http://localhost:9446/v1/datasources \
  -H "Content-Type: application/json" \
  -d '{"url": "https://cnoe-io.github.io/ai-platform-engineering/"}'

The agent will automatically use the knowledge base when answering questions about ingested content.

Distributed Mode

Distributed mode runs a supervisor that orchestrates specialized sub-agents as separate services:

DISTRIBUTED_AGENTS=all docker compose -f docker-compose.dev.yaml --profile all-agents up --build

Kubernetes Deployment

For Kubernetes, use the Helm chart:

# Multi-node mode (default) - deploys supervisor + sub-agents
helm install caipe charts/ai-platform-engineering \
  --set tags.caipe-ui=true \
  --set caipe-ui.env.NEXT_PUBLIC_A2A_BASE_URL="https://your-caipe-api.example.com"

# Single-node mode - deploys single unified agent
helm install caipe charts/ai-platform-engineering \
  --set global.deploymentMode=single-node \
  --set tags.caipe-ui=true \
  --set caipe-ui.env.NEXT_PUBLIC_A2A_BASE_URL="https://your-caipe-api.example.com"

Pod Security Standards

All Helm charts ship with security contexts configured to satisfy the Kubernetes Pod Security Standards Baseline profile and meet all Restricted profile requirements, except readOnlyRootFilesystem (left false because some agent workloads write to the filesystem at runtime). All app containers set a user ID in runAsUser so Kubernetes can enforce runAsNonRoot when the image USER directive is a name rather than a numeric UID.

To enforce Baseline and warn on Restricted at the namespace level:

kubectl label namespace <your-namespace> \
  pod-security.kubernetes.io/enforce=baseline \
  pod-security.kubernetes.io/warn=restricted \
  pod-security.kubernetes.io/audit=restricted

To reach full Restricted compliance, set readOnlyRootFilesystem: true in each chart's values and add emptyDir volume mounts for the write paths.

📦 Documentation

• Quick Start Guide
• Setup
  • Docker Compose
• Local Development setup
• Run Agents for Tracing & Evaluation
• Adding new agents

🤝 Contributing

We’d love your contributions! To get started:

1. Fork this repo
2. Create a branch for your changes
3. Open a Pull Request—just add a clear description so we know what you’re working on

Thinking about a big change? Feel free to start a discussion first so we can chat about it together.

• Browse our open issues to see what needs doing
• New here? Check out the good first issues for some beginner-friendly tasks

We’re excited to collaborate with you!

Star History

Contributors

📄 License

Licensed under the Apache-2.0 License.

---

Made with ❤️ by the CNOE Contributors