Meet TalkOps
TalkOps is an open-source, multi-agent framework that turns natural language into production-grade DevOps automation. Instead of mastering five cloud APIs, writing hundreds of lines of Terraform, and debugging Kubernetes networking and telemetry by hand — you describe what you need, and specialized AI agents plan, generate, and execute the work with human-in-the-loop safety at every step.
"Deploy the checkout service to production via Helm and ArgoCD, set up OpenTelemetry and Prometheus observability, and configure canary routing through Traefik."
Four agents. One sentence. Full GitOps audit trail.
Why TalkOps Exists
If you work in DevOps, you know the struggle:
| Problem | Impact |
|---|---|
| The Knowledge Gap | Junior engineers need years before safely touching multi-cloud production infrastructure |
| The Expert Bottleneck | Senior architects spend half their time fighting fires and mentoring — zero time for strategic work |
| Documentation Rot | Static runbooks decay fast and never account for the exact production edge case you are hitting right now |
| Tool Sprawl | Every tool (Terraform, Helm, ArgoCD, Prometheus, Loki, Tempo, OpenTelemetry) has its own CLI, config format, and failure modes |
TalkOps solves this by encoding your DevOps knowledge into autonomous, domain-specialized AI agents. Each agent is an expert in its domain — not a generic chatbot with a bash shell.
How It Works
TalkOps isn't a chatbot hooked up to a terminal. It's a structured, enterprise-grade orchestration framework powered by LangChain, LangGraph, and the Deep Agents SDK.
The flow:
- You describe what you need — in plain English or from the OpsCode terminal TUI.
- The Supervisor Agent analyzes your intent, decomposes it into logical tasks, and routes each task to the right specialist.
- Specialized agents generate plans, manifests, queries, and configurations using domain-specific MCP tools.
- Everything halts at a safety gate — the agent produces a reviewable diff or opens a GitOps PR with preflight dry-run checks.
- Only after explicit approval does the change apply to your infrastructure or cluster.
The Agent Ecosystem
TalkOps ships with specialized agents organized by domain. Each agent follows the Deep Agent pattern — a Supervisor coordinates multiple sub-agents through a LangGraph state machine with isolated BranchMemoryStore contexts.
Application & Terminal Agents
| Agent | What It Does | Status |
|---|---|---|
| OpsCode | Terminal-native AI coding agent built on Deep Agents SDK with 6 specialized subagents, 20+ LLM providers, MCP tool integration, and autonomous --rubric self-grading loops | ✅ Available |
| Kubernetes Agent (k8s-autopilot) | Multi-domain lifecycle automation — Helm chart generation, active cluster operations, ArgoCD onboarding, observability setup, and cluster diagnostics | ✅ Available |
| CI-Copilot | Generates, modifies, and debugs CI/CD pipelines (GitHub Actions) through conversation with security policy validation | ✅ Available |
Infrastructure Agents
| Agent | What It Does | Status |
|---|---|---|
| AWS Orchestrator | 7+ specialized sub-agents that generate enterprise-grade AWS Terraform modules with deep research analysis | ✅ Available |
| Azure Orchestrator | Azure infrastructure automation — Bicep/Terraform generation, AKS management, and Azure-native services | 🚧 In Development |
| GCP Orchestrator | Google Cloud infrastructure automation — GKE management, Cloud Run, and GCP-native services | 🚧 In Development |
Operations & SRE Agents
| Agent | What It Does | Status |
|---|---|---|
| SRE Agent | Incident commander and coordination layer — cross-agent triage, runbook execution, SLO tracking, and post-incident analysis | ✅ Available |
| Monitoring Agent | Non-Kubernetes observability — Datadog, CloudWatch, New Relic integration and dashboard automation | 🚧 In Development |
The Model Context Protocol (MCP) Integration Layer
Agents don't run arbitrary, unvalidated shell scripts. They use the Model Context Protocol (MCP) — an open standard that connects agents to your infrastructure tools with structured schemas, runtime validation, and scoped permissions.
| MCP Server | What It Does | Tools | Resources | Status |
|---|---|---|---|---|
| Helm MCP | Chart lifecycle, release management, values configuration, rollbacks | 18 | 10 | ✅ Available |
| Prometheus MCP | PromQL metric queries, exporter management, alert rule audits, TSDB FinOps | 28 | 12 | ✅ Available |
| Alertmanager MCP | Alert triage, silence lifecycles, routing tree introspection, governance | 14 | 8 | ✅ Available |
| OpenTelemetry MCP | Collector pipelines, span/metric telemetry diagnostics, sampling audits, receivers | 19 | 9 | ✅ Available |
| Loki MCP | Guardrailed LogQL queries, volume analytics, incident log triage, label schema | 9 | 8 | ✅ Available |
| Tempo MCP | TraceQL searches, span latency waterfalls, trace-to-metrics correlation, topology alerts | 16 | 11 | ✅ Available |
| ArgoCD MCP | GitOps application sync, cluster health, diff inspection, multi-cluster management | 29 | 15 | ✅ Available |
| Argo Rollout MCP | Progressive delivery — canary analysis, blue-green promotions, rollback gates | — | — | ✅ Available |
| Traefik MCP | Edge traffic management — canary weighting, middleware chains, traffic mirroring | 11 | 6 | ✅ Available |
| Terraform MCP | IaC module generation, drift detection, plan simulation, state inspection | — | — | ✅ Available |
The key principle: A2A connects agents to agents. MCP connects agents to infrastructure tools.
When a sub-agent needs to deploy a Helm chart or inspect distributed traces, it does not hold raw root credentials. The MCP server provides typed tool calls with strict schemas, and the agent's access is strictly constrained to approved operations.
Architecture Principles
1. The Deep Agent Pattern
Every TalkOps agent follows a modular multi-tier architecture:
Supervisor → Coordinator(s) → Specialist Sub-Agents
- Supervisor receives the user request, classifies intent, and coordinates the overall execution graph.
- Coordinators own specific domains (e.g., Helm operations, trace analysis, cluster diagnostics) and break work into sub-tasks.
- Specialist sub-agents execute atomic operations using MCP tools with isolated memory contexts (
BranchMemoryStore).
This structure enables agents to execute independent tasks in parallel (e.g., deploying an application via Helm while simultaneously configuring OpenTelemetry collectors and Prometheus alerting rules) while maintaining a unified workflow state.
2. Multi-Tier Governance & Guardrails
TalkOps was built from day one with governance embedded into every layer — not bolted on as an afterthought.
| Pillar | What It Does |
|---|---|
| Guardrails | Hard limits on what agents cannot do — resource caps, query byte thresholds, AST bash command scanners |
| Access Control | Role-based permissions scoping what agents are allowed to do per environment and cluster |
| Approval Gates | 3-tier approval policies: suggest (review all), auto-edit (prompt on execution), full-auto (guarded autonomy) |
| Audit Trails | Every agent operation creates an immutable, structured trace log for compliance (SOC 2, HIPAA, ISO 27001) |
3. GitOps-Native
Nothing is ever applied blindly. Agents generate changes, commit them to Git, and open Pull Requests. The PR becomes the approval gate, the audit trail, and the rollback mechanism — all in one.
4. Conversational & Stateful Context
TalkOps maintains context across your conversation:
You: "Deploy Tempo to the observability namespace with S3 backend." TalkOps: "Done! Tempo is running and ingested 1,240 spans/sec."
You: "Show me traces with latency over 2 seconds in that namespace." TalkOps: (Knows context refers to Tempo in observability) — "Found 3 traces matching
{ duration > 2s }. Root cause is a slow database query in serviceauth-api."
Agents maintain conversational memory, workflow state (which steps succeeded/failed), and infrastructure drift awareness (desired vs. actual state).
Technology Stack
| Layer | Technology |
|---|---|
| Agent Orchestration | LangChain & LangGraph — state machines, DAG execution, checkpointing |
| Agent Coding Core | Deep Agents SDK — isolated BranchMemoryStore, subagent orchestration, rubric grading |
| Agent Communication | A2A (Agent-to-Agent) Protocol — JSON-RPC 2.0 over HTTPS with Agent Cards discovery |
| UI Streaming | A2UI (Agent-to-User Interface) Protocol — declarative, XSS-safe JSON component streaming |
| Tool Integration | Model Context Protocol (MCP) — 10 production servers connecting tools with structured schemas |
| Infrastructure & Clouds | Kubernetes, Helm, ArgoCD, Terraform, AWS, Azure, GCP |
| Observability | OpenTelemetry, Prometheus, Alertmanager, Grafana Loki, Grafana Tempo |
Getting Started
| What you want to do | Where to go |
|---|---|
| Terminal AI coding & infrastructure automation | OpsCode Documentation |
| Deploy and manage apps on Kubernetes | Kubernetes Agent |
| Connect agents to your monitoring stack | OpenTelemetry, Loki & Tempo MCP |
| Provision AWS infrastructure with Terraform | AWS Orchestrator |
| Explore the 10 production MCP servers | MCP Overview Directory |
| Inter-agent and UI protocols reference | A2A Protocol & A2UI Protocol |