Skip to main content
plugin CX Codex

agentops — Claude Code plugin: what it does, how to install

agentops is a plugin for Claude Code and Codex that provides engineering practices and skills for coding agents to plan tasks via BDD, test code, and preserve context across sessions.

Apache-2.0 ★ 1,596 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install agentops@awesome-codex-plugins
Open on GitHub

What agentops does

The plugin introduces software delivery discipline into agentic coding. Instead of uncontrolled code edits, the agent follows defined paths from requirement definition to automated verification. Every skill is stored as a Markdown file. You can adjust the instructions directly.

The bundle provides dedicated skills such as Plan for behavior-driven expectations, plus Test and Validate for code checks. With Memory and Beads, the agent records decisions and context into a searchable graph. Next sessions read that history instead of restarting from scratch.

Running this plugin alongside an npx installation will duplicate every skill in your environment.

What it helps with

  • Define expected software behavior through BDD before modifying code
  • Reproduce incoming bug reports and create self-contained task briefs
  • Compare architectural designs by analyzing resulting call sites
  • Preserve a decision graph and project memory across agent sessions

Example prompts for the agent

  • /agentops:plan Clarify behavior scenarios for payment retries
  • /agentops:triage Reproduce the bug described in the latest report
  • /agentops:memory Save our architectural decision into project history

How to install agentops

Plugin marketplace

/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install agentops@awesome-codex-plugins

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about agentops

How to install agentops in Claude Code?

First, register the marketplace source with /plugin marketplace add hashgraph-online/awesome-codex-plugins. Then install the plugin using /plugin install agentops@awesome-codex-plugins.

What does agentops do?

It applies software engineering practices to agent sessions. The plugin guides task planning with BDD, adds automated test gates, and stores decisions between runs.

What components are included in the bundle?

The bundle provides Markdown-based skill instructions, four dedicated subagents, and tool-call admission hooks.

Source text

agentops · Apache-2.0
<div align="center">

<img src="docs/assets/logo.svg" alt="AgentOps" width="72" height="72">

# AgentOps

**DevOps discipline for AI coding agents.**

