aidevops: An OpenCode Plugin That Tries to Make AI Agents Do the DevOps

The Gap It Fills: From Chat to Coordinated Work

Most AI coding tools are good at a single task but leave the surrounding work to you. You find context, pick a model, protect secrets, manage branches, watch CI, and remember what failed last time. aidevops addresses that coordination problem. It is an OpenCode plugin and framework that adds structure around AI agents so they can work in parallel, share context, and track budget. The README describes the target user as someone who wants AI to do useful work across code, infrastructure, business, marketing, and creative projects without turning each job into a long, fragile chat. This is for people who already use OpenCode and want to push it beyond one-off prompts into longer-running, multi-step missions.

How the Framework Routes Models and Work

The core mechanism is model routing and supervision. The README recommends OpenAI GPT-5.6 with three named roles: Luna for bounded work, Terra for general implementation, and Sol for consequential reasoning and synthesis. Claude models remain as fallbacks. This is not a single agent doing everything. It is a layered system where cheap and fast models handle routine work and stronger models handle judgement and review. The framework also implements what it calls agent design patterns: multi-layer action spaces, context isolation, and iterative execution loops. The practical effect is that a mission like redesigning landing pages gets broken into milestones, dispatched to workers in parallel, validated per milestone, and tracked for budget. The routing is opinionated, which means you trade flexibility for a preset structure.

Pulse Supervision and Domain Agents: The Operational Layer

Two features stand out as the operational spine. Pulse supervision runs scheduled checks that can dispatch workers, merge ready PRs, close loops, and surface stuck work. This is a cron-like mechanism for AI agents. Domain agents give each work area its own guidance: code, automation, product, business, marketing, legal, content, research, SEO, health, reports, and framework work. Each domain gets a specialized prompt or instruction set. The README also mentions cross-model checks, where risky operations get reviewed by a second provider to reduce shared failure modes. That is a concrete safety mechanism, though the README does not specify which operations trigger it or how the second provider is chosen. The value is clear: you get unattended operation and a guard against a single model's blind spots.

Getting Started: Real Commands and Config Keys

Installation is via npm: `npm install -g aidevops && aidevops update`. Then you run `aidevops init` in any project. The entry point is the `aidevops` CLI and the agents file at `~/.aidevops/agents/AGENTS.md`. Key commands include `aidevops update`, `aidevops auto-update` for polling, and `aidevops runtime-bundle list` to see validated runtime bundles, with `rollback --bundle-id <id> --reason <text>` for audited rollbacks. There is also `aidevops gpt56-context [enable|disable|status]`, which keeps GPT-5.6 at a 300K advertised context window in OpenCode, so 80% auto-compaction runs near 240K before long-context pricing. The `status` subcommand verifies plugin discovery, initialization, hook registration, and effective limits. These are the concrete knobs you turn. The README does not show a full config file, so you will need to inspect the generated AGENTS.md after init.

Token Efficiency: The Claim and the Missing Evidence

The README repeatedly stresses token efficiency and budget tracking. The `gpt56-context` command is a real mechanism: it caps the context window so auto-compaction triggers before expensive long-context pricing kicks in. That is a sensible technical lever. However, the README provides no benchmark data, no token counts, and no cost comparisons. The claim that the framework spends model budget deliberately is a design goal, not a measured result. If you are adopting aidevops specifically for cost savings, you have no numbers to validate that. The budget tracking across missions is mentioned, but the README does not describe how budgets are set or enforced. This is a gap. You will need to run your own experiments with real workloads to see if the routing and context limits actually reduce spend.

Limitations and Failure Modes

The framework is opinionated and tightly coupled to OpenCode and specific OpenAI models. If you do not use OpenCode, this is the wrong tool. The README says Claude models are supported fallbacks, but the recommended setup is GPT-5.6, so you may lose routing benefits with other providers. Another limitation is the complexity of the operational layer. Pulse supervision, worktrees, branches, PRs, task IDs, and mailbox state add moving parts. The README acknowledges the system can struggle: stuck workers, orphaned PRs, stale assignments, CI failures, and review-bot traps are listed as things the framework should surface. That implies these are known failure modes. The framework's answer is to make them visible signals, but visibility does not mean automatic resolution. You still need to monitor those signals. Also, the README mentions audited rollbacks and deployment copies, which suggests that bad deployments are a real risk, and the framework's rollback mechanism is a mitigation, not a prevention.

Alternatives: Plain OpenCode and Custom Scripts

The direct alternative is using OpenCode without aidevops, plus your own shell scripts for git worktrees, CI checks, and model selection. That approach gives you full control and no extra dependency, but you lose the built-in routing, pulse supervision, and cross-model checks. Another alternative is a general-purpose automation tool like GitHub Actions or a cron-based bot that runs OpenCode in headless mode. That gives you scheduling but not the domain-specific agent guidance or the budget tracking. The difference is that aidevops embeds the agent design patterns into the workflow, whereas a custom setup requires you to design those patterns yourself. If you already have a working CI/CD pipeline and only need occasional AI help, plain OpenCode is lighter. If you want unattended, multi-step AI projects, aidevops provides a structured layer that custom scripts would take significant time to replicate.

Maintenance, Upgrade, and License Considerations

The project is MIT licensed, which allows commercial use and modification, provided you retain the copyright and license notices. The ATTRIBUTION.md file asks for additional notices if you build a derivative framework or product from the code or operating patterns. That is a copyright notice, not legal advice, so read it before forking. Maintenance appears active: the last push was 2026-08-28, and releases are frequent, with v3.32.293 on that date and v3.32.292 the day before. This suggests rapid iteration, but also a moving target. The `aidevops update` command and `auto-update` polling mean the framework can change under you. The README mentions `runtime-bundle list` and `rollback --bundle-id`, which indicates that updates are validated and rollback is possible. Still, frequent releases mean you should pin versions or test updates in a staging environment. The stack is Bash scripts, TypeScript (Bun), and MCP servers, so you need some comfort with those to debug issues.

Editorial conclusion

Adopt aidevops if you are an OpenCode user who wants to move from single-prompt AI help to structured, multi-agent project work with git worktrees, budget tracking, and cross-model checks. Skip it if you prefer a minimal setup or do not use OpenCode, since the framework is tightly coupled to that runtime and its recommended GPT-5.6 models. Before adopting, verify that the model routing and supervision hooks work with your exact OpenCode version and that the token-efficiency claims hold for your workload, because the README provides no benchmark numbers. The project is MIT licensed, so commercial use is allowed with notice retention, but check ATTRIBUTION.md for derivative-work obligations. The right first step is to run `aidevops init` in a test repository and inspect `~/.aidevops/agents/AGENTS.md` to see what context the agents actually load.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes