🚀 AI Agent Hub

npx ai-agent-hub@latest

🚀 Quick Start

npx ai-agent-hub@latest

One command, two simple questions:

1. 📍 Where to install? → Project / Desktop / Both
2. ⚡ Which mode? → Classic (learning) / Squad (production)

Then in Claude Code:

"Build a viral TikTok app"

✨ Agents auto-activate based on your needs and share context automatically!

⚡ Squad Mode: Build 79% Faster

Squad Mode transforms Claude into a coordinated team that works in parallel, not sequentially.

Visual Comparison

Traditional (Sequential):

Agent 1 works (30 min) → Agent 2 waits then works (30 min) → Agent 3 waits then works (30 min)
Total: 90 minutes

Squad Mode (Parallel):

Agent 1 works ┐
Agent 2 works ├─ All working simultaneously (30 min)
Agent 3 works ┘
Total: 30 minutes (66% faster!)

Performance Gains

• 97% fewer tokens - Slim, focused agents
• 66-79% faster - Parallel execution
• Smart coordination - Automatic task distribution
• Zero conflicts - File-level mutex

Parallel Commands in Claude Code

# 1. Allocate Tasks
/allocate-tasks-parallel real-time dashboard with user analytics
# Analyzes and distributes to optimal agents (1-10)

# 2. Start Execution
/start-parallel
# Launches multiple agents simultaneously

# 3. Sync Progress
/sync-parallel
# Coordinates results and dependencies

When to Use Each Mode

🧠 Intelligent Orchestration System (v3.5.0)

NEW: Production-grade quality enforcement with evidence-based verification!

How Intelligence Works

User says: "Fix the login bug" → System analyzes:
├── Intent: Debug/Fix (not create)
├── Complexity: Score 3 (single domain)
├── Domain: Authentication/Frontend
└── Routes to: Frontend Developer + Quality Reviewer

Semantic Analysis Features

• 🎯 Intent Classification - Understands what you're trying to achieve
• 📊 Complexity Scoring - Evaluates task difficulty (1-10 scale)
• 🔍 Domain Detection - Identifies which specializations are needed
• 🤝 Smart Handoffs - Agents suggest next specialists automatically
• 📈 Continuous Learning - Improves routing decisions over time

🔄 Context-Aware Collaboration (v3.4.2 Enhanced)

AUTOMATIC: All agents now auto-load context middleware for seamless collaboration!

How It Works

1. First agent creates session → Writes decisions to .claude/context/
2. Next agent reads context → Knows what's done, continues work
3. All agents stay in sync → Real-time sharing, no duplicate effort
4. Next session continues → Picks up exactly where you left off

What's New in 3.5.0

• ✅ Evidence-based verification - Proof over promises with exit codes, test results
• ✅ Quality gates - Complexity scoring prevents overwhelming tasks
• ✅ Auto-security scanning - npm audit / pip-audit on every code review
• ✅ Stuck detection - Auto-escalate after 3 failed attempts
• ✅ Failure cascades - Block dependent tasks when upstream fails
• ✅ Production-grade standards - Minimum → Production-Grade → Gold Standard

Example Flow

User: "Build a dashboard with real-time updates"
→ System scores complexity: 7 (multi-domain)
→ Routes to Studio Coach for orchestration
→ Coach coordinates: Backend → Frontend → AI Engineer
→ All agents share context automatically!

🎭 Your 10 Expert Agents

Each agent is a specialized AI personality with deep expertise in their domain.

🎬 Studio Coach

Master Orchestrator & Team Coordinator

• Coordinates complex multi-agent projects
• Assigns optimal agents for each task
• NEW: Validates quality gates before task assignment
• NEW: Detects stuck agents and escalates (3+ attempts)
• NEW: Prevents failure cascades in parallel execution
• Motivates team and ensures peak performance
• Manages parallel execution in Squad Mode
• Handles project planning and strategy

📊 Sprint Prioritizer

Agile Planning & Product Strategy

• Plans 6-day development sprints
• Prioritizes features for maximum impact
• Makes trade-off decisions with ROI analysis
• Manages product roadmaps
• Balances user needs with technical constraints

📦 Product Manager

Product Strategy & Requirements

• Defines product vision and roadmap
• Creates product requirements documents (PRDs)
• Prioritizes features based on business value
• Manages stakeholder expectations
• Validates product-market fit
• Makes data-driven product decisions

🔍 UX Researcher

User Research & Testing

• Conducts user research and interviews
• Creates user personas and journey maps
• Validates design decisions through testing
• Analyzes user behavior patterns
• Provides actionable UX insights

🎨 Rapid UI Designer

Design Systems & Visual Design

• Creates mockups and wireframes quickly
• Designs component architectures
• Establishes design tokens and styles
• Ensures accessibility compliance (WCAG 2.1)
• Balances aesthetics with implementation speed

🏗️ Backend System Architect

API Design & System Architecture

• Designs scalable backend systems
• Creates REST/GraphQL/gRPC APIs
• Plans database schemas and migrations
• Implements authentication strategies
• Optimizes for performance and scale

💻 Frontend UI Developer

React/Vue/Angular Implementation

• Builds responsive user interfaces
• Implements design system components
• Ensures cross-browser compatibility
• Optimizes frontend performance
• Handles state management and routing

🤖 AI/ML Engineer

AI Integration & ML Pipelines

• Integrates LLM APIs (OpenAI, Anthropic, Google)
• Builds ML pipelines and inference systems
• Implements recommendation engines
• Optimizes model performance
• Handles AI/ML production deployment

✨ Whimsy Injector

Delightful UX & Creative Touches

• Adds personality to user experiences
• Creates memorable interaction moments
• Designs engaging loading states
• Transforms errors into delightful surprises
• Makes products fun and shareable

✅ Code Quality Reviewer

Quality Assurance & Production-Grade Verification

• Reviews code for best practices
• NEW: Auto-triggers security scanning (npm audit/pip-audit)
• NEW: Collects evidence before approval (tests, builds, lints)
• NEW: Enforces quality standards (Minimum/Production-Grade/Gold)
• Checks security vulnerabilities (OWASP Top 10)
• Ensures proper error handling
• Validates test coverage
• Enforces code style and patterns

📚 Claude Code Skills

Updated in 3.7.1: 19 comprehensive skills including production-grade quality enforcement, DevOps, observability, prototype-to-production conversion, and 2025+ modern patterns!

What Are Skills?

Skills are specialized knowledge modules that Claude Code references when needed. They transform Claude from a general assistant into a domain expert. Each skill provides frameworks, templates, examples, and battle-tested best practices in markdown files that Claude reads during task execution.

Why Skills Matter for Development

Consistency Across Projects

• Use the same proven patterns every time
• No reinventing the wheel for common tasks
• Team members follow identical standards

Faster Onboarding

• New developers learn best practices instantly
• Comprehensive examples show the "right way"
• Checklists ensure nothing is forgotten

Higher Quality Code

• Security vulnerabilities caught early (OWASP Top 10)
• Test coverage strategies built-in
• Code review standards automated

Time Savings

• Templates eliminate boilerplate writing
• Examples provide copy-paste starting points
• Checklists prevent costly mistakes

Available Skills

🏗️ Architecture Decision Record (ADR)

Document why you made technical choices

• Creates ADRs following Nygard format
• Captures context, decision, and consequences
• Includes templates with alternatives considered
• Preserves architectural memory for teams
• Prevents endless debates about settled decisions

💡 Brainstorming (NEW in v3.5.9)

Transform rough ideas into fully-formed designs

• Structured Socratic questioning workflow
• Phase-based approach: Understanding → Exploration → Design
• Alternative exploration (2-3 approaches with trade-offs)
• Incremental validation and feedback loops
• YAGNI ruthlessly applied to prevent over-engineering

🌐 API Design Framework

Build consistent, well-documented APIs

• REST, GraphQL, and gRPC best practices
• OpenAPI 3.1 specification templates
• Proper HTTP status codes and error handling
• Pagination, filtering, and versioning patterns
• Authentication and rate limiting strategies

