English | 中文

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.

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.

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.

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

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

Not a single Agent. A structured organization:

• 22 professional Agent templates — Engineering, Testing, Research, Management — ready out of the box
• 7 structured meeting templates 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.

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

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

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.

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

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)

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

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

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

# Step 2: Install (auto-configures MCP + Hooks)
python install.py

# Step 3: Restart Claude Code — the OS activates automatically
# Verify: run /mcp in CC and check that ai-team-os tools are mounted

# Check OS health
curl http://localhost:8000/health
# Expected: {"status": "ok", "version": "0.1.0"}

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

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

22 ready-to-use professional Agent templates covering a complete software engineering team:

ai-team-os/
├── src/aiteam/
│   ├── api/           — FastAPI REST endpoints
│   ├── mcp/           — MCP Server (40+ 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

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

MIT License — see LICENSE