🚀 Agentwise

Agentwise revolutionizes software development by orchestrating multiple specialized AI agents working in parallel. Built as an extension for Claude Code, it enables teams of AI agents to collaborate on complex projects with unprecedented efficiency.

• 🚄 Parallel Execution: Run multiple agents with 30-40% token reduction
• 🎭 Self-Improving Agents: Agents learn and improve from every task
• 🔄 Smart Orchestration: Intelligent task distribution and phase management
• 📊 Real-time Monitoring: Track progress across all agents with live dashboard
• 🏗️ Smart Model Routing: Automatic model selection based on task type
• 💾 Token Optimization: 30-40% token reduction through context sharing and caching
• 🖥️ Local Model Support: Ollama, LM Studio, and OpenRouter integration
• 🧠 Hybrid AI Strategy: Mix Claude, local models, and cloud APIs for optimal cost/performance

Upload and process documents directly in Claude Code:

/upload requirements.pdf spec        # Convert PDF to project specs
/upload design-brief.docx context   # Use Word docs as project context
/upload technical-docs.pdf          # Process any document format

• Supported: PDF, Word, Text, Markdown, RTF
• Auto-extraction: Content, requirements, specifications
• Smart conversion: Documents → Project specs → Working code

Direct integration with Figma Dev Mode MCP Server for seamless design-to-code:

/figma connect                      # Connect to Figma desktop
/figma generate Button              # Generate component from selection
/figma sync                         # Sync design tokens & components
/figma tokens ./tokens.json         # Export design variables
/figma image ./screenshot.png       # Capture design screenshots

• Real-time connection: Direct link to Figma desktop app
• Multi-framework: React, Vue, Angular, Swift, Kotlin support
• Design tokens: Auto-extract colors, typography, spacing
• Code Connect: Links Figma components to actual code
• Live sync: Changes in Figma instantly available

Enhanced image processing and visual context understanding:

/image                              # Visual file browser
/upload screenshot.png              # Process UI screenshots
/upload mockup.jpg                  # Convert mockups to code

• Visual understanding: Claude analyzes images properly
• Screenshot → Code: Build UIs from screenshots
• Mockup conversion: Turn designs into working apps
• Context awareness: Understands what's in the image

Clone and customize websites with AI assistance:

/clone-website https://example.com exact     # 1:1 replica
/clone-website https://site.com similar      # Keep style, change brand

• Complete extraction: HTML, CSS, components, interactions
• Smart customization: Apply your branding automatically
• Component recognition: Identifies reusable patterns

Before Agentwise:

• ❌ No way to upload documents to Claude Code
• ❌ Manual conversion of Figma designs
• ❌ Limited image understanding
• ❌ No website cloning capabilities

With Agentwise:

• ✅ Direct document processing in CLI
• ✅ Automatic Figma → Code conversion
• ✅ Full visual context understanding
• ✅ Website replication and customization

These features extend Claude Code's capabilities for more comprehensive development workflows.

Agentwise addresses Claude Code limitations and extends its capabilities:

• File upload support for Claude Code workflows
• Figma design file integration and processing
• 30-40% token optimization through intelligent context sharing
• Comprehensive MCP integration with 61 servers
• Website cloning and customization capabilities
• Modern documentation with responsive design

• Node.js 18.0 or higher
• Claude Code CLI installed with --dangerously-skip-permissions flag
• Git for version control
• macOS/Linux or Windows with WSL

⚠️ Important: Agentwise requires Claude Code to be started with the --dangerously-skip-permissions flag for full functionality:

# Always start Claude Code with this flag when using Agentwise
claude --dangerously-skip-permissions

Why this flag is needed:

• Enables global command installation
• Allows cross-platform script execution
• Permits monitor dashboard file access
• Required for agent file operations

Security Note: This flag reduces some Claude Code security restrictions. Only use it with trusted projects and in secure environments.

# Download and run installer
curl -fsSL https://raw.githubusercontent.com/VibeCodingWithPhil/agentwise/main/installers/install.sh | bash

# Download and run installer
Invoke-WebRequest -Uri "https://raw.githubusercontent.com/VibeCodingWithPhil/agentwise/main/installers/install.ps1" -OutFile "install.ps1"
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
.\install.ps1

If the installers don't work, use manual installation:

# 1. Clone the repository
git clone https://github.com/VibeCodingWithPhil/agentwise.git
cd agentwise

# 2. Install dependencies
npm install

# 3. Build the project (ignore TypeScript errors)
npm run build 2>/dev/null || true

# 4. Install monitor dependencies
cd src/monitor
npm install
cd ../..

# 5. Start Claude Code with required flag
claude --dangerously-skip-permissions

