# Tencent/Teamai-CLI: Make Every Team AI Native

> Source: <https://github.com/Tencent/teamai-cli>
> Published: 2026-09-07 10:52:10+00:00

TeamAI manages your team's skills, rules, MCP, and knowledge across Claude Code, Codex, CodeBuddy, WorkBuddy, OpenCode, Cursor, Qoder, and other AI agents.

```
npm install -g teamai-cli
```

Create a shared-experience repo on your git host (GitHub, GitLab, GitCode, CNB, TGit, or a private Git service), **grant write access to team members**, then run `teamai init https://github.com/yourorg/yourrepo`.

**No team repo yet?** Start from a template pre-loaded with production-ready skills, rules, and review agents. Browse the [teamai-hub](https://github.com/teamai-hub) org, click **Use this template**, then `teamai init` against your new repo.

```
# Choose one, depending on where you want resources installed

# Project-scope init (default, resources installed under the project directory)
cd /path/to/my-project
teamai init https://github.com/yourorg/yourrepo

# Or, user-scope init (resources installed under ~/)
teamai init https://github.com/yourorg/yourrepo --scope user
```

Once initialized, every AI session automatically pulls the latest skills / rules and other Harness updates published by admins — no manual sync needed.

**Full usage guide:** [docs/usage-guide.md](/Tencent/teamai-cli/blob/main/docs/usage-guide.md) ([中文版](/Tencent/teamai-cli/blob/main/docs/usage-guide.zh-CN.md)) — covers everything from team creation to day-to-day use.

**Team Execution × Team Context × Team Improvement**:

| Layer | Job | In this CLI today | 
|---|---|---|
| **Team Execution** | Make every agent work the team's way | `init` /`pull` /`push` , skills, rules, agents, hooks, MCP, env | 
| **Team Context** | Make every agent understand the team | recall, learnings, codebase graph, teamwiki... | 
| **Team Improvement** | Make every execution improve the team | friction-based share-learnings, sessions, digest, dashboard... | 

| Agent | Team Execution |  |  |  |  |  |  | Team Context |  |  | Team Improvement |  |  | 
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|  | skills | rules | docs | env | agents | hooks | mcp | learnings | codebase | teamwiki | usage | sessions | dashboard | 
| Claude Code | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 
| Codex | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 
| Cursor | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 
| Qoder | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 
| CodeBuddy | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 
| OpenCode | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | — | — | — | 
| WorkBuddy | ✓ | ✓ | ✓ | ✓ | — | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | 
| OpenClaw | ✓ | ✓ | ✓ | ✓ | — | — | — | ✓ | ✓ | ✓ | — | — | — | 
| Hermes | ✓ | — | ✓ | ✓ | — | — | — | ✓ | ✓ | ✓ | — | — | — | 
| DeepSeek Harness | ✓ | — | ✓ | — | — | — | — | ✓ | ✓ | ✓ | — | — | — | 

**Git providers** — GitHub · GitLab · GitCode · CNB · TGit · private Git service.

Team-wide settings an admin configures once and delivers to every member on `teamai pull`:

| Capability | Command | What it does | 
|---|---|---|
| **Roles** | `teamai roles` | Define role → namespace mappings so each member syncs only the skills for their role. | 
| **Tags** | `teamai tags` | Tag skills / rules so members subscribe to just the tags they need. | 
| **Sources** | `teamai source` | Subscribe to additional skill repos — other teams' public repos, or shared/public repos within your own org; subscribed skills sync automatically on pull. | 

One Team. One Harness. Every Agent.

TeamAI keeps skills, rules, docs, and hooks in a shared git repo and distributes them to every member's local AI tools through a "push → review & merge → pull" flow — with support for subscribing to other teams' or shared repos' Harness.

```
teamai push → create branch + MR → reviewer approves + merges
                                         ↓
              SessionStart hook → teamai pull → synced to local AI tools
```

Members push changes via `teamai push`, which opens a Merge Request for review. Re-running `teamai push` on a resource that is still waiting in an unmerged PR updates that PR in place instead of opening a duplicate. Once merged, `teamai pull` (triggered automatically on session start via the SessionStart hook) syncs the latest resources locally. Skills sync to `~/.claude/skills/`, `~/.codex/skills/`, `~/.cursor/skills/`, `~/.codebuddy/skills/`, etc. In a **project-scope** install, SessionStart first creates that tool's project root (e.g. `<project>/.claude`) if it is missing, then pulls into it — a bare `teamai pull` still will not invent agent directories.

Declare custom hooks in `hooks/hooks.yaml` and `teamai pull` delivers them to every AI tool:

```
hooks:
  - id: block-secret
    description: Scan for secrets before commit
    event: PreToolUse
    matcher: Bash
    command: 'bash -lc "~/.teamai/team-scripts/scan-secret.sh" || true'
    tools: [claude, cursor]
teamai hooks list      # list effective hooks
teamai hooks inject    # re-reconcile into every installed tool
teamai hooks remove    # remove all teamai-managed hooks
```

Declare once in `mcp/mcp.yaml`; `teamai pull` writes each tool's native config. Use `${VAR}` for secrets.

```
servers:
  - name: gpu-analysis
    transport: http            # stdio | http | sse
    url: https://example.com/api/mcp
    headers:
      Authorization: Bearer ${GPU_ANALYSIS_TOKEN}
teamai mcp list | inject | remove
```

Subscribe to additional skill repos — other teams' public repos, or shared/public repos within your own org:

```
teamai source add https://github.com/other-team/teamai-public.git --name other-team
teamai source list
teamai source browse other-team    # browse available skills
teamai source remove other-team
```

The add/remove change takes effect locally right away, and subscribed skills sync on the next
`teamai pull`. Run `teamai push` when you want to share the `teamai.yaml` change with teammates.

Share and restore the team's npm packages and Claude Code plugins:

```
teamai install typescript
teamai install typescript@5.9.2 --npm
teamai install code-review@claude-plugins-official
teamai push       # Share the declarations
teamai install    # Install everything declared by the team
```

See the [Usage Guide](/Tencent/teamai-cli/blob/main/docs/usage-guide.md#team-packages) for the complete workflow and configuration.

Every agent understands how the team works.

Beyond distributing the Harness, TeamAI organizes accumulated team experience and code structure into a searchable knowledge base that the AI recalls automatically when needed.

When a session ends, the Stop hook scores it by **friction** — signals that the session hit something worth remembering: you interrupted or corrected the AI, denied a tool call, or the AI had to retry failing tools. A long-but-routine session (lots of tool calls, no friction) does not trigger; a session where you actually fought a problem does. If the score is high enough, the AI suggests:

```
[teamai] This session may contain a problem worth documenting: you interrupted the AI twice, the AI retried failing tools 8 times.

Task: Fix duplicate project-level Hook injection

Consider running /teamai-share-learnings to summarize what you learned and share it with your team.
```

The hint names the non-zero friction signals that triggered it and, when available, includes a redacted, single-line summary of the first task. The `/teamai-share-learnings` skill summarizes the session and pushes a learning document directly to the team repo. Each session is prompted at most once.

Let the AI automatically search accumulated team knowledge before a task. This feature is **off by default** and must be enabled explicitly — teams can set `sharing.recall.enabled: true` in `teamai.yaml` as the default, and members can override locally:

```
teamai recall enable     # on: deploy the teamai-recall subagent + inject guidance rules
teamai recall disable    # off: remove the subagent and rules
teamai recall status     # show effective state (team default + user override)
```

**Search runs via a subagent**: once enabled, `teamai pull` deploys the built-in `teamai-recall` subagent into each AI tool's `agents/` directory. The AI invokes it before a task — the subagent extracts keywords, runs the search, reads the matched source files, and returns a structured summary of team knowledge. The subagent first runs a relevance precheck (`teamai recall --check`) and skips retrieval entirely when the task is unrelated to team knowledge. Under the hood it shells out to the `teamai recall` command, which you can also run manually:

``` bash
$ teamai recall "port conflict"
[1/2] MR review caught a port-conflict bug ★1 [user]
Author: member-a | Score: 18.5 | Tags: troubleshooting, networking

[2/2] Deployment configuration best practices [project]
Author: member-b | Score: 12.0 | Tags: deploy, config
Matched: conflict | Missing: port
```

`teamai import` parses source repos into a structured graph under `teamwiki/`, enabling structurally-aware retrieval:

```
teamai import --from-repo https://github.com/org/repo
teamai import --from-org myorg              # batch import all repos
teamai codebase --lint                      # health check
```

The graph stores components, interfaces, configs, and cross-repo import edges. `teamai recall` uses it for graph-boosted re-ranking.
When a recall hit comes from a codebase page, the result includes a `Sources:` line listing the relevant source file paths — giving agents a direct starting point for code changes instead of re-exploring the repo.

Edges come from two tracks that run together, with AST results taking precedence on overlap:

- **AST track** (TypeScript/JavaScript, Python, Go): a WASM[tree-sitter](https://tree-sitter.github.io/) parser resolves`import` /`require` , call sites, and TS`implements` clauses to precise file-to-file`DEPENDS_ON` /`REFERENCES` /`IMPLEMENTS` edges (tagged`code-ast` , with confidence weights).
- **Heuristic track** (all languages, including Java/Rust): regex-based extraction (tagged`code-heuristic` ), which also covers languages the AST track does not.

The WASM parser is a pure-JavaScript dependency — no native toolchain is required. If it fails to load for any reason, extraction falls back to the heuristic track and records an `AST_UNAVAILABLE` gap. Set `TEAMAI_SKIP_AST=1` to force heuristic-only extraction.

Every execution makes the entire team smarter.

Insight into how the team actually uses its AI tools, and a starting point for turning session friction into shared skills, rules, and knowledge:

| Capability | Command | What it shows | 
|---|---|---|
| **Usage** | `teamai digest` | Weekly team digest — token usage, conversation volume, and intervention rate. | 
| **Sessions** | `teamai session save` | Privacy-scrubbed per-session summaries (tool sequence, prompt turns, interventions) that feed the digest's Session Highlights. | 
| **Dashboard** | `teamai dashboard` | Web dashboard showing team members' live coding-session status, intervention count, and token usage. | 
| **KB Health** | `teamai dashboard` → KB Health | Built-in dashboard page reporting knowledge-base usage & health — coverage by type, top recalled entries, silent entries, recall trend, author contributions, and a maintenance console. | 

| Command | Description | 
|---|---|
| `teamai init` | Initialize: OAuth login, link repo, register member, inject hooks | 
| `teamai pull` | Pull team resources and inject into local AI tools | 
| `teamai push` | Push local resources to a branch and open a Merge Request | 
| `teamai install [target]` | Install declared npm packages and Claude plugins; with a target, also update `teamai.yaml` | 
| `teamai status` | Show local vs team repo diff | 
| `teamai contribute` | Share session experience to team repo | 
| `teamai recall <query>` | Search the team knowledge base (BM25 + graph-boost) | 
| `teamai recall enable/disable/status` | Toggle or check recall state | 
| `teamai recall promote [learningId]` | Promote a high-confidence learning to formal knowledge (skills/rules/docs) | 
| `teamai recall maintenance` | Maintain knowledge base health: prune low-confidence learnings, writeback confidence scores, flag stale entries | 
| `teamai import` | Import knowledge ( `--dir` ,`--from-repo` ,`--from-org` ,`--from-repo-list` ,`--from-mr` ,`--from-iwiki` ) | 
| `teamai codebase --lint` | Knowledge graph health check | 
| `teamai ci extract-mr --url <url>` | CI: extract knowledge from MR, post comments, write after merge | 
| `teamai members` | List team members | 
| `teamai roles` | Manage team roles and namespaces | 
| `teamai tags` | Manage tag-based skill/rule filtering | 
| `teamai skill exclude add/remove/list` | Manage skills excluded from local sync ( [usage guide](/Tencent/teamai-cli/blob/main/docs/usage-guide.md#excluding-skills-you-dont-need) ) | 
| `teamai source` | Manage skill subscription sources (other teams or your org's shared repos) | 
| `teamai remove <type> <name>` | Remove a resource and open MR | 
| `teamai session save` | Record a privacy-scrubbed session summary to a monthly log ( `--push` feeds`digest` ) | 
| `teamai digest` | Generate weekly team usage digest | 
| `teamai doctor` | Diagnose configuration issues | 
| `teamai uninstall` | Remove all teamai resources and hooks | 

PRs are welcome! Please read [CONTRIBUTING.md](/Tencent/teamai-cli/blob/main/.github/CONTRIBUTING.md) first.
