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:

• 25 professional Agent templates (23 base + 2 debate roles) 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
• Channel communication: team: / project: / global channels with @mention support
• Debate mode: 4-round structured debate (Advocate→Critic→Response→Judge) via debate_start / debate_code_review
• Git automation: git_auto_commit / git_create_pr / git_status_check for streamlined version control
• Semantic cache: BM25 + Jaccard similarity matching with JSON persistence and TTL expiry
• Execution pattern memory: success/failure pattern recording + BM25 retrieval + subagent context injection

6. Safety & Behavioral Enforcement

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

• Guardrails L1: 7 dangerous pattern detections + PII warnings + InputGuardrailMiddleware
• 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
• File lock / workspace isolation: acquire/release/check/list + TTL=300s + hook warnings to prevent concurrent edits
• Agent trust scoring: trust_score (0-1) auto-adjusts on task success/failure, weighted into auto_assign
• Agent Watchdog heartbeat: agent_heartbeat / watchdog_check with 5-min TTL — detects stalled or crashed agents automatically
• SRE error budget model: GREEN/YELLOW/ORANGE/RED 4-level response with sliding window (20 tasks), error_budget_status / error_budget_update tools
• Completion verification: verify_completion checks task status + memo existence — prevents hallucinated "done" reports
• Ecosystem integration recipes: 4 preset recipes (GitHub / Slack / Linear / Full-stack team) via ecosystem_recipes() tool
• find_skill 3-layer progressive discovery: quick recommend → category browse → full detail, reducing tool-call overhead

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

8. Ecosystem Research Platform (progressive funnel in v1.5.0)

A project-isolated knowledge base that accumulates research findings over time. Each repo progresses through 4 stages, with token-efficient triggers and append-only history:

• Stage 0 — Auto shallow-summary on archive: newly-archived repos automatically get a 200-400 char ai-engineer summary (core function / positioning / advantages). 8-class failure handling with self-learning (3+ same-class fails → pattern_record, future agents read lessons via pattern_search). Worker auto-revives deleted/private repos when GitHub returns 200 again.
• Stage 1 — On-demand architecture analysis: user picks research direction ("memory_system") → batch-dispatch backend-architect agents to read architecture key files
• Stage 2 — Multi-perspective debate: triggers existing debate_start (NOT a built-in debate engine — reuses meeting system). Meeting → ecosystem reverse-writeback hook reminds Leader to record verdicts back to deep_review
• Stage 3 — Reference / Integrate marking: mark_as_reference adds tag for future quick recall (avoid re-deep-scanning); start_integration triggers existing task_create for actual implementation
• Project-customizable thresholds: each project sets min_stars / top_n / refresh_interval_days / focus_topics. AI Team OS default: stars ≥ 5K, top 200, focus on claude-code / mcp / agent-framework
• Active vs Full dual-view: data is append-only forever. Stars-falling repos kept (just is_active=False); stars climbing back auto-promotes + re-queues Stage 0
• Dashboard /ecosystem: list with stage badges + research timeline + candidate-filter page (/ecosystem/research) + per-project settings tab
• 30+ MCP tools / 15+ REST endpoints / SQLite append-only history snapshots

---

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

Dimension	AI Team OS	CrewAI	AutoGen	LangGraph	Devin
Category	CC Enhancement OS	Standalone Framework	Standalone Framework	Workflow Engine	Standalone AI Engineer
Integration	MCP Protocol into CC	Independent Python	Independent Python	Independent Python	SaaS Product
Autonomous Operation	Continuous loop, never idles	Task-by-task	Task-by-task	Workflow-driven	Limited
Meeting System	8 structured templates with auto-select	None	Limited	None	None
Failure Learning	Failure Alchemy (Antibody/Vaccine/Catalyst)	None	None	None	Limited
Decision Transparency	Decision Cockpit + Timeline	None	Limited	Limited	Black box
Workflow Orchestration	7 pipeline templates + progressive enforcement	None	None	Manual	None
Rule System	4-layer defense (48+ rules) + behavioral enforcement	Limited	Limited	None	Limited
Agent Templates	25 ready-to-use + recommendation engine	Built-in roles	Built-in roles	None	None
Dashboard	React 19 visualization	Commercial tier	None	None	Yes
Open Source	MIT	Apache 2.0	MIT	MIT	No
Claude Code Native	Yes, deep integration	No	No	No	No
Extra Cost	$0 (CC subscription only)	API costs	API costs	API costs	$500+/mo

