agent-dev Plugin
Development tools for extending existing agents - skills, memory systems, git-backed state, a GitHub Issues development cycle, cross-actor project management, long-running pipelines, multi-agent orchestration, a shared canonical-data layer, and fleet analysis and migration. Thirty-one skills in v1.24.0.
Two kinds of skill live here. Installers (add-*) put a capability into an agent. Runtime skills are what the agent then runs - the nine backlog-workflow skills and the six project-* skills. Each runtime skill is authored once in this plugin; the installers copy it in at install time (they embed nothing of their own), and the same files are mirrored into the community skills catalog Trinity ships with (trinity-skills), so a deployed agent can also receive them by assignment without running the installer.
Why Every AI Agent Needs a GitHub Repo
Apr 2026
3 AI Agents Run My Software Development Pipeline
Apr 2026
Installation
/plugin install agent-dev@abilityai
Skills
| Skill | Description |
|---|---|
| /agent-dev:create-playbook | Create a new skill/playbook for the agent - optionally self-improving under a propose-only contract |
| /agent-dev:adjust-playbook | Modify an existing skill/playbook; --review-proposals approves a self-improving skill's pending proposals |
| /agent-dev:add-memory | Add a memory system (file-index, brain, json-state, workspace) |
| /agent-dev:add-git-sync | Add git-as-state hooks for local sessions - auto-commit on stop, rebase on session start. Inside a deployed agent the hooks stand down |
| /agent-dev:add-backlog | Install the full GitHub Issues development cycle into the agent - copies the nine standalone workflow skills below |
| /agent-dev:backlog | View the agent's current GitHub Issues backlog (all, in-progress, or blocked) |
| /agent-dev:claim | Claim the next issue - picks the highest-priority todo, marks it in-progress |
| /agent-dev:autoplan | Analyze a claimed issue before implementing - affected files, changes, risks |
| /agent-dev:commit | Commit changed skill files and close the in-progress issue with traceability; with nothing claimed, a checkpoint commit of the agent-state files |
| /agent-dev:close | Close the current issue without a commit (use /commit when files changed) |
| /agent-dev:groom | Groom the backlog - label untagged issues, verify priorities, surface stale work |
| /agent-dev:roadmap | Strategic view - open issues grouped by skill area |
| /agent-dev:sprint | Human-supervised cycle: roadmap → claim → autoplan → implement → commit |
| /agent-dev:work-loop | Autonomous unit of work: pick one issue, execute, close, exit |
| /agent-dev:plan | Plan and execute a large multi-session project |
| /agent-dev:add-pipeline | Scaffold a long-running multi-stage pipeline inside the agent |
| /agent-dev:add-pipeline-instance | Add an instance (tenant / zone / case) to an existing pipeline |
| /agent-dev:add-pipeline-stage | Append a stage to an existing pipeline definition |
| /agent-dev:validate-pipeline | Lint a pipeline.yaml - schema, DAG acyclicity, referenced skills |
| /agent-dev:add-orchestrator | Make the agent a system-aware orchestrator - discover the fleet, compose systems, route and fan out work; --check reports installed-vs-bundled drift before you overwrite |
| /agent-dev:add-canon | Give the agent a shared canonical-data layer - a fleet canon repo with publish/consume/reconcile/doctor skills, plus a root projects/ zone for shared projects. When the canon has a domain map, it finds the domains the agent already reads and proposes it as their consumer |
| /agent-dev:add-canon-lint | Install deterministic consistency linting into the fleet's canon repo - two-zone schema, CI on every push |
| /agent-dev:add-project-management | Install cross-actor project management - GitHub Issues as the source of truth, an approval-ready completion lattice, and a project steward. Writes PROJECT_STANDARD.md and copies the six project-* skills below |
| /agent-dev:project-init | Create or adopt a long-term managed project - a GitHub epic with idempotent labels and a project_files/<slug>/ workspace stub. --canon puts the workspace in the fleet's canon repo as a shared project; --internal tracks the tasks as files in the project folder instead of GitHub Issues. Runs a day-zero kickoff kit before anything is created (see below). Materializes a missing PROJECT_STANDARD.md from its own template, so it works when assigned from the library without the installer |
| /agent-dev:project-task | Create a task issue in the uniform format (Objective / Definition of Done / Context / Validation) and add it to the epic's checklist - the only sanctioned task-creation path; --headless for crons and other skills |
| /agent-dev:project-steward | Autonomous sweep of every managed project - GitHub-tracked and internal alike: verify pending-verification claims, dispatch labeled work to owners that passed the participation check, read each project's build-chain ledgers, escalate stalls, age open loops and draft follow-ups, write the digest, and once a day an evening brief. Never asks a human mid-run; ships a default weekday schedule |
| /agent-dev:project-reconcile | Sync a projection adapter (Google Tasks v1 shipped) back into the GitHub Issues registry - idempotent, refuses unkeyed items with a sync-gap alert |
| /agent-dev:project-intake | Headless intake primitive - route actionable items from meetings, email, Slack, or trackers into the registry, deduped by meaning; returns the issue number. Called by other skills and crons, never interactive |
| /agent-dev:project-status | Daily status for one project (<slug>) - what moved since yesterday, what is done, what waits on the operator (raised as asks on Trinity), and a projected finish date from the remaining critical path in the project's plan.md and its build-chain ledgers. Pull requests the chain has validated become merges due asks, because merging stays the operator's. Read-only against the registry; on Trinity it delivers a report plus one notification, off Trinity it writes a committed status file |
| /agent-dev:agent-fleet-analysis | Scan directories of agents in any paradigm - score maturity, map gaps to marketplace skills, emit a report + work order |
| /agent-dev:agent-fleet-migrate | Execute the fleet-analysis work order - non-destructive migration into a verified Claude Code fleet |
Fleet-scale skills
Five of these are about a set of agents rather than one: Canon (add-canon, add-canon-lint) gives a fleet a shared, citable source of truth on plain git; Project management (add-project-management) installs a cross-actor task model on GitHub Issues; Fleet analysis and migration (agent-fleet-analysis, agent-fleet-migrate) are a pair that audits agents in any paradigm and then carries out the resulting work order. Each is described in its own section below.
Memory Systems
Add persistent memory to agents via /agent-dev:add-memory:
| System | Purpose | Use When |
|---|---|---|
| file-index | Workspace file awareness and search | Agent needs to know what files exist |
| brain | Zettelkasten-style knowledge graph | Agent builds connected notes over time |
| json-state | Structured JSON state with jq updates | Agent tracks counters, config, or structured data |
| workspace | Multi-session project tracking | Agent works on long-running projects |
Memory systems are copied directly into the agent - no plugin dependency at runtime.
Git Sync (git-as-state)
/agent-dev:add-git-sync
Installs hooks that treat the agent's own repository as durable memory:
This gives an agent you work on in local Claude Code sessions durable cross-session memory through its repo, so the branch tip the deployed copy pulls from stays current. Inside a deployed agent the hooks stand down: Trinity's own GitHub Sync heartbeat owns commit-and-push there, so there is one writer, visible in sync health. .claude/settings.json, where the hooks are registered, is committable on Trinity; keep credentials out of it (a non-empty top-level env block or another credential-bearing key stops the platform from committing the file), because secrets belong in .env.
Playbook Development
Create a New Playbook
/agent-dev:create-playbook
Guides through purpose (what the playbook accomplishes), triggers (when it should run), steps (the workflow steps), and state (what data it reads/writes).
It picks a complexity tier and generates from a bundled template:
| Tier | Shape | Template |
|---|---|---|
| 1 - Simple skill | Stateless procedure, no persistent data | simple-skill |
| 2 - Stateful skill | Reads/writes agent state between runs | stateful-skill |
| 3 - Full playbook | Multi-step, scheduled or delegated work | manual, gated, or autonomous - by automation level |
Every generated skill carries a metadata: block with a newest-first changelog and a what's-new banner, and - for anything on a schedule - invokes by slash name so the scheduler message stays a bare call. Playbooks are written to be called: from a single /name [args] line, with inputs declared in argument-hint, running only themselves when invoked by another agent. See Playbook calls for the convention, and the --autonomous run mode any gated playbook needs before it can go on a cron. A generated skill that needs a human decision raises it as an ask with the ask_operator MCP tool and reads the outcome with get_my_ask; only a person can answer an ask.
Self-improving skills (optional). The wizard asks whether the skill should improve itself. If you opt in, it asks for a counterweight (the mission written as a tension, so the skill cannot optimise one goal at the expense of another), the constraints to lock, and 3-5 fixed scenarios. The generated skill is propose-only: a run logs its standing metrics and writes proposals with a check-back to a self-improvement.md ledger, and never applies its own proposal. A later run, or /agent-dev:adjust-playbook --review-proposals, applies a proposal under rate limits after a conflict check and a replay of the scenarios. An edit whose metric did not move is reverted. Only the skill's process can change this way; its purpose, stop rules, and write scope are locked and change only when a person asks.
Modify an Existing Playbook
/agent-dev:adjust-playbook daily-report
Options: add/remove steps, change automation level, update schedule, fix issues, review proposals (--review-proposals - triage a self-improving skill's ledger and approve or reject its pending proposals; the run that proposed a change never approves it), upgrade a legacy self-improving skill (move a skill that edits itself freely onto the propose-only contract), and make callable by other agents - retrofit an existing skill to the playbook-call rule (declared arguments, one-line invocation, a headless mode if it has gates).
GitHub Backlog Workflow
Add task management via GitHub Issues:
/agent-dev:add-backlog
This installs the full development cycle directly into the agent by copying the nine standalone workflow skills from the plugin (the installer carries no copies of its own, so an installed agent always matches the maintained skills). After install, the agent has:
/backlog - view current issues/claim - claim the next issue to work on/autoplan - analyze the claimed issue before implementing/commit - commit changes and close the issue with a traceable message; with no issue in progress it becomes a checkpoint commit of the agent-state set (memory/, .claude/memory/, outputs/, .claude/skills/, CLAUDE.md, template.yaml - never .env, .mcp.json, or anything credential-shaped), so the one /commit also serves as a plain save/close - close without a commit/groom and /roadmap - keep the backlog labeled, prioritized, and surveyable/sprint - the human-supervised end-to-end cycle/work-loop - the autonomous variant (below)On Trinity the same nine skills ship in the bundled community skills catalog, so they can also be assigned to a deployed agent directly.
Autonomous Work Loop
/agent-dev:work-loop
One bounded unit of work: the agent picks the highest-priority issue, executes it, closes it, and exits. It is designed to be re-invoked - by a Trinity schedule for a steady cadence, or by a Trinity agent loop for a bounded burst ("drain up to 20 items, stop when the backlog is empty"). See the Backlog draining pattern in the Agent Loops guide.
Pipelines (long-running multi-stage work)
/agent-dev:add-pipeline
Scaffolds an agent-owned pipeline for work that spans days or weeks (e.g. perception → synthesis → publish → measure): a projects/<slug>/ directory with pipeline.yaml and per-instance state, tick/status/recover/pause/resume skills, a heartbeat schedule that advances stages, and a ~/.trinity/ read surface so Trinity can display pipeline state without owning it.
/agent-dev:add-pipeline-instance - add a tenant/zone/case to an existing pipeline/agent-dev:add-pipeline-stage - extend the stage DAG/agent-dev:validate-pipeline - lint the definition (schema, acyclicity, skill references)A stage can name a local skill or delegate to another fleet agent - agent: <fleet-agent> calls that agent's playbook as one line with --run <pipeline>/<instance>, dispatched asynchronously and polled for its result; such stages skip the local-skill check.
Pipelines are owned by the agent, not by Trinity - the platform only reads the published state. This matches Trinity's agent-defined-pipelines design: no central DAG engine.
Orchestration (multi-agent)
/agent-dev:add-orchestrator
Makes any agent a system-aware orchestrator of other agents. Two modes, picked by whether the fleet already exists: describe and route over an existing fleet (read-only - discover, then orchestrate; no manifest, no deploy) or provision a new system (author the intent, compose a manifest, deploy, then orchestrate). It installs these skills into the agent:
| Skill | Purpose |
|---|---|
| /discover-agents | Discover the fleet (from the live Trinity instance and/or a repo list) into a descriptive fleet/system-map.yaml - including each agent's pipelines and canon declarations |
| /compose-system | Turn the map into a Trinity system manifest and deploy it; members are declared as github:Org/repo so the fleet is reproducible from source, and a spec-less repo gets a post-deploy /trinity:onboard in-place playbook call |
| /orchestrate | Route work to the right agent, fan N tasks out to one agent (many agents run as parallel per-agent dispatches), chain ordered steps, open a room, wire standing event reactions, or roll out an ephemeral agent for a one-off job - via Trinity MCP |
| /sync-fleet-to-head | Non-destructively bring in-scope agents to their GitHub HEAD. Every in-scope agent is attempted on every run; a permission denial is reported with its verbatim error as a regression, never silently skipped. An agent with unpushed commits is a needs-attention finding (commit count and age of the oldest one, red after 24 hours): that work exists only on the container's disk. It stays pull-only - pushing is the agent's own job |
| /reconcile-skill-map | Compare fleet/skill-map.yaml - which Library skills each agent should hold, each with a rationale - against the agent's live assignments. Applies approved additions one skill at a time with assign_skill_to_agent, never with the replace-all set_agent_skills, and never removes a skill without a human decision. A library skill that would overwrite an agent's own skill of the same name is reported as a decision, never forced. A map entry can name a skill set (set:<name>). The orchestrator needs the Change skills permission, which an instance admin grants; without it every assignment is refused and the skill stops and reports the missing grant |
| /profile-fleet | Interview and introspect agents, reconcile reality against the fleet narrative |
| /fleet-reconcile | Fold already-verified deltas into every doc surface behind one gate |
| project-* (opt-in) | The six project-management skills from this plugin, copied rather than embedded and configured for the fleet by fleet/project-standard.md: owners resolve through the fleet map, and dispatch respects the narrative's who-calls-whom edges |
Three conventions run through the whole bundle:
/orchestrate resolves each dispatch to a playbook from the target agent's live skill catalog and sends one line - /<playbook> [args] --run <task_id> - never a prose brief (a freeform brief is the recorded exception). Fire-and-park, never block-and-wait: it subscribes to the target's task-completion event and reports back when the work lands - to a role (primary, approver, viewer) through send_message, or as an ask when the operator is the requester. A call refused for exceeding the instance's chain-depth limit is terminal and is never retried or re-routed. See Playbook calls./orchestrate wires Trinity's pub/sub layer: the source agent's playbook is instructed to emit_event a named domain event, and the reacting agent subscribes itself (subscriptions are self-service, so the setup is dispatched to the subscriber, never wired on its behalf) with a {{payload.field}}-interpolated task. The design rules the platform does not enforce - exact-match event names, keep custom event graphs acyclic (only the built-in task-completion events carry a loop guard), a wake reaches only a running subscriber, interpolated payloads are agent-authored text - are written into the fleet narrative so the wiring stays reviewable. See Event Subscriptions.model runs on whatever the target defaults to, and that default can move. So each parallel chat_with_agent and each fan_out passes a full model ID at or above the orchestrator's floor (never a bare alias, never the smallest tier). A sequential chat_with_agent cannot carry a model, so playbook dispatches go parallel=true. Reminders, schedules and run_skill are outside the floor.waiting-on:<actor>, aged, and handed back with a drafted follow-up. The agent drafts; the human sends.Re-running the installer. /agent-dev:add-orchestrator --check is a read-only divergence report - per installed skill it says whether the bundle moved ahead (upgrade available), whether the installed copy was hand-edited (an overwrite would discard it - the diff is shown), or whether the installed copy is aheadof the bundle (a field-hardened copy the marketplace should pull from - an overwrite would be a downgrade). The same comparison runs inside every overwrite prompt when you re-run the installer, so the warning arrives at the moment of decision. It compares only this bundle's own skills and keeps no state on disk.
Gated skills on crons. /sync-fleet-to-head and /profile-fleet ask questions at their decision points; put on a schedule as-is, each run would block on a prompt nobody sees. Both declare a --autonomous run mode - the schedule message is the bare /<skill> --autonomous, and the skill takes the safe default at every gate, never a destructive path, recording anything non-trivial as a needs-attention line. This is the bundle-wide convention every gated-and-scheduled skill follows.
The orchestrator builds on Trinity's existing multi-agent primitives rather than inventing a parallel standard - see System Manifest, Fan-Out, and Rooms. Pipelines are the intra-agent sibling: /orchestrate routes pipeline-shaped work to the agent that owns the pipeline instead of re-sequencing its stages as a chain; canon is the data sibling: reads of published facts are served from the canon repo, writes are dispatched to the owning agent.
Canon (shared canonical data)
/agent-dev:add-canon
Gives any agent a shared canonical-data layer - a fleet-wide canon repo on plain git where each agent owns an agents/<name>/ folder, with conventions (CONVENTIONS.md, CODEOWNERS) instead of a new platform primitive. It installs four runtime skills into the agent:
/canon-publish - commit this agent's own folder in the shared canon repo/canon-consume - read other agents' published data at a cited ref/canon-reconcile - scheduled freshness pass over the agent's own folder/canon-doctor - verify the layer end-to-end (credentials, clone, push permission) from wherever the agent runsIn orchestrator fleets (a fleet/system-map.yaml is present), it can also enroll the mapped agents - all or a subset - into the same canon.
Each agent owns a folder it publishes to and reads other agents' folders at a pinned ref. Publishing also starts propagation (canon-publish 1.6, installed by add-canon 1.11): after a push that changed the content of a domain other agents keep a copy of (propagation: copied in the canon's domains.yaml), the skill moves that domain's anchor and sends the propagation hub one line - /propagate-change --domain <id> --source <repo@sha> - over Trinity MCP, or prints the line for you to send when Trinity is not reachable. The trigger is the canon linter's deterministic changed-domains check, so re-stamping dates never wakes the fleet, and a domain whose run already started is skipped. The layer also carries relations- per-counterpart collaboration memory: each agent keeps one doc per agent it actually works with (working agreements, a capped log of recent events, open threads), reads it before acting on that counterpart's request and appends the outcome before closing the interaction. Each side keeps its own view; a divergence between the pair is a dropped-thread signal, and open threads older than 30 days surface as needs-review rows in the reconcile pass.
/agent-dev:add-canon-lint
The enforcement sibling - run once per fleet against the canon repo itself, not an agent. Seeds a deterministic linter (stdlib-only Python, no LLM), a severity config, and a GitHub Actions workflow that lints every push/PR. It defines the two-zone folder schema: facts.yaml holds purely lintable claims, docs/ holds prose with a linted envelope. Optionally makes the lint a required PR status check; the per-agent gate ships with the add-canon runtime skills (/canon-publish lints before pushing).
Project Management (cross-actor)
/agent-dev:add-project-management
Installs a cross-actor task model on GitHub Issues, with an open → pending-verification → done lattice so work isn't marked complete until it's been verified, and a loop-closure discipline: no loop closes by silence in either direction. Every run ends by stating what is now true, what is waiting on the operator, and what happens next; work parked on someone the system cannot dispatch to (a client, a vendor, a colleague) is labeled waiting-on:<actor>, aged on a 3/7/14-day ladder, listed under Your open loops in the digest, and handed back with a drafted follow-up - the agent drafts, the human sends. See add-project-management for the installed artifacts.
The installer asks for the registry repo, the operator, the agent's name, the pending-verification age limit, and a steward cadence; then it renders PROJECT_STANDARD.md - the deployer's configuration surface, which all six runtime skills read - and copies /project-init, /project-task, /project-steward, /project-reconcile, /project-intake, and /project-status into .claude/skills/. A configuration block at the top of the standard names the registry, the operator, the label vocabulary and the fleet hooks; a standard without it runs on the defaults. A fleet orchestrator runs the same six files, configured by fleet/project-standard.md. Re-running it offers to overwrite, install only what is missing, or upgrade an older standard in place. It governs cross-actor work; for a single agent's own dev backlog use add-backlog instead.
A project can live at two visibility levels and use one of two tracking modes. The rules are the same in every combination: same charter (project.md), same steward, same intake, same decision ledger.
| Choice | Options |
|---|---|
| Where the project lives | In the managing agent's repo at project_files/<slug>/ (the default), or as a shared project in the fleet's canon repo at projects/<slug>/ (/project-init --canon). Every agent and person on the canon writes the shared projects/ zone directly; the charter's owner: is the steward. The epic records the location, and every project skill reads it from there rather than guessing from the slug |
| Where the tasks are tracked | In GitHub Issues (external, the default), or internally as one file per task in the project folder (tasks/T-NNN.md plus an append-only log.md) with /project-init --internal. Internal tracking needs no GitHub access, and it is forced when the standard's registry is none. The steward sweeps both kinds in one run |
On Trinity the same six skills can be assigned from the skills library - /project-init then materializes the standard itself on first run.
Platform mode
On a Trinity instance with Projects enabled, the project skills work against the platform's project record, so the project people see in the Workspace is the one the skills manage (the person's side of it - the page, Continue, tasks and the steward - is in Workspace Projects). Each run checks once whether the platform answers; off Trinity, on an instance without Projects, or with platform: off in the standard, every skill runs as described above.
/project-init also creates the project on the platform. An external project is linked: its tasks stay GitHub issues and the epic is its tracker link. With --internal the project is platform-tracked: its tasks live in the platform's task list instead of a tasks/ folder. --no-platform keeps a new project off the platform./project-init platform <slug> brings a folder project onto the platform in one import. After that the platform is the project's home, and nothing syncs back to the folder./project-status attaches its daily report and asks to the project.Kickoff kit and build chains (standard rev 2). /project-init now writes the day-zero kit before it creates the epic: a one-page intent.md (target, what the project creates, what it retires), a delegation boundary in the charter (what the managing agent decides alone and reports, what needs the operator, what is person-only by platform rule), a rulings.md file, a probed setup.md manifest of every account, token, permission edge and model pin the project needs (with a by-hand list of what only the operator can grant), a participation table per owner agent, and the declared project_* metrics. By default (kickoff: blocking) a missing item stops the run with the one line that would satisfy it; kickoff: advisory records the gaps instead, and adopt reports them unless --strict. An owner agent that fails a machine-checkable participation row receives no dispatch until it passes, and the steward enforces that on every sweep. Engineering issues a project runs through a build chain are listed in the charter: the chain dispatches them, and the steward and /project-status only read its ledgers and keep the record current. The steward's evening brief (brief.evening_utc, default 18:00 UTC) lists the decisions with the defaults the night will run on and the access the night's work needs.
Fleet Analysis & Migration
/agent-dev:agent-fleet-analysis
Scans one or more directories of agents in any paradigm - Claude Code, n8n workflow exports, framework apps (LangChain / CrewAI / AutoGen), or freeform-coded agents. It assesses quality (a fleet maturity score for Claude Code agents, a migration-readiness score for the rest), designs the right fleet architecture (hierarchy, knowledge brain, memory, canon layer), maps every improvement to an installable skill from the abilities marketplace, and generates a PDF report plus a markdown twin that agents can execute as a work order. Value-first - useful whether or not you ever deploy to Trinity.
/agent-dev:agent-fleet-migrate
Executes that work order non-destructively: sources are never mutated. Each agent is copied or scaffolded into fleet-migrated/, its logic extracted per paradigm, every fix delegated to a named marketplace skill, and every copy verified through a review gate. The run ends with a before/after maturity report plus a gated Trinity deploy offer.
Multi-Session Planning
For large projects that span multiple sessions:
/agent-dev:plan
Creates a persistent plan that tracks overall goals and milestones, current session focus, completed work, and next steps.
See Also
/work-loop in bounded autonomous bursts