[Sandbox] CAIPE: Community AI Platform Engineering

### Project summary

CAIPE is a self-hosted, open-source AI agent platform that provides a shared control plane for building, governing, and operating agents and workflows across cloud-native engineering systems.

### Project description

CAIPE (Community AI Platform Engineering), pronounced “cape,” is a self-hosted, open source AI platform that enables individuals, teams, and organizations to build, govern, and operate AI agents and agentic workflows in cloud-native environments. It gives platform engineering, SRE, DevOps, developer productivity, and application teams a shared platform for applying AI across infrastructure, software delivery systems, knowledge sources, and collaboration channels.

CAIPE uses upstream agent frameworks for planning and tool execution while providing the shared identity, authorization, knowledge, workflow, integration, and observability layers required to operate agents as production software. Administrators can configure models, agents, reusable skills, workflows, knowledge bases, credentials, identities, and access policies. The platform includes an agent builder, dynamic agents, persisted workflow runs and artifacts, hybrid RAG with optional GraphRAG, agent memory, and first-party or bring-your-own Model Context Protocol (MCP) integrations.

Users can invoke governed automation through a streaming web interface, APIs, a command-line interface, Slack, and Webex. CAIPE uses OIDC for identity and OpenFGA for relationship-based authorization. A policy-enforcing gateway validates callers and checks relationships among users, agents, tools, and resources before forwarding MCP tool calls. MCP provides tool interoperability, while AG-UI and Server-Sent Events support live agent runs.

CAIPE addresses the gap between creating an individual agent and safely operating agents as shared production software. It is available under the Apache License 2.0 and can be deployed on Kubernetes using Helm or evaluated locally using Docker Compose.

### Project vs Reference Architecture/Implementation

- [x] This is a reusable open source project designed for broad adoption, not a reference architecture, reference implementation, or demonstration of patterns

### Org repo URL (provide if all repos under the org are in scope of the application)

https://github.com/caipe-io

### Project repo URL in scope of application

https://github.com/caipe-io/ai-platform-engineering

### Additional repos in scope of the application

- https://github.com/caipe-io/caipe-cli
- https://github.com/caipe-io/governance
- https://github.com/caipe-io/agentic-apps

### Website URL

https://caipe.io/

### Roadmap

https://github.com/orgs/caipe-io/projects/1

### Roadmap context

CAIPE has implemented human and non-human identity, fine-grained authorization, credential management, and audit capabilities across much of the platform. The project will continue extending this coverage and strengthening delegated access, policy enforcement, and operational governance.

The first phase of autonomous agents, including scheduled and event-driven execution, is also implemented. Further work will add stronger policy guardrails, human-in-the-loop escalation, confidence controls, and expanded auditability.

Work is underway on portable, pluggable agent-runtime support, including Amazon Bedrock AgentCore, the Claude Agent SDK, and Strands. Other planned areas include LLM budget and quota management, automated agent and RAG evaluations, agentic SDLC loops, and extensible agentic applications.