---

Architecture

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

Five-Layer Technical Architecture

Layer 5: Web Dashboard    — React 19 + TypeScript + Shadcn UI (18 pages)
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) + Alembic migrations

Hook System (9 Lifecycle Events — The Bridge Between CC and OS)

SessionStart     → session_bootstrap.py          — Inject Leader briefing + 5 core rules + team state
SessionEnd       → send_event.py                 — Record session end event
SubagentStart    → inject_subagent_context.py    — Inject sub-Agent OS rules (2-Action etc.)
SubagentStop     → send_event.py                 — Record sub-Agent lifecycle event
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
Stop             → send_event.py                 — Record stop event
PreCompact       → pre_compact_save.py           — Auto-save progress before context compression

---

Quick Install (AI-Assisted)

Tell Claude Code:

"Read https://github.com/CronusL-1141/AI-company/blob/master/INSTALL.md and follow the instructions to install AI Team OS"

Claude Code will read the install guide and walk you through the setup automatically.

---

Important: Install AI Team OS to your system Python, not inside a project virtual environment. If installed in a venv, AI Team OS will only work in that specific project. Run deactivate first if a venv is currently active, then install.

---

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 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 107 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

Option C: PyPI Install

pip install ai-team-os
python -m aiteam.scripts.install
# Restart Claude Code — tools activate automatically

Verify Installation

# Check OS health (API must be running — port may vary, check api_port.txt)
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

Auto-Wake System — Autonomous Task Advancement

---

Auto-Wake System

The Leader supports scheduled auto-wake to autonomously advance tasks without supervision:

• Automatically checks context usage and pending tasks every 10 minutes
• When tasks are available, autonomously creates teams and assigns work
• When user decisions are needed, records them asynchronously via the Briefing system
• When context exceeds 80%, auto-saves progress and prompts to open a new session

---

Ecosystem Integration Recipes

AI Team OS is designed as a meta-plugin — it orchestrates other MCP servers rather than reimplementing their capabilities. Pre-built recipes let you integrate popular tools in minutes:

Recipe	Integrates With	What You Get
GitHub	@modelcontextprotocol/github	Auto PR creation, issue tracking, code review coordination
Slack	@anthropics/slack-mcp	Team notifications, decision escalation, status broadcasts
Linear	linear-mcp-server	Task sync, sprint tracking, bug triage automation
Full-Stack Team	GitHub + Slack + Linear	Complete development workflow with cross-tool orchestration

Use the ecosystem_recipes MCP tool to discover recipes, or see the full guide: docs/ecosystem-recipes.md

---

CC-First Design Principles

AI Team OS is built specifically for Claude Code, not as a standalone framework:

• MCP Protocol native: All 107 tools are registered via MCP — no custom client, no API wrapper
• Hook-driven lifecycle: 9 CC lifecycle events (SessionStart → PreCompact) provide deep integration without modifying CC internals
• Agent templates as .md files: Installed to ~/.claude/agents/ (global) or .claude/agents/ (project-level) — CC's native agent system, not a custom abstraction
• Zero external dependencies at runtime: No external API calls, no cloud services — runs entirely within your CC subscription
• Context-aware: Session bootstrap injects only 5 core rules (down from 23) to minimize context budget impact, with subagent context capped at 60 lines

---

MCP Tools

Expand to see all 107 MCP tools (22 modules)

