aiwg
Version:
Deployment tool and support utility for AI context. Copies agents, skills, commands, rules, and behaviors into the paths each AI platform reads (Claude Code, Codex, Copilot, Cursor, Warp, OpenClaw, and 6 more) so one source of truth works across 10 platfo
791 lines (588 loc) • 112 kB
Markdown
<div align="center">
# AIWG
**Multi-agent AI framework for Claude Code, Copilot, Cursor, Warp, and 6 more platforms**
200+ agents, 67+ CLI commands, 400+ deployable agent/skill/command/rule artifacts, 8 core frameworks + training marketplace plugin, 27 addons. SDLC workflows, digital forensics, research management, marketing operations, media curation, ops infrastructure, knowledge base, and fine-tuning dataset curation — all deployable with one command.
```bash
npm i -g aiwg # install globally
aiwg use sdlc # deploy SDLC framework
```
[](https://www.npmjs.com/package/aiwg)
[](https://www.npmjs.com/package/aiwg)
[](LICENSE)
[](https://github.com/jmagly/aiwg/stargazers)
[](https://nodejs.org)
[](https://www.typescriptlang.org)
[](#-platform-support)
[**Get Started**](#quick-start) · [**Features**](#what-you-get) · [**Agents**](#agents) · [**CLI Reference**](docs/cli-reference.md) · [**Documentation**](#documentation) · [**Community**](#community--support)
[](https://discord.gg/BuAusFMxdA)
[](https://t.me/+oJg9w2lE6A5lOGFh)
</div>
---
## Installation Troubleshooting
If `aiwg` is not found after `npm i -g aiwg`, the npm global `bin` directory is not on your `PATH`. Confirm and fix:
```bash
which aiwg # empty? PATH is the issue
npm config get prefix # find npm's global prefix (bin lives under here)
echo 'export PATH="$(npm config get prefix)/bin:$PATH"' >> ~/.zshrc # or ~/.bashrc
source ~/.zshrc # or restart your shell
```
You can also invoke AIWG without adjusting `PATH` by using `npx aiwg <command>`. For a broader health check — version, deployed providers, missing dependencies, kernel-skill probes — run `aiwg doctor`, which surfaces the same PATH guidance on every invocation if the binary isn't reachable.
---
## What AIWG Is
AIWG is a deployment tool and support utility for AI context. At its core, `aiwg use` copies markdown and YAML source files into the specific paths each AI platform looks in — `.claude/agents/`, `~/.codex/skills/`, `.cursor/rules/`, `.github/prompts/`, and six more — so one source of truth works across 10 platforms.
Around that core, AIWG ships utilities for things the base platforms do not handle on their own: persistent artifact memory (`.aiwg/`), background orchestration (`aiwg mc`), autonomous loops (`aiwg ralph`), artifact indexing (`aiwg index`), cost telemetry, health diagnostics, and more. Most are opt-in. The deployment layer works standalone as plain text files the platform reads natively.
### Project scope (recommended) vs user scope (global)
`aiwg use` writes artifacts at one of two scopes. Both are first-class supported (see ADR-NUA-001 in `.aiwg/studies/novice-user-adoption/`):
- **Project scope** — default. Run `aiwg use sdlc` from a project root and the artifacts land in `./.claude/agents/`, `./.claude/skills/`, etc. One project's agent set never bleeds into another's session. **This is the recommended default for most use cases.**
- **User scope (global install)** — `aiwg use sdlc --scope user` writes to `~/.claude/agents/`, `~/.claude/skills/`, etc. Same artifact set loads into every session, regardless of project. Fits "AIWG in every conversation" workflows and is the canonical mode for OpenClaw and Hermes (whose primary discovery is user-scope).
The trade-off is real: when the same agent set loads into every session, context from one project can bleed into reasoning about another. Research (REF-720, *Lost in Multi-Turn Conversation*, MSR/Salesforce 2025) measured a 39% capability drop when this happens. The non-blocking project-isolation warning surfaces the trade-off at deploy time so the scope choice is informed. Neither scope is wrong; pick the one that fits the workflow.
See `docs/cli-reference.md` (under `aiwg use` → "Scope models") for the per-provider details and the global-install rough-edge inventory.
## Simple Building Blocks
AIWG ships five primitive artifact types. All are plain text:
- **Agents** — specialized personas (Security Auditor, Test Architect) with a scoped toolset
- **Skills** — natural-language workflows the platform auto-invokes on trigger phrases
- **Commands** — explicit slash invocations (`/flow-security-review-cycle`)
- **Rules** — enforcement directives the platform loads into every session
- **Behaviors** — lifecycle hooks that fire on events (pre-write, post-session)
Each is a single `.md` file with YAML frontmatter. Nothing executes until an AI platform reads it.
## Why It Compounds
Because the primitives are text, they compose without runtime coordination:
- One agent file becomes one member of a **180-agent SDLC team** that reviews architecture, tests, security, and compliance in parallel.
- One skill becomes a **natural-language entry point** — "run security review" routes to the right multi-agent flow on every platform that supports skills.
- One **framework** (SDLC, forensics, marketing) bundles dozens of agents + skills + rules + templates that cross-reference each other. Deploying a framework deploys a working multi-agent ecosystem.
- The `.aiwg/` directory gives those agents a **shared memory** — artifacts from Monday's requirements session are read by Thursday's test design.
- Flows orchestrate **Primary Author → Parallel Reviewers → Synthesizer → Archive** patterns that no single-prompt workflow can match.
The leverage is not in any one file. It is that hundreds of small files — each independently readable and editable — snap together into workflows that would otherwise take a bespoke agent platform to build.
This is also where the research background lives. AIWG implements patterns from cognitive science (Miller 1956, Sweller 1988), multi-agent systems (Jacobs et al. 1991, MetaGPT, AutoGen), and software engineering (Cooper's stage-gate, FAIR Principles, W3C PROV) — applied as file conventions and deployment rules, not as a runtime you depend on.
## What's Optional
These are CLI tools and services on top of the text-file substrate. The substrate works without them:
- `aiwg ralph` — autonomous iterate-until-done loops
- `aiwg mc` — background mission-control for parallel tasks
- `aiwg daemon` — persistent session manager
- `aiwg discover` — capability search across AIWG's 400+ skills/agents/commands/rules
- `aiwg show` — fetch the full body of a specific skill / agent / command / rule
- `aiwg index` — searchable artifact index (project + codebase + framework graphs)
- `aiwg mcp` — MCP server for runtime tool access
Turn any of these on when you want persistence, parallelism, or automation. Turn them off and your deployed agents, skills, and rules still work — they are still text files the platform reads natively.
## What AIWG Is Not
- **Not a prompt library.** Prompts are the artifacts, not the product. The product is placing the right prompts where the platform finds them.
- **Not an LLM runtime.** AIWG never calls a model. The AI platform you already use does that; AIWG configures what it sees.
- **Not a framework you import into your app.** Nothing is imported at build time. Your project gets a `.aiwg/` directory (artifacts) and a few provider-specific context dirs (deployed copies). Delete them and your app is unchanged.
## Who It's For
If you have used AI coding assistants and thought "this is amazing for small tasks but falls apart on anything complex," AIWG is the missing infrastructure layer that scales AI assistance to multi-week projects.
---
## What Problems Does AIWG Solve?
Base AI assistants (Claude, GPT-4, Copilot without frameworks) have three fundamental limitations:
### 1. No Memory Across Sessions
Each conversation starts fresh. The assistant has no idea what happened yesterday, what requirements you documented, or what decisions you made last week. You re-explain context every morning.
**Without AIWG**: Projects stall as context rebuilding eats time. A three-month project requires continuity, not fresh starts every session.
**With AIWG**: The `.aiwg/` directory maintains 50-100+ interconnected artifacts across days, weeks, and months. Later phases build on earlier ones automatically because memory persists. Agents read prior work via `@-mentions` instead of regenerating from scratch.
The segmented structure also makes large projects tractable. As code files grow, the project doesn't become harder to reason about — agents load only the slice of memory relevant to the current task (`@requirements/UC-001.md`, `@architecture/sad.md`, `@testing/test-plan.md`) rather than the entire codebase. Each subdirectory is a focused knowledge domain that fits comfortably in context, while cross-references keep everything connected.
The artifact index (`aiwg index`) takes this further. Without any tooling, agents often need to browse 3-6 documents before finding what they need. AIWG's structured artifacts reduce this to 2-3. With the index enabled, agents resolve artifact lookups in one query more often than not — a direct hit on the right requirement, architecture decision, or test case without browsing.
### 2. No Recovery Patterns
When AI generates broken code or flawed designs, you manually intervene, explain the problem, and hope the next attempt works. There is no systematic learning from failures, no structured retry, no checkpoint-and-resume.
**Without AIWG**: Research shows 47% of AI workflows produce inconsistent outputs without reproducibility constraints (R-LAM, Sureshkumar et al. 2026). Debugging is trial-and-error.
**With AIWG**: The agent loop implements closed-loop self-correction — execute, verify, learn from failure, adapt strategy, retry. External Ralph survives crashes and runs for 6-8+ hours autonomously. Debug memory accumulates failure patterns so the agent doesn't repeat mistakes.
### 3. No Quality Gates
Base assistants optimize for "sounds plausible" not "actually works." A general assistant critiques security, performance, and maintainability simultaneously — poorly. No domain specialization, no multi-perspective review, no human approval checkpoints.
**Without AIWG**: Production code ships without architectural review, security validation, or operational feasibility assessment.
**With AIWG**: 162 specialized agents provide domain expertise — Security Auditor reviews security, Test Architect reviews testability, Performance Engineer reviews scalability. Multi-agent review panels with synthesis. Human-in-the-loop gates at every phase transition. Research shows 84% cost reduction keeping humans on high-stakes decisions versus fully autonomous systems (Agent Laboratory, Schmidgall et al. 2025).
---
## The Six Core Components
### 1. Memory — Structured Semantic Memory
The `.aiwg/` directory is a persistent artifact repository storing requirements, architecture decisions, test strategies, risk registers, and deployment plans across sessions. This implements Retrieval-Augmented Generation patterns (Lewis et al., 2020) — agents retrieve from an evolving knowledge base rather than regenerating from scratch.
Each artifact is discoverable via `@-mentions` (e.g., `@.aiwg/requirements/UC-001-login.md`). Context sharing between agents happens through artifacts: the requirements analyst writes use cases, the architecture designer reads them.
### 2. Reasoning — Multi-Agent Deliberation with Synthesis
Instead of a single general-purpose assistant, AIWG provides 162 specialized agents organized by domain. Complex artifacts go through multi-agent review panels:
```
Architecture Document Creation:
1. Architecture Designer drafts SAD
2. Review Panel (3-5 agents run in parallel):
- Security Auditor → threat perspective
- Performance Engineer → scalability perspective
- Test Architect → testability perspective
- Technical Writer → clarity and consistency
3. Documentation Synthesizer merges all feedback
4. Human approval gate → accept, iterate, or escalate
```
Research shows 17.9% accuracy improvement with multi-path review on complex tasks (Wang et al., GSM8K benchmarks, 2023). Agent specialization means security review is done by a security specialist, not a generalist.
### 3. Learning — Closed-Loop Self-Correction (Ralph)
Ralph executes tasks iteratively, learns from failures, and adapts strategy based on error patterns. Research from Roig (2025) shows recovery capability — not initial correctness — predicts agentic task success.
```
Ralph Iteration:
1. Execute task with current strategy
2. Verify results (tests pass, lint clean, types check)
3. If failure: analyze root cause → extract structured learning → adapt strategy
4. Log iteration state (checkpoint for resume)
5. Repeat until success or escalate to human after 3 failed attempts
```
External Ralph adds crash resilience: PID file tracking, automatic restart, cross-session persistence. Tasks run for 6-8+ hours surviving terminal disconnects and system reboots.
### 4. Verification — Bidirectional Traceability
AIWG maintains links between documentation and code to ensure artifacts stay synchronized:
```typescript
// src/auth/login.ts
/**
* @implements @.aiwg/requirements/UC-001-login.md
* @architecture @.aiwg/architecture/SAD.md#section-4.2
* @tests @test/unit/auth/login.test.ts
*/
export function authenticateUser(credentials: Credentials): Promise<AuthResult> {
```
Verification types: Doc → Code, Code → Doc, Code → Tests, Citations → Sources. The retrieval-first citation architecture reduces citation hallucination from 56% to 0% (LitLLM benchmarks, ServiceNow 2025).
### 5. Planning — Phase Gates with Cognitive Load Management
AIWG structures work using Cooper's Stage-Gate methodology (1990), breaking multi-month projects into bounded phases with explicit quality criteria and human approval:
```
Inception → Elaboration → Construction → Transition → Production
LOM ABM IOC PR
```
Cognitive load optimization follows Miller's 7±2 limits (1956) and Sweller's worked examples approach (1988):
- 4 phases (not 12)
- 3-5 artifacts per phase (not 20)
- 5-7 section headings per template (not 15)
- 3-5 reviewers per panel (not 10)
### 6. Style — Controllable Voice Generation
Voice profiles provide continuous control over AI writing style using 12 parameters (formality, technical depth, sentence variety, jargon density, personal tone, humor, directness, examples ratio, uncertainty acknowledgment, opinion strength, transition style, authenticity markers).
Built-in voices: `technical-authority` (docs, RFCs), `friendly-explainer` (tutorials), `executive-brief` (summaries), `casual-conversational` (blogs, social). Create custom voices from your existing content with `/voice-create`.
---
## A Real Project Walkthrough
Here is how the six components work together across a project lifecycle. How long each phase takes depends entirely on the project — AIWG is a force multiplier, not a clock. Most projects arrive at a complete, reviewed document set in hours to a day. What takes time is the human work that matters: reviewing, editing, and making decisions. The more input your team provides, the better the output. AIWG memory lets operators participate through the tools they already use — industry-standard documents and templates, issues, and knowledge bases.
### Inception
```bash
/intake-wizard "Build customer portal with real-time chat" --interactive
```
**Memory**: Intake forms capture goals, constraints, stakeholders in `.aiwg/intake/`
**Planning**: Executive Orchestrator guides through structured questionnaire
**Reasoning**: Requirements Analyst drafts initial use cases, Product Designer reviews UX
**Verification**: Requirements reference intake forms, ensuring alignment
**Human Gate**: Stakeholder reviews intake → approves transition to Elaboration
### Elaboration
```bash
/flow-inception-to-elaboration
```
**Memory**: Architecture doc, ADRs, threat model, test strategy accumulate in `.aiwg/`
**Reasoning**: Multi-agent review panel — Architecture Designer drafts, Security Auditor + Performance Engineer + Test Architect critique in parallel, Documentation Synthesizer merges
**Learning**: Ralph iterates on ADRs (generate options, evaluate against constraints, refine)
**Style**: Technical documents use `technical-authority`, stakeholder summaries use `executive-brief`
**Human Gate**: Architect reviews SAD, security team approves threat model
### Construction
```bash
/flow-elaboration-to-construction
/ralph "Implement authentication module" --completion "npm test passes"
```
**Learning**: Ralph handles implementation iterations — execute, verify (run tests), learn ("async race condition in token refresh"), adapt (add synchronization), retry
**Verification**: Code references requirements (`@implements UC-001`), tests reference code
**Memory**: Test plans, implementation, deployment scripts accumulate across iterations
**Human Gate**: Code review approves merges, QA approves test results
### Transition
```bash
/flow-deploy-to-production
/flow-hypercare-monitoring 14
```
**Planning**: Deployment checklist — monitoring, rollback plan, incident response
**Learning**: Ralph retries deployment steps if validation fails
**Verification**: Deployment scripts reference architecture (which services, what order)
**Human Gate**: Operations team reviews deployment plan → approves production release
---
## Quantified Claims and Evidence
AIWG makes specific, falsifiable claims backed by peer-reviewed research:
| Claim | Evidence | Source |
|-------|----------|--------|
| 84% cost reduction with human-in-the-loop vs fully autonomous | Agent Laboratory study | Schmidgall et al. (2025) |
| 47% workflow failure rate without reproducibility constraints | R-LAM evaluation | Sureshkumar et al. (2026) |
| 0% citation hallucination with retrieval-first vs 56% generation-only | LitLLM benchmarks | ServiceNow (2025) |
| 17.9% accuracy improvement with multi-path review | GSM8K benchmarks | Wang et al. (2023) |
| 18.5x improvement with tree search on planning tasks | Game of 24 results | Yao et al. (2023) |
Full references: [docs/research/](docs/research/)
---
## When to Use AIWG (and When Not To)
### Good Fit
Multi-week or multi-month projects where requirements evolve, multiple stakeholders have different concerns, quality gates are required, auditability matters, or context exceeds conversation limits.
**Examples**: New product features with architecture/security/operational implications, legacy system migrations requiring phased rollback strategies, research projects needing literature review and reproducibility, compliance-heavy domains (healthcare, finance, aerospace) needing audit trails.
### Not the Best Fit
Single-session tasks where no memory is needed, quality gates are overkill, and overhead exceeds value.
**Examples**: "Write a Python script to parse this CSV," "Fix this typo," "Explain how this code works."
### The Trade-off
AIWG adds structure (templates, phases, gates) that slows trivial tasks but scales to complex multi-week workflows. If your project fits in a single conversation, use a base assistant. If it spans days, weeks, or months, AIWG provides the infrastructure to maintain quality and context.
```
User intent → AIWG CLI → Deploy agents + rules + templates → AI platform
│ │
▼ ▼
"aiwg use sdlc" Claude Code / Copilot /
│ Cursor / Warp / Factory /
▼ OpenCode / Codex / Windsurf
┌──────────────┐
│ 188 Agents │ Specialized AI personas with domain expertise
│ 50 Commands │ CLI + slash commands for workflow automation
│ 128 Skills │ Natural language workflow triggers
│ 35 Rules │ Enforcement patterns (security, quality, anti-laziness)
│ 334 Templates│ SDLC artifact templates with progressive disclosure
└──────────────┘
│
▼
.aiwg/ artifacts ← Persistent project memory across sessions
```
---
## How It Works
> For visual diagrams of AIWG's architecture, deploy flow, and discovery model, see [`docs/architecture-overview.md`](docs/architecture-overview.md). The prose walkthrough lives in [`docs/how-it-works.md`](docs/how-it-works.md).
**At a glance** — AIWG is a deploy-time tool. `aiwg use` copies plain-text files into your AI platform's native directories and exits. Nothing runs in the background; the AI platform's own loader handles everything from there.
```mermaid
flowchart LR
subgraph Source["AIWG framework source"]
direction TB
KERN[16 kernel skills<br/>~15-25k tokens]
STD[~385 standard skills<br/>read from $AIWG_ROOT]
AGENT[200+ agents]
RULES[60+ rules]
TPL[100+ templates]
end
CLI([aiwg use sdlc<br/>--provider X]) --> DEPLOY
subgraph DEPLOY["Deploy step (one-shot)"]
direction TB
COPY[Copy kernel skills, agents,<br/>rules to provider-native dirs]
INDEX[Build artifact index<br/>~/.local/share/aiwg/index/]
CTX[Emit AIWG.md + AGENTS.md<br/>at project root]
end
Source --> CLI
DEPLOY --> Project
subgraph Project["Your project (after deploy)"]
direction TB
PLAT[.claude/skills/<br/>.codex/agents/<br/>.warp/agents/ ...]
AIWGMD[AIWG.md / .hermes.md /<br/>WARP.md / AGENTS.md]
ART[.aiwg/<br/>requirements/<br/>architecture/<br/>...]
end
Project --> SESS
subgraph SESS["AI session (Claude / Codex / Hermes / etc.)"]
direction TB
NATIVE[Platform-native loader<br/>reads provider dir]
DISC([Optional: aiwg discover<br/>+ aiwg show])
end
classDef optional stroke-dasharray: 5 5,fill:#fef9e7
class DISC optional
class INDEX optional
```
**Multi-agent orchestration** — once deployed, AIWG coordinates specialized agents through phase-gated workflows:
```
You: "transition to elaboration phase"
AIWG: [Step 1] Requirements Analyst → Analyze vision document, generate use case briefs
[Step 2] Architecture Designer → Baseline architecture, identify technical risks } parallel
[Step 3] Security Architect → Threat model, security requirements }
[Step 4] Documentation Synth. → Merge reviews into Architecture Baseline Milestone
[Step 5] Human Gate → GO / CONDITIONAL_GO / NO_GO decision
[Step 6] → Next phase or iterate
```
The orchestration pattern: **Primary Author → Parallel Reviewers → Synthesizer → Human Gate → Archive**. Agents run in parallel where possible, with human-in-the-loop checkpoints at phase transitions.
---
## Features
- **188 specialized agents** — domain experts across testing, security, architecture, DevOps, cloud, frontend, backend, data engineering, documentation, and more
- **50 CLI commands** — framework deployment, project scaffolding, iterative execution, metrics, reproducibility validation
- **128 workflow skills** — natural language triggers for regression testing, forensics, voice profiles, quality gates, and CI/CD integration
- **35 enforcement rules** — anti-laziness detection, token security, citation integrity, executable feedback, failure mitigation across 6 LLM archetypes
- **334 artifact templates** — progressive disclosure templates for requirements, architecture, testing, security, deployment, and more
- **8 platform support** — deploy to Claude Code, Copilot, Cursor, Warp, Factory AI, OpenCode, Codex, and Windsurf
- **8 core frameworks + training marketplace plugin** — SDLC, Digital Forensics, Marketing Operations, Research Management, Media Curation, Ops Infrastructure, Knowledge Base, Security Engineering, plus [`aiwg-training`](https://github.com/jmagly/aiwg-training) for fine-tuning dataset curation (corpus-to-dataset pipeline with DPO/KTO/ORPO/SimPO export)
- **27 addons** — semantic-memory kernel, llm-wiki (Obsidian-native knowledge base), RLM recursive decomposition, voice profiles, testing quality, mutation testing, UAT automation, and more
- **Agent Loop** — iterative task execution with automatic error recovery and crash resilience (6-8 hour sessions)
- **RLM addon** — recursive context decomposition for processing 10M+ tokens via sub-agent delegation
- **YAML metalanguage** — declarative schema-validated workflow definitions (JSON Schema 2020-12)
- **MCP server** — Model Context Protocol integration for tool-based AI workflows
- **Bidirectional traceability** — @-mention system linking requirements → architecture → code → tests
- **FAIR-aligned artifacts** — W3C PROV provenance, GRADE quality assessment, persistent REF-XXX identifiers
- **Reproducibility validation** — deterministic execution modes, checkpoints, configuration snapshots
---
## Quick Start
> **Prerequisites:** Node.js >=20.0.0 and an AI platform (Claude Code, GitHub Copilot, Cursor, Warp Terminal, or others). New installs should prefer Node 24. See [Prerequisites Guide](docs/getting-started/prerequisites.md) for details.
> **Verifying releases (v2026.5.3+):** Every AIWG release ships with Sigstore-anchored npm provenance, a signed git tag, a cosign keyless tarball signature, and a signed CycloneDX SBOM. Verification is optional but recommended:
>
> ```bash
> npm view aiwg@2026.5.3 --json | jq .dist.attestations
> ```
>
> Full walkthrough at [`docs/releases/verifying.md`](docs/releases/verifying.md). Adopt the same pattern for your own packages: [`docs/security/supply-chain-hardening.md`](docs/security/supply-chain-hardening.md).
### Install & Deploy
```bash
# Install globally
npm install -g aiwg
# Deploy to your project
cd your-project
aiwg use sdlc # Full SDLC framework (98 agents, 38 rules, 200+ templates)
aiwg use forensics # Digital forensics & incident response (13 agents, 10 skills)
aiwg use marketing # Marketing operations (37 agents, 87+ templates)
aiwg use media-curator # Media archive management (6 agents, 9 commands)
aiwg use research # Research workflow automation (8 agents, 8-stage pipeline)
aiwg use rlm # RLM addon (recursive context decomposition)
aiwg use all # Everything
# Or scaffold a new project
aiwg new my-project
# Check installation health
aiwg doctor
```
### Customize Without Forking
Author project-specific rules, skills, agents, addons, or frameworks
directly under `.aiwg/{extensions,addons,frameworks,plugins}/<name>/`.
No fork, no rebuild. Discovered automatically by `aiwg use`.
```bash
aiwg new-bundle my-team-rules --type extension --starter rule
# edit the rule, then:
aiwg use my-team-rules
aiwg doctor --project-local # health check (counts, validation, drift)
aiwg promote my-team-rules # graduate to upstream when proven
```
The bundle is **byte-identical** in shape to its upstream form, so
`aiwg promote` is a hash-verified copy with zero rewrite. See the
[customization guide](docs/customization/README.md) for the three paths
(project-local, fork, corpus).
### Claude Code Plugin (Alternative)
```bash
/plugin marketplace add jmagly/ai-writing-guide
/plugin install sdlc@aiwg
```
### Multi-Platform Deployment
```bash
aiwg use sdlc # Claude Code (default)
aiwg use sdlc --provider copilot # GitHub Copilot
aiwg use sdlc --provider cursor # Cursor
aiwg use sdlc --provider warp # Warp Terminal
aiwg use sdlc --provider factory # Factory AI
aiwg use sdlc --provider opencode # OpenCode
aiwg use sdlc --provider openai # OpenAI/Codex
aiwg use sdlc --provider windsurf # Windsurf
```
---
## What You Get
### Frameworks (6)
| Framework | Agents | Templates | What It Does |
|-----------|--------|-----------|--------------|
| **[SDLC Complete](agentic/code/frameworks/sdlc-complete/)** | 98 | 200+ | Full software development lifecycle — Inception through Production with multi-agent orchestration, quality gates, and DORA metrics |
| **[Forensics Complete](agentic/code/frameworks/forensics-complete/)** | 13 | 8 | Digital forensics and incident response — evidence acquisition, timeline reconstruction, IOC extraction, Sigma rule hunting. NIST SP 800-86, MITRE ATT&CK, STIX 2.1 |
| **[Media/Marketing Kit](agentic/code/frameworks/media-marketing-kit/)** | 37 | 87+ | End-to-end marketing operations — strategy, content creation, campaign management, brand compliance, analytics, and reporting |
| **[Media Curator](agentic/code/frameworks/media-curator/)** | 6 | — | Intelligent media archive management — discography analysis, source discovery, quality filtering, metadata curation, multi-platform export (Plex, Jellyfin, MPD) |
| **[Research Complete](agentic/code/frameworks/research-complete/)** | 8 | 6 | Academic research automation — paper discovery, citation management, RAG-based summarization, GRADE quality scoring, FAIR compliance, W3C PROV provenance |
| **[Ops Complete](agentic/code/frameworks/ops-complete/)** | 12 | 3 | Operational infrastructure — incident management, runbooks, troubleshooting workflows |
| **[Security Engineering](agentic/code/frameworks/security-engineering/)** | 2 | 5 | Applied security beyond STRIDE/OWASP — cryptographic primitive selection, chain-of-trust integrity, authentication-factor architecture, degraded-mode design, runtime secret hygiene, supply-chain trust, physical-access threats. Pattern-based, product-agnostic |
### Addons (27)
| Addon | What It Does |
|-------|--------------|
| **[RLM](agentic/code/addons/rlm/)** | Recursive context decomposition — process 10M+ tokens via sub-agent delegation with parallel fan-out |
| **[Writing Quality](agentic/code/addons/writing-quality/)** | Content validation, AI pattern detection, authentic voice enforcement |
| **[Testing Quality](agentic/code/addons/testing-quality/)** | TDD enforcement, mutation testing, flaky test detection and repair |
| **[Voice Framework](agentic/code/addons/voice-framework/)** | 4 built-in voice profiles (technical-authority, friendly-explainer, executive-brief, casual-conversational) with create/blend/apply skills |
| **[UAT-MCP Toolkit](agentic/code/addons/uat-mcp/)** | User acceptance testing with MCP-powered test execution, coverage tracking, and regression detection |
| **[AIWG Evals](agentic/code/addons/aiwg-evals/)** | Agent evaluation framework — archetype resistance testing (Roig 2025), performance benchmarks, quality scoring |
| **[Agent Loop](agentic/code/addons/agent-loop/)** | Iterative task execution engine (`aiwg ralph` / `aiwg agent-loop-ext`) — automatic error recovery, crash resilience, completion tracking |
| **[Agentic Installer](agentic/code/addons/agentic-installer/)** | `setup.aiwg.io/v1` SetupManifest installer — cross-platform install workflows with recovery |
| **[AIWG Dev](agentic/code/addons/aiwg-dev/)** | AIWG development tooling — extension scaffolding, local-source dev mode |
| **[Daemon](agentic/code/addons/daemon/)** | Persistent daemon mode — background sessions, task queue, health monitoring |
| **[LLM Wiki](agentic/code/addons/llm-wiki/)** | Obsidian-native knowledge base for LLM agents — semantic linking, vault integration |
| **[NLP Prod](agentic/code/addons/nlp-prod/)** | Production NLP pipelines — entity extraction, classification, summarization |
| **[Prose Integration](agentic/code/addons/prose-integration/)** | OpenProse contract grammar integration — declarative service contracts |
| **[Semantic Memory](agentic/code/addons/semantic-memory/)** | Semantic memory kernel — query, capture, lifecycle management for agent memory |
| **[Context Curator](agentic/code/addons/context-curator/)** | Context pre-filtering to remove distractors — production-grade agent reliability |
| **[Verbalized Sampling](agentic/code/addons/verbalized-sampling/)** | Probability distribution prompting — 1.6-2.1x output diversity improvement |
| **[Guided Implementation](agentic/code/addons/guided-implementation/)** | Bounded iteration control for issue-to-code automation |
| **[Skill Factory](agentic/code/addons/skill-factory/)** | Dynamic skill generation and packaging at runtime |
| **[Doc Intelligence](agentic/code/addons/doc-intelligence/)** | Document analysis, PDF extraction, documentation site scraping |
| **[Color Palette](agentic/code/addons/color-palette/)** | WCAG-compliant color palette generation with trend research |
| **[Auto Memory](agentic/code/addons/auto-memory/)** | Automatic memory seed templates for new project context initialization |
| **[Agent Persistence](agentic/code/addons/agent-persistence/)** | Agent state management for session continuity |
| **[AIWG Hooks](agentic/code/addons/aiwg-hooks/)** | Lifecycle event handlers — pre-session, post-write, workflow tracing |
| **[AIWG Utils](agentic/code/addons/aiwg-utils/)** | Core meta-utilities (auto-installed with any framework) |
| **[Droid Bridge](agentic/code/addons/droid-bridge/)** | Factory Droid orchestration — multi-platform agent bridge |
| **[Star Prompt](agentic/code/addons/star-prompt/)** | Repository star prompt for success celebration |
---
### Agents (188)
Specialized AI personas deployed to your platform with defined tools, responsibilities, and operating rhythms.
#### SDLC Agents (90)
| Domain | Agents | Examples |
|--------|--------|---------|
| **Testing & Quality** | 11 | Test Engineer, Test Architect, Mutation Analyst, Regression Analyst, Laziness Detector, Reliability Engineer |
| **Security & Compliance** | 9 | Security Auditor, Security Architect, Compliance Checker, Privacy Officer, Citation Verifier |
| **Architecture & Design** | 12 | Architecture Designer, API Designer, Cloud Architect, System Analyst, Product Designer, Decision Matrix Expert |
| **DevOps & Cloud** | 8 | AWS Specialist, Azure Specialist, GCP Specialist, Kubernetes Expert, DevOps Engineer, Multi-Cloud Strategist |
| **Backend & Data** | 10 | Django Expert, Spring Boot Expert, Data Engineer, Database Optimizer, Software Implementer, Incident Responder |
| **Frontend & Mobile** | 6 | React Expert, Frontend Specialist, Mobile Developer, Accessibility Specialist, UX Lead |
| **AI/ML & Performance** | 5 | AI/ML Engineer, Performance Engineer, Cost Optimizer, Metrics Analyst |
| **Code Quality** | 11 | Code Reviewer, Debugger, Dead Code Analyzer, Technical Debt Analyst, Legacy Modernizer |
| **Documentation** | 7 | Technical Writer, Documentation Synthesizer, Documentation Archivist, Context Librarian |
| **Requirements & Planning** | 7 | Requirements Analyst, Requirements Reviewer, Intake Coordinator, RACI Expert |
| **Agent/Tool Smiths** | 9 | AgentSmith, CommandSmith, MCPSmith, SkillSmith, ToolSmith |
| **Governance & Meta** | 3 | Executive Orchestrator, Recovery Orchestrator, Migration Planner |
#### Forensics Agents (13)
| Agent | What It Does |
|-------|-------------|
| Forensics Orchestrator | Coordinates full investigation lifecycle from scoping through reporting |
| Triage Agent | Quick volatile data capture following RFC 3227 volatility order |
| Acquisition Agent | Evidence collection with chain of custody and SHA-256 hash verification |
| Log Analyst | Auth.log, syslog, journal, and application log analysis for brute force, privilege escalation, lateral movement |
| Persistence Hunter | Sweeps cron, systemd, SSH keys, LD_PRELOAD, PAM modules, kernel modules — maps to MITRE ATT&CK |
| Container Analyst | Docker, containerd, Kubernetes forensics — privilege escalation, container escapes, eBPF monitoring |
| Network Analyst | Connection state, DNS, traffic patterns — beaconing, C2, data exfiltration detection |
| Memory Analyst | Volatility 3 memory forensics — process analysis, rootkit detection, credential extraction |
| Cloud Analyst | AWS/Azure/GCP audit logs, IAM review, network flows, API activity anomaly detection |
| Timeline Builder | Multi-source event correlation — chronological incident timelines with attribution |
| IOC Analyst | IOC extraction, enrichment, STIX 2.1 formatting — actionable IOC register |
| Recon Agent | Target reconnaissance — system topology, services, users, network baselines |
| Reporting Agent | Structured forensic reports — executive summary, technical findings, timeline, remediation |
#### Marketing Agents (37)
| Domain | Agents |
|--------|--------|
| **Strategy** | Campaign Strategist, Brand Guardian, Positioning Specialist, Market Researcher, Content Strategist, Channel Strategist |
| **Creation** | Copywriter, Content Writer, Email Marketer, Social Media Specialist, SEO Specialist, Graphic Designer, Art Director |
| **Management** | Campaign Orchestrator, Production Coordinator, Traffic Manager, Asset Manager, Workflow Coordinator |
| **Analytics** | Marketing Analyst, Data Analyst, Attribution Specialist, Reporting Specialist, Budget Planner |
| **Communications** | PR Specialist, Crisis Communications, Corporate Communications, Internal Communications, Media Relations |
#### Research Agents (8)
Discovery Agent, Acquisition Agent, Documentation Agent, Citation Agent, Quality Agent, Archival Agent, Provenance Agent, Workflow Agent
#### Media Curator Agents (6)
Discography Analyst, Source Discoverer, Acquisition Manager, Quality Assessor, Metadata Curator, Completeness Tracker
---
### Rules (35)
Enforcement patterns that prevent common AI failure modes. Rules deploy automatically with their framework.
#### Core Rules (10) — Always Active
| Rule | Severity | What It Enforces |
|------|----------|-----------------|
| `no-attribution` | CRITICAL | AI tools are tools — never add attribution to commits, PRs, docs, or code |
| `token-security` | CRITICAL | Never hard-code tokens; use heredoc pattern for scoped lifetime; file permissions 600 |
| `versioning` | CRITICAL | CalVer YYYY.M.PATCH with NO leading zeros; npm rejects leading zeros |
| `citation-policy` | CRITICAL | Never fabricate citations, DOIs, or URLs; only cite verified sources; GRADE-appropriate hedging |
| `anti-laziness` | HIGH | Never delete tests to pass, skip tests, remove features, or weaken assertions; escalate after 3 failures |
| `executable-feedback` | HIGH | Execute tests before returning code; track execution history; max 3 retries with root cause analysis |
| `failure-mitigation` | HIGH | Detect and recover from 6 LLM failure archetypes: hallucination, context loss, instruction drift, safety, technical, consistency |
| `research-before-decision` | HIGH | Research codebase before acting: IDENTIFY → SEARCH → EXTRACT → REASON → ACT → VERIFY |
| `instruction-comprehension` | HIGH | Fully parse all instructions before acting; track multi-part requests to completion |
| `subagent-scoping` | HIGH | One focused task per subagent; <20% context budget; no delegation chains deeper than 2 levels |
#### SDLC Rules (34) — Active with Framework
Actionable feedback, mention wiring, HITL gates, agent fallback, provenance tracking, TAO loop, reproducibility validation, SDLC orchestration, agent-friendly code, agent generation guardrails, artifact discovery, HITL patterns, human gate display, thought protocol, reasoning sections, few-shot examples, best output selection, reproducibility, progressive disclosure, conversable agent interface, auto-reply chains, criticality panel sizing, qualified references.
#### Research Rules (2) — Active with Research
Research metadata (FAIR-compliant YAML frontmatter), index generation (auto-generated INDEX.md per FAIR F4).
---
### Skills (128)
Natural language workflow triggers. Say "what's the project status?" and the `project-awareness` skill activates.
| Category | Skills | Examples |
|----------|--------|---------|
| **Regression Testing** | 12 | regression-check, regression-baseline, regression-bisect, regression-performance, regression-api-contract, regression-cicd-hooks, regression-learning |
| **Voice & Writing** | 6 | voice-create, voice-analyze, voice-apply, voice-blend, ai-pattern-detection, brand-compliance |
| **Testing & Quality** | 8 | auto-test-execution, test-coverage, test-sync, mutation-test, flaky-detect, flaky-fix, tdd-enforce, qa-protocol |
| **Forensics & Security** | 8 | linux-forensics, memory-forensics, cloud-forensics, container-forensics, sigma-hunting, log-analysis, ioc-extraction, supply-chain-forensics |
| **SDLC & Workflow** | 10 | sdlc-accelerate, sdlc-reports, gate-evaluation, approval-workflow, iteration-control, risk-cycle, parallel-dispatch, decision-support |
| **Documentation** | 6 | doc-sync, doc-scraper, doc-splitter, llms-txt-support, pdf-extractor, source-unifier |
| **Artifacts & Traceability** | 6 | artifact-orchestration, artifact-metadata, artifact-lookup, traceability-check, claims-validator, citation-guard |
| **Research** | 2 | grade-on-ingest, auto-provenance |
| **Infrastructure** | 5 | config-validator, template-engine, code-chunker, decompose-file, workspace-health |
| **Iteration** | 4 | agent-loop, issue-driven-ralph, cross-task-learner, reflection-injection |
| **Other** | 19 | performance-digest, competitive-intel, audience-synthesis, skill-builder, skill-enhancer, skill-packager, quality-checker, nl-router, tot-exploration, and more |
---
## Framework Deep Dives
### SDLC Complete — Full Software Development Lifecycle
The SDLC framework implements a phase-gated development lifecycle with 90 specialized agents, 34 enforcement rules, and 170+ artifact templates. Natural language commands drive phase transitions with automated quality gates.
```
┌──────────┐ ┌─────────────┐ ┌──────────────┐ ┌────────────┐ ┌────────────┐
│ CONCEPT │───▶│ INCEPTION │───▶│ ELABORATION │───▶│CONSTRUCTION│───▶│ TRANSITION │
│ │ │ │ │ │ │ │ │ │
│ Intake │ │ Vision │ │ Architecture │ │ Code │ │ Deploy │
│ Wizard │ │ Requirements│ │ Risk Retire │ │ Test │ │ Hypercare │
│ Solution │ │ Stakeholder │ │ Prototype │ │ Review │ │ Handoff │
│ Profile │ │ Analysis │ │ API Design │ │ Iterate │ │ Knowledge │
└──────────┘ └──────┬──────┘ └──────┬───────┘ └─────┬──────┘ └────────────┘
│ │ │
┌──▼──┐ ┌──▼──┐ ┌──▼──┐
│ LOM │ │ ABM │ │ IOC │ ← Quality Gates
│Gate │ │Gate │ │Gate │
└─────┘ └─────┘ └─────┘
LOM = Lifecycle Objectives Milestone ABM = Architecture Baseline Milestone
IOC = Initial Operational Capability
```
**SDLC Flow Commands (24):**
| Command | Phase | What It Does |
|---------|-------|-------------|
| `/intake-wizard` | Concept | Generate project intake form from natural language description |
| `/intake-start` | Concept→Inception | Validate intake, kick off with agent assignments |
| `/intake-from-codebase` | Concept | Scan existing codebase, generate intake from analysis |
| `/flow-concept-to-inception` | Concept→Inception | Phase transition with intake validation and vision alignment |
| `/flow-inception-to-elaboration` | Inception→Elaboration | Architecture baselining and risk retirement |
| `/flow-elaboration-to-construction` | Elaboration→Construction | Iteration planning, team scaling, full-scale development |
| `/flow-construction-to-transition` | Construction→Transition | IOC validation, production deployment, operational handover |
| `/flow-discovery-track` | Any | Prepare validated requirements one iteration ahead of delivery |
| `/flow-delivery-track` | Any | Test-driven development, quality gates, iteration assessment |
| `/flow-iteration-dual-track` | Any | Synchronized Discovery + Delivery workflows |
| `/flow-deploy-to-production` | Transition | Strategy selection, validation, automated rollback, regression gates |
| `/flow-incident-response` | Operations | Triage, escalation, resolution, post-incident review (ITIL) |
| `/flow-security-review-cycle` | Any | Continuous security validation, threat modeling, vulnerability management |
| `/flow-performance-optimization` | Any | Baseline, bottleneck ID, optimization, load testing, SLO validation |
| `/flow-retrospective-cycle` | Any | Structured feedback, improvement tracking, action items |
| `/flow-change-control` | Any | Baseline management, impact assessment, CCB review, communication |
| `/flow-risk-management-cycle` | Any | Continuous risk identification, assessment, tracking, retirement |
| `/flow-compliance-validation` | Any | Requirements mapping, audit evidence, gap analysis, attestation |
| `/flow-knowledge-transfer` | Transition | Assessment, documentation, shadowing, validation, handover |
| `/flow-team-onboarding` | Any | Pre-boarding, training, buddy assignment, 30/60/90 day check-ins |
| `/flow-hypercare-monitoring` | Transition | 24/7 support, SLO tracking, rapid issue response |
| `/flow-gate-check` | Any | Multi-agent phase gate validation with comprehensive reporting |
| `/flow-handoff-checklist` | Any | Handoff validation between phases and tracks |
| `/flow-guided-implementation` | Construction | Bounded iteration with issue-to-code automation |
**SDLC Accelerate — Idea to Construction-Ready in One Command:**
```bash
# From a description
aiwg sdlc-accelerate "AI-powered code review tool with GitHub integration"
# From existing codebase
aiwg sdlc-accelerate --from-codebase .
# Resume interrupted pipeline
aiwg sdlc-accelerate --resume
```
Generates intake form, vision document, use cases, architecture baseline, risk register, test strategy, and deployment plan — all with human approval gates between phases.
**Dual-Track Iteration Model:**
```
┌─────────────────────────────────────────────────┐
│ ITERATION N │
│ │
│ Discovery Track Delivery Track │
│ (Next iteration) (Current iteration) │
│ │
│ ┌─────────────┐ ┌──────────────┐ │
│ │ Requirements│ │ Implement │ │
│ │ Research │ │ Test │ │
│ │ Design │ │ Review │ │
│ │ Validate │ │ Deploy │ │
│ └─────┬───────┘ └──────┬───────┘ │
│ │ │ │
│ └────────────┬────────────┘ │
│ │ │
│ ┌──────▼──────┐ │
│ │ Iteration │ │
│ │ Assessment │ │
│ └─────────────┘ │
└─────────────────────────────────────────────────┘
```
**Metrics & Quality Tracking:**
| Metric Category | Metrics Tracked |
|-----------------|-----------------|
| **DORA** (4) | Deployment Frequency, Lead Time, Change Failure Rate, MTTR |
| **Velocity** (3) | Story Points, Cycle Time, Throughput |
| **Flow** (3) | WIP Limits, Flow Efficiency, Blocked Items |
| **Quality** (13) | Test Coverage (4), Defect Metrics (4), Code Quality (3), Technical Debt (2) |
| **Operational** (16) | SLO/SLI (5), Infrastructure (4), Incidents (4), Cost (3) |
### Forensics Complete — Digital Forensics & Incident Response
Full DFIR investigation workflow following NIST SP 800-86, with MITRE ATT&CK mapping and Sigma rule hunting.
```
┌──────────┐ ┌──────────┐ ┌────────────┐ ┌──────────┐ ┌──────────┐
│ SCOPE │───▶│ TRIAGE │───▶│ ACQUIRE │───▶│ ANALYZE │───▶│ REPORT │
│ │ │ │ │ │ │ │ │ │
│ Profile │ │ Volatile │ │ Evidence │ │ Log │ │ Executive│
│ target │ │ data │ │ collection │ │ Timeline │ │ summary │
│ system │ │ capture │ │ Chain of │ │ IOC │ │ Findings │
│ │ │ RFC 3227 │ │ custody │ │ Sigma │ │ Timeline │
└──────────┘ └──────────┘ └────────────┘ └──────────┘ └──────────┘
│
SHA-256 hash
verification
```
**Investigation Commands:**
```bash
/forensics-profile # Build target system profile via SSH
/forensics-triage # Quick triage following RFC 3227 volatility order
/forensics-acquire # Evidence acquisition with chain of custody
/forensics-investigate # Full multi-agent investigation workflow
/forensics-timeline # Build correlated event timeline
/forensics-hunt # Threat hunt using Sigma rules
/forensics-ioc # Extract and enrich IOCs
/forensics-report # Generate forensic investigation report
/forensics-status # Show investigation dashboard
```