AI Agent Team: role prompts for Claude Code, and a step three you cannot skip

The product is slash commands, not an agent runtime

The stated system requirements are two items: Claude Code, already installed and configured, and Git. That tells you what this package is. The agents are prompts and skills loaded into somebody else's agent rather than processes of their own, and the interface is a set of short commands. Six role commands are documented, `/pm` for product work, `/fe` for frontend, `/be` for backend, `/qa` for testing, `/ops` for deployment and `/tl` for architecture, each taking a sentence of work. The feature list also claims eight specialist agents and then names seven, since product, fullstack, frontend, backend, testing, DevOps and tech lead is seven roles, so the count in the heading and the list beneath it disagree. The seven role skills have additionally been split out into their own repositories installable into any project, each with a stated remit, from architecture decisions and code review through to pipelines and orchestration.

Step three is the one that makes it work

Installation is three commands, and the third is described as the key step:

npm install -g ai-agent-team
ai-agent-team init
claude mcp add thread-manager node /path/to/thread-manager/dist/index.js

The second command comes in two forms, a global initialisation that writes into your home Claude configuration directory and a project-local one that writes into the current project, with global recommended for individual developers and project-local for team projects. The third registers the memory server with Claude Code, pointing at a compiled JavaScript file inside your own checkout rather than anything published, and the documentation is blunt that skipping it means the thread commands are simply unavailable. Verification is three commands of your own, listing all threads, creating a test thread, and showing the current thread's information. Precedence is defined too: when both a project-local and a global configuration exist, Claude Code uses the project-local one and falls back to global only if it is absent.

Memory is a bundled MiniLM model writing vectors into SQLite

The version 2 architecture diagram shows what the memory layer actually is. A natural language query from the user reaches the Claude assistant, which calls tools on the Thread Manager MCP server. That server parses the request and hands it to a thread manager, which does two things: it runs a semantic search, and it appends a message through a data access layer. The data access layer generates a vector on the way in, which means an embedding service, which loads a local built-in model rather than calling out, and the diagram names that model as Xenova/all-MiniLM-L6-v2. Search and storage both sit on one SQLite database, results come back as a list of relevant messages, and the thread manager formats them into context before handing them back to Claude. So the persistent memory is a local embedding model plus a SQLite file, reached over MCP, which is a conventional design and also a quiet answer to agents that argue for grep instead.

The improvement column has no measurement behind it

There is a table comparing Thread Manager against native Claude Code, and its right-hand column is the sort of number that gets quoted without context. Context memory is listed as lost on restart natively and permanently saved here, with an improvement of infinity. Multi-task management goes from a single thread to unlimited parallel, marked ten times or more. Task recovery is marked as newly added because native Claude cannot do it. Version control goes from manual to automatic at three times. And work efficiency is scored as a hundred percent natively against two hundred percent or more here. No benchmark, no task set, no methodology and no baseline model appear anywhere in the repository to support those figures, so they function as marketing rather than measurement. The Git integration underneath them is real and described concretely, with automatic task branches, file change tracking, code statistics and full version control, which is the part worth evaluating on its own.

Four of the bundled skills are not agents at all

Alongside the role prompts and the thread manager sit four utilities that have nothing to do with agent coordination, and they are the parts most likely to be useful on their own. A changelog generator analyses Git history and emits Markdown or HTML, updates incrementally, and can publish a release to GitHub in one command. A software copyright helper produces the manual and source listings that a Chinese copyright registration application requires, at fifty lines per page up to sixty pages, across twenty or more languages, cleaning comments on the way and exporting through the browser's print to PDF, trimming to the first and last thirty pages when the source runs longer. A desktop tidy tool classifies files, recognises semver version numbers to keep the newest, and insists on a dry-run preview before it moves anything. A note visualiser turns text into an image using one of five built-in style templates and saves both HTML and a PNG.

The environment template belongs to a different application

The example environment file is the most misleading document in the repository. It opens sensibly, with an Anthropic API key and a Claude model name, then continues into a service configuration that nothing in the documented flow uses: a port, a maximum agent count of fifteen, a maximum of five concurrent tasks, a task timeout in milliseconds, health check intervals, metric retention days and an alert threshold. Then a PostgreSQL block with a host, port, database name, user and password. Then a Slack webhook, an SMTP host and port with an email user and password, a JWT secret and a thirty-two character encryption key, worker thread count, memory and CPU limits, and log rotation settings. The state this tool keeps is a SQLite file inside your Claude configuration, and the runtime is Claude Code itself, so none of the database, messaging, mail or token settings have anything to attach to. The pinned model name in that file is also old enough to be worth noticing.

The command surface disagrees with itself across sections

Read the three lists of commands against each other and they do not line up. The role commands are `/pm`, `/fe`, `/be`, `/qa`, `/ops` and `/tl`. The quick-start set for the thread manager is `/pm-start`, `/fe-start`, `/be-start` and `/qa-start`, with no operations or tech lead equivalent anywhere. A later table adds `/fs-start` for the fullstack role, a role that has no plain command in the first list at all. Verification offers `/threads`, `/thread switch` and `/thread info`, which are a third namespace again. And a link in the memory section points at a release notes file that is not in the repository tree, which holds a differently named release document and a generated HTML release note instead. Around all of it sit three operating system installers, a preinstall and postinstall hook in the package manifest, a sponsor line carrying a discount code, and a referral link for a hosted alternative to the whole thing.

Editorial conclusion

AI Agent Team fits someone already working inside Claude Code who wants per-role prompts and a persistent thread history, and who is comfortable registering an MCP server by hand. It does not fit anyone wanting a standalone agent runtime, because the documented requirements are Claude Code and Git, and the agents here are prompts and skills rather than processes. Three things to know before installing. The third step is not optional, because without registering the Thread Manager MCP server the thread commands do not exist at all, and the path you register points at a built file inside your own checkout. The environment example is a generic service template carrying a Postgres block, a Slack webhook, SMTP credentials, a JWT secret and a pinned model name, none of which appear anywhere in the documented flow, so read it as scaffolding rather than configuration. And the comparison table claiming infinite and tenfold improvements over plain Claude Code contains no measurement or methodology behind the numbers, so treat it as positioning rather than evidence. MIT licensed, version 2.1.0 released in June 2026, branch last pushed on 29 June 2026.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. peterfei/ai-agent-team on GitHub
4. README
5. Releases