Team Management

Tool	Description
team_create	Create an AI Agent team; supports coordinate/broadcast modes
team_status	Get team details and member status
team_list	List all teams
team_briefing	Get a full team panorama in one call (members + events + meetings + todos)
team_setup_guide	Recommend team role configuration based on project type

Agent Management

Tool	Description
agent_register	Register a new Agent to a team
agent_update_status	Update Agent status (idle/busy/error)
agent_list	List team members
agent_template_list	Get available Agent template list
agent_template_recommend	Recommend the best Agent template based on task description

Task Management

Tool	Description
task_run	Execute a task with full execution recording
task_decompose	Break a complex task into subtasks
task_status	Query task execution status
taskwall_view	View the task wall (all pending + in-progress + completed)
task_create	Create a new task (supports auto_start and task_type pipeline parameters)
task_update	Partial update of task fields with auto timestamps
task_auto_match	Intelligently match the best Agent based on task characteristics
task_memo_add	Add an execution memo to a task
task_memo_read	Read task history memos
task_list_project	List all tasks under a project

Pipeline Orchestration

Tool	Description
pipeline_create	Attach a workflow pipeline to a task (7 templates: feature/bugfix/research/refactor/quick-fix/spike/hotfix)
pipeline_advance	Advance pipeline to next stage; returns next-stage Agent template recommendation

Loop Engine

Tool	Description
loop_start	Start the auto-advance loop
loop_status	View loop status
loop_next_task	Get the next pending task
loop_advance	Advance the loop to the next stage
loop_pause	Pause the loop
loop_resume	Resume the loop
loop_review	Generate a loop review report (with failure analysis)

Meeting System

Tool	Description
meeting_create	Create a structured meeting (8 templates, keyword auto-select)
meeting_send_message	Send a meeting message
meeting_read_messages	Read meeting records
meeting_conclude	Summarize meeting conclusions
meeting_template_list	Get available meeting template list
meeting_list	List all meetings
meeting_update	Update meeting metadata

Channel Communication

Tool	Description
channel_send	Send a message to a channel (team:/project:/global) with @mention support
channel_read	Read messages from a channel
channel_mentions	Get unread @mentions for an agent

File Lock & Workspace Isolation

Tool	Description
file_lock_acquire	Acquire a file lock (TTL=300s) to prevent concurrent edits
file_lock_release	Release a file lock
file_lock_check	Check if a file is locked and by whom
file_lock_list	List all active file locks

Git Automation

Tool	Description
git_auto_commit	Auto-commit staged changes with generated message
git_create_pr	Create a pull request from current branch
git_status_check	Check git repository status

Debate System

Tool	Description
debate_start	Start a structured 4-round debate (Advocate→Critic→Response→Judge)
debate_code_review	Start a code review debate session

Guardrails

Tool	Description
guardrail_check	Run guardrail checks on a command string
guardrail_check_payload	Run guardrail checks on a structured payload

Execution Patterns

Tool	Description
pattern_record	Record a success/failure execution pattern
pattern_search	Search execution patterns via BM25 for context injection

Intelligence & Analysis

Tool	Description
failure_analysis	Failure Alchemy — analyze root causes, generate antibody/vaccine/catalyst
what_if_analysis	What-If Analyzer — multi-option comparison and recommendation
decision_log	Log a decision to the cockpit timeline
context_resolve	Resolve current context and retrieve relevant background information

Memory System

Tool	Description
memory_search	Full-text search of the team memory store
team_knowledge	Get a team knowledge summary

Trust & Reliability

Tool	Description
agent_trust_scores	View trust scores for all agents
agent_trust_update	Manually adjust an agent's trust score
agent_heartbeat	Send a heartbeat signal from a running agent
watchdog_check	Check for stalled agents (5-min TTL timeout)
error_budget_status	View SRE error budget (GREEN/YELLOW/ORANGE/RED)
error_budget_update	Record task outcome against the error budget
verify_completion	Verify task completion (status + memo check, anti-hallucination)

