English | 中文

AI Team OS

Your AI coding tool stops when you stop prompting. Ours doesn't.

AI Team OS turns Claude Code into a self-driving AI company.
You're the Chairman. AI is the CEO. Set the vision — the system executes, learns, and evolves autonomously.

The Problem With Every Other AI Tool

Every AI coding assistant works the same way: you prompt, it responds, it stops. The moment you step away, work stops. You come back to a blank prompt.

AI Team OS works differently.

You walk away at night. The next morning you open your laptop and find:

• The CEO checked the task wall, picked up the next highest-priority item, and shipped it
• When it hit a blocker that needed your approval, it parked that thread and switched to a parallel workstream
• R&D agents scanned three competitor frameworks and found a technique worth adopting
• A brainstorming meeting was organized, 5 agents debated 4 proposals, and the best one was put on the task wall

You didn't prompt any of that. The system just ran.

How It Works

You're the Chairman. The AI Leader is the CEO.

The CEO doesn't wait for instructions. It checks the task wall, picks the highest-priority item, assigns the right specialist Agent, and drives execution. When blocked, it switches workstreams. When all planned work is done, R&D agents activate — scanning for new technologies, organizing brainstorming meetings, and feeding improvements back into the system.

Every failure makes the system smarter. "Failure Alchemy" extracts defensive rules, generates training cases for future Agents, and submits improvement proposals — the system develops antibodies against its own mistakes.

Core Capabilities

1. Autonomous Operation

The CEO never idles. It continuously advances work based on task wall priorities:

• Checks the task wall for next highest-priority item when a task completes
• When blocked on something requiring your approval, parks that thread and switches to parallel workstreams
• Batches all strategic questions and reports them when you return — no interruptions for tactical decisions
• Deadlock detection: if the loop stalls, it surfaces the blocker rather than spinning

2. Self-Improvement

The system doesn't just execute — it evolves:

• R&D cycle: Research agents scan competitors, new frameworks, and community tools. Findings go to brainstorming meetings where agents challenge each other. Conclusions become implementation plans on the task wall.
• Failure Alchemy: Every failed task triggers root cause extraction, classification, and three outputs:
  • Antibody — failure stored in team memory to prevent the same mistake
  • Vaccine — high-frequency failure patterns converted into pre-task warnings
  • Catalyst — analysis injected into Agent system prompts to improve future execution

3. Team Collaboration

Not a single Agent. A structured organization:

• 26 professional Agent templates with recommendation engine — Engineering, Testing, Research, Management — ready out of the box
• 8 structured meeting templates with keyword-based auto-select, built on Six Thinking Hats, DACI, and Design Sprint methodologies
• Department grouping — Engineering / QA / Research with cross-team coordination
• Every meeting produces actionable conclusions. "We discussed but didn't decide" is not an outcome.

4. Full Transparency

Nothing is a black box:

• Decision Cockpit: event stream + decision timeline + intent inspection — every decision has a traceable record
• Activity Tracking: real-time status of every Agent and what it's working on
• What-If Analyzer: compare multiple approaches before committing, with path simulation and recommendations

5. Workflow Pipeline Orchestration

Every task follows a structured, enforced workflow — no more ad-hoc execution:

• 7 pipeline templates: feature (Research→Design→Implement→Review→Test→Deploy), bugfix, research, refactor, quick-fix, spike, hotfix
• Auto-attach via task_type: pass task_type="feature" to task_create and the pipeline mounts automatically
• Progressive enforcement: hook detects tasks without pipelines — soft reminder → strong reminder → hard block (exit 2) on third occurrence
• Auto phase progression: each stage recommends the right Agent template; pipeline_advance moves to next stage automatically
• Lightest escape hatch: quick-fix (Implement→Test only) for truly trivial changes

6. Safety & Behavioral Enforcement

Built-in guardrails so the system can run unsupervised without surprises:

