# aidevops: an OpenCode plugin for AI DevOps work that survives past one chat

> aidevops is an MIT-licensed AI DevOps framework and OpenCode plugin built from Bash scripts, TypeScript on Bun, and MCP servers. It targets the coordination work around a job: context loading, model routing, secrets, git hygiene, and verification.

**marcusquinn/aidevops** — Vibe-Coding is easy. DevOps is hard. OpenCode & Git token-efficient AI agent automation for your app, business, and personal development. Opinionated tools, services, CLI & API stack for speed, security, and 24/7 results. Open-source first. SOTA everything. Try on your repos for money-making magic.

- Repository: https://github.com/marcusquinn/aidevops
- Website: https://www.aidevops.sh
- Stars: 400 · Forks: 69
- Language: Shell
- License: MIT
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/marcusquinn-aidevops

## The gap aidevops claims: work around the job, not the job

The README states the project is built for the gap between "the model can probably do this" and "the work is actually done, verified, safe, and worth the cost." That framing is the whole pitch. A normal coding agent handles one task well and then leaves you to pick the model, find the context, guard the credentials, manage the branch, watch CI, and remember what broke last time.

aidevops is aimed at people who run several of those loops at once. The README lists its audience indirectly through domain agents: code, automation, product, business, marketing, legal, content, research, SEO, health, reports and framework work each get their own guidance. That is a wide net. A solo developer shipping a side project and a small team running client infrastructure are both plausible users, but the second group is where the service coverage (hosting, DNS, monitoring, deployment, payments) starts to matter.

The stated recommendation is OpenCode plus OpenAI GPT-5.6 models, with Claude models described as fully supported fallbacks. That is an opinionated default, not a neutral one, and it means the framework's routing behaviour is tuned around a specific provider family first.

## How routing, worktrees and the pulse loop fit together

The mechanism visible in the README is a three-tier model router. aidevops routes Luna to bounded work, Terra to general implementation, and Sol to consequential reasoning and synthesis. The point is deliberate token spend: cheap and fast models take routine work, stronger models take judgement and review. Whether that split holds up on your tasks is something you would have to measure yourself; the README asserts the intent, not a benchmark.

Around that sits the supervision layer. The README describes pulse supervision as scheduled checks that can dispatch workers, merge ready PRs, close loops, and surface stuck work. Isolation comes from worktrees, branches, PRs, task IDs, mailbox state and memory, so parallel agents do not overwrite each other. Cross-model checks let risky operations be reviewed by a second provider, which is a reasonable way to reduce shared failure modes, though it also means one operation can consume budget on two providers.

The repository layout backs this up: .opencode/ holds the server and tooling, .agents/ holds agent definitions, and packages/ contains four Bun workspaces (gui-shared, gui-api, gui-web, gui-desktop). The stack is Bash for the CLI surface, TypeScript on Bun for the servers, plus MCP servers. That is a lot of moving parts for a framework that installs as one npm package, and it is the main reason the setup steps below matter.

## Installing aidevops and running a first command

The README gives the install line directly: a global npm install followed by the framework's own update command. Run both, because the second pulls the framework payload that the npm package bootstraps.

```bash
npm install -g aidevops && aidevops update
```

After that, initialise the framework inside a project. The README lists this as the entry point for any repository.

```bash
aidevops init
```

The framework writes its agent entry point to ~/.aidevops/agents/AGENTS.md, so expect files outside your project directory. If you want to confirm the CLI resolved before touching a real repository, the README documents a status subcommand for the GPT-5.6 context setting, which checks plugin discovery, initialization, hook registration and effective limits:

```bash
aidevops gpt56-context status
```

That command is the closest thing to a health check in the documented command list, and it is worth running first because it reports whether the plugin was actually discovered by OpenCode. If it reports nothing useful, the integration is not wired up and later commands will fail for reasons that look unrelated.

For a first real task, the README's own example is a mission: scope a redesign, break it into milestones, dispatch workers in parallel, validate each milestone, and track budget across the project. Start smaller. Pick one repository, one bounded change, and let the router assign a model before you hand it a multi-milestone mission.

## Where aidevops will frustrate you

The Python side is the sharpest edge. requirements.txt pins every version with ==, and the comment explains why: a March 2026 LiteLLM supply chain incident where compromised v1.82.7 and v1.82.8 contained credential stealers. The file also carries an unresolved note that dspy resolves diskcache transitively and no patched diskcache release is available yet, so the project keeps the audited transitive pin in requirements-lock.txt rather than a direct application pin. That is honest, and it is also a dependency you cannot fix from your side.

The install surface is heavier than the one-line npm command suggests. package.json defines a setup script that runs setup:bun (bun install --frozen-lockfile --ignore-scripts) and install:python, which creates a virtualenv at python-env/dspy-env and installs requirements.txt. The frozen lockfile and --ignore-scripts flags are deliberate supply chain hardening, but they also mean an out-of-date lockfile fails the install rather than resolving around the problem.

