The AI Operations Framework for Kubernetes.
k8s-autopilot is an open-source, extensible AI operations framework built on LangGraph and the Deep Agents SDK. Talk to your cluster in natural language to manage Helm releases, orchestrate progressive Argo Rollouts, troubleshoot crashing pods, and correlate full-stack observability — all protected by Human-in-the-Loop governance and autonomous rubric verification.
curl -LsSf https://raw.githubusercontent.com/talkops-ai/k8s-autopilot/main/scripts/install.sh | bashExtensible Architecture for Cloud-Native Operations
An open AI operations framework built on LangGraph. From out-of-the-box Kubernetes operators to custom sub-agents and plugins, automate complex infrastructure workflows with strict safety and rubric verification.
Dynamic Multi-Agent Supervisor Architecture
An open, extensible AI operations runtime built on LangGraph and the Deep Agents SDK — not a closed tool. A central Supervisor coordinates foundational out-of-the-box operators alongside dynamically spawned custom sub-agents, binding MCP tool servers Just-In-Time (JIT) to scale across any domain without token bloat.
Predictable Governance & 3 Safety Modes
Look before you touch. Control operational autonomy across 3 runtime modes: Manual (every mutating action gated), Auto (3-tier safety filter: pattern checks → AI risk evaluation → human gate), and YOLO. Always fails safe, with dry-run previews and elevated scrutiny on production workloads.
Goal Tracking & Rubric Grader Loops
Propose high-level cluster outcomes in natural language. The agent auto-generates concrete, verifiable criteria, then executes in an iterative Worker + Grader loop — an independent model evaluates actual cluster state until 100% of criteria pass before declaring completion.
Plugin Marketplace & Custom MCP Servers
Extend the runtime to any tool or cloud with zero code modifications. Discover and install plugins from remote marketplaces, GitHub, or local catalogs to add skills, new sub-agents, and tools. Natively supports Claude, OpenAI Codex, and OpsCode plugin formats with hot-reload MCP integration.
A2UI & A2A Native Visual Interfaces
Say goodbye to walls of raw terminal text. Powered by the open Agent-to-User (A2UI) and Agent-to-Agent (A2A) protocols, workflows stream into rich visual surfaces: interactive one-click approval cards with blast-radius diffs, live step execution trackers, and real-time metric charts.
Engineered Specifically for Cloud-Native Kubernetes Ops
Traditional AI assistants either lack live cluster understanding or force vendor lock-in. k8s-autopilot combines multi-operator reasoning, deep tool isolation, and rigorous safety verification.
| Capability | Kubiya | Komodor | Botkube | kagent | k8s-autopilotOPEN FRAMEWORK |
|---|---|---|---|---|---|
| Open Source License | Proprietary | Proprietary | Partial | CNCF Sandbox | Apache 2.0 (100% Open Source) |
| Multi-Agent Architecture | Yes (Proprietary) | No (Single) | No (Bot-based) | Yes (A2A per-CRD) | Supervisor + Pluggable Operators & Sub-agents |
| MCP Tool Server Ecosystem | None | None | None | Generic MCP | 11 Built-in Servers + Dynamic Custom MCP |
| Plugin Marketplace Formats | Limited | None | Internal Catalog | BYO Tool Servers | Claude, Codex, & OpsCode Formats |
| Built-in Domain Coverage | Workflow Actions | K8s Troubleshoot | Event Alerts | General Runtime | Helm, Argo, Rollouts, Traefik, Prom, Loki, Tempo |
| Human-in-the-Loop Governance | JIT Approvals | Approval Flows | Chat Commands | CRD Gates | Manual, Auto (AI Classifier), YOLO + A2UI |
| Goal Tracking & Rubric Grading | No | No | No | No | Worker + Grader Self-Evaluating Loops |
| Universal LLM Providers | Undisclosed | Undisclosed | OpenAI Only | 5 Providers | 20+ Providers with Live UI Hot-Swap |
Deep Multi-Operator Architecture. Governed by Design.
Built on LangGraph and the Deep Agents SDK. Explore the architectural foundations that make k8s-autopilot the most extensible, safe, and transparent AI operations framework for Kubernetes.
Supervisor & 4 Domain Operators
Rather than forcing a single model to do everything, k8s-autopilot uses a central Supervisor that classifies intent and delegates tasks to specialized Domain Operators. Each operator runs in an isolated context loop with dedicated MCP servers.
- Clean Context Sandboxing: Intermediate command outputs, dry-runs, and PromQL query iterations stay contained inside the operator — never polluting your conversation.
- Just-In-Time (JIT) Tooling: MCP tool servers start as lightweight subprocesses only when needed and terminate immediately after task completion.
- Cross-Operator Structured Handoffs: When investigations cross domains (e.g. Observability detects latency → K8s Operator inspects crashing pods), full context is preserved.
// Helm Operator (helm-mcp-server · 22 tools) Task: Install Redis cluster from bitnami in namespace [database] Pipeline: Discover → Plan → Confirm → Execute → Verify Safety: Values schema validated | helm install --dry-run verified Approval Gate: Pinned rollback checkpoint to exact revision #3
Human-in-the-Loop: Look Before You Touch
k8s-autopilot follows a strict co-pilot rule: read-only actions run immediately, while any action that could change infrastructure pauses and presents an interactive approval card before executing.
Every state-modifying action (deploy, upgrade, delete, scale, or traffic route) pauses and presents an interactive Approval Card with target resources and blast radius. Nothing touches your cluster without explicit confirmation.
Goals & Rubrics: Verifiable Execution
When given multi-step infrastructure tasks, k8s-autopilot doesn't execute blindly. It proposes concrete acceptance criteria that become an active rubric, running a Worker + Grader loop to verify cluster state.
- Objective Verification: Task completion is evaluated by an independent rubric grader model against actual cluster resources rather than self-assessed.
- Iterative Self-Healing: Failed criteria generate a structured deficiency report, and the worker automatically remedies gaps until all criteria pass.
- Tactical Todo Checklist: Execution tracks in real-time through pending, in_progress, and completed states, keeping the agent anchored during long tasks.
Agent & Vertical Plugins with Universal Formats
Extend k8s-autopilot without modifying core agent code. Install add-ons with one click from the Settings UI to add dedicated sub-agents, workflow playbooks, or custom MCP tool connections.
- Two Plugin Types: Agent Plugins register dedicated sub-agents in isolated scopes; Vertical Plugins add skills and commands directly to the main agent.
- Universal Marketplace Formats: Works natively with plugins built for Anthropic (Claude), OpenAI (Codex), OpsCode, or native k8s-autopilot format.
- Live Settings UI at :8888: Model selection, credentials, cluster contexts, and MCP servers configure at runtime with zero restarts.
20+ Model Providers. Zero Lock-In.
Switch model providers on the fly directly from the Settings UI. API keys are saved to your configuration database with zero server restarts required.
Frontier Reasoning & Foundation
Direct API & CloudEnterprise Cloud & Sovereignty
VPC & IAM SecuredHigh-Throughput, Gateways & Local
Zero Egress & Air-Gappedgemini-3.7-flash, gpt-5.4-mini, or llama-3.3-70b), and escalate complex multi-repo GitOps rollouts, autonomous incident postmortems, and rubric evaluations to frontier reasoning engines (such as claude-opus-4.7/5 with max thinking effort, gpt-5.5-pro with xhigh reasoning, or deepseek-r1).Governed Kubernetes Automation in Action
From zero-downtime progressive rollouts and full-stack observability triage to schema-validated Helm upgrades and Day-2 cluster governance, k8s-autopilot executes battle-tested infrastructure playbooks.
Production Incident Forensics & Auto-Remediation
Detects and resolves cluster incidents across all 5 telemetry pillars. Correlates Prometheus 5xx rate spikes and latency degradation with Tempo distributed trace spans, isolates matching error lines in Loki, diagnoses pod CrashLoopBackOff or OOMKilled events, and prepares non-destructive remediation manifests with rollback safety.
ArgoCD GitOps Sync & Canary Traffic Steering
Automates end-to-end application delivery pipelines. Converts standard Deployments to Argo Rollouts using workloadRef without duplicating pods or causing GitOps drift, configures Traefik IngressRoute for weighted traffic splits (e.g. 95/5 → 50/50), validates telemetry via AnalysisTemplate, and requires human sign-off before 100% promotion.
Helm Lifecycle & Schema-Validated Upgrades
Discovers and manages charts from public or private OCI registries. Parses values.schema.json to identify required fields, auto-detects existing releases to prevent naming collisions, preserves custom configurations via --reuse-values, and previews non-destructive dry-run manifest diffs before applying atomic updates.
Multi-Cluster Day-2 Ops, RBAC Audits & Scaling
Executes safe day-2 cluster operations across staging and production fleets. Audits RBAC bindings and service account privileges, diagnoses node CPU/memory pressure (nodes_top), monitors cluster-wide WarningEvents, safely scales workloads during load spikes, and launches isolated temporary debug pods—with automated secret masking.
Ready to Bring Governed AI to Your Kubernetes Clusters?
Deploy the lightweight k8s-autopilot Docker Compose stack on Linux, macOS, or Windows (WSL). Zero manual configuration required to launch the interactive web dashboard and connect your clusters.
$ curl -LsSf https://raw.githubusercontent.com/talkops-ai/k8s-autopilot/main/scripts/install.sh | bash