AI Team OS

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

⚡ v1.10.2 — Cross-session orchestration: wake system v2 (dynamic /loop, event watcher, turn-end guard) + targeted sibling-session driving + agent reuse recommendation + context watermark observability. Patch: server event-write exactly-once + model-tier charter (Fable orchestrates, Opus executes).

168 MCP tools · 217 REST endpoints · 22 dashboard pages · 1,758 tests · 25 agent templates · 47 ecosystem research tools · 5 machine-checked invariants

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 interaction makes the system understand you better. Memory System v2 distills your preferences and corrections into a team direction layer that every dispatched Agent inherits at birth — you never say the same thing twice, and no next Agent repeats a pit an earlier one already fell into.

Core Capabilities

1. Cross-Session Orchestration (new in v1.10.0)

A single CC session can now observe and drive its sibling sessions for one operational turn, instead of only being able to spawn brand-new ones:

Wake system v2: the /api/wake/actionable single-source predicate feeds both the event watcher and the turn-end guard; SessionStart moves from a fixed 30-minute cron to dynamic /loop intervals; a Stop-hook turn-end guard always lets decision:block and user-stop keywords pass through; a session-scoped event watcher carries a 1-hour hard timeout. No resident daemons.
Fleet downlink primitive: headless claude -p --resume <session_id> drives a target sibling session for one turn, reusing the existing wake machinery (semaphore, fuse, allowlist, per-session dedupe, full audit trail).
agent_reuse_recommend MCP tool: a three-way reuse decision (reuse / slim-then-reuse / spawn-new) scored by domain match, reachability (live / resumable / cross-session / expired), and context watermark.
Context watermark ledger: exact token usage read from the transcript tail (cheap-checks-first), surfaced as a three-color watermark bar on agent views and on the new fleet / worktree observability cards.

Usage guidance:

A new session's SessionStart briefing already points you at running /loop once - follow it instead of guessing at intervals.
Check the project detail page for the fleet card (per-session CEO / model / in-flight tasks / watermark) and the worktree card (branch ownership + unlanded-work status) before you act.
Call agent_reuse_recommend before dispatching a follow-up agent - reusing a live or resumable sibling session beats spawning a fresh one.
The S4 worktree teardown guard and per-template isolation: worktree defaults apply automatically; no configuration is needed.

2. Memory System v2 — two-layer memory, every Agent inherits at birth (new in v1.9.0)

The OS's signature differentiator: your team's preferences, corrections, and hard-won lessons flow automatically to every Agent it dispatches.

Direction layer (user preferences / corrections / design intent, 4 kinds): resident injection via both the SessionStart and SubagentStart hooks — every sub-Agent inherits the team's values and red lines the moment it's born, so you don't repeat yourself. Size guardrails (<=40 entries x 400 chars), supersedes swap to prevent bloat, invalidate-never-delete for auditability.
Episodic layer (task_memos ledger): task-level execution memos promoted to a dedicated table (row IDs / invalidation axis / quality score / scope_path), recalled on demand via pure-Python BM25 Chinese retrieval; 123 legacy memos backfilled with zero loss.
On-demand reconcile (memory_reconcile): zero-LLM BM25 candidate clustering, then merge / invalidate / score / distill on agent confirmation — "the agent computes, the tool persists", with no background resident process introduced.

Surfaces: MCP memory_add / memory_list / memory_invalidate / memory_search / memory_reconcile_candidates / memory_reconcile_apply.

3. Progressive Tool-Loading Governance (new in v1.9.0)

Treats the resident context budget as the scarce resource it is — however many tools exist, they never drown your Agent.

alwaysLoad dynamic rotation: at session start a single SQL recomputes the hot-tool whitelist by 7-day real call frequency (>=2-day span gate against bursty spikes + 20% hysteresis, hard cap <=5), and CC skips ToolSearch for them. Not additive, not hand-tuned; any stats failure silently degrades to all-defer, and every whitelist is logged for audit.
AITEAM_TOOLSETS group switch: 24 capability-domain toolsets; a startup env var decides which modules register. default core profile = task/team/memory/infra/reports (44 tools, hard cap <=50), with incremental default,ecosystem — fits non-CC clients that cap tool counts.
AITEAM_READONLY read-only profile: an orthogonal overlay that strips every write tool by explicit allowlist and keeps only read tools — ideal for audit / observer sessions.
5 templates on least privilege: meeting-facilitator / debate advocate & critic / technical-writer / project-manager carry disallowedTools structural denials; engineering / testing templates untouched.

4. Workflow / ultracode Persistent Observability (v1.7.0)

