npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2026 – Pkg Stats / Ryan Hefner

ai-control-center

v1.15.3

Published

Multi-AI orchestration control center — terminal, web dashboard, Telegram bot, and OpenClaw gateway for any project type.

Readme


A terminal CLI, web dashboard, Telegram bot, Twitch bot, and OpenClaw gateway that orchestrates multiple AI agents (Claude, Copilot, Gemini, Ollama) through a structured feature pipeline with skill-driven AI behavior at every stage. Works with any project type — Salesforce, Node.js, Python, Swift, Go, and more.

Highlights

  • OpenClaw skill engine — stage-specific skills guide AI behavior for requirement capture, PM spec, architecture, implementation, and code review
  • Terminal menu — interactive CLI with real-time pipeline status
  • Web dashboard — Express + WebSocket SPA with deploy, review, AI chat, and pixel-art office visualizer
  • Telegram & Twitch bots — remote pipeline control + push notifications + AI chat + / command suggestions
  • Multi-Agent roleplay — PM agent autonomously orchestrates the team, posts in-chat as each agent persona, handles failures and provider switching
  • Multi-AI routing — Claude → Copilot → Gemini → Ollama fallback chain with circuit breakers and auto-downgrade
  • Smart notifications — deduplicated stage updates, task-aware progress bars for implementation, pipeline cancellation on /reset
  • Fully configurable — one aicc.config.js drives everything (stages, deploy, review, models, skills, roleplay)
  • Works with any stack — no assumptions about language, framework, or deployment target

Install

# Global
npm install -g ai-control-center

# Local dev dependency
npm install ai-control-center --save-dev

# One-shot init
npx ai-control-center init

Quick Start

aicc init          # 1. Initialize — creates aicc.config.js
aicc               # 2. Launch interactive terminal menu
aicc start         # 3. Start all services (web + telegram + twitch)
aicc openclaw      # 4. Generate OpenClaw skills for all pipeline stages
aicc doctor        # 5. Health check + auto-repair

