AIWG

Reusable project context and specialist workflows for the AI tools you already use.

Plan software, coordinate specialist reviews, prepare campaigns, investigate incidents, organize research, curate media, and maintain operational knowledge. AIWG combines agents, skills, rules, templates, and workflow utilities around these tasks, adapting them to your existing AI provider.

Project artifacts carry decisions from one session to the next. Domain frameworks supply the procedures; addons extend them with writing profiles, task loops, memory, testing tools, and other capabilities. The sections below show what you can do, how the pieces work together, and how to use them.

The simplest setup is to paste this into a supported AI provider:

Install or repair AIWG for this project by following
https://aiwg.io/setup.aiwg.yaml
Explain the plan before changing anything, preserve my existing work, and ask
me only for choices you cannot safely determine.

The installer detects old, broken, duplicate, and development-mode installs, then guides you through repair or update. It deploys the preferred complete system with one self-verifying aiwg use all command. That command refreshes the indices, regenerates project context, verifies the resulting deployment, and reports whether a provider reload is actually required.

For long-running agents that need an isolated executor, optionally install AIWG Cockpit with a self-hosted Agentic Sandbox executor you control and audit:

Install or repair AIWG Cockpit and Agentic Sandbox by following
https://aiwg.io/agentic-sandbox/setup.aiwg.yaml
Install the required prerequisites, explain the plan before changing anything,
preserve my existing work, and ask me about the isolation, network, storage,
and access choices you cannot safely determine.

This option audits the host, installs the approved Docker or KVM/libvirt runtime and sandbox prerequisites, connects Cockpit to the real executor, applies your resource and access choices, and verifies the control and audit path end to end.

If you prefer to install manually:

npm i -g aiwg
cd /path/to/your/project
aiwg use all --provider <provider>

Replace <provider> with your AI tool's name, such as claude, codex, copilot, cursor, omp, or pi.

The final command deploys, indexes, connects, verifies, and reports one outcome. The standalone index, regenerate, status, and doctor commands remain available for advanced maintenance and troubleshooting; they are not extra install steps.

For the complete beginner path and provider-name table, see Install, Connect, and Verify.

For a lightweight install that resolves signed, versioned resources from the release host, install the executable:

npm i -g @aiwg/cli

Find the architecture-evolution workflow, read its requirements, and help me apply it to this project.

See Web-Backed AIWG Resources for source selection, exact-version overrides, cache verification, offline use, and the current framework-graph constraints.

For a larger project, ask your AI assistant to establish project policy as well. The agent-led setup conversation should establish remotes, issue storage, delivery behavior, signing policy, and provider choices; the assistant discovers the project-setup workflow and handles its tools.

macOS users: if npm fails with EACCES under /usr/local/lib/node_modules, use the macOS Install Guide. Agents and stewards setting up AIWG end-to-end should use the Agentic Install Runbook.

Get Started · Features · Agents · Documentation · Community · Badges

Installation Troubleshooting

Optional native features

The base global install intentionally excludes native packages whose lifecycle scripts require explicit trust. Core deployment, discovery, and provider tooling work without them. Enable only the capability you need:

Enable the native features needed for interactive terminals, semantic search, or graph-backed artifacts in this workspace. Explain which dependencies are required, install only the selected features, and verify they load.

The feature installer writes a private manifest and lockfile under the AIWG user data directory and approves scripts only for that feature. Do not set a broad user-level npm allow-scripts policy. If an older install left native package files present but unbuilt, aiwg doctor reports the broken capability and the same scoped rebuild command.

macOS npm EACCES

If npm install -g aiwg fails with EACCES while writing to /usr/local/lib/node_modules/aiwg, npm is using a system-owned global install directory. The Node.js setup guide covers the supported runtime and version-manager choices. After setting up Node, run:

npm install -g aiwg
aiwg doctor

If Node is already installed and you need a quick recovery, one manual alternative is a user-owned npm prefix. Choose this only after checking your existing Node version-manager configuration:

npm config set prefix ~/.local
echo 'PATH="$HOME/.local/bin:$PATH"' >> ~/.profile
echo 'source ~/.profile' >> ~/.zprofile
source ~/.profile
npm install -g aiwg

See macOS Install Guide for the full walkthrough. Avoid sudo npm install -g aiwg as the default fix; it can create root-owned npm files that break later upgrades.

aiwg command not found

If aiwg is not found after npm i -g aiwg, the npm global bin directory is not on your PATH. Confirm and fix:

Diagnose why this shell cannot find AIWG. Check the npm installation and PATH, and apply the appropriate local fix.

You can also invoke AIWG without adjusting PATH by using npx aiwg doctor. For a broader health check — version, deployed providers, missing dependencies, kernel-skill probes — run aiwg doctor. See the troubleshooting guide for the full recovery paths.

What AIWG Is

AIWG gives your AI assistant reusable project context and specialist workflows. Its deployment layer connects those instructions to your provider: aiwg use copies markdown and YAML source files into the paths each provider reads, so one source of truth works across 18 named provider integrations. A nineteenth generic adapter emits portable files for unrecognized or custom harnesses and is not counted as a named integration.

Around that core, AIWG ships agent-facing utilities for work that benefits from additional structure: persistent artifact memory (.aiwg/), background orchestration, autonomous loops, artifact indexing, cost telemetry, health diagnostics, and more. These are tools the agent calls when the task calls for them — you stay in chat. 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 supports project deployments, additive user mirrors, and a user-global bootstrap:

• Project scope — default. Run aiwg use all --provider <provider> from a project root and the artifacts land in that provider's project paths. This keeps project-specific instructions associated with the intended repository. Some providers also use user-level surfaces; check the reported deployment scope. This is the recommended default for new users.
• User scope (additive mirror) — aiwg use all --provider <provider> --scope user keeps the project deployment and mirrors it to ~/.claude/agents/, ~/.claude/skills/, etc.
• Global bootstrap — aiwg use all --provider claude --global installs framework and kernel assets in native user-level paths while leaving only lightweight context and provider bootstrap files in the current project. Ask the assistant to connect additional projects without deploying their own skill copies.

Shared user-level instructions can be useful for personal conventions, while project-local instructions keep a team's requirements and decisions with its repository. Review both scopes when a provider uses them together. The installer and provider inventory describe where files will go, so you can distinguish instructions that follow you across projects from instructions intended for this workspace.

See the Agentic Install Runbook for the zero-to-running setup path, and the CLI reference (under aiwg use → "Scope models") for the per-provider details and the global-install rough-edge inventory.

Simple Building Blocks

AIWG's workflow source is readable and editable. The main building blocks are:

• Agents — specialist role instructions, such as Security Auditor or Test Architect, with defined responsibilities and supported tool access.
• Skills — reusable procedures an agent can find from a goal and follow during a task.
• Commands — explicit ways to request a workflow through the provider or CLI.
• Rules — constraints for the assistant to follow, with tool-based checks where configured.
• Behaviors — lifecycle actions and hooks on providers that support them.
• Templates — structures for requirements, briefs, review reports, runbooks, and other outputs.

Many assets use Markdown with YAML metadata; hooks and utilities may also include executable scripts or structured configuration. The provider determines how each asset is loaded or invoked. A role definition is not a separate model, and a written rule is not proof that its constraint was enforced.

Why It Compounds

The building blocks become more useful when workflows share their outputs:

• A requirements analyst records acceptance criteria that the test engineer can later use to review coverage.
• A security reviewer reads the same design decision as the implementation agent and records concerns against that decision.
• A campaign brief gives content writers a shared audience, message, and review criteria.
• A research note connects a source to the claim it supports, so a later synthesis can revisit the original evidence.
• A runbook carries verification and recovery steps from planning into an operational change.

Frameworks package these relationships: agents, skills, rules, and templates reference one another, while .aiwg/ holds the project-specific work they produce. A review can follow Primary Author → Reviewers → Synthesizer → Approval → Archive, using parallel execution where the provider and task support it.

For example, Monday's architecture review can become Thursday's implementation checklist. The second session needs to read the saved artifact and check that it is still applicable, but the team has a concrete record to work from rather than reconstructing the decision from conversation fragments.

Research on structured artifacts, multi-agent review, and recovery informs this design. The research foundations section preserves that background separately from claims about AIWG's own performance.

How You Actually Use AIWG

Describe the outcome you want in your AI tool. You do not need to learn a new command language or memorize skill names: “Help me start a project,” “Review this design for security risks,” or “Prepare a deployment plan with rollback.”

The assistant interprets your intent, searches AIWG's capability graphs, reads the matching assets, and follows their procedures. Discovery brings together packaged AIWG capabilities and indexed project-local custom skills, agents, rules, and workflows; user-level assets participate when project policy allows them. Your team's indexed assets can therefore be found through the same conversation as AIWG's built-in capabilities. Newly authored assets need to be deployed or indexed before discovery can find them.

For everyday setup and maintenance, ask:

• “Set up the SDLC framework for this project and my AI tool.”
• “Help me configure this project's tracker, delivery, signing, and provider preferences.”
• “Create a new project for this idea.”
• “Check which AIWG capabilities are active here and fix any setup problems.”
• “Update AIWG and refresh this project's deployed assets.”

The assistant handles discovery, artifact lookup, and the selected workflow's tools, then reports the result and its verification. Matching a capability is a starting point: the assistant still checks scope, prerequisites, and project policy before acting.

For manual setup and maintenance, the usual commands are aiwg use, aiwg init, aiwg refresh, and aiwg doctor. The assistant handles other tooling. Advanced command syntax lives in the CLI reference.

Deployment connects the supported workflow surface. Optional servers, storage services, and automation paths have their own prerequisites; installing assets does not mean all those services are running. You can start with one review or document task, then enable additional utilities as the work requires.

What AIWG Is Not

AIWG adds context, procedures, and support utilities around the AI tools you use. The deployment core writes provider-readable assets; optional orchestration and integration components can invoke provider runtimes or other configured services. The architecture overview distinguishes those components.

It does not replace your provider subscription, your application's runtime, or the review needed before using generated work. Most workflows operate on project artifacts and source files rather than requiring your application to import an AIWG library. Keep generated configuration and project artifacts under the same review discipline as other repository changes.

Who It's For

AIWG is useful to individual developers, engineering teams, technical leaders, researchers, marketers, and operators whose work spans several tasks or sessions. It helps when you need reusable instructions, a shared record of decisions, or reviews from more than one perspective.

You can start at several levels: a small documentation review, a focused code audit, a campaign brief, an investigation plan, or a complete development lifecycle. The capability guide offers task-based routes, while this README keeps the broader feature and workflow detail available below.