✅ Testing Strategy Builder

Comprehensive test coverage made easy

• Unit, integration, and E2E test patterns
• Coverage targets and quality gates
• Test plan and test case templates
• Performance testing with k6 examples
• CI/CD integration strategies

👀 Code Review Playbook

Consistent, constructive code reviews

• Conventional comments format (praise, issue, nitpick)
• Language-specific checklists (TypeScript, Python)
• Security and performance review patterns
• PR templates and review workflows
• Feedback patterns that improve code quality

🎨 Design System Starter

Build scalable UI component libraries

• Design token structures (colors, typography, spacing)
• Atomic design methodology (atoms → organisms)
• WCAG 2.1 accessibility compliance
• Dark mode and theming patterns
• Component API design best practices

🗄️ Database Schema Designer

Design performant, scalable databases

• SQL normalization (1NF, 2NF, 3NF)
• NoSQL embedding vs referencing patterns
• Indexing strategies for query optimization
• Zero-downtime migration patterns
• N+1 query prevention techniques

🔒 Security Checklist

Protect your app from vulnerabilities

• OWASP Top 10 mitigations (SQL injection, XSS, CSRF)
• Authentication and authorization patterns
• Input validation and sanitization
• Security headers configuration
• GDPR and SOC2 compliance guidelines
• NEW in v3.5.0: Automated security scanning workflows

📊 Evidence Verification (NEW in v3.5.0)

Production-grade quality verification

• Exit code capture workflows (test, build, lint)
• Quality evidence templates and examples
• Quality standard assessment (Minimum/Production-Grade/Gold)
• Evidence storage and retrieval patterns
• Integration with Code Quality Reviewer agent

🚦 Quality Gates (NEW in v3.5.0)

Prevent overwhelming tasks with complexity scoring

• 1-5 complexity assessment framework
• Blocking threshold rules (>3 questions, dependencies, attempts)
• Stuck detection and escalation workflows
• Requirements completeness checklists
• Integration with Squad mode and Studio Coach

🤖 AI-Native Development (NEW in v3.5.9)

Build AI-first applications with LLMs

• RAG (Retrieval-Augmented Generation) pipelines
• Vector databases and embeddings patterns
• Agentic workflows and tool integration
• LLM prompt engineering and function calling
• Streaming responses and cost optimization
• AI observability and monitoring patterns

⚡ Edge Computing Patterns (NEW in v3.5.9)

Deploy to globally distributed edge runtimes

• Cloudflare Workers, Vercel Edge, Deno Deploy patterns
• Edge middleware and request handling
• Streaming and fetch APIs at the edge
• Runtime constraints and optimization
• KV storage and caching strategies

⚛️ React Server Components Framework (NEW in v3.5.9)

Modern Next.js 15 App Router patterns

• React Server Components (RSC) architecture
• Server Actions and form handling
• Streaming SSR and Suspense boundaries
• Data fetching and caching patterns
• Client/Server component composition

🌊 Streaming API Patterns (NEW in v3.5.9)

Real-time data streaming and live updates

• Server-Sent Events (SSE) implementation
• WebSockets patterns and reconnection logic
• ReadableStream and backpressure handling
• LLM streaming response patterns
• Real-time collaborative features

🛡️ Type-Safety Validation (NEW in v3.5.9)

End-to-end type safety across the stack

• Zod runtime validation schemas
• tRPC type-safe APIs
• Prisma ORM type generation
• TypeScript 5.7+ advanced features
• Full-stack type inference patterns

🚀 DevOps & Deployment (NEW in v3.7.0)

CI/CD pipelines, containerization & infrastructure as code

• GitHub Actions pipeline templates (6 stages)
• Multi-stage Dockerfile best practices
• Kubernetes deployments, services & ingress
• Helm charts and GitOps with ArgoCD
• Terraform AWS infrastructure (VPC, EKS, RDS)
• Blue-green, canary & rolling deployment strategies

⚡ Performance Optimization (NEW in v3.7.0)

