Who teamai-cli is for#
Engineering teams using Claude Code or Codex
TeamAI distributes CLAUDE.md fragments, skills, hooks, and MCP configs from a shared repo to every developer's local Claude Code or Codex environment. A SessionStart hook runs `teamai pull` automatically, so each session starts with the latest team standards without any manual steps.
Skip if:
If your team is not using any agentic AI coding tools or is on a single-user setup, TeamAI's sharing model has nothing to distribute.
Platform engineers managing AI agent standards
Admins configure role-to-namespace mappings and tag-based subscriptions once, then any new skill or rule pushed to the team repo propagates to exactly the members who need it. The `teamai status` command shows each member's local vs. team repo diff, making it easy to audit alignment.
Skip if:
If you need real-time config enforcement rather than pull-based sync, note that TeamAI updates land on session start, not continuously.
Developers capturing hard-won debugging knowledge
The friction-based learning capture scores sessions for signals like AI retries and user interruptions. When a session involved real problem-solving, TeamAI suggests running `/teamai-share-learnings` to summarize and push a structured learning document to the team repo. Future sessions can search it via `teamai recall`.
Skip if:
If your sessions are mostly routine code generation with no significant debugging, the friction scoring will rarely trigger and the recall knowledge base will grow slowly.
Teams running multiple AI coding agents
TeamAI covers Claude Code, Codex, Cursor, CodeBuddy, OpenCode, and other agents from one shared repo. Skills and rules written once are distributed to whichever agents each team member uses, removing the need to maintain separate configuration files per tool.
Skip if:
If your team has standardized on a single agent that has a built-in team sync feature, TeamAI's multi-agent breadth adds setup overhead without benefit for that specific setup.
The problem it solves#
Engineering teams using AI coding agents accumulate configuration in isolation. Each developer has their own CLAUDE.md, their own Cursor rules file, their own MCP tools configured locally. When one person figures out an effective skill or a useful coding standard for the AI, they have no channel to distribute it. Other team members either repeat the same discovery process or never benefit from it.
The challenge compounds as teams adopt more agents. A team running Claude Code and Cursor simultaneously has two separate configuration systems with no shared layer. Skills written for one agent do not transfer to another. And when team standards evolve, updating everyone's local configs is a manual, error-prone process. Teams with a strong knowledge-sharing culture still find that AI agent configuration is the one area where everything stays siloed.
How it solves it#
Cross-agent config sync
Stores skills, rules, docs, hooks, MCP configs, and environment variables in a shared git repo and distributes them to Claude Code, Codex, Cursor, CodeBuddy, WorkBuddy, OpenCode, and five other agents on pull. Each resource type has its own directory format: skills at `skills/<name>/SKILL.md`, rules at `rules/*.md`, and MCP at `mcp/mcp.yaml`.
Friction-based learning capture
When a session ends, a Stop hook scores it for friction signals: interruptions, denied tool calls, and AI retries. High-friction sessions trigger a prompt to run `/teamai-share-learnings`, which summarizes the session and opens a pull request to the team repo. Low-friction sessions generate no prompts, keeping noise low.
Team knowledge recall
An opt-in subagent (`teamai-recall`) deploys to each AI tool's agents directory and searches accumulated team knowledge before a task using BM25 ranking plus a codebase graph boost. The agent runs a relevance precheck first and skips retrieval when the task is unrelated to stored team knowledge.
Codebase knowledge graph
`teamai import` parses repositories into a structured graph under `teamwiki/` using a WASM tree-sitter parser for TypeScript, JavaScript, Python, and Go, falling back to regex-based heuristics for other languages. The graph stores components, interfaces, configs, and cross-repo import edges, which recall uses for graph-boosted re-ranking.
Role and tag-based distribution
Admins configure role-to-namespace mappings so each team member syncs only the skills relevant to their role. Tags let members subscribe to a subset of skills and rules. A `teamai source` command subscribes to skills from other teams' or shared repos, which sync automatically on pull.
Strengths and trade-offs#
Strengths
- No proprietary infrastructure requiredTeamAI runs on any standard git host: GitHub, GitLab, GitCode, CNB, TGit, or a private Git service. There is no server to operate, no vendor account to maintain, and no data leaving your git provider. The configuration lives in a repo the team already controls.
- MIT licensed with no usage restrictionsThe MIT license allows use, modification, distribution, and commercial deployment without additional restrictions. Teams can fork the CLI, adapt it for internal tooling, or include it in their own pipelines without licensing concerns.
- Broadest multi-agent coverage in the categoryOne shared repo distributes configuration to Claude Code, Codex, Cursor, CodeBuddy, WorkBuddy, OpenCode, Qoder, ZCode, and others. A single shared repo covers the agents a team already uses rather than requiring separate config management per tool.
- Git-native review workflow for AI configChanges to team skills and rules go through a standard push/MR/merge flow. The same review discipline teams apply to code applies to AI configuration, giving a versioned history of every change and a clear approval path before any update reaches team members.
Trade-offs
- -Team Context and Improvement features are betaThe recall, codebase knowledge graph, session digest, and dashboard capabilities are marked beta in the README. Teams should treat these as experimental and not depend on them for critical workflows until they stabilize.
- -Requires a shared git repository to be set upGetting started requires creating and hosting a shared git repo, granting write access to team members, and running `teamai init` on each member's machine. Teams without a self-managed Git setup will need to provision one. Straightforward, but not a zero-config install.
- -Multi-agent support varies across providersNot every agent supports every feature. WorkBuddy lacks the `agents` capability, OpenCode has no usage or session tracking, and the DeepSeek integration supports neither rules nor hooks. Teams relying on less-supported agents will get a subset of the full feature set.
teamai-cli vs alternatives#
TeamAI CLI vs GitHub Copilot Enterprise
GitHub Copilot Enterprise distributes coding instructions across an organization via repository-level instruction files and its organization settings UI. Both tools aim for consistent AI behavior across a team. The key difference is scope and vendor dependency.
| Feature | TeamAI CLI | GitHub Copilot Enterprise |
|---|---|---|
| License | MIT | Proprietary |
| Config hosting | Any git provider | GitHub only |
| Agent coverage | Claude Code, Codex, Cursor, 8+ others | Copilot only |
| Self-hosting | Yes (your git repo) | No |
TeamAI is the better choice when your team uses multiple AI coding agents or wants to avoid committing to a single vendor. The git-native config model means changes to team AI standards go through the same approval process as code changes. GitHub Copilot Enterprise is the better fit when your team is already standardized on GitHub and Copilot, since the native integration requires no additional tooling or onboarding.
TeamAI CLI vs Cursor Teams
Cursor Teams syncs rules and project-level AI context across a team within Cursor. TeamAI serves a similar need but covers a broader set of agents and adds knowledge recall and session learning capture.
| Feature | TeamAI CLI | Cursor Teams |
|---|---|---|
| License | MIT | Proprietary |
| Config hosting | Any git provider | Cursor-managed |
| Agent coverage | Claude Code, Codex, Cursor, 8+ others | Cursor only |
| Knowledge recall | Yes (opt-in) | No |
| Self-hosting | Yes (your git repo) | No |
For teams using only Cursor, the native Cursor Teams sync is simpler to set up. TeamAI adds value when teams run Cursor alongside Claude Code or Codex, or when teams want to capture and search accumulated session learnings across the codebase.
Install and self-host#
Install globally with npm, then initialize against your team's shared git repository.
```bash
npm install -g teamai-cli
teamai init https://github.com/yourorg/yourrepo
```What it's built on#
- Languages
- TypeScript
FAQ#
How does TeamAI distribute configuration to team members?
TeamAI uses a shared git repository as the source of truth. Admins push skills, rules, hooks, and MCP configs to the repo; members run teamai pull (or let the automatic SessionStart hook do it) to sync the latest resources to their local AI tools. Changes go through the standard push/merge-request/merge flow before reaching members.
Which AI agents does TeamAI support?
The README lists full support for Claude Code, Codex, Cursor, CodeBuddy, and Qoder. OpenCode, WorkBuddy, OpenClaw, Hermes, ZCode, and the DeepSeek integration have partial support, with some feature categories unavailable. The feature matrix in the README documents which capabilities apply to each agent.
What does the team knowledge recall feature do?
When enabled, recall deploys a teamai-recall subagent to each AI tool's agents directory. Before a task, the agent searches accumulated team knowledge using BM25 ranking plus a codebase graph boost, then returns a structured summary of relevant learnings. It is disabled by default and must be enabled explicitly with teamai recall enable.
Is TeamAI self-hosted?
TeamAI is a CLI that runs locally; your team's configuration lives in any git repository you choose (GitHub, GitLab, private Git). There is no cloud service to subscribe to. The CLI is MIT licensed and free to use.
How does the codebase knowledge graph work?
teamai import parses source repositories using a WASM tree-sitter parser for TypeScript, JavaScript, Python, and Go, extracting import edges, call sites, and interface implementations into a graph under teamwiki/. For other languages, a regex-based heuristic track runs instead. The graph improves recall results by boosting hits that are architecturally related to the query.
Similar open-source tools#
magic-compact
Lossless context compression for Claude Code and OpenCode
no_human
From ticket to reviewed pull request, on your machine.
FckSignups
Open-source tools that work instantly, no signup required
FreeFlow
Free, open source Mac dictation with AI cleanup and voice macros
patent-disclosure-skill
Chinese patent disclosure drafting with AI-powered point mining
guaardvark
Self-hosted AI workstation with agents, video, voice, and RAG.