What Problems Does AIWG Solve?

AI-assisted projects often need a deliberate way to carry context forward, recover from failed attempts, and make review criteria explicit. AIWG provides workflows and artifacts for each of those needs.

1. Maintaining Context Across Sessions

Useful decisions can become scattered between conversations, issues, and source files. AIWG workflows save project outputs in .aiwg/, including requirements, architecture decisions, risk notes, test strategies, and campaign material.

A later task can consult the relevant artifact and link its own work back to it. The requirements analyst writes a use case; the test engineer reads it to identify missing coverage; the implementation review checks whether the behavior matches the acceptance criteria. A changed decision can be recorded and propagated through those relationships.

The structure also helps an agent select context for a large project. Instead of treating every file as equally relevant, a task can begin with a requirement, design record, or source note and follow its supporting references. Artifact lookup and indexing utilities help locate those records as the collection grows.

The benefit depends on keeping artifacts current and actually consulting them. A saved file is a reusable source of context, not a guarantee that every later response will use it correctly.

2. Recovering from Failed Attempts

A failing test or incomplete task needs a diagnosis, not just another attempt with the same assumptions. Agent loops support an execute-and-verify cycle that records failure information, adapts the next attempt, and stops at configured limits or escalation conditions.

Use a loop for a bounded change with an observable completion criterion: fixing a regression, bringing a module under test, or carrying out a migration plan. External loop tooling adds process and session recovery where supported. Its usefulness depends on the provider, environment, task boundaries, and verification command; unattended execution is not a guarantee of completion.

The record of attempts can help a later session understand what was tried and why it failed. That makes the recovery process reviewable even when the agent needs human input or cannot complete the task.

3. Making Quality Criteria Explicit

Different reviews ask different questions. A security review examines exposure and trust boundaries; a performance review examines expected load and bottlenecks; a test review checks whether acceptance criteria are exercised; a writing review checks audience, clarity, and support for claims.

AIWG supplies specialist roles and workflows that separate these concerns, combine their findings, and record open decisions. Phase gates can check whether the required artifacts and reviews are ready before the work advances. Project policy determines who must approve a decision and which checks are required.

Multiple reviewers can still share an error. The practical benefit is a clearer review procedure and a saved account of the findings, with tests or other independent checks where available.

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. Artifacts provide retrievable project knowledge that can ground later work in recorded decisions and sources.

Artifacts can be referenced with @-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

AIWG provides specialist role definitions organized by domain. A workflow can route a complex artifact through the reviewers the task requires:

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

Each reviewer receives a defined responsibility and relevant context. The synthesis should resolve duplicate or conflicting findings, preserve uncertainty, and identify which conclusions were checked against sources or tests. Parallel reviews require the corresponding provider capability and available task budget.

3. Learning — Closed-Loop Self-Correction (Agent Loop)

The agent loop executes tasks iteratively and uses verification results to guide the next attempt. Its task record can preserve failure analysis and revised strategies for subsequent iterations.

Agent Loop 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 within configured limits; stop or escalate when required

The external agent loop (agent-loop-ext) adds process tracking, session persistence, and recovery controls. For long-running work, define a time or iteration budget and inspect the provider-specific recovery behavior; surviving a particular failure depends on how the runner and host are configured.

4. Verification — Bidirectional Traceability

AIWG supports links between documentation and code so reviewers can inspect relationships and find drift:

// 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 can follow Doc → Code, Code → Doc, Code → Tests, and Citations → Sources. These relationships make claims easier to inspect; they do not prove that implementation or citations are correct. Ask the workflow to report missing targets, inconsistent behavior, and unsupported source claims.

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

Phase structure gives a team bounded decisions and review points: establish goals during Inception, evaluate design and risks during Elaboration, implement and verify during Construction, and prepare operational handoff during Transition. Templates help make the expected outputs visible. The project determines which artifacts, reviewers, and approval gates are appropriate; a small task need not use the full lifecycle.

6. Style — Controllable Voice Generation

Voice profiles describe writing preferences such as formality, technical depth, directness, examples, uncertainty, and sentence variation. They give the assistant a reusable style specification that can be reviewed against the audience and document purpose.

Built-in voices: technical-authority (docs, RFCs), friendly-explainer (tutorials), executive-brief (summaries), and casual-conversational (blogs, social). Ask “Create a reusable voice profile from these writing samples” to define your own.

A Real Project Walkthrough

The following illustrative customer-portal project shows how ordinary prompts connect the components across a lifecycle. These examples describe requests you can make, not a measured project outcome. The assistant discovers the relevant procedures and reads their instructions before carrying out each request.

Start with a bounded goal, agree on acceptance criteria, and inspect the artifacts at each step. The time and review effort depend on the project, source quality, tools, and decisions involved. Smaller changes can enter at the phase that fits their current state rather than repeating the entire lifecycle.

Inception

Help me define a customer portal with real-time chat. Walk me through the goals, users, constraints, and acceptance criteria.

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

Review the approved intake, develop the architecture and test strategy, and identify the risks we need to resolve.

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: The agent loop 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

Turn the reviewed design into an implementation plan. Implement authentication, verify its acceptance criteria, and run the relevant tests.

Learning: The agent loop 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

Prepare the production rollout with monitoring and rollback. After the required release approval, deploy it and organize fourteen days of early-life support.

