接入你的智能体
发布者自己的命令。不是 PlugMCP 端点。
用我们的密钥与日志托管一份副本。
npx -y [email protected]Claude Code 没有针对本地命令的安装链接。复制下方命令并在终端中运行。
claude mcp add aiwg -- npx -y aiwg@2026.11.5在终端中运行。
{ "mcpServers": { "aiwg": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}claude_desktop_config.json
远程 URL 还是本机命令？ 两种安装方式的区别
来自发布者
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.
Reusable project context and specialist workflows for the AI tools you already use. AIWG places agents, skills, commands, and rules in provider-readable locations, with optional utilities for artifact memory, workflow orchestration, recovery, and discover
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, decision support, 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. Once the CLI is healthy, guided setup records an interview plan, lets you review it, and applies the selected frameworks and integrations through the existing deployment owners. The apply report distinguishes core readiness from optional integration failures.
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 setup --scope project --providers <provider>
aiwg setup --review
aiwg setup --apply
Replace <provider> with your AI tool's name, such as claude, codex,
copilot, cursor, omp, or pi.
The interview saves a plan without changing provider configuration. Review is
read-only; apply asks for confirmation and reports the verified outcome. Optional
Jev decision offload and direct workers require explicit opt-in. Repeating apply
resumes unfinished actions and leaves completed actions alone. See the
guided setup reference for headless flags,
credential references, scope choices, and recovery. For a direct complete-system
deployment, aiwg use all --provider <provider> remains available.
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 · Decision Support · Documentation · Community · Badges
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.
EACCESIf 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 foundIf 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.
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.
aiwg use supports project deployments, additive user mirrors, and a
user-global bootstrap:
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 simplest start
for a single project.aiwg use all --provider <provider> --scope user keeps the
project deployment and mirrors it to ~/.claude/agents/,
~/.claude/skills/, etc.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.Several repositories under one assistant or orchestrating session are supported. See Working Across Multiple Projects for setup, access, and sharing boundaries.
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.
AIWG's workflow source is readable and editable. The main building blocks are:
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.
The building blocks become more useful when workflows share their outputs:
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.
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:
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.
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.
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.
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.
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.
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.
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 .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.
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. Small bounded judgments inside a workflow, such as a yes/no gate or a severity score, can go to decision support instead of a full reasoning pass.
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.
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.
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.
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.
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.
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
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
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
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
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.
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.
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.
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."
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
For visual diagrams of AIWG's architecture, deploy flow, and discovery model, see
docs/architecture-overview.md. The prose walkthrough lives indocs/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.
aiwg-training project covers training-data curation and
exports.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.
Prerequisites: Node.js >=24 and an AI platform (Claude Code, GitHub Copilot, Cursor, Warp Terminal, or others). 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.
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.
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.
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).
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.
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 dsh # DeepSeek Harness
aiwg use all --provider factory # Factory AI
aiwg use all --provider grokbot # Grok Bot
aiwg use all --provider grok-build # Grok Build
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.
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.
If you ship a product that bundles AIWG and want to be listed here, open an issue at https://github.com/jmagly/aiwg/issues.
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.
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.
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.
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.
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 are durable guardrails that deploy with the frameworks or addons that own them. They prevent common agent failure modes and define review boundaries.
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.
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:
SDLC Accelerate — from idea to reviewed planning artifacts:
Turn an AI-powered code review tool with GitHub integration into reviewed intake, architecture, risks, and a delivery plan. Use the existing codebase if present, and resume saved planning work instead of starting over.
It can generate intake, vision, use cases, architecture baseline, risk register, test strategy, and deployment planning artifacts with human review between major 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 and Quality Tracking:
Forensics Complete supports authorized DFIR work following NIST SP 800-86-style evidence handling, MITRE ATT&CK mapping, Sigma hunting, timeline construction, and structured reporting.
┌──────────┐ ┌──────────┐ ┌────────────┐ ┌──────────┐ ┌──────────┐
│ 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
Example investigation prompts:
Profile the affected system, triage the incident, and plan evidence acquisition with chain-of-custody records.
Investigate the collected evidence, build a timeline, and look for related indicators of compromise.
Summarize the findings, unresolved questions, and current investigation status.
Supported Evidence Sources:
Media/Marketing Kit treats campaign work as a lifecycle with artifacts and review gates, so strategy, content, legal/brand review, publication planning, and performance analysis remain inspectable.
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ STRATEGY │───▶│ CREATION │───▶│ REVIEW │───▶│ PUBLISH │───▶│ ANALYZE │
│ │ │ │ │ │ │ │ │ │
│ Research │ │ Copy │ │ Brand │ │ Schedule │ │ KPIs │
│ Audience │ │ Design │ │ Legal │ │ Channels │ │ Reports │
│ Strategy │ │ Content │ │ Quality │ │ Launch │ │ Learnings│
└──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘
Media Curator helps assess, acquire, organize, verify, transcribe, and export media collections. It starts with assessment and planning so unknown or mixed media is routed before downloads or metadata rewrites.
Assess my Pink Floyd collection, identify gaps, and suggest sources for the missing material.
Transcribe
/path/to/media.wavand retain timestamps and source provenance.Review the collection's tags and completeness, assemble the 1973 live recordings, and prepare a Plex export. Verify the archive and report anything unresolved.
Quality tiers help reviewers choose what to keep. Transcript sidecars preserve source hashes, transcript hashes, timestamps, and optional speaker labels for review and later research handoff. Common standards include ID3v2.4, Vorbis Comments, MusicBrainz, PREMIS 3.0, and W3C PROV-O.
Research Complete turns search results and PDFs into source-grounded, reviewable research artifacts with persistent identifiers, quality checks, and provenance.
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ DISCOVER │───▶│ ACQUIRE │───▶│ DOCUMENT │───▶│ ARCHIVE │
│ │ │ │ │ │ │ │
│ Search │ │ Download │ │ RAG │ │ OAIS │
│ databases│ │ PDF │ │ summaries│ │ lifecycle│
│ Rank │ │ Metadata │ │ Citations│ │ FAIR │
│ results │ │ extract │ │ GRADE │ │ W3C PROV │
└──────────┘ └──────────┘ └──────────┘ └──────────┘
Pipeline stages: Discovery -> Acquisition -> Documentation -> Citation ->
Quality Assessment -> Synthesis -> Gap Analysis -> Archival. The framework uses
REF-XXX identifiers, GRADE-style evidence quality labels, FAIR-style checks,
and Unpaywall lookup for open-access discovery. It flags unsupported claims for
review instead of promising error-free summaries.
Knowledge Base is for open-ended knowledge accumulation where the taxonomy emerges over time. It uses entity, concept, source, comparison, and synthesis pages so future sessions can find what is known, what is missing, and how ideas connect.
Ops Complete gives operational procedures a structured envelope: inventory, capabilities, playbooks, gates, targets, schedules, pipelines, and extensions. It is useful when procedures must be idempotent, verifiable, and evidence-aware.
apiVersion: ops.aiwg.io/v1
kind: OpsPlaybook
metadata:
name: deploy-auth-stack
namespace: production
spec:
# Desired state
status:
# Observed state written by the executor
Extensions add domain-specific ops support for systems, IT, development infrastructure, and streaming workflows. See Ops Complete overview and Ops evidence governance.
Security Engineering complements SDLC and forensics by focusing on security decisions that need explicit assumptions and reviewable tradeoffs.
Install with:
aiwg use security-engineering
Validation Complete provides a small validation workflow surface for teams that need structured review without adopting a broader lifecycle. Use it where a project already has its own process but wants AIWG-style validation gates and reports.
Voice Framework defines reusable writing profiles and output modes that can be applied across docs, release notes, campaigns, reports, and internal guidance. It describes the desired voice directly rather than relying only on banned word lists.
Apply the technical-authority voice to
docs/architecture.md.Create a reusable company voice from
blog-posts/*.md, and analyze howdocs/existing-content.mdcompares.Blend technical-authority and casual-conversational voices at a 70:30 ratio for this draft.
AIWG can expose its project context, discovery catalog, and governed workflows through a Model Context Protocol server. This lets MCP-capable tools call AIWG without learning the repository layout or memorizing provider-specific file locations.
The MCP server is useful when you want an assistant to ask AIWG questions such as “what capabilities are available for release planning?”, “show the SDLC quickstart”, or “run this governed workflow and return the evidence artifact.” The base server keeps a small default tool surface; larger toolsets can be enabled explicitly for teams that want richer orchestration, mission, dataset, or framework operations.
Connect this AI tool to AIWG’s MCP server. Start with the default tool surface; enable flow, mission, and catalog operations when this workspace needs them, and verify the connection.
Provider installation depends on the host. AIWG can write MCP configuration for supported targets where the provider has a stable local MCP config format; other providers use the same server command in their own UI or settings.
Configure the AIWG MCP connection for the provider I use in this workspace. Check its supported
Reusable project context and specialist workflows for the AI tools you already use. AIWG places agents, skills, commands, and rules in provider-readable locations, with optional utilities for artifact
{ "mcpServers": { "aiwg": { "command": "npx", "args": [ "-y", "[email protected]" ] } }}概览
Reusable project context and specialist workflows for the AI tools you already use. AIWG places agents, skills, commands, and rules in provider-readable locations, with optional utilities for artifact memory, workflow orchestration, recovery, and discover
工具
暂无工具列表。远程服务器在首次健康检查后会获得工具列表。
常见问题
在本页复制适用于 Cursor、Claude Desktop、Claude Code 或 VS Code 的 stdio 配置。它使用发布者的安装方式，而不是 PlugMCP 代理。
此记录未列出必需的环境变量。
Aiwg 通过 stdio 在本地运行。
上次检查时间：2026-11-14。 Reusable project context and specialist workflows for the AI tools you already use. AIWG places agents, skills, commands, and rules in provider-readable locations, with optional utilities for artifact memory, workflow orchestration, recovery, and discover