The OS does not intercept CC's built-in ultracode/Workflow — it becomes its persistent governance layer. Every Workflow run is automatically tracked into the OS, with no manual team_create:

Auto-tracking: a hook turns each Workflow run into an OS "team" (workflow-<wf_id>) the moment it starts
Dashboard /workflows: a live feed of run cards, a phase swimlane timeline, and per-agent telemetry — tokens / duration / status / tool-call counts, advancing live via incremental journal tailing while a run executes
Calibrated stall detection: the stall threshold was calibrated on 3,378 real agent intervals (p99 = 77.6s, longest healthy silence 173.8s) and set at 5.2× the worst healthy case — it flags late rather than crying wolf
Project-detail integration: workflow team rows carry an inline run summary (status / agent count / duration / finish time) plus a "view swimlane" deep link; members display semantic phase labels (e.g. audit:sourceA) instead of ids
Leader auto-detection: a project's Leader session / model / liveness is probed directly from the ~/.claude/projects/ file truth by the backend — zero registration dependency, /model switches surface in real time
MCP tools: workflow_list (browse runs), workflow_get (full archive + per-agent rows), workflow_reconcile (repair from on-disk snapshots after the OS was offline)
Self-healing ingestion: hook receipt anchors + on-disk snapshot reconciliation + a reaper backstop close offline gaps automatically — finished runs on disk are ingested idempotently; cross-project attribution matches the on-disk path slug against registered projects

5. Ecosystem Research Platform — 47 tools

A project-isolated knowledge base that accumulates research findings over time. Each repo progresses through 4 stages (a progressive funnel, since v1.5.0), 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)
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)
Stage 3 — Reference / Integrate marking: mark_as_reference adds tag for future quick recall; start_integration triggers existing task_create for actual implementation
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 + project filter dropdown + candidate-filter page (/ecosystem/research) + per-project settings tab — the single largest tool family in the OS

6. Knowledge Layer — Reference Graph + Unified Search (v1.8.0)

Everything the OS records — task memos, reports, tasks — becomes recallable knowledge:

Reference graph (P1a): a zero-LLM regex extractor mines OS-native ID references (wf_id / commit hash / task uuid / [[memory]]) out of memos and reports into an append-only knowledge_links table — the graph is a derived view, rebuildable from source text at any time
Unified search (P1b): /api/search fuses three arms via RRF — BM25 full-text (Chinese bigram native), knowledge-graph fanout (an ID query pulls in everything linked to it), and exact ID-prefix / title match
Global search box in the Dashboard header, plus MCP tools unified_search / link_query / link_trace — recall past work by natural language ("how was the attribution fix done"), a wf_ id, or a commit hash

Why zero-LLM? The graph is a derived view: plain regexes extract the IDs, the whole graph can be rebuilt from source text at any time, and both extraction and retrieval cost zero tokens. Your recall pipeline never touches your model budget.

7. Task Wall · Meetings · 22-Page Dashboard

Governance ledger and panoramic visualization — everything leaves a trace:

Task wall: a live board of pending / in-progress / done, event-driven + intelligent Agent matching + deadlock detection
8 structured meeting templates (keyword auto-select, built on Six Thinking Hats / DACI / Design Sprint) — every meeting must produce an actionable conclusion; "we discussed but didn't decide" is not an outcome
22-page React 19 Dashboard: Command Center / /workflows swimlane / decision timeline / meeting room / Ecosystem suite / Model Governance Settings

8. Autonomous Operation

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

Checks the task wall for the 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

And it 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

9. File Truth as Source of Truth

Most multi-agent stacks trust agents to register themselves and self-report their status. AI Team OS treats self-reports as claims and files as facts — three subsystems already run on this philosophy:

Leader probing: a project's Leader session, model, and liveness are read straight from ~/.claude/projects/ — transcript mtime is liveness, the model name in the transcript tail is the model. We don't ask an agent which model it runs — what's read out of the transcript is what's true.
Model discovery: "available models" = every model that has actually appeared in your CC transcripts. Zero API dependency, zero hardcoded list — a hardcoded list will never contain your third-party gateway model; a transcript scan can't miss it.
Workflow telemetry: on-disk run files are the full telemetry truth; the OS's projection tables are rebuildable caches of immutable files. Attribution iron law: a run belongs to a project only when its on-disk path slug exactly matches the registered project root — never guessed.

10. Model Governance (v1.8.1)

Know which models you can actually launch — and control what your sessions start on:

Auto-discovery of genuinely available models: scans every CC transcript on your machine in about a second (60s cache) — including third-party gateway models that no hardcoded list would ever ship
One-click global default startup model: written to ~/.claude/settings.json under triple write protection — touches only the model key, keeps a .bak-aiteam backup, writes atomically, refuses corrupted files
Zero coercion: soft reminders only, never a block — and CC Workflow runs are fully exempt

Surfaces: REST /api/models/{available,default} · MCP model_config_get / model_config_set · the Model Governance card in Dashboard Settings.

11. 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
Department grouping — Engineering / QA / Research with cross-team coordination
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
Execution pattern memory: success/failure pattern recording + BM25 retrieval + subagent context injection

12. 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

13. 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
Self-patrol: watchdog lease patrol + reaper reconciliation backstop + identity verification before any kill — the OS keeps eyes on itself, not just on your agents
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

14. 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
The memory system and knowledge layer are zero-LLM by design — direction-layer injection, graph extraction, search, and reconcile coarse-pass all cost zero tokens
100% utilization of your CC plan

More Capabilities (legacy & secondary — still running, queryable on demand)

Failure Alchemy: failure_analysis still runs as part of the loop subsystem — every failed task extracts root cause and produces Antibody (stored in team memory to prevent repeats) / Vaccine (high-frequency failures become pre-task warnings) / Catalyst (analysis injected into future Agent system prompts). No longer the headline, but defensive rules keep accruing.
Pipeline orchestration (Legacy): the built-in 7-template pipeline was retired in v1.7.0, superseded by CC Workflow + the observability layer; pipeline_create / pipeline_advance are still registered and existing pipeline data stays readable.
AWARE loop memory · find_skill 3-layer discovery · Prompt Registry · cross-project messaging · ecosystem integration recipes: see the full tool table below. The scheduler was retired to on-demand ecosystem_refresh (CC-is-not-always-on principle).

It Built Itself

AI Team OS manages its own development — and since v1.7.0, it can prove it with its own telemetry:

Every feature line from v1.7.0 to v1.9.0 — the observability layer, the knowledge layer, model governance, Memory System v2, tool-loading governance — shipped through CC Workflow runs that the OS tracked itself. Open /workflows and replay how the system built its own features, swimlane by swimlane.
Competitive research across CrewAI, AutoGen, LangGraph, and Devin feeds the roadmap through multi-agent brainstorming meetings — the minutes live in the OS's own report store.
It learns from its own incidents, too: every machine-checked invariant in scripts/check_invariants.sh was distilled from a real accident in this repo's history.

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

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
Memory System	Two-layer: direction layer inherited at birth + episodic BM25 ledger + on-demand reconcile	Short-term context	Short-term context	Checkpoint state	In-session
Tool-Loading Governance	alwaysLoad rotation + group switch + read-only profile + template least-privilege	None	None	None	None
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 Observability	Swimlane timeline + per-agent telemetry + offline reconcile over CC Workflow	None	None	Graph state only	None
State Source	File truth — transcripts / journals read directly	Agent self-report	Agent self-report	In-process state	Black box
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  │    │                           │
│              │  │ (168 tools)  │    │                           │
│              │  └──────┬───────┘    │                           │
│              │         │            │                           │
│              │  ┌──────▼───────┐    │                           │
│              │  │  FastAPI     │    │                           │
│              │  │  REST API    │    │                           │
│              │  └──────┬───────┘    │                           │
│              │         │            │                           │
│              │  ┌──────▼───────┐    │                           │
│              │  │  Dashboard   │    │                           │
│              │  │ (React 19)   │    │                           │
│              │  └──────────────┘    │                           │
│              └──────────────────────┘                           │
│                         │                                       │
│              ┌──────────▼──────────┐                            │
│              │  Storage (SQLite)   │                            │
│              │  + WAL journaling   │                            │
│              │  + Memory System    │                            │
│              └─────────────────────┘                            │
└─────────────────────────────────────────────────────────────────┘

Five-Layer Technical Architecture

Layer 5: Web Dashboard    — React 19 + TypeScript + Shadcn UI (22 pages)
Layer 4: CLI + REST API   — Typer + FastAPI
Layer 3: Team Orchestrator — LangGraph StateGraph (optional extra — CLI graph execution only)
Layer 2: Memory Manager   — SQLite-backed store + pure-Python BM25 retrieval
Layer 1: Storage          — SQLite (WAL journaling) · PostgreSQL support on the roadmap

Hook System (14 scripts across 12 Lifecycle Events — The Bridge Between CC and OS)

SessionStart     → auto_install.py, session_bootstrap.py, send_event.py
                   — Auto-install deps + inject Leader briefing / core rules / team state
