Terminal-Native DevOps & Platform Agent|Open Source

The AI Coding Agent for DevOps, SRE, and Platform Engineers.

OpsCode is a terminal-native AI agent built for the complete DevOps and Platform Engineering lifecycle. Ships with built-in subagents for cloud infrastructure and CI/CD, an extensible plugin engine to build custom agents for any stack, autonomous CI/CD rubric grading, and modes to manage human in the loop.

View on GitHub Quickstart Guide Explore Architecture

Extend to any custom stackHuman in the loop governanceDeep Agents SDK + LangGraph

opscode — zsh — 80x24

# Launch the interactive terminal UI with live reasoning stream
$ ops
OpsCode v1.0.0 — DevOps, SRE, and Platform Engineering Agent
Orchestrator: LangGraph State Machine | SDK: Deep Agents SDK
Active Agent: root (4 global skills) | 6 Domain Subagents loaded
ops> Investigate failing ArgoCD sync on staging and generate fixed Helm values
-> Auto-routed to [k8s-helm-provisioner] with isolated memory
[MCP Tool] Querying Kubernetes API: ingress schema deprecation detected
-> Generated values.yaml patch (networking.k8s.io/v1 updated)
Approval? [Approve Patch] [Inspect Diff] [Reject] (Mode: Manual)

Extendable

To Any Stack

Plugins, Custom Subagents, MCP

Human-in-Loop

3 Approval Modes

Manual, Auto, and YOLO with Shift+Tab

Autonomous

CI/CD Rubric Loops

Worker + Grader self-evaluations

20+ Models

Universal Providers

Claude, OpenAI, Gemini, Ollama

Core Capabilities

Purpose-Built for DevOps, SRE, and Platform Engineering

A flexible, terminal-native AI runtime that adapts to your team's tooling, manages human-in-the-loop safety, and automates complex multi-step operations.

Infinite Extensibility

Extend to Any Stack & Custom Agents

OpsCode is not locked to a fixed set of tools. Define custom subagents with a simple AGENTS.md file, install bundled marketplace plugins with one command, connect external MCP tools, or bind async remote LangGraph subagents for distributed workloads.

Custom subagents in .opscode/agents/

Marketplace plugins with bundled MCP tools

Deterministic 7-tier skill hierarchy

Human in the Loop

Modes Built for Safe Governance

Engineered specifically for infrastructure risk. Switch instantly between Manual Mode (prompt on every mutating action), Auto Mode (read-only fast-tracked with destructive gates), and YOLO Mode with Shift+Tab. Unicode and shell security scanners catch injections before execution.

Shift+Tab runtime mode hot-swapping

Shell command & Unicode injection scanners

Headless 4-tier MCP security classification

Autonomous CI/CD

Rubric Grading & Isolated Memory

Run unattended in CI/CD with self-grading Worker + Grader loops that evaluate acceptance criteria against markdown specs. 6 specialized subagents use isolated BranchMemoryStore sandboxes, keeping intermediate token churn out of your root context.

Worker + Grader autonomous CI loops

BranchMemoryStore context isolation

SQLite-backed thread checkpointing & resume

Why OpsCode

Engineered for DevOps & Platform Teams

General coding assistants excel at frontend and backend application code, but DevOps, SRE, and infrastructure demand customizable subagents, multi-tier safety governance, and autonomous CI/CD loops.

Capability	Aider	OpenHands	Claude Code	OpsCodeEXTENSIBLE DEVOPS
Core Target & Engineering Scope	Application Code	General Software	General Coding	DevOps, SRE, & Platform Engineering
Custom Subagents (.opscode/agents/)	None	Hardcoded Archetypes	None	Custom Subagents via simple AGENTS.md
Extensibility & Marketplace Plugins	Limited	Plugin API	MCP Only	Plugins, Marketplace, MCP, Remote Agents
Human-in-the-Loop Runtime Modes	Git Revert	Docker Sandbox	Confirm on tool call	Manual, Auto (-y), & YOLO with Shift+Tab
Multi-Agent Memory Sandboxes	Monolithic	Multi-Threaded	Monolithic	Isolated BranchMemoryStore per Subagent
Skill Hierarchy & Precedence	Single Prompt	System Prompt	Skills / Rules	Deterministic 7-Tier Resolution Order
Autonomous CI/CD Rubric Self-Grading	None	Unit Test Runner	None	Worker + Grader Self-Evaluating Loops
Multi-Model Hot-Swapping & Reasoning	CLI Flags	Web Dropdown	Single Provider	20+ Providers with /model & Reasoning