Full-stack performance analysis & tuning

• Core Web Vitals optimization (LCP, INP, CLS)
• Database query optimization & N+1 fixes
• Redis caching patterns & cache hierarchies
• React memoization & virtualization
• Bundle size optimization & code splitting
• API compression, ETags & pagination

📊 Observability & Monitoring (NEW in v3.7.0)

Structured logging, metrics, tracing & alerting

• Winston structured logging with correlation IDs
• Prometheus metrics (RED method)
• OpenTelemetry distributed tracing
• Alerting rules (critical, high, medium severity)
• Health check endpoints (liveness, readiness, startup)

🎨 Prototype to Production (NEW in v3.7.1)

Convert design prototypes into production-ready components

• Accepts super-design HTML, generic HTML/CSS, Figma exports
• Atomic design decomposition (atoms → molecules → organisms)
• Design token extraction from prototype CSS/styles
• Tech stack detection (defaults to React + TypeScript)
• Accessibility-first component generation
• Component templates with TypeScript interfaces

🎨 Design to Production Workflow

The super-design instruction and prototype-to-production skill work together for a streamlined design workflow:

┌─────────────┐         ┌─────────────┐         ┌─────────────┐
│   DESIGN    │   →     │   CONVERT   │   →     │    SHIP     │
│             │         │             │         │             │
│ "Design a   │         │ "Convert to │         │  React +    │
│  dashboard" │         │  components"│         │  TypeScript │
└─────────────┘         └─────────────┘         └─────────────┘
   super-design          prototype-to-            Production
   (HTML prototype)      production skill         Components

Step 1: Design - Use super-design workflow to create HTML prototypes