• Local agent blocking: all non-readonly agents must declare team_name/name — prevents rogue background agents
• S1 safety rules: regex-based scan catches destructive commands (rm -rf, force push, hardcoded secrets) including uppercase flags and heredoc patterns
• 4-layer defense rule system: 48+ rules covering workflow, delegation, session, and safety layers
• find_skill 3-layer progressive discovery: quick recommend → category browse → full detail, reducing tool-call overhead
• task_update API: programmatic partial update of tasks with auto timestamps, enabling fine-grained task state management

7. Zero Extra Cost

Runs entirely within your existing Claude Code subscription:

• No external API calls, no extra token spend
• MCP tools, hooks, and Agent templates are all local
• 100% utilization of your CC plan

It Built Itself

AI Team OS managed its own development:

• Organized 5 innovation brainstorming meetings with multi-agent debate
• Conducted competitive analysis across CrewAI, AutoGen, LangGraph, and Devin
• Shipped 67 tasks across 5 major innovation features
• Generated 14 design documents totaling 10,000+ lines

The system that builds your projects... built itself.

How It Compares

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                     User (Chairman)                              │
│                         │                                       │
│                         ▼                                       │
│                   Leader (CEO)                                   │
│            ┌────────────┼────────────┐                          │
│            ▼            ▼            ▼                          │
│       Agent Templates  Task Wall  Meeting System                 │
│      (22 roles)       Loop Engine  (7 templates)                 │
│            │            │            │                          │
│            └────────────┼────────────┘                          │
│                         ▼                                       │
│              ┌──────────────────────┐                           │
│              │   OS Enhancement Layer│                           │
│              │  ┌──────────────┐    │                           │
│              │  │  MCP Server  │    │                           │
│              │  │  (60+ tools) │    │                           │
│              │  └──────┬───────┘    │                           │
│              │         │            │                           │
│              │  ┌──────▼───────┐    │                           │
│              │  │  FastAPI     │    │                           │
│              │  │  REST API    │    │                           │
│              │  └──────┬───────┘    │                           │
│              │         │            │                           │
│              │  ┌──────▼───────┐    │                           │
│              │  │  Dashboard   │    │                           │
│              │  │ (React 19)   │    │                           │
│              │  └──────────────┘    │                           │
│              └──────────────────────┘                           │
│                         │                                       │
│              ┌──────────▼──────────┐                            │
│              │  Storage (SQLite)   │                            │
│              │  + Memory System    │                            │
│              └─────────────────────┘                            │
└─────────────────────────────────────────────────────────────────┘

Five-Layer Technical Architecture

Layer 5: Web Dashboard    — React 19 + TypeScript + Shadcn UI
Layer 4: CLI + REST API   — Typer + FastAPI
Layer 3: Team Orchestrator — LangGraph StateGraph
Layer 2: Memory Manager   — Mem0 / File fallback
Layer 1: Storage          — SQLite (development) / PostgreSQL (production)

Hook System (The Bridge Between CC and OS)

SessionStart     → session_bootstrap.py          — Inject Leader briefing + rule set + team state
SubagentStart    → inject_subagent_context.py    — Inject sub-Agent OS rules (2-Action etc.)
PreToolUse       → workflow_reminder.py          — Workflow reminders + safety guardrails
PostToolUse      → send_event.py                 — Forward events to OS API
UserPromptSubmit → context_monitor.py            — Monitor context usage rate

Quick Start

Prerequisites

• Python >= 3.11
• uv (pip install uv)
• Claude Code (MCP support required)
• Node.js >= 20 (Dashboard frontend, optional)

Option A: Plugin Install (Recommended)

# Install uv (Python package runner, required for MCP server)
pip install uv

# Add marketplace + install plugin
claude plugin marketplace add github:CronusL-1141/AI-company
claude plugin install ai-team-os

# Restart Claude Code — first launch takes ~30s to set up dependencies
# Subsequent launches are instant

# Update to latest version anytime
claude plugin update ai-team-os@ai-team-os

Note: First launch after install takes ~30 seconds while dependencies are automatically configured. This only happens once — subsequent sessions start instantly with 63 MCP tools ready.

Option B: Manual Install

# Step 1: Clone the repository
git clone https://github.com/CronusL-1141/AI-company.git
cd AI-company