Architecture & Extensibility

Extend to Any Stack. Governed by Design.

Deep dive into the architectural principles that make OpsCode the most flexible, extensible, and safe AI runtime for modern DevOps and Platform Engineering teams.

Multi-Agent Orchestration

Extend with Custom Subagents

OpsCode is built on a modular LangGraph orchestrator that dynamically routes tasks to specialized subagents. Beyond the 6 built-in agents, you can create custom subagents for any domain (SRE, database ops, observability, compliance) with a simple AGENTS.md file.

Custom Subagents via AGENTS.md: Define domain personas, scoped skills, and system prompts directly inside your repository.
Isolated Memory Sandboxes: Each subagent runs in its own BranchMemoryStore. Intermediate research and tool noise never leak to the root session.
Progressive Disclosure: Subagent skills load on-demand when relevant files appear in your workspace, keeping token overhead minimal.

Subagent Inspector & Memory Sandbox

MULTI-AGENT

sre-incident-responder

Incident Triage & Alert Remediation

6 Scoped Skills

datadog-alert-parserloki-log-correlationrunbook-executorpostmortem-generatorincident-slack-broadcastpagerduty-ack

// Custom Subagent defined via .opscode/agents/sre-incident-responder/AGENTS.md
---
name: sre-incident-responder
description: Triages Datadog alerts, correlates error logs, and executes runbooks
skills: [datadog-alert-parser, loki-log-correlation, runbook-executor]
mcp_servers: [prometheus, datadog-api]
---
Task: Triage 502 spike on production checkout service
Status: Correlated 47 logs across 3 pods | Memory: Isolated BranchMemoryStore

Human in the Loop

Modes to Manage Oversight

Production infrastructure demands predictable human oversight. OpsCode provides three distinct runtime modes to control the degree of autonomy. Toggle between them anytime mid-session with Shift+Tab.

DEFAULT FOR PROD

Every single mutating action (file edit, delete, shell command, or remote API call) stops the agent and prompts for interactive approval. You inspect the exact diff before anything touches the filesystem or cloud accounts.

Security Pipeline: Manual Mode

4-TIER GUARD

Shell Scanner

PASS

Unicode Scanner

PASS

Mutating Action Filter

PROMPT REQUIRED

Execution

USER GATED

Governance: Shell & Unicode Scanners + Headless MCP Guard Active

CI / CD Automation

Autonomous Rubric Self-Grading

Running AI agents in CI/CD pipelines requires objective quality verification. OpsCode implements an autonomous Worker + Grader loop: the Worker generates code, and the Grader model evaluates it against your markdown rubric spec.

Autonomous Repair Loop: If the Grader scores below threshold, the Worker reads structured feedback and iteratively repairs the output.
Multi-Model Architecture: Author code with fast models and grade strictly with frontier reasoning models (Claude 3.7 / GPT-4.1 / DeepSeek R1).
Pipeline Ready: Exits 0 on rubric pass, non-zero on failure with full audit traces for pull request comments.

Attempt #1

Worker generates cloud architecture & manifests

Grader Score: 6/10 (FAIL)

Feedback: Missing Multi-AZ NAT redundancy and KMS rotation

↓ Auto-Refactoring with Grader Feedback ↓

Attempt #2

Worker adds 3-AZ NAT gateways + KMS key rotation

Grader Score: 10/10 (PASSED)

All 5 rubric assertions verified. PR diff created.

Extensibility & Plugins

7-Tier Skill Hierarchy & Plugins

Teach OpsCode new capabilities with simple Markdown files (SKILL.md). A deterministic resolution hierarchy guarantees that your team's repository rules always take precedence.

Project Overrides: Commit .opscode/skills/ directly to Git so your entire team shares identical agent conventions.
Marketplace Plugins: Install bundled skills, agents, MCP tools, and slash commands with ops plugin install.
Tool Execution Hooks: Trigger custom security audit scripts before or after any tool executes via hooks.json.

