# agent-native

Adopt this skill: https://proskills.md/skills/other/boshu2-agentops-skills-agent-native

Page: https://proskills.md/skills/other/boshu2-agentops-skills-agent-native
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/agent-native/SKILL.md
size: 8008
upstream: https://github.com/boshu2/agentops/blob/main/skills/agent-native/SKILL.md

```text
---
name: agent-native
description: 'Dispatch independent tasks to parallel workers or selected persistent roles. Use when: delegation is authorized with disjoint scopes; execution does not validate output.'
practices: [team-topologies, design-by-contract]
hexagonal_role: supporting
consumes: [explicit-role-packets]
produces: [runtime-evidence, worker-handoff, per-packet-results]
context_rel:
- kind: customer-of
  with: codex-exec
skill_api_version: 1
user-invocable: true
metadata:
  tier: meta
  dependencies: []
  capabilities: [role_dispatch, observe_workers, handoff, dispatch_once]
  effects: [manage_runtime_sessions, invoke_selected_executor]
  canonical_status: canonical
  disposition: keep_optional_adapter
output_contract: runtime evidence and per-packet candidate, evidence, or error for explicit authorized work
---

# Agent Native

Operate caller-selected agent sessions as explicit roles without turning the
runtime into AgentOps lifecycle authority.

For judgment, default to a fresh context in the author's model family.
Cross-model Validate, mixed Council and dueling model perspectives are explicit
caller selections. Follow
[references/model-dispatch.md](references/model-dispatch.md): the working
session is the controller; check the explicitly selected adapter at runtime;
no factory is required and Agent Mail is never the judgment path. The recipe
owns host authorization, finite input/output, timeout and cleanup requirements.

Role requests declare authority; actual native runtime/OS filesystem and egress
controls must enforce it. A prompt, worktree, chmod or unrestricted same-user
process does not establish isolation. Observe synthetic canary denials before
restricted-source work; unavailable protection remains unavailable.

Use native waits or status notifications while workers or checks are pending.
Unchanged state is no reason for another analysis, review or provisional
retrospective. Observation consumes time and context; it is not free. A known
blocking failure deserves action even while other jobs run. For a suspected
stall, inspect observable state before choosing a nudge or replacement within
authority and remaining bounds. Stop observing at terminal status or the end
of the caller's observation window; impatience alone does not justify restart.

Named failure mode — **prompt-send optimism**: treating a successfully
delivered prompt as a working worker; delivery proves transport, not
engagement.

For new authorized work after a worker completes, use the selected runtime's
documented follow-up or resume operation that starts a turn. A message operation
may only queue text for a running worker. Check native state and engagement;
do not treat a queued repair request as a resumed implementation attempt.

Anti-pattern: restarting an unresponsive worker as the first move. Corrective:
capture its observable state first — a restart destroys the evidence of why it
stalled, and rescue is usually cheaper than rerun.

## Roles

- **Orchestrator:** passes focused intent, scope and evidence references, names
  the integration/final-review owner, and reports runtime facts. Retrieve extra
  history only for a consequential uncertainty; a fresh context is not
  necessarily small. A new goal does not clear history or renew spent bounds.
- **Implementer:** may modify only its packet's declared subject.
- **Validator:** receives exact candidate content in a fresh, read-only context.
- **Scribe:** records runtime evidence without judging acceptance.

Reader and Writer are bounded cheap delegations, not roles with authority: a
Reader returns line-referenced bullets over files the caller never loads, and a
Writer lands one patterned file from a spec plus a reference file and returns a
receipt the caller never reads back. Both are caller-selected per call, default
to a cheap model, and yield runtime facts only — a receipt is not validation.
For Codex, use the source-owned `bulk-reader` or `code-writer` native role
(`gpt-5.6-luna`); pass a fresh bounded task and receive findings or a receipt.
The reader uses explicit slices of at most 350 lines; the parent keeps file
content out of its context. A reference file is required for a writer. See
[context-budget delegation](references/context-budget-delegation.md) for
installation, native invocation, opt-in refusal hooks and the limits of role
instructions.

## Contract

For a caller-selected parallel batch, validate every complete packet before the
first launch. Require the selected executor, packet identity and all transitive
effects, with canonical workspace-relative write scopes in separate isolation.
Resolve symlinks and normalize paths; compare scopes case-insensitively so an
alias cannot hide a collision. A lexical disjointness check alone cannot prove
symlink or runtime isolation. The reference batch contract rejects nonempty
`write_scope.exclude` because its proof cannot honor those exclusions.

Dispatch each validated packet once and preserve its identity with the result:
candidate, evidence or executor error. Do not partly launch a batch that later
fails validation, or retry an error as if it had never happened. Native caller
authority determines any repair or follow-up. The developer reference
`scripts/swarm/dispatch_once.py` requires an AgentOps source checkout; it is
exercised by repository tests and is not bundled with standalone skills.
Installed use dispatches through the selected native runtime. This optional
batch mode selects no backlog work, creates no queue and integrates no changes.

1. Require caller intent, role, workspace, authorized source/output scope and
   evidence destination before starting a worker. Pass source-store/project/work
   identity and permitted intent locators before execution can fail. Record this
   dispatch association in caller-owned native comments/metadata or runtime
   facts, with actual worker session/context IDs explicitly unknown until
   observed; a requested ID is not an observed ID. This adds no AO packet schema.
2. Capture observed native runtime/session/context identity at startup, before
   substantive work and independently of final handoff. Return the observation
   through the caller-owned native recording channel with its provenance and
   permitted source locator. Preserve launch failures and unknowns if startup
   never becomes observable. Follow
   [session associations](references/session-associations.md#work-to-session-associations)
   for separate parent/resume links, supported multi-work spans and frozen source
   bounds. A controller is not necessarily a native parent; every requested
   child and resumed execution needs its own observed association. If recording
   fails, report the gap; do not claim crash recovery from prompt delivery alone.
   Prove runtime readiness and engagement from observable state; a successful
   prompt send is not proof of work.
3. Keep concurrent writers disjoint and isolated. Runtime coordination is not a
   claim, lease, queue, or completion state in AgentOps.
4. Record provider state, transcript references, artifacts, and terminal status.
5. Return runtime evidence to the caller. Do not convert provider retries,
   reconnects, idle states, or failures into Plan, Candidate, or verdict state.
6. A validator session may supply judgment to Validate, but only Validate writes
   `verdict.v2`. The adapter cannot select AgentOps semantics, issue a binding verdict, or turn factory completion into delivery or validation proof.

NTM, Codex exec, native processes, Agent Mail, and Gas City are replaceable
adapters. Use them only when the caller selected that execution shape. A
single local agent pays no factory coordination cost. Model identity, when
recorded, is a declared runtime fact like context identity — see
[references/model-dispatch.md](references/model-dispatch.md).

[Native judgment receipts](references/judgment-receipts.md) defines exact private
receipt references and the independent profile/subject/acceptance ch
```