Analytics

Tool	Description
task_execution_trace	Get unified execution timeline for a task
task_replay	Replay task execution history
task_compare	Compare two task executions side-by-side
diagnose_task_failure	Auto-diagnose why a task failed

Briefing System

Tool	Description
briefing_add	Add a decision item for user review
briefing_list	List pending briefing items
briefing_resolve	Resolve a briefing item with a decision
briefing_dismiss	Dismiss a briefing item

Reports (Database-backed)

Tool	Description
report_save	Save a report to database with project isolation (research/design/analysis/meeting-minutes)
report_list	List reports with filtering by project, type, author, topic
report_read	Read a report by ID

Scheduler

Tool	Description
scheduler_create	Create a scheduled periodic task
scheduler_list	List scheduled tasks
scheduler_delete	Delete a scheduled task
scheduler_pause	Pause a scheduled task

Cache Management

Tool	Description
cache_stats	View semantic cache hit/miss statistics
cache_clear	Clear the semantic cache

Ecosystem

Tool	Description
ecosystem_recipes	Discover integration recipes (GitHub/Slack/Linear/Full-stack)
send_notification	Send notifications via Slack/webhook
cross_project_send	Send cross-project messages
cross_project_inbox	Read cross-project inbox

Prompt Registry

Tool	Description
prompt_version_list	List agent template versions
prompt_effectiveness	View template effectiveness metrics

Project Management

Tool	Description
project_create	Create a project
project_list	List all projects
project_update	Update project settings
project_delete	Delete a project
project_summary	Get a quick project status summary
phase_create	Create a project phase
phase_list	List project phases

System Operations

Tool	Description
os_health_check	OS health check
event_list	View the system event stream
os_report_issue	Report an issue
os_resolve_issue	Mark an issue as resolved
agent_activity_query	Query agent activity history and statistics
find_skill	3-layer progressive skill discovery (quick recommend / category browse / full detail)
team_close	Close a team and cascade-close its active meetings
team_delete	Delete a team

---

Agent Template Library

25 ready-to-use professional Agent templates with recommendation engine, covering a complete software engineering team. Templates are installed to plugin/agents/ (project-level) and ~/.claude/agents/ (global, available across all projects).

Engineering (13 templates)

Template	Role	Use Case
engineering-software-architect	Software Architect	System design, architecture review
engineering-backend-architect	Backend Architect	API design, service architecture
engineering-frontend-developer	Frontend Developer	UI implementation, interaction development
engineering-ai-engineer	AI Engineer	Model integration, LLM applications
engineering-mcp-builder	MCP Builder	MCP tool development
engineering-code-reviewer	Code Reviewer	Code quality review, PR review
engineering-database-optimizer	Database Optimizer	Query optimization, schema design
engineering-devops-automator	DevOps Automation Engineer	CI/CD, infrastructure
engineering-sre	Site Reliability Engineer	Observability, incident response
engineering-security-engineer	Security Engineer	Security review, vulnerability analysis
engineering-rapid-prototyper	Rapid Prototyper	MVP validation, fast iteration
engineering-mobile-developer	Mobile Developer	iOS/Android development
engineering-git-workflow-master	Git Workflow Master	Branch strategy, code collaboration

Testing (4 templates)

Template	Role	Use Case
testing-qa-engineer	QA Engineer	Test strategy, quality assurance
testing-api-tester	API Test Specialist	Interface testing, contract testing
testing-bug-fixer	Bug Fix Specialist	Defect analysis, root cause investigation
testing-performance-benchmarker	Performance Benchmarker	Performance analysis, load testing

Research & Support (3 templates)

Template	Role	Use Case
specialized-workflow-architect	Workflow Architect	Process design, automation orchestration
support-technical-writer	Technical Writer	API docs, user guides
support-meeting-facilitator	Meeting Facilitator	Structured discussion, decision facilitation

