A community-driven registry for Claude, Cursor, Windsurf, Cline & more. Not affiliated with Anthropic.
Are you the author? Sign in to claim
Claude Multi-Agent Project Management Framework - AI-driven orchestration with LangGraph and OpenAI integration
A lightweight, flexible multi-agent framework for orchestrating AI-driven development workflows with unlimited custom agent creation.
Claude PM brings the power of AI orchestration to your development workflow through a simple CLAUDE.md configuration file. By defining your project's goals and constraints in natural language, you enable specialized AI agent teams to collaborate on your codebase - with a PM orchestrator intelligently delegating tasks to Documentation, QA, Engineering, Security, and other specialized agents (including your own custom agents). This framework makes it remarkably easy to leverage AI assistance while maintaining full control over your development process.
| Aspect | Claude PM Framework | claude-flow |
|---|---|---|
| Focus | Individual developers & small teams | Large enterprises |
| Agent System | Unlimited custom agents + 9 core agents | Fixed enterprise agent set |
| Setup | Lightweight, immediate start | Heavy enterprise configuration |
| Customization | User-generated agents, self-improving | Static templates, manual updates |
| Best For | Rapid development, creative workflows | Enterprise governance, compliance |
Choose your preferred package manager:
npm install -g @bobmatnyc/claude-multiagent-pm
claude-pm --version
pip install claude-multiagent-pm
claude-pm --version
pipx install claude-multiagent-pm
claude-pm --version
macOS users often encounter "externally-managed-environment" errors with Homebrew Python. We recommend using pipx:
# Install pipx if you don't have it
brew install pipx
pipx ensurepath
# Install Claude PM Framework
pipx install claude-multiagent-pm
Alternative for macOS: Use npm installation (avoids Python environment issues)
npm install -g @bobmatnyc/claude-multiagent-pm
# Using pip with user flag
pip install --user claude-multiagent-pm
# Or using pipx (recommended)
pipx install claude-multiagent-pm
# Or using npm
npm install -g @bobmatnyc/claude-multiagent-pm
# Using pip
pip install claude-multiagent-pm
# Or using npm (requires Node.js)
npm install -g @bobmatnyc/claude-multiagent-pm
After installation, verify everything is working:
# Check CLI is available
claude-pm --version
# Initialize in your project
cd your-project
claude-pm init
# Start using the framework
claude-pm
echo 'export PATH="$PATH:$(npm prefix -g)/bin"' >> ~/.bashrc
source ~/.bashrc
echo 'export PATH="$PATH:$HOME/.local/bin"' >> ~/.bashrc
source ~/.bashrc
pipx ensurepath and restart your terminalpython --versionpip install --force-reinstall claude-multiagent-pmpip show claude-multiagent-pmnode --versionnpm cache clean --forcenpm install -g @bobmatnyc/claude-multiagent-pm --ignore-scriptsFor contributors who want to work on the framework itself:
# Clone the repository
git clone https://github.com/bobmatnyc/claude-multiagent-pm.git
cd claude-multiagent-pm
# Install in development mode
pip install -e .
# Or use npm link
npm link
⚠️ Important: Development installations are for framework contributors only. For using the framework in your projects, use the standard installation methods above.
New to Claude PM Framework? Start with our comprehensive user guide:
👉 Complete User Guide - Your essential starting point for understanding and using the framework effectively.
The user guide covers everything from basic concepts to advanced workflows, including practical examples and best practices for orchestrating AI-driven development workflows.
IMPORTANT: The Claude PM Framework uses its own custom-built process management system for agent orchestration. This is NOT Claude's Task Tool subprocess system - this is our framework's innovation.
The PM (Project Manager) agent orchestrates all work by delegating to specialized agents through our own built-in process manager:
NEW: Natural language task descriptions are now automatically mapped to the right agent with 94.1% accuracy:
Examples:
# Natural language automatically selects the right agent
"Research the latest Next.js features" → Research Agent
"Update the API documentation" → Documentation Agent
"Check test coverage" → QA Agent
"Deploy to staging" → Ops Agent
# Explicit agent selection with @
"@engineer implement user authentication"
"@security scan for vulnerabilities"
This custom process management system is a core differentiator of the Claude PM Framework, purpose-built for AI agent coordination.
One of Claude PM Framework's most powerful features is its built-in agent training system that enables continuous improvement:
This means your custom agents get smarter and more efficient the more you use them, without manual intervention.
The Claude PM Framework includes intelligent prompt optimization that automatically reduces token usage by 50-66% while maintaining or improving task execution quality:
# Prompt optimization is enabled by default
# To disable (not recommended):
export ENABLE_DYNAMIC_MODEL_SELECTION=false
# The framework automatically optimizes all agent interactions
See Prompt Optimization Guide for detailed configuration and best practices.
push - Complete development pipeline: documentation, testing, Git operations, and changelog generationdeploy - Local deployment with validation and health checkspublish - Package publication with validation and registry deploymentThe Claude PM Framework now includes seamless integration with ai-trackdown-pytools for comprehensive project management:
# The ticketing system is automatically available
# Use ai-trackdown commands within your project workflow
ai-trackdown --help
For detailed ticketing documentation, see the ai-trackdown-pytools documentation.
Claude Sonnet: Recommended for multi-agent orchestration due to fast response times and efficient task delegation capabilities. The framework's architecture is optimized for Sonnet's coordination patterns.
YOLO Mode: Reduces approval prompts during extended development sessions. Enables continuous multi-agent workflows for feature development and refactoring tasks.
QA Agents: Provide automated testing, linting, and quality validation throughout the development process. Integrated validation occurs at multiple workflow points rather than only at project completion.
Feature Branch Strategy: Recommended approach for team development:
git checkout -b feature/my-feature
claude-pm # Work with agents in isolated branch
# Agents coordinate testing, documentation, and validation
push # Multi-agent quality pipeline before merge
Agent Specialization: 8 core agent types + custom agent creation enables domain-specific expertise:
Documenter): Pattern analysis and operational understandingQA): Testing, linting, and quality validationVersioner): Git operations and branch managementResearcher): Investigation and analysisOps): Deployment and infrastructureSecurity): Security analysis and vulnerability assessmentEngineer): Code implementation and developmentData Engineer): Data store and AI API managementTraditional Development: Manual testing → Manual documentation → Manual review → Deploy
Orchestrated Development: Your custom agents handle testing, documentation, and review processes while you focus on creative problem-solving and core logic. Enables rapid prototyping and agile development with minimal setup overhead.
After installation (see Installation section above), get started:
# Navigate to your project
cd your-project
# Initialize Claude PM Framework
claude-pm init
# Start orchestrating with AI agents
claude-pm
Establish framework-based development patterns from project start:
npm install -g @bobmatnyc/claude-multiagent-pm
cd my-new-project
claude-pm
# Agents assist with establishing patterns, testing setup, and documentation structure
💡 Orchestrated Development: Feature branch workflow with agent coordination:
git checkout -b feature/auth-system
# Coordinate with specialized agents for different development aspects
# QA Agents manage testing, Documentation Agents handle documentation
push # Multi-agent validation pipeline
💡 Recommendation: Create design documents before major feature development. Example prompt:
"Help me design a user authentication system with JWT tokens and role-based access control"
Apply framework-guided modernization to existing codebases:
# Install globally (compatible with monorepos)
npm install -g @bobmatnyc/claude-multiagent-pm
cd existing-project
claude-pm
# Agents suggest improvements without automatic application
# Existing scripts and workflows remain unchanged
💡 Orchestrated Refactoring: Coordinate agent specialization for systematic refactoring:
git checkout -b refactor/typescript-migration
# Documentation Agents analyze current patterns
# QA Agents validate against regressions during refactoring
# Version Control Agents coordinate branch strategy
push # Validate all changes before merge
💡 Recommendation: Start with a refactoring design document. Simple prompts aren't as ideal, but claude-pm can figure things out, especially if you ask it to research:
"Refactor file src/auth.js to keep line size under 100 characters" --> research which best practices should be used with code patterns in those files "Refactor files in src/components/ to use TypeScript with strict typing" --> research which best practices should be used with code patterns in those files
Understand inherited or unfamiliar codebases through systematic analysis:
cd inherited-project
claude-pm
# Agents scan and analyze codebase patterns
# Accelerated project understanding through coordinated analysis
💡 Orchestrated Analysis: Coordinate specialized agents for comprehensive project understanding:
💡 Recommendation: Document findings in a project analysis design document. Example prompt:
"Analyze the current authentication flow and document any security concerns or improvement opportunities"
Managing multiple packages in a single repository:
cd my-monorepo
claude-pm
# AI agents understand workspace structures and cross-package dependencies
# Provides coordinated development across multiple projects
Key Monorepo Features:
Simple Monorepo Prompts:
"Update all packages in workspace to use TypeScript 5.0" "Run tests for packages affected by changes in packages/shared" "Refactor common utilities from packages/app-a and packages/app-b into packages/shared" "Ensure all packages follow the same ESLint configuration"
💡 Orchestrated Monorepo Management: Use agent coordination for complex monorepo operations:
# Feature branch for cross-package changes
git checkout -b feature/shared-utility-extraction
# Documentation Agent analyzes package dependencies
# QA Agent validates cross-package impacts
# Ops Agent coordinates workspace builds
# Use ai-trackdown to track cross-package changes
push # Comprehensive validation across all packages
💡 Monorepo Recommendation: Create package-specific design documents to track individual package evolution while maintaining overall architecture coherence.
The Claude PM Framework is fully extensible through custom agent creation. Instead of providing a fixed set of agents, the framework enables you to create project-specific agents tailored to your domain, technology stack, and workflow needs.
Why Create Custom Agents?
How It Works: Build specialized agents through a two-tier hierarchy system with dynamic discovery via AgentRegistry and real-time modification tracking. Your custom agents automatically integrate with the framework's orchestration system.
The framework includes a sophisticated Agent Training System that enables:
Directory Precedence (Highest to Lowest Priority):
User Agents: Directory hierarchy with precedence walking
$PWD/.claude-pm/agents/ (highest precedence)../.claude-pm/agents/, ../../.claude-pm/agents/, etc.~/.claude-pm/agents/ (fallback user location)System Agents: claude_pm/agents/
$PWD/.claude-pm/agents/
├── specialized/
│ ├── performance-agent.md
│ ├── architecture-agent.md
│ └── integration-agent.md
├── custom/
│ ├── project-manager-agent.md
│ └── business-analyst-agent.md
└── overrides/
├── documentation-agent.md # Override system Documentation Agent
└── qa-agent.md # Override system QA Agent
MANDATORY: Custom agents must provide clear usage guidelines:
# Custom Agent: Performance Optimization Specialist
## When to Use This Agent
- Database query optimization tasks
- Application performance bottlenecks
- Memory usage analysis and optimization
- Load testing and stress testing coordination
- Performance monitoring setup
## Why This Agent Exists
- Specialized knowledge in performance profiling tools
- Deep understanding of database optimization techniques
- Experience with load testing frameworks and analysis
- Focused expertise beyond general QA or Engineering agents
## Agent Capabilities
- **Primary Role**: Application and database performance optimization
- **Specializations**: ['performance', 'monitoring', 'database', 'optimization']
- **Tools**: Profiling tools, performance monitors, load testing frameworks
- **Authority**: Performance analysis, optimization recommendations, monitoring setup
## Specific Tasks This Agent Handles
1. **Database Optimization**: Query analysis, index optimization, schema tuning
2. **Application Profiling**: Memory analysis, CPU optimization, bottleneck identification
3. **Load Testing**: Stress test design, performance baseline establishment
4. **Monitoring Setup**: Performance dashboard creation, alerting configuration
5. **Optimization Reporting**: Performance analysis reports, improvement recommendations
# [Agent Name] Agent
## Agent Profile
- **Nickname**: [Short name for Task Tool delegation]
- **Type**: [Agent category]
- **Specializations**: [List of specialization tags]
- **Authority**: [What this agent has authority over]
## When to Use
[Specific scenarios where this agent should be selected]
## Why This Agent Exists
[Rationale for specialized functionality beyond core agents]
## Capabilities
[Detailed list of what this agent can do]
## Task Tool Integration
**Standard Delegation Format:**
[Agent Nickname]: [Task description]
TEMPORAL CONTEXT: Today is [date]. Apply date awareness to [agent-specific considerations].
Task: [Specific work items]
Context: [Agent-specific context requirements] Authority: [Agent's decision-making scope] Expected Results: [Specific deliverables] Integration: [How results integrate with other agents]
## Collaboration Patterns
[How this agent works with other agents]
## Performance Considerations
[Agent-specific performance requirements or optimizations]
Dynamic Agent Discovery with 99.7% Performance Improvement:
from claude_pm.core.agent_registry import AgentRegistry
# Initialize registry with SharedPromptCache integration
registry = AgentRegistry()
# List all available agents with metadata (cached for performance)
agents = registry.listAgents()
# Discover agents by specialization (optimized lookup)
performance_agents = registry.listAgents(specialization='performance')
ui_agents = registry.listAgents(specialization='ui_ux')
architecture_agents = registry.listAgents(specialization='architecture')
# Multi-specialization discovery with cache optimization
multi_spec = registry.listAgents(specializations=['integration', 'performance'])
Extensible Agent System:
Dynamic Agent Selection Examples:
5-Minute Setup:
# 1. Create agent directory in your project
mkdir -p .claude-pm/agents/specialized/
# 2. Create a custom agent (example: API Testing Agent)
cat > .claude-pm/agents/specialized/api-testing-agent.md << 'EOF'
# API Testing Agent
## Agent Profile
- **Nickname**: APITester
- **Type**: testing
- **Specializations**: ['api', 'testing', 'integration']
- **Authority**: API testing strategies and validation
## When to Use
- API endpoint testing and validation needed
- Integration testing between services
- API documentation and contract testing
## Why This Agent Exists
- Specialized knowledge of API testing frameworks
- Understanding of REST/GraphQL testing patterns
- Focused expertise beyond general QA testing
## Capabilities
- API endpoint testing with multiple frameworks
- Contract testing and schema validation
- Load testing for API performance
- API documentation generation and validation
EOF
# 3. Test agent discovery
python -c "from claude_pm.core.agent_registry import AgentRegistry; registry = AgentRegistry(); print('Custom agent discovered:', 'api-testing-agent' in str(registry.listAgents()))"
Usage in Workflows:
claude-pm
# Your custom APITester agent is now available for delegation
# Task Tool can automatically discover and use it for API-related tasks
Extensibility Over Fixed Sets: Rather than providing a predetermined list of agents, the Claude PM Framework empowers you to build exactly what your project needs. Whether you're working with specific cloud platforms, compliance requirements, architectural patterns, or unique deployment workflows, you can create agents that understand your context and provide specialized expertise.
Seamless Integration: Custom agents automatically integrate with the framework's orchestration system, AgentRegistry discovery, and Task Tool delegation patterns. Your custom agents work alongside the 9 core agents to provide comprehensive project coverage.
Performance Optimized: Custom agents benefit from the same 99.7% performance improvements through SharedPromptCache integration and real-time modification tracking that core agents enjoy.
Traditional Approach: Manual handling of testing, documentation, deployment, and quality checks.
Orchestrated Approach: Specialized agents coordinate their respective domains while developers focus on architecture and core logic:
# Start feature development
git checkout -b feature/user-dashboard
# Work with orchestrated agents
claude-pm
# Documentation Agent: Analyze patterns and requirements
# QA Agent: Set up testing framework and validation
# Ops Agent: Configure deployment pipeline
# Use ai-trackdown to track feature development progress
# Continuous validation throughout development
push # Multi-agent quality pipeline before commit
Documentation Agent (Documenter):
Ticketing Integration:
QA Agent (QA):
Version Control Agent (Versioner):
Engineer Agent (Engineer):
Ops Agent (Ops):
push command for comprehensive quality checksBegin with smaller projects to understand the framework's coordination patterns before applying to larger codebases.
Safety Approach: Agents provide recommendations and coordinate workflows without automatic code application. Recommended starting points:
Technical Requirements: Node.js 16+, Python 3.8+
📚 Documentation: User Guide | Quick Start Guide | Framework Guide | Custom Agents
For contributors and developers working on the framework:
📖 Developer Documentation - Comprehensive guide for framework development
Native macOS app to monitor Claude AI usage limits and watch your coding sessions live
npx CLI installing 100+ agents, commands, hooks, and integrations in one command
干净、强大、属于你的 AI Agent 平台 --AI agents, without the clutter.
Pocket Flow: Codebase to Tutorial