Planning: Deployment checklist — monitoring, rollback plan, incident response Learning: Failed validation produces a diagnosis and a revised plan; retries follow the operation's recovery and approval requirements Verification: Deployment scripts reference architecture (which services, what order) Human Gate: Operations team reviews deployment plan → approves production release

Claims, Evaluation, and Evidence

Evaluate a workflow against the task it is meant to support. AIWG provides structures for review, traceability, and recovery; it does not promise a fixed cost saving, perfect citations, or error-free execution.

| Capability to evaluate | Evidence to collect | Useful comparison | |------------------------|---------------------|-------------------| | Persistent project context | Whether a later session reads and applies a prior decision | The same kind of task with the team's usual handoff | | Specialist review | Correct findings, missed issues, and reviewer effort | A comparable review using the existing process | | Task recovery | Failure diagnosis, attempts, limits, and final verification | Similar failures handled without the loop | | Citation checking | Source existence and support for each material claim | Manual source inspection | | Structured planning | Completeness and usefulness of the resulting plan | The team's existing planning artifact | | Cost and throughput | Model calls, elapsed time, and human review effort | Comparable tasks with the same acceptance criteria |

Research results from Agent Laboratory, self-consistency, tree search, and other systems inform the design. Their percentages and benchmark scores are not measurements of AIWG. The research foundations and reading list retain the underlying sources. The executive brief describes a practical pilot.

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

A full lifecycle is usually unnecessary for a one-off question that needs no shared context, saved artifact, or follow-up. A focused writing, lookup, or review capability can still be useful without introducing every phase and gate.

Examples: "Write a Python script to parse this CSV," "Fix this typo," "Explain how this code works."

The Trade-off

Match the workflow to the task. Use a bounded skill for a small result, a saved artifact when work needs to carry forward, and a phase-based process when coordination and review warrant it. Additional context, reviewers, or verification steps can add model calls and human effort; judge their value against the outcome you need.

User intent → AIWG CLI → Deploy agents + rules + templates → AI platform
                │                                                │
                ▼                                                ▼
         "aiwg use all --provider X"                  Claude Code / Copilot /
                │                                     Cursor / Warp / Factory /
                ▼                                  OpenCode / Codex / Devin Desktop
         ┌──────────────┐
         │ Agents       │  Specialized AI personas with domain expertise
         │ Commands     │  CLI + slash commands for workflow automation
         │ Skills       │  Natural language workflow triggers
         │ Rules        │  Enforcement patterns (security, quality, anti-laziness)
         │ 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. The prose walkthrough lives in docs/how-it-works.md.

At a glance — the deployment layer copies instructions into provider-readable locations, connects project context, and reports verification. The provider loads those instructions. Optional runtime components, such as artifact services or orchestration tools, perform additional work when configured and invoked.

