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

$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

$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

$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

$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

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.

Advanced Skills (when you need them)

Expert Skills (specialized workflows)

Knowledge Flywheel

Every $post-mortem promotes learnings and patterns into .agents/ so future $research starts with better context instead of zero.

Runtime Modes

AgentOps has three runtime modes. Do not assume hook automation exists everywhere.

In Codex hookless mode, entry skills such as $rpi, $research, $implement, $status, $recover, and $discovery should ensure the start path once per thread. Dedicated closeout skills such as $validation, $post-mortem, and $handoff should ensure the stop path once per thread.

Issue Tracking

This workflow uses beads for git-native issue tracking:

bd ready              # Unblocked issues
bd show <id>          # Issue details
bd close <id>         # Close issue
bd vc status          # Inspect Dolt state if needed (JSONL auto-sync is automatic)

Examples

Startup Context Loading

1. The first entry skill in a Codex thread should run ao codex ensure-start, which records startup once per thread and skips duplicate startup automatically.
2. AgentOps inspects .agents/, runs safe close-loop maintenance, syncs MEMORY.md, and writes .agents/ao/codex/startup-context.md.
3. Surfaced learnings, patterns, and findings are cited as retrieved.
4. Use ao lookup for automatic citations during work, or ao search --cite retrieved|reference|applied when a search result is adopted.
5. End the session through $validation, $post-mortem, or $handoff, which ensure ao codex ensure-stop once for the current thread, then verify loop health with ao codex status when needed.

Result: In hookless Codex mode, the agent still gets prior context, citations, and closeout without hidden hooks.

Workflow Reference During Planning

User says: "How should I approach this feature?"

What happens:

1. Agent references this skill's RPI workflow section
2. Agent recommends Research → Plan → Implement → Validate phases
3. Agent suggests $research for codebase exploration, $plan for decomposition
4. Agent explains $pre-mortem for failure simulation before implementation
5. User follows recommended workflow with agent guidance

Result: Agent provides structured workflow guidance based on this meta-skill, avoiding ad-hoc approaches.

Troubleshooting

Local Resources

scripts/

• scripts/validate.sh