# AgentTeam

> 13 specialized AI agents collaborating via SQLite. 44 MCP tools. One-command install.

- **Type:** MCP server
- **Install:** `agentstack add mcp-richardlemmon-agentteam`
- **Verified:** Pending review
- **Seller:** [RichardLemmon](https://agentstack.voostack.com/s/richardlemmon)
- **Installs:** 0
- **Latest version:** 1.5.1
- **License:** MIT
- **Upstream author:** [RichardLemmon](https://github.com/RichardLemmon)
- **Source:** https://github.com/RichardLemmon/AgentTeam

## Install

```sh
agentstack add mcp-richardlemmon-agentteam
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# AgentTeam

**AgentTeam** is a reusable AI software development team built on the Model Context Protocol (MCP). Thirteen specialized agents — Product Manager, Project Manager, UX Researcher, UX/UI Designer, Frontend, Backend, Full-Stack, Mobile, DevOps, QA, Security, Data Engineer, and Data Scientist — collaborate on software projects through a shared SQLite database, each constrained strictly to their role.

The Project Manager orchestrates: it creates the project, recruits the specialists it needs, breaks work into tasks, and returns a **dispatch manifest** — a JSON array that the calling session uses to spawn each specialist as an independent parallel agent. Specialists read the project summary on joining, log their work and decisions as they go, and share structured research artifacts so no agent re-researches what another has already found.

All project state is persisted in SQLite (44 MCP tools across 12 domains: projects, summaries, team members, tasks, work entries, task comments, discussions, decisions, artifacts, and a user journal). Projects are UUID-scoped and lifecycle-managed (active → paused → archived → closed), so teams can pause and resume work across sessions without losing context.

**Designed to be called from any Claude Code project via MCP** — point your `claude_desktop_config.json` at the server and any project can spin up a full team.

### User Journal

As the team works, the Project Manager captures your decisions, preferences, and reasoning from the conversation into a persistent **user journal** — things like devices considered and rejected, cost constraints, form factor preferences, and next-step intentions. These are stored as structured entries scoped to the project (or globally, for cross-project preferences) and reviewed at close-out so nothing important is lost between sessions. The journal is queryable via `list_journal_entries` so future agents can read what past conversations established before starting new work.

---

## Project Structure

```
AgentTeam/
├── agents/               # Agent prompt files — one per role
│   ├── _base-protocol.md # Shared team protocol, constraints, efficiency rules
│   ├── project-manager.md
│   ├── product-manager.md
│   ├── backend-developer.md
│   └── ...
├── mcp-server/           # TypeScript MCP server
│   └── src/
│       ├── index.ts      # Server entry — all 44 tools registered
│       ├── db/
│       │   ├── schema.ts # Table definitions and migrations
│       │   └── connection.ts
│       └── tools/        # One file per domain
└── docs/                 # Design specs and reference guides
```

## MCP Tool Domains

| Domain | Tools |
|---|---|
| Projects | `create_project`, `get_project`, `update_project_status`, `list_projects`, `delete_project` |
| Summaries | `update_project_summary`, `get_project_summary`, `get_summary_version`, `list_summary_history` |
| Team Members | `add_team_member`, `remove_team_member`, `list_team_members` |
| Tasks | `create_task`, `update_task`, `get_task`, `list_tasks` |
| Work Entries | `log_work`, `get_my_work`, `get_work_history` |
| Task Comments | `add_task_comment`, `list_task_comments`, `list_my_comments` |
| Discussions | `create_discussion`, `add_discussion_participant`, `add_discussion_message`, `update_discussion_summary`, `get_discussion`, `list_discussions` |
| Decisions | `log_decision`, `list_decisions`, `get_decision` |
| Artifacts | `share_artifact`, `update_artifact`, `list_artifacts`, `get_artifact` |
| Team Protocol | `get_team_protocol` |
| User Journal | `log_journal_entry`, `list_journal_entries` |
| User Questions | `ask_user_question`, `list_user_questions`, `answer_user_question` |
| Expansion Requests | `request_team_expansion`, `list_expansion_requests`, `resolve_expansion_request` |

## Getting Started

### 1. Install the MCP server

**One command (recommended):**

```bash
claude mcp add agent-team -- npx agent-team-mcp
```

That's it. Claude Code will launch the server automatically, and the `/team` skill is installed globally on first run.

**Or manually edit your MCP config** (`~/.claude/settings.json` or project `.claude/settings.json`):

```json
{
  "mcpServers": {
    "agent-team": {
      "command": "npx",
      "args": ["agent-team-mcp"]
    }
  }
}
```

**Or from a local clone:**

```bash
git clone https://github.com/RichardLemmon/AgentTeam.git
cd AgentTeam/mcp-server
npm install
npm run build
claude mcp add agent-team -- node /path/to/AgentTeam/mcp-server/dist/index.js
```

### Token-Efficient Architecture

Agent prompt files contain only the role-specific **Identity** section (~100 words each). Shared team protocol, constraints, and efficiency rules live in a single `agents/_base-protocol.md` file, served on demand via the `get_team_protocol` MCP tool. This lazy-loading approach saves ~6,000 words of context when spawning a full team compared to duplicating the protocol in every agent file. The artifact JSON schema is embedded in the `share_artifact` tool description so agents discover it from the tool itself.

### 2. Use it

The `/team` skill is automatically installed to `~/.claude/skills/agent-team/` on first server startup. Just type:

```
/team build me a REST API for task management
```

Or use `/team` with no arguments to see your existing projects and pick one to work on.

## Quick Start

**With the `/team` skill (Claude Code):**

```
/team build me a REST API for task management
```

**Without the skill:**

"Spin up the Project Manager and ask them to investigate [subject]"

**Manage projects:**

```
/team --projects              # list all projects
/team --projects active       # filter by status
/team --projects delete  # delete a project
```

## How It Works

1. **PM sets up the project** — creates the project record, recruits the specialists it needs, creates tasks, writes the project summary, and returns a dispatch manifest.
2. **Calling session spawns specialists** — each specialist in the manifest is launched as an independent agent with its `project_id` and `member_id`.
3. **Specialists work in parallel** — each reads the project summary, logs work entries, shares artifacts, and communicates via task comments and discussions.
4. **State persists across sessions** — any agent can rejoin a project by reading the current summary and picking up where the team left off.
5. **PM closes out** — on completion, the PM writes a close-out summary and logs key user decisions and preferences to the journal for future reference.

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [RichardLemmon](https://github.com/RichardLemmon)
- **Source:** [RichardLemmon/AgentTeam](https://github.com/RichardLemmon/AgentTeam)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Versions

- **1.5.1** — security scan: pending review — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-richardlemmon-agentteam
- Seller: https://agentstack.voostack.com/s/richardlemmon
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.