How It Works

  ┌─────────────────────────────────────────────────────────────────────────────┐
  │                         USER CHANNELS                                       │
  │                                                                             │
  │  Telegram   WhatsApp    Slack     Discord    Web Dashboard    CLI Terminal   │
  └──────┬──────────┬─────────┬─────────┬──────────────┬──────────────┬────────┘
         │          │         │         │              │              │
         └──────────┴─────────┴─────────┘              │              │
                         │                             │              │
                ┌────────▼────────┐                    │              │
                │   OpenClaw      │                    │              │
                │   Gateway       │                    │              │
                │  :18789 (WS)    │                    │              │
                │                 │                    │              │
                │ • AI Skills     │                    │              │
                │ • Multi-channel │                    │              │
                │ • Cron jobs     │                    │              │
                │ • Sessions      │                    │              │
                └────────┬────────┘                    │              │
                         │ WebSocket                   │              │
                ┌────────▼────────┐                    │              │
                │  AICC Bridge    │                    │              │
                │  (bridge.js)    │                    │              │
                │                 │                    │              │
                │ • Event forward │                    │              │
                │ • Command exec  │                    │              │
                │ • Tool exposure │                    │              │
                │ • Skill inject  │                    │              │
                └────────┬────────┘                    │              │
                         │                             │              │
         ┌───────────────┴─────────────────────────────┴──────────────┘
         │
  ┌──────▼──────────────────────────────────────────────────────────────┐
  │                        AICC ENGINE                                  │
  │                                                                     │
  │  ┌──────────────┐   ┌──────────────┐   ┌─────────────────────┐     │
  │  │ Action Runner │   │  Event Bus   │   │   Skill Loader      │     │
  │  │ (orchestrator)│◀─▶│ (status.json │   │ (3-source priority, │     │
  │  │              │   │  watcher)    │   │  stage injection)   │     │
  │  └──────┬───────┘   └──────────────┘   └─────────────────────┘     │
  │         │                                                           │
  │  ┌──────▼───────────────────────────────────────────────────┐      │
  │  │                    Runner (AI Router)                     │      │
  │  │              pipeline[] drives stage routing              │      │
  │  └──────┬───────────┬───────────┬───────────┬──────────────┘      │
  │         │           │           │           │                       │
  │    ┌────▼───┐  ┌────▼───┐  ┌────▼───┐  ┌────▼───┐                 │
  │    │Copilot │  │ Claude │  │ Gemini │  │ Ollama │                  │
  │    │  CLI   │  │  Code  │  │  CLI   │  │ (local)│                  │
  │    └────────┘  └────────┘  └────────┘  └────────┘                  │
  │    PM, Arch,    Implement   Fallback    Last resort                 │
  │    Review,                  provider    (offline)                   │
  │    Deploy                                                           │
  └─────────────────────────────────────────────────────────────────────┘


  Feature Pipeline Flow (each stage guided by OpenClaw skills):

  ┌──────┐    ┌────┐    ┌──────┐    ┌─────────┐    ┌──────┐    ┌──────┐    ┌────────┐
  │ User │───▶│ PM │───▶│ Arch │───▶│Implement│───▶│Review│───▶│Approve│───▶│ Deploy │
  │ idea │    │spec│    │design│    │  code   │    │ code │    │/reject│    │  ship  │
  └──────┘    └────┘    └──────┘    └─────────┘    └──────┘    └──────┘    └────────┘
       ▲      copilot   copilot      claude        copilot     human       copilot
       │     (sonnet)  (sonnet)    (sonnet)       (sonnet)                (sonnet)
       │        ▲          ▲           ▲              ▲
  via OpenClaw  │          │           │              │
  (any channel) └──────────┴───────────┴──────────────┘
                    OpenClaw skills injected at each stage:
                    SPEC skill → ARCH skill → IMPL skill → REVIEW skill

                Each stage produces a document:
                SPEC.md → ARCH.md → TASKS.md → REVIEW.md


  On failure at any stage:
    Primary ──fail──▶ Fallback 1 ──fail──▶ Fallback 2 ──fail──▶ Circuit Open
    e.g.              e.g.                 e.g.                 (wait 5 min,
    copilot           gemini               ollama                then retry)

OpenClaw Skills

OpenClaw is the AI skill engine that powers every pipeline stage. Running aicc openclaw generates 6 stage-specific skills that guide each AI agent's behavior:

  Skills — injected into AI prompts at each pipeline stage

  ┌───────────┐    ┌───────────┐    ┌───────────┐    ┌───────────┐    ┌───────────┐
  │ Requirement│    │  PM Spec  │    │ Architect │    │ Implement │    │  Review   │
  │  Capture   │    │   Skill   │    │   Skill   │    │   Skill   │    │   Skill   │
  │            │    │           │    │           │    │           │    │           │
  │ Analyze    │    │ User      │    │ Design    │    │ Coding    │    │ Structured│
  │ raw input, │    │ stories,  │    │ arch doc, │    │ standards,│    │ verdict,  │
  │ ask missing│    │ criteria, │    │ task list,│    │ tests,    │    │ checklist,│
  │ info,      │    │ risks,    │    │ exact     │    │ security  │    │ blockers  │
  │ confirm    │    │ priority  │    │ file paths│    │ rules     │    │ vs warns  │
  └──────┬─────┘    └─────┬─────┘    └─────┬─────┘    └─────┬─────┘    └─────┬─────┘
         │                │                │                │                │
         ▼                ▼                ▼                ▼                ▼
      [User Input]     [PM Agent]     [Architect]      [Coder]        [Reviewer]
      stage:capture    stage:spec     stage:arch       stage:impl     stage:review

Skill loading priority (first match wins):

| Priority | Location | Description | |----------|----------|-------------| | 1 (highest) | .ai-workflow/skills/ | Project-local overrides | | 2 | ~/.openclaw/skills/<project>/ | OpenClaw directory (generated by aicc openclaw) | | 3 | ~/.aicc/skills/ | Global user fallback |

Generated skill files:

| File | Stage | What it does | |------|-------|-------------| | SKILL.md | — | PM Agent persona, cron monitoring, session config | | SKILL-requirement-capture.md | capture | Analyze raw user input, ask clarifying questions, confirm before submit | | SKILL-pm-spec.md | spec | Write structured PM spec with user stories, acceptance criteria, risks | | SKILL-architect.md | arch | Design architecture doc + implementation task list with exact file paths | | SKILL-implement.md | impl | Code implementation following architecture, with tests and security rules | | SKILL-review.md | review | Structured code review with verdict, blockers vs warnings, checklist |

Skills are injected via injectSkills(prompt, 'stage') — the system loads all matching skills and appends their content to the AI prompt before execution.

OpenClaw bridge features:

  • Event forwarding: AICC pipeline events → OpenClaw Gateway → all channels
  • Bidirectional commands: Users on any channel can invoke AICC commands via OpenClaw
  • Tool exposure: AICC tools (status, feature, deploy, etc.) registered as OpenClaw tools
  • Cron monitoring: Pipeline health checks (2min active, 5min stall, 30min idle)
  • Stage document injection: On stage transitions, output docs are sent to OpenClaw session

Configuration

The init wizard creates aicc.config.js at your project root:

export default {
  name: 'my-project',
  description: 'A full-stack web application',
  workflowDir: '.ai-workflow',
  envPrefix: 'MYPROJ',

  deploy: { command: 'npm run deploy', options: [] },
  review: { extensions: ['.js', '.ts'], sourceDir: 'src/' },
  web: { port: 3847 },

  roleplay: {
    enabled: true,
    verbosity: 'normal',        // 'quiet' | 'normal' | 'verbose'
    pmPersonality: 'professional', // 'professional' | 'casual' | 'funny'
    agentChat: true,
    progressUpdates: true,
    progressInterval: 180000,     // 3 min between PM "still working" updates
    maxReviewCycles: 3,
    autoDeployOnApproval: false,
    openclawBridge: true,       // enable OpenClaw WebSocket bridge
  },

  // Each line = one stage. Change provider/model to switch instantly.
  pipeline: [
    { stage: 'chat',      provider: 'openclaw', model: 'auto',               fallbacks: ['copilot:claude-haiku-4.5']                },
    { stage: 'pm',        provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
    { stage: 'architect', provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
    { stage: 'implement', provider: 'claude',  model: 'claude-sonnet-4-6',  fallbacks: ['copilot:claude-sonnet-4.6', 'ollama']    },
    { stage: 'review',    provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
    { stage: 'deploy',    provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
  ],

  ollama: { model: 'llama3.1', baseUrl: 'http://localhost:11434' },
};

To switch a model, just change the model value for that stage. No other config needed.

Providers: openclaw (OpenClaw gateway), copilot (GitHub Copilot CLI), claude (Claude Code CLI), gemini (Gemini CLI), ollama (local).

Fallback format: 'provider:model' or just 'provider' (uses default model). On primary failure, tries each fallback in order.

Config Reference

| Property | Type | Default | Description | |----------|------|---------|-------------| | name | string | — | Project name (shown in header, dashboard, bot) | | description | string | — | Short project description | | workflowDir | string | .ai-workflow | Directory for pipeline state files | | envPrefix | string | AICC | Prefix for environment variables | | deploy.command | string | null | Shell command to run on deploy (if null, deploy marks feature as done without running anything) | | deploy.options | array | [] | Deploy option presets { name, value } | | review.extensions | string[] | ['.js','.ts','.py','.go'] | File extensions to include in code reviews | | review.sourceDir | string | src/ | Source directory for git diffs | | web.port | number | 3847 | Web dashboard port | | roleplay.enabled | boolean | true | Enable multi-agent chat room | | roleplay.verbosity | string | normal | quiet, normal, verbose | | roleplay.pmPersonality | string | professional | PM agent tone | | roleplay.maxReviewCycles | number | 3 | Auto-approve after N review loops | | roleplay.autoDeployOnApproval | boolean | false | Auto-deploy when review passes | | roleplay.openclawBridge | boolean | true | Enable OpenClaw WebSocket bridge | | pipeline | array | See above | Array of { stage, provider, model, fallbacks } entries | | ollama.model | string | llama3.1 | Default Ollama model | | ollama.baseUrl | string | http://localhost:11434 | Ollama server endpoint |

CLI Commands

aicc                     Launch interactive terminal menu
aicc init                Set up a new project (creates aicc.config.js)
aicc start               Start all services (web + telegram + twitch + openclaw bridge)
aicc web                 Start the web dashboard
aicc telegram            Start the Telegram bot
aicc twitch              Start the Twitch bot
aicc openclaw            Generate OpenClaw skills for all pipeline stages
aicc doctor              Health check + auto-repair (validates skills, dirs, tools)
aicc events              Stream pipeline events as NDJSON (for scripting)
aicc status              Show pipeline status (JSON)
aicc health              Show health check (JSON)
aicc feature "desc"      Create a new feature
aicc deploy              Deploy to target
aicc approve             Approve current feature
aicc reject "reason"     Reject with feedback
aicc review              Get latest review
aicc logs                Show recent logs
aicc cleanup             Archive workflow files
aicc reset               Abandon current feature
aicc --version           Show version
aicc --help              Show this help

Multi-Agent Roleplay

When roleplay.enabled = true, the PM agent becomes an autonomous orchestrator that runs the entire pipeline and communicates with the team in a shared chat room — visible in Telegram, Slack, WebSocket, and the Office Visualizer.

CEO (you): /feature Add user notification system

📝 PM is writing the feature spec...
⏳ PM spec in progress... (2min elapsed)
📝 Spec complete
🏗 Architect is designing the architecture...
🏗 Architecture + tasks complete
⚡ Coder is implementing...
[█████████░░░░░░░░░░░] 45%  (4/9 tasks)
🔨 Working on: TASK-005: Add PushAdapter module
✅ TASK-004: Create notification schema
⚡ Implementation complete
🔍 Reviewer is reviewing implementation... (cycle 1/3)
🔍 Review cycle 1/3: APPROVED
✅ Feature approved — deploying now...
🚀 Deployment complete! Feature shipped! 🎉

PM Authority — the PM is an employee with authority, not an assistant:

| PM Acts Alone | PM Informs You After | PM Asks You | |--------------|---------------------|-------------| | Switch AI providers when rate-limited | Had to switch providers mid-stage | Feature is truly ambiguous | | Retry failed stages (up to 5 attempts) | Used Ollama as fallback | Deploy to production | | Kill hung processes and restart | Review loop exceeded 3 cycles | All providers down >30 min | | Break review loops after 3 cycles | Stage took longer than estimated | Budget limit reached | | Auto-resume when providers recover | — | — |

Set roleplay.enabled = false to disable — the system behaves as a direct pipeline with no chat messages.

Project Structure

your-project/
├── aicc.config.js              # Project configuration
├── GEMINI.md                   # Gemini role instructions
├── .env                        # Secrets (Telegram tokens, AI mode)
│
├── .ai-workflow/               # Pipeline state (auto-managed)
│   ├── status.json             # Current pipeline status
│   ├── model-bans.json         # Rate-limit / capacity bans with TTL
│   ├── circuit-breakers.json   # Provider health state
│   ├── costs.jsonl             # Token usage log
│   ├── skills/                 # Project-local skill overrides (highest priority)
│   ├── inbox/                  # Feature requests
│   ├── specs/                  # PM specifications (SPEC-*.md)
│   ├── architecture/           # Architecture documents (ARCH-*.md)
│   ├── tasks/                  # Implementation tasks (TASKS-*.md)
│   ├── reviews/                # Code review reports (REVIEW-*.md)
│   ├── checkpoints/            # Per-stage checkpoints (SHA-256 integrity)
│   ├── sessions/               # AI conversation session IDs
│   └── logs/                   # Activity logs
│
├── .claude/
│   ├── skills/                 # Legacy AI skill prompt templates
│   └── agents/                 # Claude Code agent definitions
│
└── .github/
    └── copilot-instructions.md # Copilot CLI project context

~/.openclaw/skills/<project>/   # OpenClaw skills (generated by `aicc openclaw`)
    ├── SKILL.md                # PM Agent persona + cron config
    ├── SKILL-requirement-capture.md
    ├── SKILL-pm-spec.md
    ├── SKILL-architect.md
    ├── SKILL-implement.md
    └── SKILL-review.md

Telegram Bot

# Set credentials in .env
MYPROJ_TELEGRAM_TOKEN=your_bot_token
MYPROJ_TELEGRAM_CHAT_ID=your_chat_id
MYPROJ_TELEGRAM_ALLOWED_IDS=user_id_1,user_id_2

# Start
aicc telegram

Typing / in Telegram shows all available commands with descriptions (auto-registered via setMyCommands).

| Command | Description | |---------|-------------| | /feature <desc> | Submit a new feature | | /bug <desc> | Report and fix a bug | | /status | Pipeline status | | /review | Trigger code review | | /approve | Approve current feature | | /reject <reason> | Reject with reason | | /implement | Trigger Coder implementation | | /deploy | Deploy to environment | | /health | System health check | | /logs | View session logs | | /docs | Browse pipeline documents | | /costs | AI usage & cost summary | | /leaderboard | AI model performance | | /audit | Recent audit log | | /autopilot | Toggle auto-pilot mode | | /reset | Reset / abandon feature | | /cleanup | Clean up workspace | | /retry | Retry from checkpoint | | /ask <question> | Ask AI a question | | /aimode | View/toggle AI mode | | /dryrun | Pipeline dry run | | /menu | Show main menu buttons | | (plain text) | When roleplay is on: talks to PM agent |

When OpenClaw bridge is active, the built-in Telegram bot is skipped to avoid conflicts — OpenClaw handles all channels.

Twitch Bot

MYPROJ_TWITCH_CHANNEL=your_channel
MYPROJ_TWITCH_ACCESS_TOKEN=your_oauth_token
MYPROJ_TWITCH_CLIENT_ID=your_client_id
MYPROJ_TWITCH_ALLOWED_IDS=twitch_user_id_1

aicc twitch

Commands use ! prefix: !status, !feature <desc>, !review, !deploy, !approve, !reject <reason>, !ai <question>.

Web Dashboard

aicc web
# => http://localhost:3847

Real-time dashboard with WebSocket updates:

  • Pipeline status with stage visualization
  • Feature creation and management
  • Code review viewer with verdict display
  • Deploy controls with live output
  • Log viewer with session history
  • AI chat for project questions
  • AI Office Visualizer — pixel-art RPG canvas with animated agent characters (PM, Architect, Coder, Reviewer, Deployer), A* pathfinding, day/night cycle, chat bubbles, sound effects, feature ticket handoff animations with delivery tracking, work state indicators (📝 On it!, 📐 Designing..., 🔍 Reviewing..., 🚀 Deploying!), bug battle animations, and real-time pipeline stage sync

Hub Server

The hub aggregates status from multiple AICC-powered projects into a single dashboard:

aicc hub
# => http://localhost:3850/office/
  • Real-time WebSocket subscriptions to each project's /ws for instant status updates
  • Health polling as a fallback with configurable interval
  • Office Visualizer at /office/ — multi-project pixel-art view with all characters and pipelines
  • REST API at /api/projects — aggregated project states, health, and summary

Configure in aicc.config.js:

hub: {
  port: 3850,
  projects: [
    { name: 'MyApp',   url: 'http://localhost:3847', icon: '🎯' },
    { name: 'Backend', url: 'http://localhost:3848', icon: '⚙️' },
  ],
},

Environment Variables

All variables use the configured prefix (default: AICC).

| Variable | Required | Description | |----------|----------|-------------| | {PREFIX}_AI_MODE | No | hybrid (default), cloud, local | | {PREFIX}_TELEGRAM_TOKEN | For Telegram | Bot token from @BotFather | | {PREFIX}_TELEGRAM_CHAT_ID | For notifications | Your chat ID | | {PREFIX}_TELEGRAM_ALLOWED_IDS | For security | Comma-separated user ID whitelist | | {PREFIX}_TWITCH_CHANNEL | For Twitch | Channel name | | {PREFIX}_TWITCH_ACCESS_TOKEN | For Twitch | OAuth token | | {PREFIX}_TWITCH_CLIENT_ID | For Twitch | Client ID | | {PREFIX}_TWITCH_ALLOWED_IDS | For security | Comma-separated user ID whitelist | | {PREFIX}_WEB_PORT | No | Override web dashboard port | | GEMINI_MODEL | No | Override Gemini model | | CLAUDE_MODEL | No | Override Claude Code model (hyphen format) | | COPILOT_MODEL | No | Override Copilot model (period format) | | OLLAMA_MODEL | No | Override Ollama model | | OLLAMA_BASE_URL | No | Ollama API endpoint |

Examples

Claude Code Max

export default {
  name: 'my-project',
  envPrefix: 'MYPROJ',
  roleplay: { enabled: true, verbosity: 'normal' },
  pipeline: [
    { stage: 'chat',      provider: 'openclaw', model: 'auto',               fallbacks: ['copilot:claude-haiku-4.5']                },
    { stage: 'pm',        provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
    { stage: 'architect', provider: 'copilot', model: 'claude-opus-4.6',    fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
    { stage: 'implement', provider: 'claude',  model: 'claude-sonnet-4-6',  fallbacks: ['copilot:claude-sonnet-4.6', 'ollama']    },
    { stage: 'review',    provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
    { stage: 'deploy',    provider: 'copilot', model: 'claude-sonnet-4.6',  fallbacks: ['gemini:gemini-2.5-pro', 'ollama']        },
  ],
};

Salesforce

export default {
  name: 'xConnector',
  envPrefix: 'XCONN',
  deploy: {
    command: 'sf project deploy start',
    options: [
      { name: 'Run Tests', value: '--test-level RunLocalTests' },
      { name: 'No Tests', value: '--test-level NoTestRun' },
    ],
  },
  review: { extensions: ['.cls', '.js', '.html', '.xml', '.css'], sourceDir: 'force-app/' },
};

Node.js API

export default {
  name: 'my-api',
  envPrefix: 'MYAPI',
  deploy: { command: 'npm run deploy' },
  review: { extensions: ['.ts', '.tsx', '.js', '.jsx'], sourceDir: 'src/' },
};

Programmatic API

import { loadConfig, getConfig } from 'ai-control-center/config';
import { getStatusData, runNewFeature, runDeploy } from 'ai-control-center/actions';
import { getStatus, updateStatus } from 'ai-control-center/pipeline';

await loadConfig();
const status = getStatusData();
console.log(`Stage: ${status.stage}`);

Prerequisites

Required: Node.js >= 18, Git

Optional (at least one AI CLI recommended):

FAQ

No. The control center works with whichever tools you have. You need at least one AI CLI for the pipeline to work; Ollama can serve as a fully local fallback.

OpenClaw is a self-hosted AI gateway. AICC leverages OpenClaw's skill system as its primary feature — aicc openclaw generates 6 stage-specific skills that guide each AI agent's behavior throughout the pipeline. Skills are loaded from ~/.openclaw/skills/<project>/ and injected into AI prompts at each stage. OpenClaw also bridges messaging channels (Telegram, WhatsApp, Slack, Discord) to the pipeline.

Each pipeline[] entry has a primary provider:model and optional fallbacks. On rate limits, the system waits and retries. On capacity exhaustion, it moves to the next fallback. Circuit breakers prevent hammering a broken provider.

Yes. Edit skill files in .ai-workflow/skills/ (project-local, highest priority) or ~/.openclaw/skills/<project>/ (generated by aicc openclaw). Skills are markdown files with YAML frontmatter that define how each AI agent should behave — what to analyze, what format to output, what rules to follow.

Yes. Place aicc.config.js at your monorepo root. Set review.sourceDir to the relevant subdirectory.

Contributing

Contributions are welcome. Please open an issue first to discuss what you'd like to change.

License

MIT