[![Validate](https://github.com/boshu2/agentops/actions/workflows/validate.yml/badge.svg?branch=main)](https://github.com/boshu2/agentops/actions/workflows/validate.yml)
[![License: Apache-2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
[![Latest release](https://img.shields.io/github/v/release/boshu2/agentops)](https://github.com/boshu2/agentops/releases/latest)
[![Skills](https://img.shields.io/badge/skills-catalog-black.svg)](docs/SKILL-ROUTER.md)

[Install](#quickstart) · [The loop](#the-operational-loop) ·
[Goals](#goals) · [Try it](#try-it) · [Skills](#skills-at-a-glance) ·
[Make it yours](#make-it-yours) · [Evidence](#evidence) ·
[Beyond AgentOps](#beyond-agentops)

</div>

DevOps makes software delivery repeatable through shared practices, automated
checks and feedback. AgentOps brings that discipline to agentic coding sessions:
paved paths your agents can follow from intent to checked results, with memory
to carry useful context into the next task.

Those paths combine [skills](docs/SKILL-ROUTER.md) with the [`ao` CLI](#optional-ao-cli)
and your existing engineering tools. [Plan](skills/plan/SKILL.md) clarifies the
expected behavior; [Test](skills/test/SKILL.md) helps check it;
[Validate](skills/validate/SKILL.md) adds independent judgment where needed.
Skills guide the agent's decisions; executable gates check specific contracts.
[Beads](https://github.com/gastownhall/beads) preserves the work graph, decisions,
results and project memories. [Memory](skills/memory/SKILL.md) curates supported
findings into linked project knowledge, connecting lessons to the work and
sources behind them. The next session can use that record instead of starting over.

The skills are a kit, and you are expected to change it. Each skill is one
Markdown file of instructions. Keep the ones that fit how you work, rewrite the
ones that almost fit, delete the rest, and add skills you write yourself or find
in other libraries. What you end up with is your own operating model for agents,
which is the reason this project exists. [Make it yours](#make-it-yours) shows
how.

Use these paths with Claude Code, Codex, Cursor, OpenCode, Gemini CLI, Pi and
other coding agents, or personal assistants such as OpenClaw and Grok Bot.
Start with [one useful task](#try-it); follow the [operational loop](#the-operational-loop)
for a change or the [goal workflow](#goals) for work across sessions. When you
need a larger software factory, [extend the same practices](#beyond-agentops)
with Gas City or tools from the Agentic Coding Flywheel.

<a id="why-these-skills-exist"></a>

## Why use AgentOps?

A [software factory](https://learn.microsoft.com/en-us/archive/msdn-magazine/2006/december/service-station-web-service-software-factory)
makes engineering practices reusable through tools, guidance and repeatable
workflows. AgentOps brings that approach into the coding session: clear intent,
automated checks, recorded decisions and a feedback loop into later work. Pick
the path your task needs and use the same practices when you change agents.

[Behavior-driven development (BDD)](https://dannorth.net/introducing-bdd/)
starts by agreeing on what the software should do in a concrete situation.
For retries, that could mean: “If a completed job arrives again, return its
result and charge the customer only once.” The same behavior guides the
implementation, its tests and any review. [Plan](skills/plan/SKILL.md) helps you
settle those expectations before the agent starts editing.

| When you need to… | AgentOps adds |
|---|---|
| Decide what to do with an incoming report | [Triage](skills/triage/SKILL.md) reproduces a bug report, external PR or alert, checks for duplicates and earlier decisions, and recommends an outcome with the evidence behind it. Accepted work gets a brief an agent can act on without the original conversation. |
| Get the agent to build what you meant | [Plan](skills/plan/SKILL.md) makes the expected behavior clear enough to implement and test. [Domain](skills/domain/SKILL.md) keeps the same names for concepts in the request, code and tests. |
| Fix a design that makes every change expensive | [Architecture](skills/architecture/SKILL.md) finds where the structure makes change costly and compares at least two interface designs by the call sites they produce. [Refactor](skills/refactor/SKILL.md) then makes the chosen change without changing behavior. |
| Build a tool that agents can use | [Ergonomics](skills/ergonomics/SKILL.md) checks whether an agent can find a CLI, API or MCP tool, read its output and recover from its errors, with the exact command and output behind each finding. |
| Keep a project moving after the chat ends | [Interview](skills/interview/SKILL.md) settles a large goal with you. [Beads](https://github.com/gastownhall/beads) preserves its intent, decisions and results in a searchable work graph, with persistent project memories for later sessions. [Navigate](skills/navigate/SKILL.md) identifies ready work, blockers and gaps in the goal. |
| Check whether the finished change meets the request | [Test](skills/test/SKILL.md) helps write checks for the intended behavior. Ordinary changes finish on checks and CI; [Validate](skills/validate/SKILL.md) adds one fresh review when requested, hard to undo, or uncovered by a deterministic check. |
| Turn earlier work into useful context | [Research](skills/research/SKILL.md) traces the code and cites what it finds. [Memory](skills/memory/SKILL.md) can draw on Beads handoffs, Git changes and check results to explain a decision in a report, or curate supported lessons into reviewed project documents. Later agents can recall the lesson and follow its sources. |
| Make a useful method repeatable | [Skill Builder](skills/skill-builder/SKILL.md) turns supported expertise into guidance with clear inputs, actions and limits. [Skill Eval](skills/skill-eval/SKILL.md) measures whether that guidance helps a named task, so it can be retained, revised or removed. |

<a id="install"></a>

## Quickstart

Pick one method per agent: a plugin plus npx on the same agent gives you every
skill twice.

<details>
<summary><strong>Claude Code</strong></summary>

<a id="claude-code"></a>

```bash
claude plugin marketplace add boshu2/agentops
claude plugin install agentops@agentops-marketplace
claude plugin details agentops@agentops-marketplace
```

Check that `agentops` appears in the plugin inventory. The bundle includes
skills, four agents and [tool-call guards](#optional-admission-control-hooks).

</details>

<details>
<summary><strong>Codex</strong></summary>

<a id="codex"></a>

```bash
codex plugin marketplace add boshu2/agentops
codex plugin add agentops@agentops-marketplace
codex plugin list --json
```

Check that `agentops` appears in the inventory. Skills use the `agentops:` prefix;
custom roles and read limits have [separate setup](docs/install-day2-ops.md#install-and-update-runtime-plugins).

</details>

<details>
<summary><strong>Everything else</strong> (Cursor, OpenCode, Gemini CLI, Pi, OpenClaw, Grok Bot)</summary>

<a id="everything-else"></a>

With Node.js installed, run from your project directory, then pick your agents
and skills:

```bash
npx skills@latest add boshu2/agentops
```

Add `-g` for a user-level install. In scripts, name the agents:
`npx skills@latest add boshu2/agentops -g -a cursor opencode -y`
(`-y` without `-a` can install into every agent the installer knows).
Installer targets include `cursor`, `opencode`, `gemini-cli`, `antigravity`,
`pi`, `grok` (Grok Build) and `openclaw`. Grok Bot has no installer target; add
the same `SKILL.md` folders through [its skill settings](https://docs.x.ai/grok-bot/skills-routines-and-automations).
Some skills need extra tools ([install guide](docs/install-day2-ops.md)); what
each host has been tested for is in [host coverage and limits](docs/contracts/multi-runtime-tier-charter.md#host-and-install-surface-mapping).

</details>

Start a new session so the skills load. Most skills need only your coding
agent; a few use the [`ao` CLI](#optional-ao-cli) when it is installed. Invocation names
vary by agent: this README shows Claude Code's `/agentops:<skill>`; Codex uses
`$agentops:<skill>`.

<a id="workflow"></a>

## The operational loop

Each change is shaped, built and checked. Use one fresh review when requested,
when a mistake cannot be cheaply undone, or when no deterministic check covers
the changed behavior. You (or Plan) write intent as
behavior ([BDD](https://dannorth.net/introducing-bdd/)), using one word per
concept ([DDD](https://martinfowler.com/bliki/DomainDrivenDesign.html)'s
[ubiquitous language](https://martinfowler.com/bliki/UbiquitousLanguage.html)).
For a system that calls queued work a **Job**, in [Gherkin](https://cucumber.io/docs/gherkin/reference/):

```gherkin
Feature: Job redelivery is idempotent
  A Job is one unit of queued work. Delivering it again never repeats its side effect.

  Scenario: A completed Job is delivered again
    Given Job "J-42" completed and charged the customer $20
    When the worker receives Job "J-42" again
    Then it returns the completed result of "J-42"
    And the customer has been charged $20 exactly once

  Scenario: A Job that failed before charging is delivered again
    Given Job "J-43" failed before charging the customer $20
    When the worker receives Job "J-43" again
    Then Job "J-43" completes
    And the customer has been charged $20 exactly once
```

The feature defines the domain term once; each scenario has concrete data, one
action and an observable result. Keep scenarios in the issue or conversation;
no `.feature` file is required.

<p align="center">
  <img src="docs/assets/agentops-routes.svg" alt="Clear accepted intent goes straight to Implement; unclear intent goes to Plan first. Implement runs native checks and CI. Ordinary changes finish on those checks. Use one fresh author-distinct review when requested, when a mistake cannot be cheaply undone, or when no deterministic check covers the changed behavior. An existing change can enter at review. Repair findings within scope and confirm with affected checks; another review requires a caller request. NOT_PROVEN reports missing evidence without claiming PASS. The optional learning loop sends a result to a protected draft, fresh support and disclosure review, reviewed .context/ pages, and later work." width="100%">
</p>

| Step | Skill | What it does with the scenarios |
|---|---|---|
| Shape | [`plan`](skills/plan/SKILL.md) | Turns the request into scenarios for one small change. Skip it when intent is clear. |
| Build | [`implement`](skills/implement/SKILL.md) | Makes the change and tests both scenarios. |
| Judge when needed | [`validate`](skills/validate/SKILL.md) | A new session that didn't write it returns `PASS`, `FAIL` or `NOT_PROVEN` against the same scenarios. |
| Learn | [`memory`](skills/memory/SKILL.md) | Optional: reviewed `.context/` pages that later work can query. |

Enter at the step you need. An existing change can enter at Validate when an
acceptance judgment is needed. Ordinary changes finish on checks and CI. Review
is one round: repair findings and confirm with affected checks; review again only
when you ask. Report `NOT_PROVEN` with its gaps. The author cannot issue its own
`PASS`. Merging and releasing follow your repo's rules.

<a id="goals-many-rpis-over-a-bead-graph"></a>

## Goals

[`rpi`](skills/rpi/SKILL.md) runs Plan → Implement → checks, with Validate where a
mistake is costly, for one outcome
without check-ins (your agent's permission prompts still apply) and stops at
acceptance, a blocker or a spent limit. Bigger work becomes a goal (it
needs Beads: `brew install beads`, then `bd init` in your repo):

1. **[Interview](skills/interview/SKILL.md).** One question at a time, each with
   a recommended answer. You settle the outcome, its examples, domain terms,
   non-goals, authority and budget before agents go autonomous.
2. **[Craft Goal](skills/craft-goal/SKILL.md).** Returns `SAFE_TO_CREATE` plus a
   prompt to paste into `/goal` (Claude Code or Codex), `USE_RPI` (small enough
   for `rpi`), or `UNSAFE_GOAL` plus what's undecided. It creates nothing itself.
3. **[Navigate](skills/navigate/SKILL.md) each round.** Picks a few ready work
   items (beads); each gets one RPI, checks and CI, with one fresh Validate
   when requested, hard to undo, or uncovered by a deterministic check. The goal ends
   `ACHIEVED`, `NOT_ACHIEVED` or `NEEDS_OPERATOR`.

<p align="center">
  <img src="docs/assets/agentops-goal-graph.svg" alt="A goal observes the Beads work graph, picks ready beads, consumes checks and any verdicts, then ratchets or stops. Each bead gets one RPI: Plan when unclear, Implement, and checks. When delegation is authorized, each fresh worker starts with one bead. Validate runs in a separate fresh context only when requested, when a mistake is hard to undo, or when no deterministic check covers the change. Results and notes return to the bead." width="100%">
</p>

**Beads remembers the work.** [Beads](https://github.com/gastownhall/beads) (`bd`)
keeps the goal and its history outside any conversation. The root epic holds
acceptance; child beads carry the scoped work, design decisions, handoffs and
result notes. Record which checks ran and link any review evidence to the same
bead. That connects the original intent to the checked output, so the next
session can continue from the record instead of reconstructing the chat.
`bd ready` finds unblocked work; search and history help explain earlier choices.

Beads also has a [persistent memory store](https://github.com/gastownhall/beads/blob/main/docs/cli-reference/remember.md).
`bd remember` saves project facts, `bd memories` searches them, `bd recall`
retrieves one by key, and `bd prime` brings stored memories into session context.
The work graph and the memory store serve different needs: one preserves what
happened; the other keeps selected facts easy to find again.

[Memory](skills/memory/SKILL.md) helps you use that material: recall relevant
context, examine recorded decisions and outcomes, or draft a report with links
to its evidence. When you want a reusable project document, it curates supported
findings into reviewed `.context/` pages or an external document bundle. Beads
keeps the work record; Git and the original evidence locations keep the code and
check artifacts. Reusable documents link back to those sources.

```bash
bd search "redelivery" --status all     # include finished work
bd show <bead-id>                        # intent, notes and relationships
bd history <bead-id>                     # how the record changed
bd remember "Redelivery returns the stored Job result" --key job-redelivery
bd recall job-redelivery                # retrieve the saved project fact
```

**One bead per worker.** When the goal delegates, the orchestrator holds the
graph and results, and each worker starts with one bead instead of the
orchestrator's transcript. Reviewers, when needed, start fresh.

```bash
bd create "Job redelivery is idempotent" -t epic
bd create "Return the completed result on redelivery" --parent <epic-id>
bd dep add <later-id> <earlier-id>         # real ordering only
bd ready --parent <epic-id>                # the frontier
```

Navigate shows `bd` commands; another tracker with status, dependencies and
notes works if you map them. AgentOps never builds a second work index.

## Try it

Start read-only in any repo, then swap the Job example for your own change.

```text
# First look (changes nothing)
/agentops:research how does this repo validate input? cite files and lines, change nothing

# One change
/agentops:plan make Job redelivery return the completed result without repeating the side effect
/agentops:implement
/agentops:validate     # when requested, hard to undo, or uncovered by checks; use a new session

# One outcome, end to end
/agentops:rpi make Job redelivery return the completed result without repeating the side effect

# A goal
/agentops:interview make the job worker safe under redelivery, retries and crash recovery
/agentops:craft-goal   # then paste its prompt into /goal
```

<a id="how-independent-review-works"></a>

<details>
<summary><strong>Validate an existing change</strong></summary>

Pick a finished change whose accepted behavior is recorded in an issue or
conversation. Run the required checks and keep the candidate unchanged.
[Installing `ao`](#optional-ao-cli) is optional; it gives Validate a content
manifest for the change. Then open a **new conversation**, fill in the
references and paste:

```text
Use the AgentOps Validate skill to judge this finished change.
Original accepted behavior: [issue link or original request text]
Candidate: [commit, branch or working tree; list every changed path]
Author context ID: [task/session ID that made the change]
Checks run: [commands and results]
I opened this new conversation for fresh review. Derive the exact subject
identity at the start and end, inspect every changed path against the original
behavior, and do not modify the candidate. Report PASS, FAIL or NOT_PROVEN with
evidence for each criterion, checked, not_checked, author and reviewer context
IDs, and freshness attestation.
```

`PASS` needs evidence for every criterion and an empty `not_checked`. `FAIL`
names failed behavior or an out-of-scope change. Missing proof, identity or
path coverage is `NOT_PROVEN`.

</details>

<a id="try-one-task"></a>

<details>
<summary><strong>Read-only skill-loading smoke test</strong></summary>

Paste this in an agent conversation in your project. It needs no `ao` CLI.

```text
Use the AgentOps Research skill to trace how this repository validates user
input. Follow one path from the input through its checks and tests. Cite the
files and line numbers, explain one edge case, and identify missing coverage.
Name the Research skill file you loaded. Answer here without changing files.
```

The reported skill path catches missing or duplicate installs. Invoke Research
directly with `/agentops:research` in Claude Code, `$agentops:research` in
Codex, or `/` and the installed Research entry in Cursor.

</details>

<a id="choose-skills-by-the-work"></a>

## Skills at a glance

All skills are optional. Load one when it answers a specific question. Full
catalog: **[docs/SKILL-ROUTER.md](docs/SKILL-ROUTER.md)**.

| Group | Skills | What it covers |
|---|---|---|
| Operational loop | [`plan`](skills/plan/SKILL.md) [`implement`](skills/implement/SKILL.md) [`validate`](skills/validate/SKILL.md) | Shape and build a change; judge it where a mistake is costly |
| Autonomous | [`rpi`](skills/rpi/SKILL.md) | One outcome, end to end |
| Goals | [`interview`](skills/interview/SKILL.md) [`craft-goal`](skills/craft-goal/SKILL.md) [`navigate`](skills/navigate/SKILL.md) | Shape, write and walk a goal over the bead graph |
| Coordination | [`orchestrate`](skills/orchestrate/SKILL.md) [`agent-native`](skills/agent-native/SKILL.md) | Fresh workers per bead, disjoint scopes, integration |
| On demand | [`research`](skills/research/SKILL.md) [`domain`](skills/domain/SKILL.md) [`test`](skills/test/SKILL.md) [`refactor`](skills/refactor/SKILL.md) [`review`](skills/review/SKILL.md) [`security`](skills/security/SKILL.md) [`doc`](skills/doc/SKILL.md) [`reverse-engineer`](skills/reverse-engineer/SKILL.md) [`triage`](skills/triage/SKILL.md) [`architecture`](skills/architecture/SKILL.md) [`ergonomics`](skills/ergonomics/SKILL.md) | Reached for when a specific question comes up |
| Learning | [`memory`](skills/memory/SKILL.md) | Curated `.context/` pages safe to commit |
| Judgment strategies | [`council`](skills/council/SKILL.md) [`premortem`](skills/premortem/SKILL.md) [`postmortem`](skills/postmortem/SKILL.md) [`idea-genie`](skills/idea-genie/SKILL.md) | Multi-model councils (debates, idea duels, interview panels), idea brainstorms, plan challenges and postmortems |
| Runtimes and factories | [`codex-exec`](skills/codex-exec/SKILL.md) [`claude-exec`](skills/claude-exec/SKILL.md) [`agy-native`](skills/agy-native/SKILL.md) [`using-gc`](skills/using-gc/SKILL.md) | Selected executors and Gas City integration |
| Skill craft | [`skill-builder`](skills/skill-builder/SKILL.md) [`skill-eval`](skills/skill-eval/SKILL.md) | Author skills and measure whether they help |

## Make it yours

Every skill here is a folder with one `SKILL.md`: plain instructions an agent
loads when a task calls for them. No skill depends on the full set, and coding
with none of them still works. That makes the library easy to take apart, and
you should. The 31 skills are a starting point for an operating model that fits
your work.

- **Start small.** Install two or three skills that match work you already do.
  Add another when a real task asks for it.
- **Cut what you override.** If you or the agent keep ignoring a rule, change
  the rule or remove the skill. `npx skills` lets you pick skills per agent, and
  [`ao skills link --skill <name>`](docs/install-day2-ops.md#install-source-checkout)
  links an exact subset from a checkout.
- **Rewrite what almost fits.** Fork this repository, edit the `SKILL.md` and
  install from your fork with the same commands, or link a checkout so every
  agent on your machine reads your edits. A plugin update replaces the installed
  copy, so keep your changes in a repository you control.
- **Write your own.** When you have explained the same thing to an agent three
  times, it is a skill. [Skill Builder](skills/skill-builder/SKILL.md) drafts the
  package, and tells you when a note in an existing file is enough.
- **Mix libraries.** Run these next to your company's skills, the
  [Agentic Coding Flywheel](#agentic-coding-flywheel) tools or any other
  library. `ao skills link` never replaces a skill it did not install.
- **Change the workflows too.** The [operational loop](#the-operational-loop)
  and the [goal workflow](#goals) are defaults. Skip the steps your work does
  not need, reorder them, or write your own.
- **Measure what you change.** `claude plugin eval` compares an agent with and
  without a plugin on the same request. To measure one edit, run the old and
  the new version as two plugins. [Skill Eval](skills/skill-eval/SKILL.md)
  covers how to read the result, and [Evidence](#evidence) shows the cases this
  repository runs; copy them for your own skills.

## Evidence

A skill is a page of instructions, so the test is whether an agent does anything
differently with it installed. AgentOps runs that test on Claude Code's own
evaluator, `claude plugin eval`: one realistic request per skill, graded against
four or five criteria taken from the practice the skill teaches. For Test, one
criterion is that a regression test is shown failing without the fix.

On Claude Opus 5.5, measured 2026-10-22 and 2026-10-23 over five rounds; the
3.10 column is the stored 2026-10-05 result:

| | No plugin | AgentOps 3.10 | AgentOps 3.11 |
|---|---:|---:|---:|
| Practice criteria met on 29 requests | 265 of 387 (68%) | 363 of 387 (94%) | 704 of 774 (91%) |
| Matching skill loaded on its own request | | 62 of 75 runs | 104 of 150 runs |

Sixteen of the 32 skills moved their case by 0.15 or more. Claude Exec, Skill
Builder, Plan, Craft Goal and Using GC gained the most. Seven cases had no room
to move: the agent met every criterion with no plugin.

Read the limits before you quote these numbers:

- One request per skill, six runs with 3.11, three with 3.10 and three
  without, one model. A difference under 0.15 is noise.
- The criteria come from each skill's own rules. A pass shows the rule landed on
  that request. It says nothing about the outcome of a real task, and an earlier
  [coding pilot](PRODUCT.md#evidence-and-claim-limits) found no end-to-end
  difference.
- Loading is the weak point. 3.11 loads its skills less often than 3.10 did,
  and Implement and Research never load on their own. Four tested causes do not
  explain it. Name the skill when you want its rules applied: RPI, Postmortem,
  Interview and Craft Goal loaded on 22 of 24 requests that named them.

The [full report](docs/evals/2026-10-22-plugin-eval-opus-5-5.md) has every case,
each round's rule and result, and what was rerun. The cases live in
[`evals/plugin-eval/`](evals/plugin-eval/README.md): run them against your own
changes, or copy the layout to test your own skills.

## Where AgentOps fits

AgentOps grew from applying DevOps experience and established engineering
practice to agents. The [Practice Registry](PRACTICE-REGISTRY.md) records the
lineage; [how it works](docs/how-it-works.md) covers responsibilities.

<details>
<summary>Compare libraries, trackers and agent factories</summary>

| Project or tool | Role alongside AgentOps |
|---|---|
| [Compound Engineering](https://github.com/EveryInc/compound-engineering-plugin) | A connected development workflow and reusable solution records |
| [Matt Pocock's skills](https://github.com/mattpocock/skills) | Composable practices for intent, domain modeling, TDD and review |
| [Beads](https://github.com/gastownhall/beads) or your existing tracker | Owns work status, dependencies and handoffs |
| Factories such as [Gas City](skills/using-gc/SKILL.md) | Own agent coordination and execution through their native control plane |

Choose which workflow leads the task. Carry accepted behavior and evidence
into checks, and into [independent judgment](skills/validate/SKILL.md) where a
mistake would be costly. Shared practices are not
proof that every combination has been tested.

</details>

<a id="optional-ao-cli"></a>

## `ao` CLI (optional)

Most skills need only your coding agent. With `ao` installed, Validate binds
the exact change it judges to a content manifest; without it, Validate names
the commit and the changed paths.

```bash
brew tap boshu2/agentops
brew trust --tap boshu2/agentops
brew install agentops
ao version
```

With Go installed: `go install github.com/boshu2/agentops/cli/cmd/ao@latest`.
`ao init` is optional evidence setup; `ao config --show` inspects configuration;
`ao gate check` runs this repository's own gates (mainly for contributors). See the [command reference](cli/docs/COMMANDS.md) and
[installation guide](docs/install-day2-ops.md).

## Updating and advanced setup

<details>
<summary><strong>Upgrading to 3.11</strong></summary>

<a id="upgrading-to-311"></a>
<a id="upgrading-to-310"></a>
<a id="upgrading-to-39"></a>
<a id="upgrading-to-38"></a>
<a id="upgrading-to-37"></a>

Version 3.11 keeps every 3.10 command and skill name. It adds
[`triage`](skills/triage/SKILL.md), [`architecture`](skills/architecture/SKILL.md)
and [`ergonomics`](skills/ergonomics/SKILL.md), and folds methods from other
public skill libraries into 27 skills; none of that is measured yet.
Read the [3.11 release notes](docs/releases/2026-10-22-v3.11.0-notes.md). Use the
[plugin update instructions](docs/install-day2-ops.md#install-and-update-runtime-plugins)
or, for npx installs, `npx skills@latest update` ([update notes](docs/install-day2-ops.md#update)).
For Homebrew: `brew update && brew upgrade agentops`. In a source checkout, run
`git pull --ff-only`, then rerun `ao skills link` with the selectors you used
before, adding `--skill triage --skill architecture --skill ergonomics` for the
new skills; without selectors it links every skill. Start a new session
afterward; new installs do not silently remove obsolete copies.

**Upgrading from 3.8 or earlier:** version 3.9 removed ten bundled external tool
skills, retired three delivery workflows, deleted the old curl installers and
changed the Codex plugin to read `skills/` directly. Read the
[3.9 release notes](https://github.com/boshu2/agentops/releases/tag/v3.9.0) first.

**Upgrading from 3.6 or earlier:** read the [migration guide](docs/MIGRATION.md).
Version 3.7 removed commands and skill names, including `learn`, `codebase-recon`
and `swarm`; their current owners are `memory`, `research` and `agent-native`.
See the [3.7 release notes](https://github.com/boshu2/agentops/releases/tag/v3.7.0).

</details>

<details>
<summary><strong>Skill dependencies</strong></summary>

<a id="other-installation-paths"></a>

Skill installation does not install tool dependencies:

| Skill | Needs | Why |
|---|---|---|
| `rpi` | `ao`, conditional | delegates exact-subject checks to Validate; only persists `verdict.v2` when requested |
| `plan` | `ao`, conditional | runs `ao provenance snapshot-intent` with an explicit evidence root when the intent source is not durable |
| `implement` | `ao`, conditional | at an integration boundary whose changed paths affect bound evidence, runs `ao provenance evidence-orphans` |
| `validate` | `ao`, optional | with `ao`, derives exact subject identity from a content manifest and uses `ao provenance store-verdict` when persistence is requested; without it, names the commit and changed paths |
| `council` | `ao`, optional | with `ao`, `subject_digest` is the `canonical_manifest_digest` from `ao provenance manifest`; without it, a sha256 over the subject's repo-relative files or its text |
| `research` | `ao`, conditional | inspect selected goal measurements with `ao goals` or evidence-store facts with `ao status` |
| `using-gc` | `ao` | rig prep runs `ao gc prepare` and `ao gc check` |
| `doc` | `ao`, optional | a requested continuity handoff may use `ao session handoff`/`rehydrate` |
| `reverse-engineer` | `python3` | Phase 1's mechanical teardown runs `scripts/reverse_engineer.py` |
| `skill-builder` | `ao` 3.9 or later outside a source checkout, Go inside one; `python3`, conditional | build, check, heal and audit run through `ao skills`; build (any mode) and heal's fix mode refuse with exit 2 outside an AgentOps source checkout (no `scripts/generate-skill-mesh.py`, as in...

© hashgraph-online · Apache-2.0 · hashgraph-online/awesome-codex-plugins

Similar plugins

All plugins for Agent setup: memory, context, orchestration →

From the same set391

The whole set →
ai-sdlc ai-sdlc runs a change through six SDLC stages, each one leaving a committed Markdown artifact and pausing for a person to approve. CX Codex ★ 1,596repo stars agiflow Connects AI coding agents to AgiFlow via MCP to handle planning, backlog grooming, task execution, and progress reporting. CX Codex ★ 1,596repo stars agentry agentry is a Claude Code and Codex plugin that gives coding agents product analytics, error logging, and deploy attribution through an HTTP API. Agents can use it to inspect telemetry and production issues. CX Codex ★ 1,596repo stars agentpack agentpack gives your agent a task-shaped map of the repo — likely files, rules, skills and warnings — before it touches the code. CX Codex ★ 1,596repo stars codiris-agentizer The codiris-agentizer plugin turns a website into a Next.js agent interface with chat, voice calls, and interactive products. Use it to generate and deploy the project. CX Codex ★ 1,596repo stars agentic-readiness-assessment The agentic-readiness-assessment plugin for Claude Code and Codex checks whether an agent can work independently in a repository, then returns a 14-area scorecard and prioritized fixes. CX Codex ★ 1,596repo stars agent-workflow-system agent-workflow-system — a plugin with seven skills that turn vague ideas into step-by-step plans, guide projects from start to handoff, and restore context after closing the window. CX Codex ★ 1,596repo stars agent-retro agent-retro is a plugin for Claude Code and Codex that reviews weekly activity in 12 animated slides with stats and four prompt-coaching tips to inspect your own habits. CX Codex ★ 1,596repo stars

Project sponsors

Companies that keep this analytics open