Skip to main content

Frequently Asked Questions

Welcome to the TalkOps FAQ. Here you will find direct, technical answers about the framework, multi-agent architecture, Model Context Protocol (MCP) servers, security guardrails, and getting started.

General​

What is TalkOps?​

TalkOps is an open-source, multi-agent framework designed specifically for DevOps, platform engineering, and Site Reliability Engineering (SRE). Instead of interacting with infrastructure through raw bash commands or generic chat windows, TalkOps coordinates specialized AI agents that autonomously plan, generate, validate, and troubleshoot infrastructure code, Kubernetes manifests, and observability pipelines.

Explore the Architecture Overview to learn more.

Is TalkOps open source? What license does it use?​

Yes. TalkOps, its specialized agents, and its suite of Model Context Protocol (MCP) servers are 100% open source and distributed under the permissive Apache 2.0 License. You are free to inspect, modify, self-host, and deploy TalkOps across commercial and non-commercial environments.

Check out our code repositories on GitHub.

What LLM providers does TalkOps support?​

TalkOps is model-agnostic and supports over 20 LLM providers, including:

  • Anthropic: Claude 3.5 Sonnet, Claude 3 Opus
  • OpenAI: GPT-4o, GPT-4 Turbo, o1
  • Google Cloud: Gemini 1.5 Pro, Gemini 1.5 Flash
  • AWS Bedrock & Azure OpenAI: Enterprise-managed model endpoints
  • Local & Offline Models: Ollama, vLLM, and LocalAI for air-gapped environments

See how to configure providers in the OpsCode Authentication Guide.

How is TalkOps different from ChatGPT or GitHub Copilot?​

General-purpose AI assistants are designed for IDE text autocomplete or generic conversational reasoning. They struggle with cloud infrastructure because they lack state awareness, hallucinate deprecated provider arguments, and fail to comprehend live API locks.

CapabilityGeneric Assistants (Copilot, ChatGPT)TalkOps Framework
Execution ModelMonolithic text generationHierarchical multi-agent DAG (Supervisor $\rightarrow$ Coordinator $\rightarrow$ Subagent)
State AwarenessBlind to remote state files & locksState-aware lock inspection & drift prevention
Tool InterfaceRaw shell execution or generic plugins10 standardized MCP servers with 4-Tier Security Guards
Context IsolationSingle prompt context overflowBranchMemoryStore per subagent
Safety GovernanceOptimistic executionMandatory Human-in-the-Loop (HITL) approval gates

Read more about our approach in the Deep Agent Pattern Guide.

What infrastructure does TalkOps manage?​

TalkOps manages a comprehensive cloud-native ecosystem:

  • Kubernetes: Helm chart lifecycles, ArgoCD GitOps sync, Argo Rollouts canary deployments, Traefik edge routing, Pod Security Standards (PSS Restricted).
  • Infrastructure as Code (IaC): Multi-cloud Terraform module generation for AWS, Azure, and GCP.
  • CI/CD Pipelines: Automated GitHub Actions workflow generation and actionlint verification.
  • Cloud-Native Observability: Prometheus metrics, Alertmanager triage, OpenTelemetry collector topologies, Loki log querying, and Tempo distributed tracing.

Can I use TalkOps without Kubernetes?​

Yes. TalkOps is completely modular. You can use standalone agents like OpsCode in your terminal to author Terraform modules or manage CI/CD pipelines for virtual machines, serverless stacks, and cloud VPCs without running a Kubernetes cluster.

What is the pricing model for TalkOps?​

TalkOps is completely free and open source. There are no license fees, seat fees, or feature gates. You only pay for the LLM API tokens you consume from your chosen model provider (e.g., OpenAI or Anthropic) and the underlying cloud infrastructure you provision.

Agents & Architecture​

What agents are currently available?​

Can I use agents independently or do I need the full framework?​

Agents are entirely decoupled. You can run OpsCode locally as a standalone terminal binary (ops), run the Kubernetes Agent in a headless CI/CD container, or connect individual MCP servers to external IDEs without running the entire TalkOps control plane.

How do agents communicate with each other?​

TalkOps agents collaborate across trust boundaries using the Agent-to-Agent (A2A) Protocol. A2A uses JSON-RPC 2.0 over HTTPS with cryptographic request validation, allowing agents to negotiate proposals, pass structured execution states, and stream UI components dynamically.

What is the Deep Agent pattern?​

The Deep Agent pattern is TalkOps' cognitive architecture built on LangGraph state machines. Instead of dumping entire cluster logs and terraform plans into a single prompt, a top-level Supervisor Agent evaluates intent and passes tasks to a Task Coordinator, which dispatches atomic tasks to specialized Subagents running in isolated memory branches (BranchMemoryStore). Only clean diffs and verified statuses are returned to the user.

┌────────────────────────────────────────────────────────┐
│                    Supervisor Agent                    │
└───────────────────────────┬────────────────────────────┘
                            │ Evaluates Intent & Policy