/create "project description"     # Create new project with AI agents
/task "feature description"       # Add feature to active project
/create-plan "feature"            # Collaborative planning mode
/projects                         # List and switch between projects
/task-[project] "feature"        # Add feature to specific project

/init-import                      # Step 1: Select project folder to import
/task-import                      # Step 2: Execute import with agent analysis

/monitor                          # Start dashboard (auto-installs global command)
/monitor install                  # Manually install global command
/monitor global                   # Alternative install command
/monitor status                   # Check installation status
/docs                            # Open local documentation hub

/generate-agent "specialization"  # Create custom specialized agent
/figma [subcommand]              # Figma Dev Mode integration
/upload "file.pdf"               # Upload documents for processing
/clone-website "url"             # Clone and customize websites
/image                           # Visual file browser
/resume                          # Resume after restart

# IMPORTANT: Start Claude Code with required flag
claude --dangerously-skip-permissions

# Create a new project
/create "an e-commerce platform with Next.js and Stripe"

# Monitor progress in real-time
/monitor

# Add features to active project
/task "add user authentication with OAuth"

Agentwise includes a comprehensive web-based monitoring dashboard that provides real-time visibility into your agent orchestration:

• Live Agent Status: Real-time progress tracking for all active agents
• Task Feed: Live stream of task completions and updates
• Interactive Controls: Pause, resume, or manage individual agents
• Progress Visualization: Progress bars, completion percentages, and timelines
• System Health: CPU, memory, and network monitoring
• Multi-Project Support: Automatic project detection and switching

/monitor                    # Opens dashboard (auto-installs global command)
/monitor install            # Manually install global command
/monitor global             # Alternative install command  
/monitor status             # Check installation status
/monitor help               # Show monitor command help

Note: Running /monitor without subcommands now automatically installs the global command if not present.

Global Command: After installation, use agentwise-monitor from anywhere:

agentwise-monitor           # Start monitor from any directory
agentwise-monitor status    # Check system status

Or manually:

cd src/monitor
./start.sh                  # Starts both WebSocket server and web UI

• Agent Grid: Visual cards showing each agent's status, progress, and current task
• Task Feed: Real-time activity log with timestamps and agent assignments
• Overall Progress: Project-wide completion metrics and token usage
• System Health: Resource utilization and performance metrics
• Emergency Controls: Quick pause/resume and emergency shutdown

The monitoring dashboard is designed for local development use only. It runs on localhost and should not be exposed to external networks without additional security measures.

agentwise/
├── .claude/                 # Claude Code integration
│   ├── agents/             # Agent definitions (frontend, backend, etc.)
│   └── commands/           # Custom command handlers
├── src/                    # Core system architecture
│   ├── agents/             # Dynamic agent management
│   ├── ai/                 # AI prompt enhancement & optimization
│   ├── analytics/          # Performance & usage analytics
│   ├── backup/             # Project backup & restore system
│   ├── cli/                # Command-line interface handlers
│   ├── commands/           # Command implementations
│   │   ├── GlobalMonitorInstaller.ts  # Cross-platform global commands
│   │   ├── MonitorCommand.ts           # Monitor dashboard controller
│   │   ├── ImageCommand.ts             # Visual context processing
│   │   ├── ModelCommands.ts            # Local model management
│   │   └── UploadHandler.ts            # Document & design file processing
│   ├── context/            # Project context & persistence
│   ├── learning/           # Self-improving agent capabilities
│   ├── mcp/                # MCP server integration (61 servers)
│   ├── models/             # Smart model routing & local model support
│   ├── monitor/            # Real-time dashboard (Next.js app)
│   │   ├── server/         # WebSocket server for live updates
│   │   └── src/            # Dashboard UI components
│   ├── monitoring/         # Task completion & progress tracking
│   ├── optimization/       # Token optimization (30-40% reduction)
│   ├── orchestration/      # Multi-agent coordination
│   ├── orchestrator/       # Agent orchestration & management
│   ├── project-registry/   # Project synchronization system
│   ├── projects/           # Project management utilities
│   ├── spec-templates/     # Project specification templates
│   ├── utils/              # Helper utilities & shared code
│   └── validation/         # Code, style, and tech stack validation
├── config/                 # Configuration files
├── docs/                   # Comprehensive documentation
│   ├── examples/           # Usage examples & tutorials
│   ├── monitor-command.md  # Monitor command documentation
│   ├── custom-agents.md    # Custom agent creation & management
│   ├── ci-cd-integration.md # CI/CD pipeline integration guide
│   ├── architecture.md     # System architecture details
│   ├── mcp-integration.md  # MCP server integration guide
│   └── smart-model-routing.md  # Model routing documentation
├── installers/             # Platform-specific installers
└── workspace/              # Project workspaces (git-ignored)
    └── [project-name]/     # Individual project directories
        └── agent-todos/    # Agent task management per project

