Using Agentops
Understand and run AgentOps as the operational layer for coding agents—bookkeeping, validation, primitives, and named flows like RPI.
Overview
using-agentops is a journey-wide agent skill that explains the AgentOps operating model—bookkeeping, validation, primitives, and RPI flows—for coding agents across the solo-builder journey.
Install
npx skills add https://github.com/boshu2/agentops --skill using-agentopsWhat is this skill?
- Four public pillars: Bookkeeping, Validation, Primitives, and named Flows
- Core RPI loop: Research → Plan → Implement → Validate with a knowledge flywheel
- Context-compiler model: session signal → reusable knowledge and compiled prevention
- CLI surfaces: ao search, ao lookup, and citation when reusing retrieved knowledge
- Named flow compositions such as /research, /validation, and /rpi
- 4 public pillars: Bookkeeping, Validation, Primitives, Flows
- RPI core flow with 4 phases: Research, Plan, Implement, Validate
Adoption & trust: 776 installs on skills.sh; 384 GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You run coding agents ad hoc without a shared model for capturing learnings, validating work, or composing repeatable research-plan-implement-validate loops.
Who is it for?
Solo builders standardizing how agents capture knowledge, run /research and /validation flows, and close the RPI loop before shipping changes.
Skip if: Teams that only need a one-off task skill with no agent operations layer, or builders who will not install or adopt the broader AgentOps toolkit.
When should I use this skill?
When you need the AgentOps operating guide, RPI flow semantics, or CLI patterns for knowledge search and lookup (internal; not user-invocable by default).
What do I get? / Deliverables
You get a clear operating guide for AgentOps flows and CLI knowledge surfaces so the next agent session can search, cite, and validate work inside an RPI flywheel.
- stdout operating guide
- documentation of flows and CLI usage
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Run /research on a topic and ao search before committing to an architecture.
Wire primitives, hooks, and flows so the agent compiles session signal into reusable docs.
Use the validation pillar for plan and code review before merge or release.
Close the knowledge flywheel by looking up prior learnings and citing reused results.
How it compares
Use as the operating-model doc for an agent ops stack, not as a single-purpose Figma or frontend generator.
Common Questions / FAQ
Who is using-agentops for?
It is for indie and solo developers who orchestrate coding agents and want AgentOps bookkeeping, validation, primitives, and named flows documented in one place.
When should I use using-agentops?
Use it when onboarding to AgentOps, before standing up /rpi or /research flows, during build and ship when you need validation gates, and in operate when you iterate on captured learnings and knowledge search.
Is using-agentops safe to install?
Treat it as internal reference material tied to your AgentOps install; review the Security Audits panel on this Prism page and your repo policies before enabling hooks or CLI that touch the filesystem or git.
SKILL.md
READMESKILL.md - Using Agentops
# AgentOps Operating Model AgentOps is the operational layer for coding agents. Publicly, it gives you four things: - **Bookkeeping** — captured learnings, findings, and reusable context - **Validation** — plan and code review before work ships - **Primitives** — single skills, hooks, and CLI surfaces - **Flows** — named compositions like `/research`, `/validation`, and `/rpi` Technically, AgentOps acts as a context compiler: raw session signal becomes reusable knowledge, compiled prevention, and better next work. ## Core Flow: RPI ``` Research → Plan → Implement → Validate ↑ │ └──── Knowledge Flywheel ────┘ ``` ### Research Phase ```bash /research <topic> # Deep codebase exploration ao search "<query>" # Search existing knowledge ao search "<query>" --cite retrieved # Record adoption when a search result is reused ao lookup <id> # Pull full content of specific learning ao lookup --query "x" # Search knowledge by relevance ``` **Output:** `.agents/research/<topic>.md` ### Plan Phase ```bash /pre-mortem <spec> # Simulate failures (error/rescue map, scope modes, prediction tracking) /plan <goal> # Decompose into trackable issues ``` **Output:** Beads issues with dependencies ### Implement Phase ```bash /implement <issue> # Single issue execution /crank <epic> # Autonomous epic loop (uses swarm for waves) /swarm # Parallel execution (fresh context per agent) ``` **Output:** Code changes, tests, documentation ### Validate Phase ```bash /vibe [target] # Code validation (finding classification + suppression + domain checklists) /post-mortem # Validation + streak tracking + prediction accuracy + retro history /retro # Quick-capture a single learning ``` **Output:** `.agents/learnings/`, `.agents/patterns/` ## Phase-to-Skill Mapping | Phase | Primary Skill | Supporting Skills | |-------|---------------|-------------------| | **Discovery** | `/discovery` | `/brainstorm`, `/research`, `/plan`, `/pre-mortem` | | **Implement** | `/crank` | `/implement` (single issue), `/swarm` (parallel execution) | | **Validate** | `/validation` | `/vibe`, `/post-mortem`, `/retro`, `/forge` | **Choosing the skill:** - Use `/implement` for **single issue** execution. **Now defaults to TDD-first** — writes failing tests before implementing. Skip with `--no-tdd`. - Use `/crank` for **autonomous epic execution** (loops waves via swarm until done). Auto-generates file-ownership maps to prevent worker conflicts. - Use `/discovery` for the **discovery phase only** (brainstorm → search → research → plan → pre-mortem). - Use `/validation` for the **validation phase only** (vibe → post-mortem → retro → forge). - Use `/rpi` for **full lifecycle** — delegates to `/discovery` → `/crank` → `/validation`. - Use `/ratchet` to **gate/record progress** through RPI. ## Start Here (12 starters) These are the skills every user needs first. Everything else is available when you need it. | Skill | Purpose | |-------|---------| | `/quickstart` | Guided onboarding — run this first | | `/bootstrap` | One-command full AgentOps setup — fills gaps only | | `/research` | Deep codebase exploration | | `/council` | Multi-model consensus review + finding auto-extraction | | `/validate` | Canonical PASS/WARN/FAIL verdict over an artifact, plan, code change, PR, or gate | | `/vibe` | Code validation (classification + suppression + domain che