Roadmap priorities and progress are maintained in the public [GitHub project](https://github.com/orgs/caipe-io/projects/1/views/5) and summarized on the [CAIPE roadmap](https://caipe.io/roadmap/).

### Contributing guide

https://github.com/caipe-io/ai-platform-engineering/blob/main/CONTRIBUTING.md

### Code of Conduct (CoC)

https://github.com/caipe-io/ai-platform-engineering/blob/main/CODE_OF_CONDUCT.md

### Adopters

https://github.com/caipe-io/ai-platform-engineering/blob/main/ADOPTERS.md

### Maintainers file

https://github.com/caipe-io/ai-platform-engineering/blob/main/MAINTAINERS.md

### Security policy file

https://github.com/caipe-io/ai-platform-engineering/blob/main/SECURITY.md

### Standard or specification?

N/A

### Business product or service to project separation

CAIPE is an Apache-2.0 open-source project hosted in the `caipe-io` organization under public, vendor-neutral governance. It is not the upstream version, community edition, or source mirror of any commercial product or managed service.

Organizations may use CAIPE internally or build products, integrations, support, or managed services around it. These downstream offerings remain outside the project’s scope and governance.

Upstream source code, issues, releases, roadmap discussions, and technical decisions are public. Governance is defined by the [CAIPE Charter](https://github.com/caipe-io/governance/blob/main/CHARTER.md) and [decision-making policy](https://github.com/caipe-io/governance/blob/main/DECISION-MAKING.md). Maintainers and Steering Committee members act in the project’s interest rather than as employer representatives. Affiliation limits, conflict-of-interest requirements, and public decision records help prevent control by any single vendor. Contributing organizations receive no separate governance rights or private upstream roadmap.

### Why CNCF?

CAIPE is built for the platform engineering, SRE, DevOps, and application teams that operate cloud-native environments. It is deployable on Kubernetes through Helm and integrates with technologies such as Kubernetes, Argo CD, Backstage, OpenTelemetry, and OpenFGA. CAIPE provides a shared control plane for applying governed AI automation across these systems rather than replacing them.

CNCF is the appropriate home for CAIPE because:

- **Neutral stewardship:** Agent platforms interact with sensitive infrastructure, credentials, operational data, and delivery systems. Foundation governance gives adopters confidence that CAIPE’s interfaces, roadmap, and ecosystem will not be controlled by a single vendor.

- **Cloud-native interoperability:** CAIPE can collaborate directly with the communities responsible for the systems its agents operate. This supports reusable integrations, portable deployment patterns, and consistent approaches to identity, authorization, observability, and lifecycle management.

- **Project maturity:** CNCF guidance can help CAIPE strengthen governance, security practices, contributor onboarding, release processes, interoperability testing, and long-term maintainership as adoption grows.

- **Community growth:** CNCF provides access to the project’s natural community of platform engineers, operators, maintainers, and end users. This can broaden participation beyond the project’s current organizations and help develop a more diverse maintainer and contributor base.

- **Value to the ecosystem:** CAIPE contributes installable software and reusable patterns for operating AI agents as shared production systems. It demonstrates how open protocols, cloud-native identity, policy enforcement, knowledge systems, workflows, and observability can be combined into governed agent automation.

CAIPE expects acceptance into the CNCF Sandbox to provide a durable, vendor-neutral home and a framework for responsible community growth. In return, CAIPE will contribute an open platform and community for developing practical, interoperable approaches to AI-assisted cloud-native operations.

### Benefit to the landscape

CAIPE extends the Cloud Native Landscape from building and running individual agents to governing and operating agents as shared production software.

CAIPE deliberately uses upstream agent frameworks for planning and tool execution. Its differentiator is the shared control plane around those frameworks:

- Human and non-human identity, fine-grained authorization, delegated credentials, and policy enforcement across users, agents, tools, knowledge, and workflows.
- Persisted workflows, run history, artifacts, audit records, memory, and hybrid RAG/GraphRAG.
- Governed access through a web UI, APIs, CLI, Slack, Webex, and Backstage.
- First-party and bring-your-own MCP integrations for cloud-native and software-delivery systems.
- Portable deployment through Helm on Kubernetes, with Docker Compose for local evaluation.

CAIPE complements rather than replaces adjacent projects. Agent SDKs and frameworks provide agent execution loops. [[kagent](https://kagent.dev/docs/)](https://kagent.dev/docs/) focuses on declarative agents and MCP servers running on Kubernetes. [[Backstage](https://backstage.io/docs/ai/)](https://backstage.io/docs/ai/) provides a developer portal, software catalog, actions, and AI integration points. CAIPE operates across these layers, coordinating agents, knowledge, workflows, identities, policies, and operational tools through one governed platform.

Adding CAIPE would provide the landscape with:

- A deployable implementation of organization-wide governance patterns for AI agents operating cloud-native infrastructure.
- Reusable MCP integrations, skills, workflows, and authorization patterns for platform engineering and operations.
- A practical interoperability environment for upstream agent frameworks and managed runtimes.
- Production feedback for emerging agent observability conventions, including the work underway in [[OpenTelemetry](https://opentelemetry.io/blog/2025/ai-agent-observability/)](https://opentelemetry.io/blog/2025/ai-agent-observability/).
- A community where platform engineers, SREs, security teams, and agent-framework developers can collaborate on safe AI-assisted operations.

CAIPE’s contribution is therefore not another agent framework. It is the operational and governance layer that helps existing agent and cloud-native technologies work together safely as a shared platform.

### Cloud native 'fit'

CAIPE fits at the intersection of cloud-native AI, platform engineering, and automation and configuration. It provides an AI agent control plane for teams operating Kubernetes, infrastructure, delivery systems, observability platforms, knowledge sources, and developer tooling.

CAIPE embodies cloud-native principles in several ways:

- **Kubernetes-native deployment:** CAIPE is distributed as versioned container images and OCI Helm charts. Components expose health, readiness, and startup probes and support Kubernetes configuration for resources, replicas, ingress, services, and secrets.

- **Composable architecture:** The platform is divided into independently deployable components, including the web UI and API layer, agent runtimes, policy-enforcing gateway, audit service, schedulers, MCP servers, collaboration integrations, and optional RAG services. Operators can enable only the capabilities required for their environment.

- **Declarative and portable operation:** Agents, models, tools, skills, integrations, and deployment settings are configured declaratively. CAIPE can run on managed or self-hosted Kubernetes distributions without depending on a single cloud provider. Docker Compose supports local development and evaluation.

- **Externalized durable state:** Conversations, agent configuration, checkpoints, workflow runs, artifacts, and other runtime state are persisted outside agent execution processes. Deployments can use bundled services for evaluation or externally managed data services for production environments.

- **Cloud-native identity and policy:** CAIPE uses OIDC for human and workload identity and OpenFGA for relationship-based authorization. A policy-enforcing gateway evaluates caller, agent, tool, and resource relationships before forwarding MCP tool calls. Kubernetes Secrets and external secret providers can be used for deployment credentials.

- **Observability and operability:** Components provide health endpoints, structured logs, metrics, audit events, and OpenTelemetry-compatible tracing. Agent runs, workflows, tool calls, and authorization decisions can be observed as part of the platform’s operational lifecycle.

- **Open interoperability:** CAIPE uses MCP for tool interoperability and AG-UI with Server-Sent Events for streaming agent interactions. Its architecture uses upstream agent frameworks while keeping platform identity, policy, knowledge, workflows, and observability independent of a single model or agent framework.

CAIPE therefore applies established cloud-native patterns—containers, orchestration, declarative configuration, service boundaries, externalized state, workload identity, policy enforcement, observability, and open interfaces—to the emerging challenge of operating AI agents safely across shared engineering environments.

### Cloud native 'integration'

CAIPE integrates CNCF projects with open agent and model technologies to provide a governed AI control plane for cloud-native engineering.

#### CNCF project integrations

- **[Kubernetes](https://www.cncf.io/projects/kubernetes/):** CAIPE’s primary production environment. Its scheduler creates Kubernetes CronJobs for recurring agent tasks and Jobs for one-time runs, using constrained pod templates and scoped RBAC. CAIPE also runs its services on Kubernetes and can ingest Kubernetes resources into its knowledge system.

- **[Helm](https://www.cncf.io/projects/helm/):** CAIPE is distributed as OCI Helm charts with configurable components, integrations, identity services, storage, networking, resources, and security controls.

- **[Keycloak](https://www.cncf.io/projects/keycloak/):** Provides the bundled OIDC identity service, identity federation, service accounts, and token exchange. CAIPE can also connect to external OIDC providers.

- **[OpenFGA](https://www.cncf.io/projects/openfga/):** Provides relationship-based authorization across users, teams, agents, tools, workflows, credentials, knowledge sources, and collaboration channels.

- **[External Secrets Operator](https://www.cncf.io/projects/external-secrets/):** CAIPE’s Helm charts can create `ExternalSecret` resources for model credentials, databases, identity providers, bots, MCP servers, and gateway configuration. Existing Kubernetes Secrets remain supported.

- **[OpenTelemetry](https://www.cncf.io/projects/opentelemetry/) and [Prometheus](https://www.cncf.io/projects/prometheus/):** CAIPE emits agent and authorization traces through OpenTelemetry-compatible instrumentation and exposes Prometheus-format operational and agent metrics. Its charts optionally create Prometheus Operator `ServiceMonitor` resources.

- **[ArgoCD](https://www.cncf.io/projects/argo/):** A first-party Argo CD MCP integration exposes applications, projects, clusters, repositories, resources, events, and logs to governed agents. CAIPE’s charts also support Argo CD hooks and sync waves.

- **[Backstage](https://www.cncf.io/projects/backstage/):** CAIPE provides an MCP integration for the Backstage catalog and TechDocs, together with an Agent Forge plugin for invoking CAIPE agents from a Backstage application.

- **[gRPC](https://www.cncf.io/projects/grpc/):** CAIPE uses gRPC for the external authorization boundary between its MCP gateway and OpenFGA.

#### Broader open-source ecosystem integrations

- **[Agentgateway](https://agentgateway.dev/):** Serves as CAIPE’s policy-enforcement and routing point for MCP traffic. It validates caller identity, invokes CAIPE’s OpenFGA authorization bridge, and forwards approved requests to MCP servers. Agentgateway is a Linux Foundation project and is also used by the CNCF Kgateway project.

- **[Model Context Protocol](https://modelcontextprotocol.io/):** Provides the common interface between CAIPE agents and first-party or user-supplied tools. CAIPE adds identity, per-agent and per-tool authorization, credential handling, discovery, and auditability around MCP calls. MCP is hosted by the Linux Foundation’s Agentic AI Foundation.

- **[LiteLLM](https://www.litellm.ai/):** CAIPE can use LiteLLM as an OpenAI-compatible model and embedding gateway. It also includes an optional read-only LiteLLM MCP integration for model inventory, health, usage, spend, budget, and FinOps reporting.

CAIPE’s role is to connect these projects and technologies through common identity, policy, knowledge, workflow, audit, and operational controls.

### Cloud native overlap

The closest functional overlap is with **kagent**, with narrower overlap across **Kgateway, Backstage, Dapr, and Argo Workflows**:

- **kagent:** Both projects support building and operating AI agents with tools, MCP integrations, skills, memory, human approval, and multi-agent composition. [kagent](https://kagent.dev/docs/kagent/concepts/architecture/) is primarily a Kubernetes-native agent framework and runtime managed through CRDs and controllers. CAIPE provides a broader, multi-user control plane spanning multiple agent frameworks, Kubernetes and external engineering systems, with centralized identity, fine-grained authorization, credential management, knowledge bases, persisted workflows, auditability, and access through web, API, CLI, Slack, and Webex.

- **Kgateway:** There is overlap in MCP discovery, routing, security policy enforcement, and observability. [Kgateway](https://www.cncf.io/projects/kgateway/), including its integration with the agentgateway data plane, focuses on AI and agent traffic connectivity. CAIPE uses Agentgateway as part of its architecture and adds the application-level control plane for users, agents, tools, credentials, knowledge, workflows, and resource relationships. CAIPE complements rather than replaces the gateway data plane.

- **Backstage:** Both projects provide platform-engineering interfaces, catalogs, actions, skills, and integrations with engineering systems. Backstage is primarily an internal developer portal and extensible software catalog, including emerging [AI and MCP capabilities](https://backstage.io/docs/ai/). CAIPE is an agent operations platform with agent runtimes, policy enforcement, knowledge and memory, workflow execution, and conversational access. CAIPE can integrate with Backstage rather than requiring organizations to replace it.

- **[Dapr Agents](https://docs.dapr.io/developing-ai/dapr-agents/dapr-agents-introduction/):** The [Dapr Agents](https://docs.dapr.io/developing-ai/dapr-agents/dapr-agents-introduction/) framework overlaps in agent development, durable execution, state management, multi-agent coordination, event-driven workflows, MCP, and observability. Dapr Agents is a developer framework and distributed runtime building block. CAIPE is a deployable, multi-user control plane that can host or integrate heterogeneous agent runtimes while supplying governance, credentials, knowledge, workflow management, audit, and user-facing channels. CAIPE does not currently depend on Dapr.

- **[Argo Workflows](https://argo-workflows.readthedocs.io/):** Both can represent persisted, multi-step workflows. [Argo Workflows](https://argo-workflows.readthedocs.io/) orchestrates Kubernetes containers and DAG-based workloads. CAIPE workflows coordinate agent reasoning, tool calls, human approvals, artifacts, and interactions across engineering systems under user- and agent-specific authorization. CAIPE can invoke or interact with Argo projects without replacing their Kubernetes reconciliation or workload-orchestration functions.

CAIPE does not seek to duplicate Kubernetes, Helm, OpenTelemetry, Prometheus, OpenFGA, Keycloak, or External Secrets; it consumes or integrates with those technologies. It also does not provide model serving in the manner of KServe or llm-d. Its primary differentiator is an organization-wide, framework-neutral control plane that governs agents, knowledge, tools, workflows, credentials, and access channels as shared production software.

### Similar projects

Within CNCF, the closest projects are [kagent](https://kagent.dev/), which provides a Kubernetes-native platform and runtime for AI agents, and [Dapr Agents](https://docs.dapr.io/developing-ai/dapr-agents/dapr-agents-introduction/), which provides durable agent execution, state, workflows, and multi-agent coordination.

Outside CNCF, [LiteLLM](https://github.com/BerriAI/litellm) is adjacent in its support for model access, routing, credentials, quotas, and budgets. However, it is primarily an AI model gateway rather than an agent operations platform. It does not provide CAIPE’s end-user agent and workflow experience or OpenFGA-based relationship authorization across users, agents, tools, and resources.

CAIPE’s focus is a self-hosted, framework-neutral control plane for governing and operating agents and agentic workflows as shared production software.

### Landscape

No

### Insights

No

### Trademark and accounts

- [x] If the project is accepted, I agree to donate all project trademarks and accounts to the CNCF

### IP policy

- [x] If the project is accepted, I agree the project will follow the CNCF IP Policy

### Will the project require a license exception?

N/A - Projects uses Apache 2.0 license already

### Does the project utilize any dependencies with licenses not on the allowlist or an approved exception?

Yes. CAIPE currently uses MongoDB Community Server, which is licensed under SSPL v1 and is not on the CNCF license allowlist. Mitigation is underway through [PR #2418](https://github.com/caipe-io/ai-platform-engineering/pull/2418), which adds the MIT-licensed [DocumentDB](https://github.com/documentdb/documentdb) project as an alternative persistence backend. MongoDB remains the default, so remediation is underway but not yet complete.

### Project "Domain Technical Review"

No

### Application contact email(s)

haskalpa@cisco.com,sraradhy@cisco.com,nvlatko@cisco.com,tiswanso@cisco.com

### Contributing or sponsoring entity signatory information

If an organization:
| Name | Address | Type (e.g., Delaware corporation) | Signatory name and title | Email address |
|------|---------|-----------------------------------|----------------------------|---------------|
| Cisco Systems, Inc. | 170 W Tasman Dr, San Jose, CA 95134 | Delaware corporation | Cisco OSPO Legal | oss-legal@cisco.com |

Or, if an individual or individual(s):
| Name | Country | Email address | Title / role |
|------|---------|---------------|--------------|
| Hasith Kalpage | United States | haskalpa@cisco.com | Project maintainer; Director (business approval) |
| Natali Vlatko | United States | nvlatko@cisco.com | Cisco OSPO Lead (additional signatory) |
| Tim Swanson | United States | tiswanso@cisco.com | Cisco OSPO Lead (additional signatory) |

### CNCF contacts

- [Natali Vlatko](https://github.com/natalisucks) (Director of Open Source Software Engineering, Cisco OSPO)
- [Tim Swanson](https://github.com/tiswanso) (Cloud Native & Open Source Advocate, Cisco OSPO)
- Josh Halley (CNAI TCG)
- Ricardo Aravena (CNCF TOC/CNAI TCG)
- Lin Sun (CNCF TOC)

### Additional information

_No response_