Agentwise includes 8 specialized agents, each with unique capabilities and MCP integrations:

• Focus: UI/UX, React, Vue, Angular, styling, responsive design
• MCPs: Figma, Shadcn UI, Material UI, Ant Design, Chakra UI, Tailwind CSS
• Capabilities: Component creation, state management, animations, accessibility

• Focus: APIs, server logic, authentication, middleware, microservices
• MCPs: REST API, GraphQL, TestSprite, Fetch, database connectors
• Capabilities: RESTful APIs, GraphQL, WebSockets, authentication, caching

• Focus: Schema design, queries, migrations, optimization, NoSQL/SQL
• MCPs: PostgreSQL, MongoDB, MySQL, Multi-Database, MongoDB Atlas
• Capabilities: Schema design, query optimization, migrations, indexing

• Focus: CI/CD, deployment, containers, cloud infrastructure
• MCPs: Kubernetes, Terraform, Azure DevOps, AWS, Buildkite, Cloudflare
• Capabilities: Pipeline setup, containerization, auto-scaling, monitoring

• Focus: Unit tests, integration tests, E2E, performance testing
• MCPs: Jest, Playwright, Cypress, Storybook, Puppeteer, BrowserStack
• Capabilities: Test automation, coverage reports, performance testing

• Focus: UI design, component libraries, design systems, branding
• MCPs: Figma, Canva, Framer, Sketch, Adobe XD, design token tools
• Capabilities: Design-to-code, component extraction, style guide creation

• Focus: Requirements analysis, technology research, best practices, documentation
• Capabilities:
  • Real-time web search with date awareness
  • Technology stack recommendations
  • Security vulnerability research
  • Library compatibility analysis
  • Best practices documentation
  • Market research and competitor analysis
• Special Features:
  • Dynamic date/time awareness for current information
  • Cross-references multiple sources for accuracy
  • Generates comprehensive research reports
  • Integrates findings directly into project specs

• Create specialized agents for your specific needs
• Use /generate-agent "specialization" command
• Automatically integrated with orchestration system
• Full MCP support for custom tools

graph TD
    A[User Command] --> B[Agentwise Orchestrator]
    B --> C[Smart Model Router]
    C --> D[Claude/Ollama/LM Studio]
    B --> E[Dynamic Task Distributor]
    E --> F[Tech Stack Validator]
    F --> G[Agent Selection]
    G --> H1[Frontend Specialist]
    G --> H2[Backend Specialist]
    G --> H3[Database Specialist]
    G --> H4[DevOps Specialist]
    G --> H5[Testing Specialist]
    G --> H6[Designer Specialist]
    G --> H7[Research Agent]
    G --> H8[Custom Agents]
    H1 --> I[MCP Integration]
    H2 --> I
    H3 --> I
    H4 --> I
    H5 --> I
    H6 --> I
    H7 --> I
    H8 --> I
    I --> J[61 MCP Servers]
    J --> K[Phase Controller]
    K --> L[Self-Improving Agents]
    L --> M[Performance Analytics]
    M --> N[Token Optimizer 30-40%]
    N --> O[Project Output]

Agentwise features the most comprehensive MCP (Model Context Protocol) integration available:

• Design Tools: Figma, Canva, Framer, Sketch, Adobe XD
• UI Libraries: Shadcn UI, Material UI, Ant Design, Chakra UI, Radix UI, Mantine
• Styling: Tailwind CSS

• API Tools: REST API, GraphQL, TestSprite, Fetch
• Payment: Stripe, PayPal

• PostgreSQL, PostgreSQL Advanced, MongoDB, MongoDB Atlas, MySQL, Multi-Database

• Orchestration: Kubernetes, Terraform
• CI/CD: Azure DevOps, Buildkite
• Cloud: AWS, Azure, Cloudflare (x2 variants)
• Build Tools: Vite

• Testing Frameworks: Jest, Playwright, Cypress, Puppeteer
• Visual Testing: Storybook, BrowserStack
• Tools: MCP Inspector, MCP Tester, Frontend Testing
• Accessibility: A11y
• Performance: Lighthouse, Web Vitals
• API Testing: TestSprite

• Webpack, Vite, Next.js, Remix, Astro

• Slack, Discord, Confluence, Notion

• Memory, Sequential Thinking, Brave Search
• Claude Desktop MCP, Firecrawl, GitHub

1. Automatic Assignment: Each agent gets relevant MCPs based on their specialization
2. Dynamic Loading: MCPs are loaded only when needed to optimize performance
3. Seamless Integration: Agents can directly use MCP tools without additional configuration
4. Cross-Agent Sharing: MCPs can be shared between agents for collaborative tasks

