ai-control-center
v1.15.3
Published
Multi-AI orchestration control center — terminal, web dashboard, Telegram bot, and OpenClaw gateway for any project type.
Maintainers
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.jsdrives 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 initQuick 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-repairHow 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:reviewSkill 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 helpMulti-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.mdTelegram 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 telegramTyping / 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 twitchCommands use ! prefix: !status, !feature <desc>, !review, !deploy, !approve, !reject <reason>, !ai <question>.
Web Dashboard
aicc web
# => http://localhost:3847Real-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
/wsfor 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):
- Claude Code — primary for
implementstage - GitHub Copilot CLI — PM, architecture, review
- Gemini CLI — fallback for all stages
- Ollama — local AI fallback
- OpenClaw — AI skill engine + multi-channel gateway (optional)
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.
