OPAL is a Kubernetes-native control plane extension that replaces manual YAML configuration with declared business outcomes, and replaces reactive reconciliation with predictive pre-reconciliation — powered by a multi-agent AI control loop built on kagent.
You declare what you want. OPAL figures out how to run it — today, tomorrow, and before problems happen.
Kubernetes requires engineers to specify how to run workloads:
replicas: 3
resources:
requests:
cpu: 500m
memory: 512MiThis means:
- Deep Kubernetes expertise required for every service
- Reactive scaling: problems fixed after they occur
- No memory: the cluster forgets everything every restart
- Config drift: YAML diverges from business reality over time
OPAL introduces three new Kubernetes primitives:
apiVersion: opal.io/v1alpha1
kind: WorkloadOutcome
metadata:
name: checkout-service
namespace: production
spec:
targetRef:
kind: Deployment
name: checkout
slo:
latencyP99Ms: 80
availability: "99.95"
errorRatePercent: "0.1"
cost:
monthlyCeiling: "400"
currency: USD
compliance:
- PCI-DSS
horizon: 72h
autoApply: trueapiVersion: opal.io/v1alpha1
kind: ClusterForecast
metadata:
name: cluster-forecast
namespace: opal-system
status:
forecasts:
- workloadRef: production/checkout
predictedEvents:
- type: CPUSpike
predictedAt: "2025-12-20T20:00:00Z"
confidence: 0.87
recommendedActions:
- pre-scale-replicas-to-8
- increase-cpu-limit-to-2000mOPAL maintains an episodic memory of your cluster — every pattern, every incident, every seasonal trend. The longer OPAL runs, the smarter it gets.
┌──────────────────────────────────────────────────────────────────┐
│ OPAL Control Plane │
│ │
│ ┌─────────────────┐ A2A ┌──────────────────────────────┐ │
│ │ ForecastAgent │ ──────► │ ReconcilerAgent │ │
│ │ (kagent) │ │ (kagent) │ │
│ │ │ │ │ │
│ │ Reads: │ │ Pre-acts on predictions │ │
│ │ - Metrics │ │ before drift occurs │ │
│ │ - Events │ └──────────────┬───────────────┘ │
│ │ - ClusterMemory│ │ A2A │
│ │ │ ┌──────────────▼───────────────┐ │
│ │ Writes: │ │ OutcomeAgent │ │
│ │ ClusterForecast│ │ (kagent) │ │
│ └─────────────────┘ │ │ │
│ │ Translates WorkloadOutcome │ │
│ ┌─────────────────┐ │ → k8s config, validates │ │
│ │ AuditAgent │◄── A2A ───│ every change against SLOs │ │
│ │ (kagent) │ └──────────────────────────────┘ │
│ │ │ │
│ │ Every decision │ ┌──────────────────────────────────────┐ │
│ │ → K8s Event │ │ ClusterMemory Store │ │
│ └─────────────────┘ │ Episodic + Semantic temporal memory │ │
│ │ Queried by all agents │ │
│ └──────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────┘
│ │
▼ ▼
WorkloadOutcome CRDs Generated k8s manifests
(your declared goals) (owned and maintained by OPAL)
OPAL is built on top of kagent (CNCF Sandbox), using kagent's agent runtime, A2A protocol, and Kubernetes-native tooling as its foundation.
Intel IDO is the closest existing project — it also uses SLO declarations to drive Kubernetes decisions. Here is the precise difference:
| Intel IDO | OPAL | |
|---|---|---|
| What you declare | SLO targets | SLO + cost ceiling + compliance |
| What it generates | Scaling decisions only | Full k8s config: resources, replicas, HPA, PDB, NetworkPolicy |
| Predictive | No — reactive only | Yes — acts before problems occur |
| Cluster memory | No | Yes — learns patterns over time |
| AI agents | No | Yes — 4 kagent agents as the control plane |
| Built on CNCF project | No | Yes — built on kagent (CNCF Sandbox) |
| Open source activity | Limited community | Actively building community |
Intel IDO proves the idea is valid. OPAL goes significantly further.
Keptn used SLOs for delivery pipeline quality gates. It was archived in September 2025. OPAL fills the gap Keptn leaves: continuous, runtime outcome management — not just deployment gates.
These tools each solve one dimension reactively:
| Tool | What it solves | What it misses |
|---|---|---|
| KEDA | Scale replicas on events | Doesn't derive config from outcomes; reactive only |
| Karpenter | Right-size nodes | Node provisioning only; no SLO awareness |
| Flagger | Safe progressive delivery | Deployment strategy only; no predictive capability |
OPAL is not a replacement for these — it sits above them, using outcomes to drive their configuration.
These are reactive AI troubleshooting tools — they help you fix problems after they occur. OPAL predicts problems before they occur and prevents them. Fundamentally different.
| Capability | Intel IDO | Cast AI | k8sgpt | Keptn | Karpenter | OPAL |
|---|---|---|---|---|---|---|
| Outcomes → full k8s config | Partial | No | No | No | No | Yes |
| Predict future cluster state | No | Partial | No | No | No | Yes |
| Temporal cluster memory | No | No | No | No | No | Yes — first ever |
| AI agents as control plane | No | No | No | No | No | Yes (via kagent) |
| CNCF native | No | No | Sandbox | Archived | Sandbox | Building |
| Pre-emptive action | No | Limited | No | No | No | Yes |
- Kubernetes 1.28+
- kagent installed
- Helm 3.x
helm repo add opal https://charts.opal.io
helm repo update
helm install opal opal/opal \
--namespace opal-system \
--create-namespace \
--set llm.provider=anthropic \
--set llm.apiKeySecret=anthropic-key# Install CRDs
kubectl apply -f https://github.com/opalnewharshal/opal/releases/latest/download/crds.yaml
# Install controller
kubectl apply -f https://github.com/opalnewharshal/opal/releases/latest/download/opal.yaml
# Install agents
kubectl apply -f https://github.com/opalnewharshal/opal/releases/latest/download/agents.yamlkubectl apply -f config/samples/checkout-outcome.yamlWatch OPAL derive configuration:
kubectl get workloadoutcome checkout-service -n production -w
kubectl get events -n production --field-selector reason=OPALOutcomeApplied- Getting Started
- Architecture
- WorkloadOutcome Concept
- ClusterForecast Concept
- ClusterMemory Concept
- Contributing Guide
- GitHub Discussions: Start a discussion
- GitHub Issues: Report a bug or request a feature
- kagent Community: Join the conversation — OPAL is built on kagent
OPAL is built on kagent — a CNCF Sandbox project. We are actively building community and plan to apply to CNCF once we have demonstrated adoption. Contributions and feedback are very welcome.
Apache 2.0 — see LICENSE.