## File: README.md
upstream: https://github.com/boshu2/agentops/blob/main/README.md

````text
<div align="center">

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

# AgentOps

**Software engineering practice, re-tested for AI 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>

Fifty years of software engineering produced practices that work for human
teams: state the behavior first, work in small slices, keep the checker separate
from the author, isolate concurrent work. AgentOps runs those practices against
AI coding agents and keeps the ones that hold up.

You get three things:

- **[Skills](docs/SKILL-ROUTER.md).** Each one is a Markdown file that carries
  one engineering practice into an agent session: [Plan](skills/plan/SKILL.md)
  to state the expected behavior, [Implement](skills/implement/SKILL.md) to
  change code without weakening its tests, [Validate](skills/validate/SKILL.md)
  for an independent judgment where a mistake would be costly.
- **[The practice ledger](docs/practice-ledger.md).** It says which practices
  held, which changed shape, which did not survive, and which are still being
  tested, with the evidence for each.
- **[Eval cases](evals/plugin-eval/README.md).** Run them on your own model
  before you trust a skill. Results change with the model and the harness.

The skills are a kit, and you are expected to change it. 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. [Make it yours](#make-it-yours)
shows how.

Every measurement here was taken with Claude Code. The skills are plain
Markdown and also install in Codex, Cursor, OpenCode, Gemini CLI and Pi, where
they are untested. 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. The [`ao` CLI](#optional-ao-cli)
and [Beads](https://github.com/gastownhall/beads) are optional.

<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
````