Management (2 templates)

Template	Role	Use Case
management-tech-lead	Tech Lead	Technical decisions, team coordination
management-project-manager	Project Manager	Schedule management, risk tracking

Debate Roles (2 templates)

Template	Role	Use Case
debate-advocate	Debate Advocate	Propose and defend solutions in structured debates
debate-critic	Debate Critic	Challenge proposals and find weaknesses

Utility (1 template)

Template	Role	Use Case
team-member	Generic Team Member	Default role for general-purpose tasks

---

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
• 25 professional Agent templates (23 base + 2 debate roles) with recommendation engine
• 4-layer defense rule system (48+ rules) + behavioral enforcement
• Dashboard Command Center (React 19) — 18 pages including Pipeline, Failures, Prompts, Agent Live Board
• 107 MCP tools across 22 modules
• 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)
• 631+ automated tests (28 cross-functional integration tests)
• Prompt Registry (version tracking + effectiveness metrics)
• BM25 search upgrade (Chinese bigram + English word tokenization, 3-5x quality improvement)
• Event log enhancement (entity_id / entity_type / state_snapshot fields)
• CC Plugin Marketplace submission
• File lock / workspace isolation (acquire/release/check/list + TTL=300s)
• Channel communication system (team:/project:/global + @mention)
• Execution pattern memory (success/failure recording + BM25 retrieval)
• Git automation tools (git_auto_commit / git_create_pr / git_status_check)
• Guardrails L1 (7 dangerous patterns + PII warnings)
• Alembic database migration system
• Debate mode (4-round structured debate + code review)
• Agent trust scoring system (auto-adjust on task success/failure)
• Semantic cache layer (BM25 + Jaccard similarity, TTL expiry)
• Tool tier classification (CORE 15 vs ADVANCED 46)
• Agent Watchdog heartbeat system (5-min TTL timeout detection)
• SRE error budget model (GREEN/YELLOW/ORANGE/RED 4-level response)
• Completion verification protocol (anti-hallucination completion check)
• Ecosystem integration recipes (GitHub/Slack/Linear/Full-stack presets)
• Session bootstrap rule compression (23 → 5 core rules, 60% context reduction)
• Atomic API startup lock (multi-session port conflict prevention)
• Auto port discovery (API finds available port, writes to api_port.txt)
• MCP HTTP Streamable endpoint (/mcp/ on FastAPI)
• PyPI 1.2.0 release (pip install ai-team-os)
• INSTALL.md CC-assisted installation guide

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/
│   │   ├── server.py  — MCP server entry point
│   │   └── tools/     — 22 tool modules (107 tools total)
│   │       ├── agent.py, analytics.py, briefing.py, cache.py,
│   │       ├── channels.py, error_budget_tool.py, file_lock.py,
│   │       ├── git_ops.py, guardrails.py, infra.py, loop.py,
│   │       ├── meeting.py, memory.py, pipeline.py, project.py,
│   │       ├── reports.py, scheduler.py, task.py, task_analysis.py,
│   │       ├── team.py, trust.py, watchdog.py
│   │       └── __init__.py  — Tool tier definitions (CORE 15 / ADVANCED)
│   ├── loop/          — Loop Engine
│   ├── meeting/       — Meeting system
│   ├── memory/        — Team memory
│   ├── orchestrator/  — Team orchestrator
│   ├── storage/       — Storage layer (SQLite/PostgreSQL) + Alembic migrations
│   ├── templates/     — Agent template base classes
│   ├── hooks/         — CC Hook scripts (9 lifecycle events)
│   └── types.py       — Shared type definitions
├── plugin/
│   ├── agents/        — 25 Agent templates (.md)
│   └── .claude-plugin/ — Plugin manifest
├── dashboard/         — React 19 frontend (18 pages)
├── docs/              — Design documents + ecosystem recipes
├── tests/             — Test suite (631+ tests)
├── 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

---