┌───────────────────────────▼────────────────────────────┐
│                    Task Coordinator                    │
└───────┬───────────────────┬───────────────────┬────────┘
        │                   │                   │
┌───────▼────────┐  ┌───────▼────────┐  ┌───────▼────────┐
│ Terraform Agent│  │Kubernetes Agent│  │ CI/CD Agent    │
│ (BranchMemory) │  │ (BranchMemory) │  │ (BranchMemory) │
└────────────────┘  └────────────────┘  └────────────────┘

Can I build custom agents?​

Yes. TalkOps is extensible. You can define custom subagents by extending the LangGraph state machine, writing a YAML definition file, and attaching custom MCP toolsets.

Model Context Protocol (MCP) Servers​

What is the Model Context Protocol (MCP)?​

The Model Context Protocol (MCP) is an open specification pioneered by Anthropic that standardizes how AI models interface with external tools, APIs, and data sources. Instead of writing custom API wrappers for every LLM, MCP servers expose structured tool definitions and resource URIs that any MCP-compliant AI client can discover and execute.

Read our MCP Integration Overview.

What MCP servers does TalkOps provide?​

TalkOps maintains 10 production-grade MCP servers:

  1. Helm MCP Server: 18 tools for Helm chart search, template rendering, deployment, rollback, and validation.
  2. Prometheus MCP Server: 28 tools for PromQL queries, exporter lifecycle management, and TSDB FinOps.
  3. Alertmanager MCP Server: 14 tools for alert triage, silence creation, and routing tree inspection.
  4. OpenTelemetry MCP Server: 19 tools for collector provisioning, auto-instrumentation, processor ordering, and cardinality control.
  5. Loki MCP Server: 9 tools for LogQL query building, structural pattern analysis, and query cost guardrails.
  6. Tempo MCP Server: 16 tools for TraceQL distributed tracing, critical path latency summarization, and RED metrics.
  7. ArgoCD MCP Server: 29 tools for GitOps app synchronization, health monitoring, and rollback.
  8. Argo Rollouts MCP Server: Progressive delivery with automated canary analysis, blue-green, and promotion triggers.
  9. Traefik MCP Server: 11 tools for IngressRoute traffic splitting, middleware governance, and NGINX migrations.
  10. Terraform MCP Server: Infrastructure as Code plan/apply execution and semantic provider doc search.

Can I use TalkOps MCP servers with Claude Desktop, Cursor, or Windsurf?​

Yes. All TalkOps MCP servers conform strictly to the official MCP specification. You can point Claude Desktop, Cursor, Windsurf, or LangChain agents to any TalkOps server via stdio or streamable-http transports.

Security, Governance & Safety​

Does TalkOps execute commands automatically in production?​

No. TalkOps operates on a strict "Produce Diffs, Not Deployments" philosophy. The framework defaults to dry-runs and plan outputs. Before mutating any live cluster state, provisioning cloud resources, or applying Terraform changes, the agent pauses and presents a clear diff for human validation.

What is Human-in-the-Loop (HITL)?​

Human-in-the-Loop (HITL) is an architectural governance checkpoint. In interactive modes (like the OpsCode TUI), mutating actions pause and require pressing [y] to execute. In headless CI/CD environments, HITL is implemented via Git Pull Request reviews or structured confidence thresholds.

How does TalkOps enforce RBAC and prevent destructive actions?​

TalkOps enforces a 4-Tier Security Guard across all MCP tools:

  • Tier 1 (Read-Only): Queries, metric reads, log retrieval, and configuration dry-runs (executed automatically).
  • Tier 2 (Mutating Safe): Reversible changes with automated rollback capabilities.
  • Tier 3 (Mutating Destructive): Resource deletions, cluster scaling down, or state modifications (requires explicit human confirmation).
  • Tier 4 (Privileged): ClusterRole bindings, secret decryption, and credential rotations (requires administrative authorization).

Does TalkOps store my cloud credentials?​

No. TalkOps agents never store long-lived IAM keys, database passwords, or permanent kubeconfigs. Authentication is handled at the MCP server layer using ephemeral, task-scoped tokens that automatically expire after 30 minutes.

Getting Started​

How do I install and run TalkOps?​

For the interactive terminal coding agent, install OpsCode via our automated script:

curl -LsSf https://raw.githubusercontent.com/talkops-ai/opscode/main/scripts/install.sh | bash

Launch the terminal interface:

ops

For full multi-agent cluster deployments, follow our Installation Guide.

What are the prerequisites?​

  • Operating System: Linux, macOS, or Windows (via WSL2).
  • Runtimes: Python 3.12+ (if running from source) or Docker.
  • LLM API Key: OpenAI, Anthropic, Gemini, or a running local Ollama instance.
  • CLI Tools (Optional depending on workflow): kubectl, helm, terraform, aws, az, gcloud.

Where can I get support or contribute?​