Nine cooperating plugins covering the full development lifecycle, connected by shared JSON schemas and a common verification gate.

Use this when you're building non-trivial software with AI coding agents and need to know every acceptance criterion was implemented and tested — not assumed. The specific problem: agents working across long sessions silently drop criteria as context compresses. Specs live on disk. Agents read from disk. Drift is detectable, not silent.

Nine plugins cover the complete path from raw idea to shipped release. Each plugin produces a typed output schema consumed by the next stage. They are composable — install only the stages your workflow needs.

flowchart LR
    gr[graph\nneed] -->|"requirement@1"| tr[trace\nresearch]
    tr -->|"research-report@1"| ca[canon\nspec]
    ca -->|"spec@1"| ve[vector\nplan]
    ve -->|"plan@1"| la[lambda\ncode]
    la -->|"changeset@1"| ax[axiom\ngate]
    ax -->|"verdict@1"| de[delta\nship]
    de -. iterate .-> gr

    pr([proof\naudit]) -.->|"finding-report@1"| de
    pr -.->|"remediate"| ca
    ba([basis\nmeta]) -. scaffold .-> gr

Four decisions shape how every plugin and agent in this repository is built. They are enforced by shared/constitution.md and explained in shared/agent-best-practices.md.

Schema-Driven Development — every handoff between agents is a typed JSON document.

• JSON Schema draft-2020-12 with additionalProperties: false — a schema-invalid output halts the pipeline before any downstream agent acts on bad data
• Schema versions are immutable — a breaking change creates <name>@2.json, never mutates the existing file
• Every schema includes a reasoning scratchpad field for chain-of-thought; never forwarded downstream

EARS output contracts — hard constraints live exclusively in <output> sections, using WHEN / IF / WHILE / WHERE / THE SYSTEM SHALL.

• Encodes what the agent must produce, must not produce, or must do under a specific condition
• The prompt interior — how the agent searches, reasons, and decides — is intentionally unconstrained
• EARS is the fence; backstory and goal fill the interior with judgment

4-part agent structure — every agent body has exactly four sections; no role labels, no success-criteria checklists.

• <backstory> — experiential perspective that shapes judgment in open situations (not a role label)
• <goal> — intent, not steps
• <judgment> — the specific failure mode that looks like success
• <output> — schema reference and EARS contracts

Cognitive mode separation — agents are dispatched by the cognitive mode they require, not their pipeline position.

• A scanner (exhaustive pattern matching, no filtering) and an adversary (default-to-skepticism, requires a concrete failing scenario) cannot share a mental mode — combining them produces an agent worse at both
• Model and effort tiers follow the same logic: haiku / low for enumeration, sonnet / medium for analysis, opus / high for binding judgment

See ARCHITECTURE.md §7 for the full authoring guide, and docs/pipeline-walkthrough.md for a concrete end-to-end example showing schemas at each stage.

All inter-plugin handoffs are typed. Schemas live in shared/schemas/ and use JSON Schema draft-2020-12 with additionalProperties: false. Schema versions are immutable — a breaking change requires a new file (e.g. [email protected]). Every schema includes a reasoning scratchpad field that is never forwarded downstream.

Runtime-pullable guides in shared/references/. Agents pull these themselves during task execution — they are not loaded into context at startup. Language reference files are split by concern so each agent loads only its phase slice.

Add this repo as a marketplace, then install the plugins you need:

/plugin marketplace add orin-dx/agent-plugins
/plugin install graph
/plugin install trace
/plugin install canon
/plugin install vector
/plugin install lambda
/plugin install axiom
/plugin install delta

Install proof and basis as needed:

/plugin install proof
/plugin install basis

Install individual plugins via the native CLI (uses a Git URL):

agy plugin install https://github.com/orin-dx/agent-plugins.git

Or use agy-plugins-cli for an interactive TUI with update tracking:

npm install -g agy-plugins-cli
agy-plugin marketplace add orin-dx/agent-plugins
agy-plugin add graph@orin-dx
agy-plugin add trace@orin-dx
agy-plugin add canon@orin-dx
agy-plugin add vector@orin-dx
agy-plugin add lambda@orin-dx
agy-plugin add axiom@orin-dx
agy-plugin add delta@orin-dx
agy-plugin add proof@orin-dx
agy-plugin add basis@orin-dx

agent-plugins/
├── marketplace.json              ← Plugin registry
├── ARCHITECTURE.md               ← System architecture
├── CONTRIBUTING.md               ← Plugin authoring guide
├── shared/
│   ├── schemas/                  ← Versioned inter-agent JSON schemas
│   ├── references/               ← Runtime-pullable domain guides (split by concern)
│   └── agent-best-practices.md  ← Authoring-time principles
└── plugins/
    ├── graph/                    ← Requirement capture
    ├── trace/                    ← Research synthesis
    ├── canon/                    ← Specification drafting and gating
    ├── vector/                   ← Implementation planning
    ├── lambda/                   ← TDD implementation
    ├── axiom/                    ← Verification gate
    ├── delta/                    ← Ship tooling
    ├── proof/                    ← Fast cross-language bug scan
    └── basis/                    ← Plugin scaffolding

MIT © Gabriel Castro (Orin DX)