flowchart LR
  subgraph Source["AIWG framework source"]
    direction TB
    KERN["Kernel skills<br/>within provider listing budgets"]
    STD["Standard skills<br/>read from $AIWG_ROOT"]
    AGENT["Specialist agents"]
    RULES["Workflow rules"]
    TPL["Artifact templates"]
  end

  CLI(["aiwg use all<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(["Assistant capability discovery<br/>+ asset lookup"])
  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

• Specialist agents — roles for architecture, implementation, testing, security, cloud, data engineering, research, content, and operations.
• Workflow skills and commands — discoverable procedures for reviews, intake, research, curation, planning, and delivery.
• Rules and review criteria — instructions for preserving work, handling sensitive configuration, checking claims, and reporting verification.
• Artifact templates — structured requirements, design decisions, campaign briefs, source notes, runbooks, and review reports.
• Multi-provider deployment — Google Antigravity CLI, Claude Code, OpenAI Codex, GitHub Copilot, Cursor, DeepSeek Harness, Factory AI, Hermes, OpenCode, OpenClaw, OpenHuman, Pi Coding Agent, Oh My Pi, Warp Terminal, and Devin Desktop.
• Domain frameworks — software development, forensics, marketing, research, media curation, operations, knowledge base, and security engineering.
• Dataset workflows — assessment, indexing, lineage, synchronization, and retirement through dataset intelligence; the separate aiwg-training project covers training-data curation and exports.
• Memory addons — compound memory, line memory, wiki-oriented knowledge, and artifact lookup for different persistence needs.
• Writing and voice tools — reusable voice profiles, context-sensitive diagnostics, revision workflows, and alternatives for content generation.
• Testing quality — test conformance, reversible normalization, mutation testing, and flaky-test review. See the AIWG test conformance example for reviewed source controls and runner evidence.
• Agent loops — bounded execution, failure analysis, checkpoints, and supported process recovery.
• RLM — recursive context decomposition for tasks whose source material needs to be divided into smaller working sets.
• YAML metalanguage — structured workflow and artifact definitions with schema-oriented validation.
• MCP integration — tools and resources exposed through configured servers and provider connections.
• Traceability and provenance — relationships between requirements, code, tests, sources, and generated artifacts.
• Session history and diagnostics — import and inspect prior AI work, check deployment health, and diagnose provider wiring.
• Project-local extensions and marketplace delivery — keep custom instructions with the project and package reusable capabilities through the appropriate distribution path.

The framework and addon catalog below describes these capabilities in more detail. Compatibility and execution requirements are explicit in the provider inventory and CLI reference.

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 for details.

Release verification: Inspect the provenance and signature material for the release you install. The verification guide describes the available artifacts and commands.

Install & Deploy

The prompt-led installer at the top of this README is the canonical beginner path. For manual setup:

npm i -g aiwg
cd /path/to/your/project
aiwg use all --provider claude   # replace claude with your provider selector

Deployment refreshes the shared context and reports verification and any required reload. Follow that result, then ask the agent to check the intended project and its AIWG connection. The manual installation reference covers the terminal path in detail.

For a deliberately narrower deployment, choose the relevant framework or addon instead of all. These are alternatives, not a sequence of required setup steps:

aiwg use sdlc --provider claude          # Software development
aiwg use forensics --provider claude     # Investigation workflows
aiwg use marketing --provider claude     # Campaign and content work
aiwg use media-curator --provider claude # Media collections
aiwg use research --provider claude      # Research artifacts
aiwg use civic-action --provider claude  # Civic review and preparation
aiwg use rlm --provider claude           # Context decomposition

For maintenance or an existing workspace that needs context migration, preview the relevant regeneration branch rather than treating every branch as installation:

Preview how to refresh this workspace’s provider context. If it needs existing-project extraction or migration, explain the proposed changes, preserve project-specific instructions, and verify the result.

The regeneration guide also covers canonical refresh and legacy compatibility. Use the branch that matches the workspace state. To scaffold a new project rather than connect the current one, see the new-project guide.

Get a First Useful Result

After setup, ask your agent:

Use AIWG to review this project's README for unclear positioning and missing
onboarding steps. Save a report at
.aiwg/marketing/brand/audit/readme-review.md with file references and the
three highest-priority fixes. Leave the README unchanged.

Open the report and check the source references, reader impact, and proposed fixes. In a later session, ask the agent to read that report and implement the first agreed change. The first-result walkthrough includes an illustrative finding and alternative tasks. Setup readiness is the prerequisite; a useful artifact is what lets you assess the workflow.

Customize Without Forking

Author project-specific rules, skills, agents, addons, or frameworks directly under .aiwg/{extensions,addons,frameworks}/<name>/. Use .aiwg/plugins/<name>/ only when you are wrapping a bundle for marketplace delivery. No fork, no rebuild. Discovered automatically by aiwg use.

Create a project-local extension named my-team-rules with a starter rule. Deploy it here, check its health, and help me prepare it for upstream promotion once it is proven.

The bundle is byte-identical in shape to its upstream form, so promotion uses a hash-verified copy with zero rewrite. See the customization guide for the three paths (project-local, fork, corpus).

Claude Code Marketplace (Alternative)

Add the AIWG marketplace to Claude Code and install the SDLC, Agent Loop, and Compound Memory plugins.

The marketplace contains independently packaged framework and addon plugins, so you can install only the capabilities a Claude Code workspace needs. Source-distributed opt-in addons such as Civic Action deploy with aiwg use civic-action and do not imply a marketplace wrapper.

Multi-Platform Deployment

aiwg use all --provider antigravity    # Google Antigravity CLI (alias: agy)
aiwg use all --provider claude         # Claude Code
aiwg use all --provider codex          # OpenAI Codex
aiwg use all --provider copilot        # GitHub Copilot
aiwg use all --provider cursor         # Cursor
aiwg use all --provider factory        # Factory AI
aiwg use all --provider opencode       # OpenCode
aiwg use all --provider warp           # Warp Terminal
aiwg use all --provider devin          # Devin Desktop
aiwg use all --provider openclaw       # OpenClaw
aiwg use all --provider hermes         # Hermes
aiwg use all --provider openhuman      # OpenHuman
aiwg use all --provider pi             # Pi Coding Agent
aiwg use all --provider omp            # Oh My Pi
aiwg use all --provider muse           # Muse Code

all means the complete deployable end-user surface. It intentionally omits contributor-only development bundles and packages that cannot be deployed directly.

First-Party Integrators

AIWG can also be distributed through another runtime. Check the integrator's version and included assets before assuming that its bundled surface matches a standalone AIWG install. Follow that runtime's setup instructions, then verify the project connection.

| Partner | Install | What you get | |---------|---------|--------------| | Omnius | npm i -g omnius | An integration path for AIWG assets in an autonomous coding runtime. Consult the package documentation for the bundled version, supported asset surface, and setup requirements. |

If you ship a product that bundles AIWG and want to be listed here, open an issue at https://github.com/jmagly/aiwg/issues.

What You Get

AIWG installs reusable context, specialist agents, workflow skills, rules, and artifact templates into the AI tools your team already uses. This fragment keeps the older README's broad inventory shape while updating claims against the current repository. Counts shown in framework rows are source-file counts from this working tree; addon rows omit totals because several addons expose capabilities through manifests, docs, scripts, or nested skill packages.

Frameworks

| Framework | Source Snapshot | What It Helps You Do | |-----------|-----------------|----------------------| | SDLC Complete | 100 agents, 116 skills, 217 templates, 39 rules, 12 commands, 8 flows | Run a full software delivery lifecycle from intake through transition with phase gates, planning artifacts, implementation support, test strategy, deployment handoff, and maintenance workflows | | Forensics Complete | 13 agents, 20 skills, 12 templates, 4 rules | Preserve and analyze incident evidence through scoping, triage, acquisition, log review, persistence hunting, timeline building, IOC extraction, and reporting | | Media/Marketing Kit | 38 agents, 34 skills, 97 templates, 2 flows | Plan, produce, review, publish, and analyze marketing campaigns with reusable briefs, brand/legal gates, channel assets, and performance artifacts | | Media Curator | 6 agents, 21 skills | Assess mixed media collections, research sources, acquire approved material, tag metadata, verify integrity, create transcript sidecars, and prepare exports or research handoffs | | Research Complete | 8 agents, 41 skills, 16 templates | Turn literature searches and PDFs into reviewable research artifacts: source records, grounded summaries, citation work, GRADE/FAIR-style quality checks, gap notes, and provenance | | Knowledge Base | 3 skills, 5 templates | Build a linked AI-assisted wiki from loose sources, notes, entities, concepts, comparisons, and synthesis pages without forcing formal literature-review overhead | | Ops Complete | 12 agents, 1 skill, 17 templates, 6 rules | Convert operational procedures into executable runbooks, inventories, incident reports, troubleshooting trees, and extension-backed ops workflows | | Security Engineering | 2 agents, 27 skills, 7 templates, 13 rules | Make applied security decisions for crypto primitives, chains of trust, auth factors, degraded modes, runtime secrets, supply-chain trust, physical threats, and DFIR readiness | | Validation Complete | 1 skill | Add focused validation workflow support where a project needs reviewable checks without adopting a full lifecycle framework |

Start with Install, Connect, and Verify, then deploy a framework with aiwg use <framework>. The capability reference lists the current framework names accepted by the CLI.

Addons

| Addon | What It Helps You Do | |-------|----------------------| | AIWG Utils | Shared rules, discovery helpers, regeneration support, mention tooling, workspace maintenance, and stewardship primitives used across AIWG | | Agent Loop | Run bounded iterative agent loops with recovery, reflection, completion tracking, and resumable progress tracking | | RLM | Decompose large codebases or document corpora into smaller reviewed slices through recursive planning and subtask execution | | Composition Engine | Define and validate provider-neutral Flow graph contracts for composed workflows | | Graph Pattern | Add an optional graph-oriented profile over AIWG Flow for conditional routes, reducers, and graph validation | | Orchestration Topology Lab | Compare single-agent, bounded-parallel, and planner-worker orchestration topologies using local fixtures and explicit evidence | | Guided Implementation | Keep issue-to-code work inside a bounded retry loop with validation after each attempt and structured escalation when needed | | Daemon | Run opt-in persistent session support for background tasks, queues, health checks, and scheduler integration | | Agentic Installer | Use setup.aiwg.io/v1 SetupManifest files for reproducible, agent-driven install workflows with recovery paths | | AIWG Dev | Scaffold and validate AIWG source packages, skills, agents, commands, and rules; install explicitly for contributor work | | Skill Factory | Build, enhance, validate, and package skills through a dedicated skill-authoring workflow | | AIWG Evals | Run agent and workflow evaluation patterns with explicit benchmark inputs and quality scoring | | Monitorability Red Team | Exercise synthetic local fixtures that expose multi-agent monitoring limits and evidence blind spots | | Long-Context Bench | Benchmark compressed skim plus exact recovery against current context baselines | | Natural-Language Harness | Map inspectable natural-language policy documents to deterministic AIWG mechanisms and ablation reports | | Premortem v2 | Generate, select, and independently verify bounded risk sets before execution | | Century Readiness | Review long-horizon stewardship, degradation, replacement, evidence, and meaning-preservation risks | | Dataset Intelligence | Route dataset intake, planning, materialization, traceability, verification, export, synchronization, and retirement through governed workflows | | Schema Governance | Discover, author, validate, evolve, and normalize schemas across datasets and SDLC artifacts | | Compound Memory | Govern promotion from raw evidence and session candidates into line memory or linked wiki knowledge with lineage | | Line Memory | Keep a bounded plain-text set of durable project facts with recency retention and reviewed lifecycle operations | | LLM Wiki | Maintain a Markdown wiki topology for entities, concepts, sources, comparisons, and syntheses | | Semantic Memory | Provide topology-agnostic memory operations for ingest, lint, query/capture, and event logging | | Auto Memory | Seed Claude Code Automatic Memory files with AIWG-aware testing, debugging, and architecture sections | | Agent Persistence | Supply reusable human-in-the-loop gate definitions for destructive actions, overrides, and recovery escalation | | AIWG Hooks | Provide hook templates for workflow tracing, permissions, session management, context injection, and quality gates | | AIWG Fleet | Apply quiet-bot, mention-only participation, and small-plan cost-discipline policies across multi-project fleets | | Browser Control | Drive a user-authorized Chromium-derived browser through Playwright MCP with allow-list and audit boundaries | | Droid Bridge | Bridge Claude Code to Factory Droid for batch operations and automated fixes through MCP | | MCP/UAT Toolkit | Generate, execute, and report user-acceptance tests against MCP tool surfaces | | Civic Action | Prepare evidence-bound civic research, public-records planning, meeting review, local-resource profiles, corrections, and publication review | | Network Analysis | Governed saved-PCAP/PCAPNG analysis with bounded TShark recipes, cited packet evidence, and optional local Termshark review | | Testing Quality | Assess test conformance, normalize suites with reversible plans, and add TDD, mutation, flaky-test, and factory workflows | | Writing Quality | Review editorial quality, author requirements, and voice consistency without treating heuristic scores as authorship proof | | Voice Framework | Define, analyze, blend, and apply reusable writing voice profiles and runtime-selectable output modes | | Color Palette | Generate and review accessible color palettes using color theory, trend research, and WCAG checks | | Doc Intelligence | Scrape, extract, split, audit, and synchronize documentation sources | | Prose Integration | Detect, read, validate, wire, and run OpenProse contract programs in supported AIWG sessions | | NLP Prod | Design and productionize LLM inference pipelines with eval-first, pattern-guided workflow support | | Context Curator | Filter distractors and curate context packs for agent work where irrelevant material can derail results | | Twelve-Factor | Review or design applications against Twelve-Factor and modern cloud-native criteria | | Verbalized Sampling | Apply and evaluate verbalized probability-distribution prompting for output diversity experiments | | Star Prompt | Offer a tasteful repository-star prompt after successful command completion |

Addon details live in each source directory and, where public docs exist, under docs/addons/. Use Key Addons for a guided end-user selection path.

Agents

Specialized AI personas deploy to your platform with defined responsibilities, tools, and operating rhythms. The exact inventory changes as frameworks evolve, so this README keeps durable groupings and examples instead of relying on one global total.

SDLC Agents

| Domain | Examples | |--------|----------| | Testing & Quality | Test Engineer, Test Architect, Mutation Analyst, Regression Analyst, Reliability Engineer | | Security & Compliance | Security Auditor, Security Architect, Compliance Checker, Privacy Officer, Citation Verifier | | Architecture & Design | Architecture Designer, API Designer, Cloud Architect, System Analyst, Product Designer, Decision Matrix Expert | | DevOps & Cloud | AWS Specialist, Azure Specialist, GCP Specialist, Kubernetes Expert, DevOps Engineer, Multi-Cloud Strategist | | Backend & Data | Django Expert, Spring Boot Expert, Data Engineer, Database Optimizer, Software Implementer, Incident Responder | | Frontend & Mobile | React Expert, Frontend Specialist, Mobile Developer, Accessibility Specialist, UX Lead | | AI/ML & Performance | AI/ML Engineer, Performance Engineer, Cost Optimizer, Metrics Analyst | | Code Quality | Code Reviewer, Debugger, Dead Code Analyzer, Technical Debt Analyst, Legacy Modernizer | | Documentation | Technical Writer, Documentation Synthesizer, Documentation Archivist, Context Librarian | | Requirements & Planning | Requirements Analyst, Requirements Reviewer, Intake Coordinator, RACI Expert | | Agent/Tool Smiths | AgentSmith, CommandSmith, MCPSmith, SkillSmith, ToolSmith | | Governance & Meta | Executive Orchestrator, Recovery Orchestrator, Migration Planner |

Forensics Agents

| Agent | What It Does | |-------|-------------| | Forensics Orchestrator | Coordinates investigation scope, evidence handling, analysis, and reporting | | Triage Agent | Captures volatile data following evidence-priority guidance | | Acquisition Agent | Collects evidence with chain-of-custody and hash verification | | Log Analyst | Reviews auth, syslog, journal, and application logs for suspicious activity | | Persistence Hunter | Checks cron, systemd, SSH keys, LD_PRELOAD, PAM modules, and kernel-module indicators | | Container Analyst | Reviews Docker, containerd, and Kubernetes evidence | | Network Analyst | Reviews connection state, DNS, beaconing, and exfiltration indicators | | Memory Analyst | Supports Volatility-style memory forensics workflows | | Cloud Analyst | Reviews AWS, Azure, and GCP audit trails and IAM posture | | Timeline Builder | Correlates events into chronological incident timelines | | IOC Analyst | Extracts and formats indicators for downstream response | | Recon Agent | Builds a target baseline for authorized investigation | | Reporting Agent | Produces structured executive and technical investigation reports |

Marketing Agents

| Domain | Examples | |--------|----------| | 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 |

Other Framework Agents

Research uses discovery, acquisition, documentation, citation, quality, archival, provenance, and workflow roles. Media Curator uses discography/source, acquisition, quality, metadata, and completeness roles. Ops Complete adds runbook execution and inventory roles. Security Engineering adds security specialists for applied security decisions and supply-chain review.

Rules

Rules are durable guardrails that deploy with the frameworks or addons that own them. They prevent common agent failure modes and define review boundaries.

Core Rules

| Rule | Severity | What It Enforces | |------|----------|-----------------| | no-attribution | CRITICAL | AI tools are tools; do not add AI attribution to commits, PRs, docs, or code | | token-security | CRITICAL | Keep tokens and secrets out of source; use scoped lifetime and restricted file permissions | | versioning | CRITICAL | Use the repository's CalVer release format consistently | | citation-policy | CRITICAL | Do not fabricate citations, DOIs, URLs, or research claims | | anti-laziness | HIGH | Do not delete tests, skip required checks, remove features, or weaken assertions to pass | | executable-feedback | HIGH | Run appropriate validation before returning implementation work | | failure-mitigation | HIGH | Detect and recover from hallucination, context loss, instruction drift, safety, technical, and consistency failures | | research-before-decision | HIGH | Inspect the codebase and docs before making technical decisions | | instruction-comprehension | HIGH | Parse prohibitions, requirements, and preferences before acting | | subagent-scoping | HIGH | Keep delegated tasks focused and bounded when delegation is used |

Domain Rules

| Domain | Examples | |--------|----------| | SDLC | HITL gates, provenance tracking, artifact discovery, phase gates, reproducibility validation, agent-friendly code, fallback, review, and handoff rules | | Forensics | Evidence integrity, chain of custody, forensic reporting, and authorized investigation boundaries | | Security Engineering | Cryptographic decision boundaries, runtime secret hygiene, supply-chain trust, physical-access threat modeling, and DFIR readiness handoff | | Ops | Ops safety, executable runbook format, evidence governance, issue tracking, and cross-repo reference rules | | Civic Action | Human authority, citation, publication, public-source, privacy, and anti-targeting boundaries | | Addon Rules | Browser authorization, dataset boundaries, agentic installer safety, voice/output behavior, and hook discipline |

Skills

Skills are natural-language workflows. A user describes an outcome, the agent discovers the relevant skill, loads its instructions, and applies its protocol. The current repo contains a large and changing skill surface, so this section keeps durable categories and examples.

| Category | Examples | |----------|---------| | Capability discovery and setup | aiwg-utils-quickref, steward, aiwg-status, aiwg-doctor, use, provider regeneration | | SDLC and delivery | intake-wizard, sdlc-accelerate, gate evaluation, delivery-track flows, deployment, guided implementation | | Testing and quality | test-conformance, test-normalize, test-platform-research, TDD, mutation, flaky-test review, factory generation | | Security and forensics | supply-chain hardening, auth-factor design, degraded-mode review, DFIR readiness, log analysis, IOC extraction | | Research and knowledge | source acquisition, paper induction, GRADE checks, citation work, wiki ingest, synthesis, knowledge-base health | | Marketing and content | campaign intake, creative brief, brand compliance, social strategy, email campaigns, performance digests | | Media curation | source discovery, acquisition planning, transcript sidecars, metadata tagging, quality filtering, archive verification | | Datasets and schemas | dataset intake, source assessment, capability recommendation, plan review, ingest, trace, verify, export, retire | | Memory and persistence | line-memory operations, compound-memory review, semantic-memory capture/query, llm-wiki topology | | Operations and automation | runbook execution, ops verification, activity logs, hooks, daemon sessions, schedule support | | Authoring and development | skill creation, addon/framework scaffolding, validation, schema governance, doc synchronization |

Framework Deep Dives

SDLC Complete — Full Software Development Lifecycle

The SDLC framework implements a phase-gated development lifecycle with specialized agents, enforcement rules, and artifact templates. Natural-language requests drive phase transitions with reviewable 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 │
                     │Gate │            │Gate │            │Gate │
                     └─────┘            └─────┘            └─────┘

 LOM = Lifecycle Objectives Milestone    ABM = Architecture Baseline Milestone
 IOC = Initial Operational Capability

Example SDLC prompts:

| Ask your assistant | Phase | What It Does | |---------|-------|-------------| | “Help me define the goals and constraints for this project.” | Concept | Generate project intake from a natural-language description | | “Validate our intake and assign the initial work.” | Concept -> Inception | Validate intake and begin agent assignments | | “Understand this codebase and draft its project intake.” | Concept | Scan an existing codebase and generate intake from analysis | | “Turn this concept into an agreed project vision.” | Concept -> Inception | Transition with intake validation and vision alignment | | “Review our architecture and resolve the major risks.” | Inception -> Elaboration | Baseline architecture and retire major risks | | “Plan the implementation from our reviewed design.” | Elaboration -> Construction | Prepare iteration planning, scale delivery, and begin implementation | | “Check whether this implementation is ready for release.” | Construction -> Transition | Validate IOC, deployment readiness, and operational handoff | | “Validate the requirements for the next delivery batch.” | Any | Prepare validated requirements ahead of delivery | | “Implement this batch with tests and quality checks.” | Any | Run test-driven delivery with quality gates | | “Coordinate requirements discovery with the next delivery iteration.” | Any | Coordinate discovery and delivery tracks | | “Prepare this release for production, including rollback.” | Transition | Select deployment strategy, validate, and prepare rollback/regression checks | | “Help us triage this incident and plan recovery.” | Operations | Triage, resolve, and review incidents | | “Review security risks and track the required fixes.” | Any | Run continuous security validation and threat review | | “Find the performance bottlenecks and verify improvements.” | Any | Baseline, identify bottlenecks, optimize, and validate SLOs | | “Review what we learned and track improvements.” | Any | Capture feedback and track improvement actions | | “Assess this change and coordinate its review.” | Any | Assess impact, coordinate review, and manage communication | | “Identify and track the risks to this project.” | Any | Identify, assess, track, and retire risks | | “Map our requirements to evidence and identify gaps.” | Any | Map requirements, collect evidence, and identify gaps | | “Prepare the documentation and operational handover.” | Transition | Prepare documentation, shadowing, validation, and handover | | “Create an onboarding plan for our new teammate.” | Any | Structure onboarding, training, buddy support, and follow-up | | “Organize early-life support for this release.” | Transition | Track early-life support, SLOs, and rapid-response items | | “Review the evidence for our next phase gate.” | Any | Run multi-agent phase-gate validation | | “Check that the next team has a complete handoff.” | Any |