"Design a modern dashboard with analytics charts"
→ Creates .superdesign/design_iterations/*.html

Step 2: Convert - Transform prototype to production components

"Convert this prototype to React components"
→ Analyzes HTML structure
→ Extracts design tokens
→ Generates typed components

Step 3: Ship - Production-ready output

• TypeScript components with full type safety
• Design tokens (colors, typography, spacing)
• Accessibility built-in (ARIA, keyboard support)
• Atomic design structure (atoms → molecules → organisms)

How They Work

Skills use progressive disclosure to optimize token usage:

1. Claude sees skill metadata in SKILL.md frontmatter (description, tags)
2. Decides if skill is relevant to your task
3. Reads .claude/skills/<skill-name>/SKILL.md with core framework (~4k words)
4. Accesses detailed examples/templates only when needed via file reads

What's Included

Location: .claude/skills/ (v3.5.9+ unified structure)

Each skill contains:

• SKILL.md - Core framework and workflow (~300-400 lines)
• templates/ - Reusable file templates
• references/ - Detailed code examples
• checklists/ - Verification checklists
• assets/ - Additional resources

Example Usage

# Architecture Decision
"Document why we chose microservices over monolith"
→ Claude reads /skills/architecture-decision-record/SKILL.md
→ Creates ADR following Nygard format
→ Includes context, decision, consequences

# API Design
"Design a REST API for user management"
→ Claude reads /skills/api-design-framework/SKILL.md
→ Follows OpenAPI 3.1 specification
→ Implements proper resource naming, status codes

# Security Audit
"Review authentication implementation"
→ Claude reads /skills/security-checklist/SKILL.md
→ Checks OWASP Top 10 vulnerabilities
→ Provides mitigation recommendations

Token Optimization

Skills are designed for maximum efficiency:

• Main file: <5k words (compressed, focused)
• References: Loaded only when needed
• Templates: Accessed on-demand
• Total savings: ~80% compared to monolithic documentation

Location

All skills are installed in /skills/ directory in your project.

🏭 Production Features (v3.5.0)

NEW: Enterprise-grade quality enforcement that prevents bugs before they happen

AI Agent Hub v3.5.0 introduces production-ready features that transform Claude from a helpful assistant into a quality-enforcing development system. These features eliminate hallucinations, prevent wasted work, and ensure production-grade output.

📊 Evidence-Based Verification

Proof Over Promises - No more "trust me, it works!" responses.

How It Works

Every agent now must collect evidence before marking work complete:

1. Agent runs tests → Captures exit code (0 = pass, non-zero = fail)
2. Agent runs build → Records errors, warnings, artifacts
3. Agent runs linter → Documents code quality issues
4. Evidence saved to shared context → Permanent proof
5. Quality standard auto-assessed → Minimum/Production-Grade/Gold

Quality Standards

🥉 Minimum (Basic Verification)

• ✅ At least one check executed and passing
• ✅ Exit code 0 from test OR build OR lint
• 📊 Score: Work is functional

🥈 Production-Grade (Ready for Production)

• ✅ All checks executed and passing
• ✅ Test coverage ≥70%
• ✅ Build succeeds with no critical errors
• ✅ Linter passes with no errors
• ✅ Type checker passes
• 📊 Score: Production-ready quality

🥇 Gold Standard (Excellence)

• ✅ All Production-Grade criteria
• ✅ Test coverage ≥80%
• ✅ Zero linter warnings
• ✅ Zero type errors
• ✅ Security scan passes
• 📊 Score: Best-in-class quality

Example Evidence

{
  "quality_evidence": {
    "tests": {
      "executed": true,
      "exit_code": 0,
      "passed": 24,
      "failed": 0,
      "coverage_percent": 87.5,
      "timestamp": "2025-11-03T14:30:22Z"
    },
    "build": {
      "executed": true,
      "exit_code": 0,
      "errors": 0,
      "warnings": 2,
      "timestamp": "2025-11-03T14:30:25Z"
    },
    "linter": {
      "executed": true,
      "exit_code": 0,
      "errors": 0,
      "warnings": 0
    },
    "security_scan": {
      "executed": true,
      "tool": "npm audit",
      "critical": 0,
      "high": 0,
      "moderate": 3
    },
    "quality_standard_met": "gold-standard",
    "all_checks_passed": true
  }
}

🚦 Quality Gates

Prevent Overwhelming Tasks - Complexity scoring prevents agents from getting stuck.

Complexity Scoring (1-5 Scale)

Level 1-2 (Simple): Assign directly

• Small changes (<50 lines)
• Single file modifications
• Clear requirements

Level 3 (Moderate): Assign with checkpoint plan

• 200-500 lines of code
• 3-10 files affected
• Some unknowns

Level 4-5 (Complex): BLOCK until broken down

• 500+ lines of code
• 10+ files affected
• Multiple unknowns
• Cross-cutting concerns

Blocking Thresholds

Quality gates automatically BLOCK work when:

• >3 critical questions unanswered → Need clarification
• Dependencies not ready → Wait for upstream tasks
• 3+ failed attempts → Agent is stuck, escalate to user
• Complexity Level 4-5 without plan → Break down into subtasks

Example Gate Check

Gate Check: "Add real-time notifications"
├── Complexity: Level 4 (700 lines, 12 files, WebSocket + DB)
├── Critical Questions: 2 (notification format, delivery guarantee)
├── Dependencies: 1 blocked (user authentication not complete)
├── Attempts: 0
└── Decision: BLOCKED - Break into Level 1-3 subtasks

Subtasks Created:
1. Design notification schema (Level 2)
2. Implement WebSocket server (Level 3)
3. Add notification UI component (Level 2)
4. Write integration tests (Level 2)

🔒 Automated Security Scanning

Zero-Day Protection - Security vulnerabilities caught before code review.

Auto-Trigger On Every Review

Code Quality Reviewer agent automatically runs:

JavaScript/TypeScript Projects:

npm audit --json

Python Projects:

pip-audit --format=json

Blocking Thresholds

• CRITICAL: Any critical vulnerability → 🛑 BLOCK approval
• HIGH: >5 high severity vulnerabilities → 🛑 BLOCK approval
• MODERATE: >20 moderate vulnerabilities → ⚠️ WARNING
• LOW: >50 low vulnerabilities → ⚠️ WARNING

Example Security Report

### 🔒 Security Scan: ⚠️ WARNING

**Tool:** npm audit
**Executed:** 2025-11-03 14:35:10

**Vulnerability Summary:**
- Critical: 0 ✅
- High: 3 ⚠️
- Moderate: 8
- Low: 2

**High Severity Vulnerabilities:**
1. **lodash@4.17.19** - Prototype Pollution (GHSA-xxxx)
   Fix: `npm install lodash@4.17.21`

2. **minimist@1.2.5** - Prototype Pollution (GHSA-yyyy)
   Fix: `npm install minimist@1.2.6`

3. **axios@0.21.1** - SSRF Vulnerability (GHSA-zzzz)
   Fix: `npm install axios@1.6.0`

**Quick Fix:** `npm audit fix`

### Overall Status: BLOCKED ⛔
Must fix 3 high severity vulnerabilities before approval.

🎯 Stuck Detection & Escalation

No More Infinite Loops - Automatically detect when agents are stuck.

How It Works

1. Track Attempts - System records every task attempt
2. Learn from Failures - Each failure documents what was tried
3. Escalate at 3 Attempts - After 3 failed attempts, escalate to user
4. Suggest Alternatives - Provide context for human intervention

Example Escalation

🚨 AGENT STUCK - Escalating to User

Task: "Fix authentication bug"
Attempts: 3 failed

Attempt History:
1. Tried: Check JWT expiration logic
   Result: Failed - Bug persists
   Learning: JWT expiration is working correctly

2. Tried: Verify password hashing
   Result: Failed - Bug persists
   Learning: Password hashing is correct

3. Tried: Review session management
   Result: Failed - Bug persists
   Learning: Sessions are properly managed

Recommendation: Human guidance needed
- Bug may be in external service integration
- Consider checking API rate limiting
- May need to review network logs

⛓️ Failure Cascade Prevention

Stop Wasted Work - Automatically block dependent tasks when upstream fails.

How It Works

Task A fails → System detects
                 ↓
        Block all tasks that depend on A
                 ↓
        Recursively block their dependents
                 ↓
        No wasted cycles on doomed work

Example Cascade

⚠️ CASCADE DETECTED: Database migration failed

Blocked Tasks (3):
├── Task B: Add user preferences table (depends on migration)
├── Task C: Update user profile API (depends on Task B)
└── Task D: Create preferences UI (depends on Task C)

Action Required:
1. Fix database migration
2. Re-run quality gate checks
3. System will automatically unblock tasks

📈 Production Readiness Score

Before v3.5.0: 4.0/10 After v3.5.0: 9.4/10 Improvement: +5.4 points (135% increase)

🎓 New Skills for Production

evidence-verification - Comprehensive guide to collecting quality evidence

• Exit code capture workflows
• Test, build, and lint evidence templates
• Quality standard assessment criteria
• Evidence storage and retrieval patterns

quality-gates - Complexity assessment and gate validation

• 1-5 complexity scoring system
• Blocking threshold rules
• Stuck detection algorithms
• Requirements completeness checks

security-checklist (Enhanced) - Automated security scanning

• npm audit / pip-audit workflows
• Semgrep, Bandit, TruffleHog integration
• Critical threshold enforcement
• Fix command generation

💡 How to Use

It Just Works™ - All production features are automatic.

1. Install: npx ai-agent-hub@latest
2. Use agents normally
3. Quality gates enforce automatically
4. Evidence collected automatically
5. Security scans run automatically
6. Stuck detection monitors automatically

No configuration required!

⚙️ MCP Servers

Your Claude gets enhanced capabilities through MCP servers:

Core Servers (Always Included)

• Memory - Conversation history and context preservation
• Sequential Thinking - Step-by-step reasoning
• Context7 - Library documentation lookup
• Playwright - Browser automation and testing

Desktop-Specific

• Filesystem - File system access (read-only)
• GitHub - Repository management

Optional (with API Keys)

• GitHub (project) - GITHUB_TOKEN
• Supabase - SUPABASE_ACCESS_TOKEN
• Postgres - POSTGRES_CONNECTION_STRING

📦 Installation

Requirements

• Node.js 20+ (Download)
• Claude Desktop or Claude Code

Interactive Install

npx ai-agent-hub@latest

Advanced Options

# Skip prompts
npx ai-agent-hub@latest --project-only --mode squad
npx ai-agent-hub@latest --desktop-only --mode classic
npx ai-agent-hub@latest --both --mode auto

What Gets Installed

Project (.claude/)

• 10 AI agents (Classic: full, Squad: slim)
• 7 Claude Code skills (comprehensive frameworks & templates)
• Context system (session persistence, shared decisions)
• Context middleware (auto-loaded for all agents)
• Context triggers (keyword-based activation)
• Context bridge (Squad mode synchronization)
• MCP configuration
• Mode-specific instructions

Claude Desktop

• Enhanced config with 7 MCP servers
• Global agent availability
• Cross-project context awareness

🚀 How to Use

Auto Mode (Default) - Just Describe What You Need

"I need user authentication with social login"
# Backend Architect automatically handles API design
# Frontend Developer automatically creates UI
# Context shared between them instantly

"Make the loading screens more fun"
# Whimsy Injector automatically activates

"Build a real-time dashboard"
# Studio Coach coordinates multiple agents in parallel

Explicit Commands (When You Want Control)

"Use Studio Coach to plan my startup MVP"
"Have the Backend Architect design a scalable API"
"Get the UI Developer to create a responsive dashboard"

Squad Mode Workflow

Squad Mode Example

# Step 1: Allocate
/allocate-tasks-parallel social media dashboard
# Output: "Optimal: 3 agents for frontend, backend, database"

# Step 2: Execute
/start-parallel
# Agents work simultaneously on different parts

# Step 3: Sync
/sync-parallel
# Coordinate and merge results

🔧 Configuration

Environment Variables (Optional)

Create .env for additional features:

# MCP Servers
GITHUB_TOKEN=ghp_xxxxxxxxxxxx
SUPABASE_ACCESS_TOKEN=eyJxxxxxxxxx
POSTGRES_CONNECTION_STRING=postgresql://...
BRAVE_API_KEY=BSA-xxxxxxxxx

# AI Services
OPENAI_API_KEY=sk-xxxxxxxxx
ANTHROPIC_API_KEY=sk-ant-xxxxxx
GOOGLE_GENERATIVE_AI_API_KEY=AIzaxxxxxxxx

🛠️ Troubleshooting

Verify Installation

ls -la .claude/agents/                      # Should show 10 agents
ls -la skills/                              # Should show 7 skills directories
ls -la .claude/context/                     # Should show session & shared-context files
ls -la .claude/instructions/                # Should show context-middleware.md
cat .claude/context-triggers.md             # Should show keyword triggers
cat .mcp.json                               # Should show MCP config
node .claude/scripts/context-bridge.js      # Squad mode: Should run without errors

📝 Changelog

v3.4.2 (Latest)

• 🎓 7 Claude Code Skills - Comprehensive frameworks for architecture, API design, testing, code review, design systems, databases, and security
• ✅ Context middleware - Auto-loaded for all agents, enabling automatic context preservation
• ✅ Squad mode fixes - Package.json now includes all required dependencies
• ✅ Context bridge - Gracefully handles missing dependencies with helpful messages
• ✅ Zero-complexity - Everything works out of the box with npx, no manual setup
• ✅ Bug fixes - Fixed test scripts and improved error handling

v3.4.1

• 🧠 Intelligent orchestration with semantic routing
• 🚀 Squad mode for parallel execution
• 📊 Context-aware collaboration

v3.4.0

• Initial release with 9 specialized agents
• MCP server integration
• Classic and Squad modes

🤝 Contributing

Development

git clone https://github.com/ArieGoldkin/ai-agent-hub
cd ai-agent-hub
npm install
npm run build

Before PR

npm run lint
npm run typecheck
npm run build

📄 License

MIT © 2024 AI Agent Hub

Created by Arie Goldkin

npx ai-agent-hub@latest