AI Control Center

Turn AI coding conversations into an observable, reviewable delivery system.

把分散的 AI 编程对话，变成可追踪、可审查、可交付的工程流程。

Why · Capabilities · Workflow · Quick Start · Windows Desktop · Architecture

AI agents can write code. The difficult part is everything around the code: knowing what is running, preserving the right conversation, proving that a task is actually complete, keeping documentation synchronized, and deciding what can move forward safely.

AI Control Center is a local-first desktop and web workspace for that coordination layer. It combines a visual task board, live agent sessions, Codex thread import, isolated Git worktrees, evidence-based review gates, document governance, and autonomous scheduling in one place.

It is designed for developers who want the speed of coding agents without giving up context, control, or an audit trail.

Why AI Control Center

The usual AI coding problem	What the control center adds
Important work is scattered across terminal sessions and chat threads	One project board with live state, history, events, and follow-up controls
A thread preview is mistaken for the latest requirement or final result	Turn-aware Codex projection separates the current brief from the implementation summary
“The agent finished” is treated as proof that the work is ready	Checks, review evidence, merge state, and lifecycle policy decide what can advance
ADRs and task documents silently drift away from the implementation	Document governance classifies them as awaiting implementation, implemented, or out of sync
Parallel agents collide in the same checkout	Optional per-task Git worktrees isolate branches and file changes
Automation becomes a black box	Plans, leases, retries, dependencies, audit events, and adapter decisions stay visible

What Makes It Different

A real control plane, not just another task board

The Kanban view is the entry point, not the limit. Each project can expose plans, dependency gates, autonomous runs, verification checks, workflow templates, audit events, and extension adapters. The board remains useful for manual work while the control plane handles repeatable automation.

Codex threads become durable project state

Import projects already known to the Codex desktop app without modifying the Codex session store. The importer understands turns and lifecycle events:

• the latest user_message becomes the current task brief;
• the matching task_complete.last_agent_message becomes implementation evidence;
• running, completed, aborted, failed, and archived outcomes remain distinct;
• subagent threads stay attached to their parent instead of creating duplicate cards;
• active projects resynchronize while their board is open.

The result is a board that reflects the conversation that is actually happening, not a stale preview string.

A dockable workspace for long-running agent sessions

The task workspace behaves like a lightweight IDE panel:

• dock it on the right or bottom;
• resize it with a persistent splitter;
• float, move, resize, or maximize it;
• drag it to an edge and preview the docking target;
• keep the event stream, terminal, actions, and instruction composer available without losing the board.

Document governance that connects intent to delivery

Specifications, ADRs, and task documents are scanned as first-class project artifacts. They appear in three explicit states:

1. Awaiting implementation — intent exists, but no completed implementation is linked.
2. Implemented — the linked task and required evidence satisfy project policy.
3. Out of sync — the document or implementation changed after the verified revision.

Documents remain documents; implementation tasks are created deliberately and linked back to their source.

Evidence-driven completion

Completion is a policy decision rather than a color change. AI Control Center can combine agent outcome, required checks, independent review, worktree merge evidence, and activity timestamps before moving work through Review and Done. Every important transition remains inspectable.

Local-first by design

SQLite works with zero configuration, PostgreSQL is available for shared deployments, and agent credentials stay with the CLIs already authenticated on your machine. Optional API-key protection covers REST and WebSocket access. Repository roots and worktree operations are validated before agents receive filesystem access.

The Delivery Loop

flowchart LR
    A["Define intent<br/>task, ADR, or specification"] --> B["Delegate<br/>Codex or another agent"]
    B --> C["Observe<br/>events, terminal, files, and status"]
    C --> D["Verify<br/>checks and independent review"]
    D -->|changes requested| B
    D -->|approved| E["Deliver<br/>merge or pull request"]
    E --> F["Learn<br/>retrospective and archive"]
    F --> A

Loading

1. Define the work — create a task, import a Codex project, or generate an implementation task from a governed document.
2. Run in isolation — select an agent and optionally create a dedicated worktree and branch.
3. Stay in context — watch normalized events and continue the saved conversation from the task panel.
4. Review independently — launch a separate read-only Codex review and keep implementation and review evidence distinct.
5. Deliver safely — merge locally or create a pull request when a GitHub remote is available.
6. Retain the learning — run a final retrospective, clean the worktree, and archive the implementation and review history.

Who It Is For

• Solo developers coordinating several coding agents across multiple repositories.
• Technical leads who need visible dependencies, review gates, and evidence.
• AI-native teams experimenting with autonomous execution without surrendering oversight.
• Codex desktop users who want durable project state across multi-turn and subagent threads.
• Documentation-heavy projects where ADRs and specifications must stay aligned with code.

Supported Agent Providers

Provider	Typical use
OpenAI Codex	Turn-aware implementation, follow-up, review, and retrospective workflows
GitHub Copilot	General coding sessions through the shared provider contract
Claude Code	Repository-aware implementation sessions
OpenCode	Alternative local coding-agent workflow
Hermes	ACP-based agent sessions
OpenClaw	ACP bridge and optional Gateway integration

