AI公司多智能体操作系统

Prerequisites

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

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

pip install uv

Restart Claude Code — first launch takes ~30s to set up dependencies

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.

---

Option A: Plugin Install (Recommended — for most users)

```bash

Add marketplace + install plugin

claude plugin marketplace add CronusL-1141/AI-company claude plugin install ai-team-os

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

```bash

Step 2: Run the installer (auto-configures MCP + Hooks + Agent templates + API)

python3 install.py

Verify Installation

```bash

Uninstall

```bash

Plugin install:

claude plugin uninstall ai-team-os

Source install — full cleanup:

python scripts/uninstall.py

Quick Start

Example: lean core + ecosystem, read-only

AITEAM_TOOLSETS=default,ecosystem AITEAM_READONLY=1 <launch CC / MCP server> ```

Dashboard Screenshots

Tool Loading Configuration (optional)

By default the MCP server registers all 113 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 113 (backward compatible)
• default - core groups only (task,team,memory,infra,reports = 29 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 16 groups (default groups marked *):

```bash

Start the Dashboard (optional)

```bash cd dashboard npm install npm run dev

Set up the development environment

git clone https://github.com/CronusL-1141/AI-company.git cd AI-company python3 install.py

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.

API server starts automatically when MCP loads. No manual startup needed.

Check OS health (API must be running — port may vary, check api_port.txt)

curl http://localhost:8000/api/health

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 setup:

• 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

Windows: rmdir /s %USERPROFILE%\.claude\plugins\data\ai-team-os-ai-team-os

Unix: rm -rf ~/.claude/plugins/data/ai-team-os-*

Workflows — CC ultracode Run Observability

Persistent governance layer for CC ultracode Workflow runs — every run is auto-tracked as a team, surfacing stage progress plus per-agent token and tool-call telemetry.

Workflow Detail — Phase Swim Lane & Per-Agent Telemetry

Drill into a single run: a phase swim lane aligns every stage against one timeline, and a per-agent telemetry table breaks down tokens, tool calls, duration and state per stage — with a failed contract check surfaced in red.

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:

Use find_skill(level=2, category="integration") to discover recipes, or see the full guide: docs/ecosystem-recipes.md

---

How It Compares

---

"Create a web development team with a frontend dev, backend dev, and QA engineer"

```