Skip to main content
Trinity
Updated Nov 17, 2026main@87e21ff

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

SkillDescription
/agent-dev:create-playbookCreate a new skill/playbook for the agent - optionally self-improving under a propose-only contract
/agent-dev:adjust-playbookModify an existing skill/playbook; --review-proposals approves a self-improving skill's pending proposals
/agent-dev:add-memoryAdd a memory system (file-index, brain, json-state, workspace)
/agent-dev:add-git-syncAdd 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-backlogInstall the full GitHub Issues development cycle into the agent - copies the nine standalone workflow skills below
/agent-dev:backlogView the agent's current GitHub Issues backlog (all, in-progress, or blocked)
/agent-dev:claimClaim the next issue - picks the highest-priority todo, marks it in-progress
/agent-dev:autoplanAnalyze a claimed issue before implementing - affected files, changes, risks
/agent-dev:commitCommit changed skill files and close the in-progress issue with traceability; with nothing claimed, a checkpoint commit of the agent-state files
/agent-dev:closeClose the current issue without a commit (use /commit when files changed)
/agent-dev:groomGroom the backlog - label untagged issues, verify priorities, surface stale work
/agent-dev:roadmapStrategic view - open issues grouped by skill area
/agent-dev:sprintHuman-supervised cycle: roadmap → claim → autoplan → implement → commit
/agent-dev:work-loopAutonomous unit of work: pick one issue, execute, close, exit
/agent-dev:planPlan and execute a large multi-session project
/agent-dev:add-pipelineScaffold a long-running multi-stage pipeline inside the agent
/agent-dev:add-pipeline-instanceAdd an instance (tenant / zone / case) to an existing pipeline
/agent-dev:add-pipeline-stageAppend a stage to an existing pipeline definition
/agent-dev:validate-pipelineLint a pipeline.yaml - schema, DAG acyclicity, referenced skills
/agent-dev:add-orchestratorMake 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-canonGive 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-lintInstall deterministic consistency linting into the fleet's canon repo - two-zone schema, CI on every push
/agent-dev:add-project-managementInstall 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-initCreate 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-taskCreate 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-stewardAutonomous 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-reconcileSync 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-intakeHeadless 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-statusDaily 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-analysisScan directories of agents in any paradigm - score maturity, map gaps to marketplace skills, emit a report + work order
/agent-dev:agent-fleet-migrateExecute 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:

SystemPurposeUse When
file-indexWorkspace file awareness and searchAgent needs to know what files exist
brainZettelkasten-style knowledge graphAgent builds connected notes over time
json-stateStructured JSON state with jq updatesAgent tracks counters, config, or structured data
workspaceMulti-session project trackingAgent 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:

•Auto-commit on Stop - work-in-progress is committed when a session ends
•Rebase on SessionStart - each session begins from the latest remote state
•Snapshot on PreCompact - state is preserved before context compaction

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:

TierShapeTemplate
1 - Simple skillStateless procedure, no persistent datasimple-skill
2 - Stateful skillReads/writes agent state between runsstateful-skill
3 - Full playbookMulti-step, scheduled or delegated workmanual, 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:

SkillPurpose
/discover-agentsDiscover 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-systemTurn 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
/orchestrateRoute 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-headNon-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-mapCompare 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-fleetInterview and introspect agents, reconcile reality against the fleet narrative
/fleet-reconcileFold 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:

•Dispatch is a playbook call. /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.
•Standing wiring uses events, not pollers. For “whenever X happens, have Y react”, /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.
•Every dispatch names its model. A delegated run with no 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.
•Loop closure. A run is not done until the requester has been told the outcome, including failure; work parked on someone outside the fleet is labeled 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 runs

In 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.

ChoiceOptions
Where the project livesIn 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 trackedIn 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.

•New projects. /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.
•Existing projects. /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.
•The steward starts from the platform's digest of what needs it, sets the project's health (on track, at risk, off track), and writes one shared-log entry per outcome - a verified deliverable, a new blocker, a hand-off - so members see what it did. /project-status attaches its daily report and asks to the project.
•What stays a person's. Creating a project needs the agent's Start projects permission, which an instance admin grants; without it the project is created off the platform and the skill says what to do next. Task priority, reopening a done task, the project's own status, its members and who can see it are never changed by an agent.

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

•create-agent Plugin - Create new agents
•trinity Plugin - Deploy, sync, and loop agents on Trinity
•Agent Loops - Drive /work-loop in bounded autonomous bursts
•Skills and Playbooks - How skills work in Trinity
•Abilities Overview - Full toolkit overview