Providers are auto-detected at startup. Every provider is normalized into the same task, event, status, and follow-up model.

Feature Highlights

• Configurable Classic and Autonomous workflow templates
• Drag-and-drop task lifecycle with validated transitions
• Multi-agent task groups with configurable parallelism
• Real-time WebSocket event streaming and terminal-style output
• Turn-aware Codex project import and subagent aggregation
• Separate implementation, review, merge, retrospective, and archive stages
• Dockable, floating, resizable, and maximizable task workspace
• Document/ADR/specification governance with revision evidence
• Autonomous scheduler with leases, heartbeats, retries, WIP limits, and dependencies
• Versioned Agent, Git, Check, Task Source, Notification, and Widget adapters
• Git worktree isolation, local merge, pull-request creation, and cleanup
• SQLite and PostgreSQL repository implementations
• English and Simplified Chinese UI
• Windows Electron shell with installer and portable builds
• Optional Bearer authentication for REST and WebSocket traffic

Quick Start

Prerequisites

• Node.js 22+
• npm 10+
• At least one supported agent CLI installed and authenticated

git clone https://github.com/WW010/AI-Control-Center-Windows.git
cd AI-Control-Center-Windows
npm install
npm run dev

Open http://localhost:8081. The API listens on port 8080 by default.

To run the services separately:

# Terminal 1
npm run dev:server

# Terminal 2
npm run dev:client

On Windows, the following command starts the application and opens it when the services are ready:

powershell -ExecutionPolicy Bypass -File scripts/start-control-center.ps1

Windows Desktop

Run the Electron desktop application:

npm run dev:desktop

For live desktop development with Vite HMR, API watch mode, and isolated development data:

npm run dev:desktop:live

Build both the installer and portable executable:

npm run dist:windows

Packaged artifacts are written to AI-Control-Center-Windows/ and intentionally excluded from Git. The desktop shell binds the API to loopback on a dynamic port and stores application data under the current Windows user profile.

See Desktop Codex workflow for the complete desktop lifecycle.

Configuration

SQLite is the zero-configuration default. To use PostgreSQL:

docker compose up -d

Then set DATABASE_URL in packages/server/.env.

Environment variables

Variable	Default	Purpose
API_KEY	unset	Protect REST and WebSocket traffic with a Bearer token
VITE_API_KEY	unset	Client-side key matching API_KEY
PORT	8080	API server port
DATABASE_URL	unset	PostgreSQL connection string; unset uses SQLite
DB_PATH	./data/agentboard.db	SQLite database path
CODEX_MODEL	gpt-5.2-codex	Codex model override
COPILOT_MODEL	claude-opus-4-20250514	Copilot model override
CLAUDE_MODEL	claude-opus-4-20250514	Claude Code model override
HERMES_COMMAND	hermes	Hermes executable or command
OPENCLAW_COMMAND	openclaw	OpenClaw executable or command
OPENCLAW_GATEWAY_URL	unset	Optional OpenClaw Gateway WebSocket URL
ALLOWED_REPO_ROOTS	home, temp, workspace	Repository path allowlist
ALLOWED_ORIGINS	local development origins	CORS allowlist
AGENT_TIMEOUT_MS	600000	Maximum agent execution time
PROJECTS_DIR	~/projects	Default project clone directory

Copy the committed .env.example files before adding local secrets. Real environment files are ignored by Git.

Architecture

AI Control Center
├── packages/client      React 19, Vite, Tailwind 4, Framer Motion, xterm.js
├── packages/server      Express, WebSocket, agent orchestration, repositories
├── packages/desktop     Electron main process and preload bridge
├── packages/e2e         Playwright browser and API scenarios
├── shared               Cross-package types and validation contracts
├── scripts              Required gate, desktop tooling, process helpers
└── docs                 Control plane, governance, workflow, and ADRs

The server uses provider, repository, and adapter contracts so agents, database backends, and automation integrations can evolve independently. Events are persisted, cached, and broadcast through WebSocket; the React client projects them into the board and dockable task workspace.

Read the deeper design documents:

• Control plane
• Document governance ADR
• AI collaboration workflow
• Desktop Codex workflow
• Implementation status

Quality Gate

The required gate builds the shared contracts, client, server, and desktop shell; runs server tests; and executes the deterministic Playwright suite.

npm run gate:required

Current verified baseline on main:

• 37 server tests passed
• 156 Playwright scenarios passed
• 4 integration scenarios skipped when their external prerequisites are absent

Enable the committed pre-push hook with:

npm run hooks:install

Project Lineage

AI Control Center is built on Dan Wahlin's AI Agent Board and retains its MIT-licensed foundation. This fork expands the project toward a Windows-first, Codex-aware control plane with document governance, richer lifecycle semantics, and desktop workflow tooling.

Contributing

Contributions, bug reports, and design discussions are welcome. Start with CONTRIBUTING.md, run the required gate, and keep public interfaces and their tests in the same change.

License

MIT