# Frontend agent uses Figma MCP
/figma generate Button      # Extracts button from Figma

# Database agent uses PostgreSQL MCP
# Automatically optimizes queries and suggests indexes

# Testing agent uses Playwright MCP
# Generates and runs E2E tests automatically

We love contributions! See CONTRIBUTING.md for guidelines.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/AmazingFeature)
3. Commit your changes (git commit -m 'Add some AmazingFeature')
4. Push to the branch (git push origin feature/AmazingFeature)
5. Open a Pull Request

# Clone your fork
git clone https://github.com/YOUR_USERNAME/agentwise.git
cd agentwise

# Install dependencies
npm install

# Run tests
npm test

# Build project
npm run build

• Private workspaces never committed to git
• Secure token management
• Isolated project environments
• No credential storage

Found a security issue? Please email [email protected] (or open a private security advisory).

• Development Speed: 10x faster than traditional development
• Token Optimization: 30-40% reduction through context sharing
• Agent Scalability: Support for 100+ specialized agents
• Integration Coverage: 61 MCP servers integrated (comprehensive design, backend, database, testing, and DevOps coverage)
• Model Support: Claude, Ollama, LM Studio, OpenRouter
• File Processing: PDF, Word, Figma, websites
• Learning Capability: Self-improving agents with persistence

• Core orchestration system with 5 specialist agents
• Intelligent agent selection based on task analysis
• Project backup and restore system
• Code validation to prevent phantom code
• Hallucination detection and prevention
• Automatic agent discovery for custom agents

• Web UI Dashboard - Real-time monitoring interface with live agent status
• MCP Integration - 61 MCP servers (complete development ecosystem coverage)
• Performance Analytics - Comprehensive metrics, error tracking, and insights
• Self-Improving Agents - Learning capabilities with knowledge persistence
• Token Optimization - 30-40% reduction achieved
• Smart Model Routing - Automatic model selection based on task requirements
• Local Model Support - Full Ollama, LM Studio, and OpenRouter integration
• Document Upload - Process PDFs, Word docs, and design files
• Figma Dev Mode Integration - Direct connection to Figma desktop for design-to-code
• Website Cloning - Clone and customize existing websites with Firecrawl
• Documentation Site - Beautiful documentation at https://agentwise-docs.vercel.app
• Repository Protection - Branch protection, rulesets, and security automation
• Automated PR Management - Dependabot integration with auto-merge capabilities

• Agent Marketplace - Share and discover custom agents
• Visual Workflow Editor - Drag-and-drop orchestration
• Enterprise Features - SSO, audit logs, compliance
• Multi-language Support - Python, Go, Rust agents
• Advanced Security - Sandboxing, encryption, audit trails
• Webhook Support - External integrations and notifications

We're keeping Agentwise focused and lightweight. See ROADMAP.md for details.

Agentwise is developed and maintained through community support. Your donations help continue development and add new features!

• PayPal Donations: Donate via PayPal
• GitHub Sponsors: Click the "Sponsor" button above
• Commercial License: For business use, see LICENSE

Every donation, no matter the size, is greatly appreciated and helps keep Agentwise free for personal use! 🙏

We're planning to extend Agentwise to support additional AI CLI tools:

• Crush CLI - Coming soon
• Qwen Coder - In planning
• Gemini CLI - Under evaluation
• Cursor CLI - Researching integration
• More - Suggest your favorite CLI!

This project uses the Agentwise Custom License - see the LICENSE file for details.

• Use Agentwise as a tool to build commercial websites, apps, and software
• Use Agentwise in your company's internal development workflow
• Create and sell products built WITH Agentwise (not embedding it)
• Personal, educational, and research use
• Build your own orchestration system from scratch (without using our code)

• Using Agentwise source code to build competing products
• Copying or referencing our code for similar systems
• Embedding Agentwise into your product for end-users
• Reselling or rebranding Agentwise
• Offering Agentwise capabilities as a service (SaaS)
• Using our code as a reference to build orchestration systems

• Use our source code to build competing products
• Remove copyright notices
• Use "Agentwise" name for your products
• Claim you created Agentwise
• Study our code to replicate functionality

TL;DR: Use Agentwise to BUILD projects = Free. Use our CODE to compete = License required.

For commercial licensing questions:

• Discord: @vibecodingwithphil
• GitHub: @VibeCodingWithPhil

• Claude Code by Anthropic
• All our amazing contributors
• The open-source community

• 📖 Documentation
• 💡 Issues
• 💬 Discussions
• 📧 Contact: Open an Issue