# Step 2: Run the installer (auto-configures MCP + Hooks + Agent templates + API)
python install.py

# Step 3: Restart Claude Code — everything activates automatically
# API server starts automatically when MCP loads. No manual startup needed.
# Verify: run /mcp in CC and check that ai-team-os tools are mounted

Verify Installation

# Check OS health (API must be running)
curl http://localhost:8000/api/health
# Expected: {"status": "ok"}

# Create your first team via CC
# Type in Claude Code:
# "Create a web development team with a frontend dev, backend dev, and QA engineer"

Uninstall

# Plugin install:
claude plugin uninstall ai-team-os
# Then manually remove residual data:
# Windows: rmdir /s %USERPROFILE%\.claude\plugins\data\ai-team-os-ai-team-os
# Unix:    rm -rf ~/.claude/plugins/data/ai-team-os-*
# Restart Claude Code to stop active hooks.

# Manual install:
python scripts/uninstall.py        # full cleanup
python scripts/uninstall.py --dry-run  # preview first

Start the Dashboard (optional)

cd dashboard
npm install
npm run dev
# Visit http://localhost:5173

Dashboard Screenshots

Command Center

Team Working — Live Activity Tracking

Task Board — 68 Tasks Completed

Meeting Room

Activity Analytics

Event Log

MCP Tools

Team Management

Agent Management

Task Management

Pipeline Orchestration

Loop Engine

Meeting System

Intelligence & Analysis

Memory System

Project Management

System Operations

Agent Template Library

26 ready-to-use professional Agent templates with recommendation engine, covering a complete software engineering team:

Engineering

Testing

Research & Support

Management

Specialized Templates

Roadmap

Completed

• Core Loop Engine (LoopEngine + Task Wall + Watchdog + Review)
• Failure Alchemy (Antibody + Vaccine + Catalyst)
• Decision Cockpit (Event stream + Timeline + Intent inspection)
• Event-driven Task Wall 2.0 (Real-time push + Intelligent matching)
• Living Team Memory (Knowledge query + Experience sharing)
• What-If Analyzer (Multi-option comparison)
• 8 structured meeting templates with keyword auto-select
• 26 professional Agent templates with recommendation engine
• 4-layer defense rule system (48+ rules) + behavioral enforcement
• Dashboard Command Center (React 19)
• 60+ MCP tools
• AWARE loop memory system
• find_skill 3-layer progressive discovery
• task_update API for programmatic task management
• Workflow pipeline orchestration (7 templates + auto phase progression + progressive enforcement)
• 467+ automated tests

In Progress / Planned

• Multi-tenant isolation
• Production validation and performance optimization
• Claude Code Plugin Marketplace listing
• Full integration test suite
• Documentation site (Docusaurus)
• Video tutorial series

Project Structure

ai-team-os/
├── src/aiteam/
│   ├── api/           — FastAPI REST endpoints
│   ├── mcp/           — MCP Server (60+ tools)
│   ├── loop/          — Loop Engine
│   ├── meeting/       — Meeting system
│   ├── memory/        — Team memory
│   ├── orchestrator/  — Team orchestrator
│   ├── storage/       — Storage layer (SQLite/PostgreSQL)
│   ├── templates/     — Agent template base classes
│   ├── hooks/         — CC Hook scripts
│   └── types.py       — Shared type definitions
├── dashboard/         — React 19 frontend
├── docs/              — Design documents (14 files)
├── tests/             — Test suite
├── install.py         — One-click install script
└── pyproject.toml

Contributing

Contributions are welcome! We especially appreciate:

• New Agent templates: If you have prompt designs for specialized roles, PRs are welcome
• Meeting template extensions: New structured discussion patterns
• Bug fixes: Open an Issue or submit a PR directly
• Documentation improvements: Found a discrepancy between docs and code? Please correct it

# Set up development environment
git clone https://github.com/CronusL-1141/AI-company.git
cd AI-company/ai-team-os
pip install -e ".[dev]"
pytest tests/

Before submitting a PR, please ensure:

• ruff check src/ passes
• mypy src/ has no new errors
• Relevant tests pass

License

MIT License — see LICENSE