SubagentStart    → inject_subagent_context.py, send_event.py   — Inject sub-Agent OS rules (2-Action etc.)
SubagentStop     → send_event.py                 — Record sub-Agent lifecycle event
PreToolUse       → workflow_reminder.py, pipeline_gate.py, send_event.py
                   — Workflow tracking reminders + pipeline gate + event forwarding
PostToolUse      → workflow_reminder.py, pipeline_gate.py, deep_review_link.py,
                   meeting_ecosystem_writeback.py, send_event.py
TaskCreated      → cc_task_bridge.py             — Bridge CC-native tasks onto the OS task wall
TaskCompleted    → task_completed_gate.py        — Completion gate verification
UserPromptSubmit → context_tracker.py, autopilot_auto_stop.py  — Track context usage + autopilot auto-stop
SessionEnd       → send_event.py                 — Record session end event
Stop             → send_event.py                 — Record stop event
PermissionDenied → permission_denied_recovery.py — Permission-denied self-recovery
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 — for most users)

# 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 168 MCP tools ready.

Option B: Source Install (for developers — editable, tracks latest source)

# 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)
python3 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

Dependencies: greenlet (needed by SQLAlchemy async on Apple Silicon) is bundled by default. LangGraph is an optional extra — only the CLI graph-execution path needs it: pip install 'ai-team-os[langgraph]'.

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"

Tool Loading Configuration (optional)

By default the MCP server registers all 168 tools. Two startup environment variables let you trim the surface for leaner sessions or non-CC clients with tool-count limits (e.g. Cursor only forwards the first 40 tools). Both are read once at server startup - no runtime state, no restart-on-change.

AITEAM_TOOLSETS - pick which capability-domain groups register:

unset or all - full 168 (backward compatible)
default - core groups only (task,team,memory,infra,reports = 44 tools, hard-capped at <=50)
a comma list of group names, mixable with default for incremental loading, e.g. AITEAM_TOOLSETS=default,ecosystem
unknown names are warned on stderr and ignored (a config typo never blocks server start)

AITEAM_READONLY=1 - orthogonal overlay that strips every write tool (create/update/delete/apply/send/... plus os_restart_api) after registration, keeping only read tools. Handy for audit/observer sessions.

The 24 groups (default groups marked *):

Group	Tools	Group	Tools	Group	Tools
task *	12	briefing	4	trust	2
team *	7	scheduler	4	watchdog	3
memory *	9	task_analysis	5	error_budget	2
infra *	13	agent	6	file_lock	4
reports *	3	meeting	10	git	3
project	8	loop	7	channels	3
pipeline	3	analytics	3	guardrails	2
links	3	ecosystem	47	workflows	3

# Example: lean core + ecosystem, read-only
AITEAM_TOOLSETS=default,ecosystem AITEAM_READONLY=1 <launch CC / MCP server>

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.

# Source install — full cleanup:
python scripts/uninstall.py
# Preview first:
python scripts/uninstall.py --dry-run

Start the Dashboard (optional)

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

Dashboard Screenshots

Command Center

Team Working — Live Activity Tracking

Team Working

Task Board

Project Detail — Decision Timeline

Decision Timeline

Meeting Room

Ecosystem Research Platform

Ecosystem

Activity Analytics

Analytics

Event Log

Events

Auto-Wake System — Autonomous Task Advancement

Auto-Wake Demo

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 168 MCP tools are registered natively — no custom client, no API wrapper
Hook-driven lifecycle: 12 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

The tables below are a curated selection — the full inventory lives in src/aiteam/mcp/tools/ and is machine-counted by scripts/check_readme_numbers.sh.

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 (Legacy — retired in v1.7.0, tools still registered, data read-only)

Tool	Description
`pipeline_create` (Legacy)	Attach a workflow pipeline to a task (7 templates: feature/bugfix/research/refactor/quick-fix/spike/hotfix)
`pipeline_advance` (Legacy)	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`	Search team memory — recency-window recall within scope + pure-Python BM25 rerank (Chinese bigram, no embeddings)
`team_knowledge`	Get a team knowledge summary
`memory_add`	Write a direction-layer memory (preference/correction/design intent, 4 kinds; size guardrails <=40 entries x 400 chars, supersedes swap)
`memory_invalidate`	Explicitly invalidate a direction-layer memory (invalidate, never delete — auditable)
`memory_list`	List valid direction-layer entries (kind filter; data source for both injection hooks)
`memory_reconcile_candidates`	On-demand reconcile coarse pass (zero-LL

AI Company

README