Skill Precedence Cascade

HIERARCHY

1. HIGHESTProject Level (./.opscode/skills/)

Committed to Git repo — overrides all lower tiers

2. USERUser Level (~/.opscode/skills/)

Developer personal defaults across all workspaces

3. PLUGINInstalled Plugins (.opscode/plugins/)

Community and team marketplace extensions

4. DEFAULTBuilt-In Baseline Skills (34 Skills)

Core cloud, docker, kubernetes, and subagent skills

Model Freedom

20+ Model Providers. Zero Lock-In.

Switch model providers on the fly with /model in interactive sessions or --model in CI/CD pipelines. All model streams route through the identical safety gate and subagent memory sandbox.

Frontier & Reasoning Models

Cloud & API

Anthropic Claude

Claude 3.7 Sonnet, 3.5 Haiku

OpenAI

GPT-4.5, GPT-4o, o3-mini

Google Gemini

Gemini 2.5 Flash, 2.0 Pro

DeepSeek

DeepSeek R1, DeepSeek V3

xAI Grok

Grok 2.0, Grok Beta

Enterprise Cloud Endpoints

VPC & IAM Secured

AWS Bedrock

Claude 3.5, Llama 3.3, Amazon Titan

Azure OpenAI

Private VNet, Microsoft Entra ID

Google Vertex AI

Gemini Enterprise, Custom Tuned

IBM watsonx.ai

Granite Models, Guardrails

NVIDIA NIM

Self-hosted Microservices

High-Throughput & Local Offline

Zero Egress & Air-Gapped

Ollama

Fully offline local execution

Groq

LPU Ultra-low latency inference

Together AI

Open weight hosting & finetunes

Fireworks AI

Fast speculative decoding

Any OpenAI-Compatible

vLLM, LocalAI, TGI endpoints

Multi-Model Pipeline Strategy: Use fast models (e.g. gemini-2.5-flash or deepseek-v3) for code scaffolding and frontier reasoning models (e.g. claude-3.7-sonnet or o3-mini) as strict rubric graders.

DevOps & Platform Engineering

What You Can Automate with OpsCode

From SRE incident triage and Kubernetes platform engineering to multi-cloud infrastructure suites, OpsCode delivers battle-tested automation you can govern with confidence.

SRE & OBSERVABILITY

Incident Triage & Automated Runbooks

Diagnose production incidents across Kubernetes clusters, cloud logs, and observability tools. With custom subagents and Prometheus/Datadog MCP servers, OpsCode correlates traces, identifies root causes, and generates remediation runbooks.

Deliverable:Diagnostics Trace + Remediation Runbook

sre-incident-responder + MCP

CONTAINER PLATFORMS

Kubernetes, Helm, & GitOps Delivery

Author hardened Helm charts and ArgoCD applications with Pod Security Standards (Restricted), PodDisruptionBudgets, zero-trust NetworkPolicies, and horizontal autoscaling. Includes automated dry-run linting and recovery loops.

Deliverable:Chart.yaml + values.yaml + ArgoCD Application

k8s-helm-provisioner (5 skills)

CLOUD & IAC

Modular Terraform & OpenTofu Architectures

Generate production-grade Infrastructure as Code with IAM least privilege, multi-AZ VPC topologies, S3/DynamoDB state locking, and KMS key management. Features automated tflint validation loops and Terratest harnesses.

Deliverable:main.tf + variables.tf + outputs.tf

aws-terraform & opentofu subagents

CI/CD & PLATFORM TOOLS

Hardened Pipelines & Custom Platform Skills

Author keyless AWS OIDC GitHub Actions workflows and declarative Jenkins pipelines. In headless CI mode, OpsCode uses autonomous Worker + Grader loops to score generated code against acceptance rubrics before merging.

Deliverable:.github/workflows/*.yml | Jenkinsfile

github-actions-writer + ci-jenkins

Get Started in 60 Seconds

Ready to Bring AI Safety to Your Infrastructure?

Install the lightweight OpsCode CLI binary on Linux, macOS, or Windows (WSL). Zero external runtime dependencies required.

One-Command Installation

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

Quickstart Guide Read the Documentation Star on GitHub