Scope is the other mismatch. If you want a coding assistant that edits files in one repository, this is the wrong tool. The framework's value sits in the coordination, service coverage and supervision layers, and those only pay off when you have ongoing work across more than one project. A single-repo, single-task workflow gets the dependency weight without the routing benefit. The README also does not document what happens on a partial failure of a mission, so plan for manual recovery on the first few runs.

## How this differs from a general coding agent like Aider

Aider is a terminal coding assistant: you point it at a repository, it edits files and commits. The unit of work is the change. aidevops treats the change as one step inside a larger loop, and its documented commands are about the loop rather than the edit: aidevops init, aidevops update, aidevops auto-update for polling, aidevops runtime-bundle list for retained validated runtime bundles, and aidevops buzz for inspecting or applying something the README truncates before explaining.

The practical difference shows up in two places. First, model selection: Aider leaves the choice to you per session, while aidevops routes by task class through Luna, Terra and Sol. Second, state: aidevops keeps mailbox state, task IDs, memory and worktrees so multiple workers can run without colliding. If you have never needed parallel agents on one repository, that machinery is overhead. If you have, it is the part you were building by hand.

The update path is also more developed here. The README documents runtime-bundle list plus a rollback subcommand taking --bundle-id and --reason, described as an explicit audited rollback. A plain coding agent has no equivalent; you pin a version and reinstall.

## Versioning, licence and what an upgrade actually costs

Releases are frequent and granular. The three most recent are v3.32.293 on 2026-08-28, v3.32.292 on 2026-08-27 and v3.32.291 on 2026-08-26, and package.json carries 3.32.368. The last push to the repository was on 2026-08-28. That cadence means the framework is being changed continuously, and it means an update can land mid-project.

The mitigation the README documents is the runtime bundle path: aidevops runtime-bundle list shows retained validated runtime bundles, and rollback --bundle-id <id> --reason <text> performs an explicit audited rollback. The --reason argument is not decoration; it is what makes the rollback auditable later. If you enable aidevops auto-update, you are opting into polling, and the bundle list is your recovery surface when a poll brings in something that breaks your workflow.

Licensing is MIT, stated in the README and in the SPDX headers at the top of the source files. Reuse is permitted, including commercial use, provided copyright and license notices are retained. The README points to ATTRIBUTION.md for notices and preferred credit text if you build a derivative framework, automation bot, workflow library or commercial product from the code or its distinctive operating patterns. That is a request rather than an MIT condition, but it is the project's stated expectation, and a derivative product that ignores it is relying on a distinction a lawyer would need to draw. Nothing here is legal advice.

## Conclusion

Adopt aidevops if you already run OpenCode and want the coordination layer around agent work: model routing, worktrees, secret handling and audited rollbacks. Skip it if you want a single-purpose coding assistant, or if you are unwilling to have the framework write into ~/.aidevops/ and your project. Verify first that your Bun and Node versions satisfy package.json, that the pinned requirements.txt resolves in your environment, and that the runtime-bundle rollback path works before you rely on an update.

## FAQ

### What is aidevops?

It is an OpenCode plugin and AI DevOps framework that puts structure around agent work: context loading, model routing, secret handling, git hygiene, verification and memory. The README describes it as built for the gap between a model being able to do something and the work actually being done, verified and safe.

### How do I install aidevops?

The README gives the install as npm install -g aidevops && aidevops update, followed by aidevops init inside a project. The Python side is installed separately through the package.json setup script, which creates python-env/dspy-env and installs the pinned requirements.txt.

### Which is better, Aider or OpenCode?

The README does not compare them, so this cannot be answered from what the project documents. What it does say is that aidevops is an OpenCode plugin and that the recommended setup is OpenCode with OpenAI GPT-5.6 models, with Claude models as supported fallbacks.

### What does the aidevops model routing actually do?

It routes Luna to bounded work, Terra to general implementation, and Sol to consequential reasoning and synthesis. The stated goal is deliberate token and budget spend, with cheap models on routine work and stronger models on judgement and review.

### Can I roll back an aidevops update?

The README documents aidevops runtime-bundle list to show retained validated runtime bundles and a rollback subcommand taking --bundle-id and --reason for an explicit audited rollback. The reason text is what makes the rollback auditable afterwards.

### Is aidevops free to use commercially?

It is MIT licensed, and the README states reuse is welcome including commercial use, provided copyright and license notices are retained. It also points to ATTRIBUTION.md for required notices and preferred credit text if you build a derivative framework or product from the code.

## Sources

- [Official documentation](https://www.aidevops.sh)
- [Official README](https://github.com/marcusquinn/aidevops#readme)
- [Project repository](https://github.com/marcusquinn/aidevops)
- [Release notes](https://github.com/marcusquinn/aidevops/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/marcusquinn-aidevops