ABSOLUTE RULES:
- ALL operations MUST be concurrent/parallel in a single message
- NEVER save working files, text/mds and tests to the root folder
- ALWAYS organize files in appropriate subdirectories
- USE CLAUDE CODE'S TASK TOOL for spawning agents concurrently, not just MCP
MANDATORY PATTERNS:
- TodoWrite: ALWAYS batch ALL todos in ONE call (5-10+ todos minimum)
- Task tool (Claude Code): ALWAYS spawn ALL agents in ONE message with full instructions
- File operations: ALWAYS batch ALL reads/writes/edits in ONE message
- Bash commands: ALWAYS batch ALL terminal operations in ONE message
- Memory operations: ALWAYS batch ALL memory store/retrieve in ONE message
Claude Code's Task tool is the PRIMARY way to spawn agents:
// ✅ CORRECT: Use Claude Code's Task tool for parallel agent execution
[Single Message]:
Task("Research agent", "Analyze requirements and patterns...", "researcher")
Task("Coder agent", "Implement core features...", "coder")
Task("Tester agent", "Create comprehensive tests...", "tester")
Task("Reviewer agent", "Review code quality...", "reviewer")
Task("Architect agent", "Design system architecture...", "system-architect")MCP tools are ONLY for coordination setup:
mcp__claude-flow__swarm_init- Initialize coordination topologymcp__claude-flow__agent_spawn- Define agent types for coordinationmcp__claude-flow__task_orchestrate- Orchestrate high-level workflows
NEVER save to root folder. Use these directories:
/src- Source code files/tests- Test files/docs- Documentation and markdown files/config- Configuration files/scripts- Utility scripts/examples- Example code
This project uses SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) methodology with Claude-Flow orchestration for systematic Test-Driven Development.
npx claude-flow sparc modes- List available modesnpx claude-flow sparc run <mode> "<task>"- Execute specific modenpx claude-flow sparc tdd "<feature>"- Run complete TDD workflownpx claude-flow sparc info <mode>- Get mode details
npx claude-flow sparc batch <modes> "<task>"- Parallel executionnpx claude-flow sparc pipeline "<task>"- Full pipeline processingnpx claude-flow sparc concurrent <mode> "<tasks-file>"- Multi-task processing
npm run build- Build projectnpm run test- Run testsnpm run lint- Lintingnpm run typecheck- Type checking
- Specification - Requirements analysis (
sparc run spec-pseudocode) - Pseudocode - Algorithm design (
sparc run spec-pseudocode) - Architecture - System design (
sparc run architect) - Refinement - TDD implementation (
sparc tdd) - Completion - Integration (
sparc run integration)
- Modular Design: Files under 500 lines
- Environment Safety: Never hardcode secrets
- Test-First: Write tests before implementation
- Clean Architecture: Separate concerns
- Documentation: Keep updated
coder, reviewer, tester, planner, researcher
hierarchical-coordinator, mesh-coordinator, adaptive-coordinator, collective-intelligence-coordinator, swarm-memory-manager
byzantine-coordinator, raft-manager, gossip-coordinator, consensus-builder, crdt-synchronizer, quorum-manager, security-manager
perf-analyzer, performance-benchmarker, task-orchestrator, memory-coordinator, smart-agent
github-modes, pr-manager, code-review-swarm, issue-tracker, release-manager, workflow-automation, project-board-sync, repo-architect, multi-repo-swarm
sparc-coord, sparc-coder, specification, pseudocode, architecture, refinement
backend-dev, mobile-dev, ml-developer, cicd-engineer, api-docs, system-architect, code-analyzer, base-template-generator
tdd-london-swarm, production-validator
migration-planner, swarm-init
- Task tool: Spawn and run agents concurrently for actual work
- File operations (Read, Write, Edit, MultiEdit, Glob, Grep)
- Code generation and programming
- Bash commands and system operations
- Implementation work
- Project navigation and analysis
- TodoWrite and task management
- Git operations
- Package management
- Testing and debugging
- Swarm initialization (topology setup)
- Agent type definitions (coordination patterns)
- Task orchestration (high-level planning)
- Memory management
- Neural features
- Performance tracking
- GitHub integration
KEY: MCP coordinates the strategy, Claude Code's Task tool executes with real agents.
# Add MCP servers (Claude Flow required, others optional)
claude mcp add claude-flow npx claude-flow@alpha mcp start
claude mcp add ruv-swarm npx ruv-swarm mcp start # Optional: Enhanced coordination
claude mcp add flow-nexus npx flow-nexus@latest mcp start # Optional: Cloud featuresswarm_init, agent_spawn, task_orchestrate
swarm_status, agent_list, agent_metrics, task_status, task_results
memory_usage, neural_status, neural_train, neural_patterns
github_swarm, repo_analyze, pr_enhance, issue_triage, code_review
benchmark_run, features_detect, swarm_monitor
Flow-Nexus extends MCP capabilities with 70+ cloud-based orchestration tools:
Key MCP Tool Categories:
- Swarm & Agents:
swarm_init,swarm_scale,agent_spawn,task_orchestrate - Sandboxes:
sandbox_create,sandbox_execute,sandbox_upload(cloud execution) - Templates:
template_list,template_deploy(pre-built project templates) - Neural AI:
neural_train,neural_patterns,seraphina_chat(AI assistant) - GitHub:
github_repo_analyze,github_pr_manage(repository management) - Real-time:
execution_stream_subscribe,realtime_subscribe(live monitoring) - Storage:
storage_upload,storage_list(cloud file management)
Authentication Required:
- Register:
mcp__flow-nexus__user_registerornpx flow-nexus@latest register - Login:
mcp__flow-nexus__user_loginornpx flow-nexus@latest login - Access 70+ specialized MCP tools for advanced orchestration
- Optional: Use MCP tools to set up coordination topology
- REQUIRED: Use Claude Code's Task tool to spawn agents that do actual work
- REQUIRED: Each agent runs hooks for coordination
- REQUIRED: Batch all operations in single messages
// Single message with all agent spawning via Claude Code's Task tool
[Parallel Agent Execution]:
Task("Backend Developer", "Build REST API with Express. Use hooks for coordination.", "backend-dev")
Task("Frontend Developer", "Create React UI. Coordinate with backend via memory.", "coder")
Task("Database Architect", "Design PostgreSQL schema. Store schema in memory.", "code-analyzer")
Task("Test Engineer", "Write Jest tests. Check memory for API contracts.", "tester")
Task("DevOps Engineer", "Setup Docker and CI/CD. Document in memory.", "cicd-engineer")
Task("Security Auditor", "Review authentication. Report findings via hooks.", "reviewer")
// All todos batched together
TodoWrite { todos: [...8-10 todos...] }
// All file operations together
Write "backend/server.js"
Write "frontend/App.jsx"
Write "database/schema.sql"1️⃣ BEFORE Work:
npx claude-flow@alpha hooks pre-task --description "[task]"
npx claude-flow@alpha hooks session-restore --session-id "swarm-[id]"2️⃣ DURING Work:
npx claude-flow@alpha hooks post-edit --file "[file]" --memory-key "swarm/[agent]/[step]"
npx claude-flow@alpha hooks notify --message "[what was done]"3️⃣ AFTER Work:
npx claude-flow@alpha hooks post-task --task-id "[task]"
npx claude-flow@alpha hooks session-end --export-metrics true// Step 1: MCP tools set up coordination (optional, for complex tasks)
[Single Message - Coordination Setup]:
mcp__claude-flow__swarm_init { topology: "mesh", maxAgents: 6 }
mcp__claude-flow__agent_spawn { type: "researcher" }
mcp__claude-flow__agent_spawn { type: "coder" }
mcp__claude-flow__agent_spawn { type: "tester" }
// Step 2: Claude Code Task tool spawns ACTUAL agents that do the work
[Single Message - Parallel Agent Execution]:
// Claude Code's Task tool spawns real agents concurrently
Task("Research agent", "Analyze API requirements and best practices. Check memory for prior decisions.", "researcher")
Task("Coder agent", "Implement REST endpoints with authentication. Coordinate via hooks.", "coder")
Task("Database agent", "Design and implement database schema. Store decisions in memory.", "code-analyzer")
Task("Tester agent", "Create comprehensive test suite with 90% coverage.", "tester")
Task("Reviewer agent", "Review code quality and security. Document findings.", "reviewer")
// Batch ALL todos in ONE call
TodoWrite { todos: [
{id: "1", content: "Research API patterns", status: "in_progress", priority: "high"},
{id: "2", content: "Design database schema", status: "in_progress", priority: "high"},
{id: "3", content: "Implement authentication", status: "pending", priority: "high"},
{id: "4", content: "Build REST endpoints", status: "pending", priority: "high"},
{id: "5", content: "Write unit tests", status: "pending", priority: "medium"},
{id: "6", content: "Integration tests", status: "pending", priority: "medium"},
{id: "7", content: "API documentation", status: "pending", priority: "low"},
{id: "8", content: "Performance optimization", status: "pending", priority: "low"}
]}
// Parallel file operations
Bash "mkdir -p app/{src,tests,docs,config}"
Write "app/package.json"
Write "app/src/server.js"
Write "app/tests/server.test.js"
Write "app/docs/API.md"Message 1: mcp__claude-flow__swarm_init
Message 2: Task("agent 1")
Message 3: TodoWrite { todos: [single todo] }
Message 4: Write "file.js"
// This breaks parallel coordination!- 84.8% SWE-Bench solve rate
- 32.3% token reduction
- 2.8-4.4x speed improvement
- 27+ neural models
- Auto-assign agents by file type
- Validate commands for safety
- Prepare resources automatically
- Optimize topology by complexity
- Cache searches
- Auto-format code
- Train neural patterns
- Update memory
- Analyze performance
- Track token usage
- Generate summaries
- Persist state
- Track metrics
- Restore context
- Export workflows
- 🚀 Automatic Topology Selection
- ⚡ Parallel Execution (2.8-4.4x speed)
- 🧠 Neural Training
- 📊 Bottleneck Analysis
- 🤖 Smart Auto-Spawning
- 🛡️ Self-Healing Workflows
- 💾 Cross-Session Memory
- 🔗 GitHub Integration
- Start with basic swarm init
- Scale agents gradually
- Use memory for context
- Monitor progress regularly
- Train patterns from success
- Enable hooks automation
- Use GitHub tools first
- Documentation: https://github.com/ruvnet/claude-flow
- Issues: https://github.com/ruvnet/claude-flow/issues
- Flow-Nexus Platform: https://flow-nexus.ruv.io (registration required for cloud features)
Remember: Claude Flow coordinates, Claude Code creates!
Do what has been asked; nothing more, nothing less. NEVER create files unless they're absolutely necessary for achieving your goal. ALWAYS prefer editing an existing file to creating a new one. NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User. Never save working files, text/mds and tests to the root folder.
This project uses the Agentic QE Fleet - a distributed swarm of 18 AI agents for comprehensive software testing and quality assurance.
- qe-test-generator: AI-powered test generation with sublinear optimization
- qe-test-executor: Multi-framework test execution with parallel processing
- qe-coverage-analyzer: Real-time gap detection with O(log n) algorithms
- qe-quality-gate: Intelligent quality gate with risk assessment
- qe-quality-analyzer: Comprehensive quality metrics analysis
- qe-performance-tester: Load testing with k6, JMeter, Gatling integration
- qe-security-scanner: Multi-layer security with SAST/DAST scanning
- qe-requirements-validator: INVEST criteria validation and BDD generation
- qe-production-intelligence: Production data to test scenarios conversion
- qe-fleet-commander: Hierarchical fleet coordination (50+ agents)
- qe-deployment-readiness: Multi-factor risk assessment for deployments
- qe-regression-risk-analyzer: Smart test selection with ML patterns
- qe-test-data-architect: High-speed realistic data generation (10k+ records/sec)
- qe-api-contract-validator: Breaking change detection across API versions
- qe-flaky-test-hunter: Statistical flakiness detection and auto-stabilization
- qe-visual-tester: Visual regression with AI-powered comparison
- qe-chaos-engineer: Resilience testing with controlled fault injection
```javascript // Spawn agents directly in Claude Code Task("Generate tests", "Create comprehensive test suite for UserService", "qe-test-generator") Task("Analyze coverage", "Find gaps using O(log n) algorithms", "qe-coverage-analyzer") Task("Quality check", "Run quality gate validation", "qe-quality-gate") ```
```bash
claude mcp list
mcp__agentic_qe__test_generate({ type: "unit", framework: "jest" }) mcp__agentic_qe__test_execute({ parallel: true, coverage: true }) mcp__agentic_qe__quality_analyze({ scope: "full" }) ```
```bash
aqe test # Generate tests aqe coverage # Analyze coverage aqe quality # Run quality gate aqe status # Check fleet status ```
All agents coordinate through AQE hooks (Agentic QE native hooks - zero external dependencies, 100-500x faster):
Agents extend `BaseAgent` and override lifecycle methods:
```typescript protected async onPreTask(data: { assignment: TaskAssignment }): Promise { // Load context before task execution const context = await this.memoryStore.retrieve('aqe/context', { partition: 'coordination' });
this.logger.info('Pre-task hook complete'); }
protected async onPostTask(data: { assignment: TaskAssignment; result: any }): Promise { // Store results after task completion await this.memoryStore.store('aqe/' + this.agentId.type + '/results', data.result, { partition: 'agent_results', ttl: 86400 // 24 hours });
// Emit completion event this.eventBus.emit('task:completed', { agentId: this.agentId, result: data.result });
this.logger.info('Post-task hook complete'); }
protected async onTaskError(data: { assignment: TaskAssignment; error: Error }): Promise { // Handle task errors await this.memoryStore.store('aqe/errors/' + data.assignment.id, { error: data.error.message, stack: data.error.stack, timestamp: Date.now() }, { partition: 'errors', ttl: 604800 // 7 days });
this.logger.error('Task failed', { error: data.error }); } ```
| Feature | AQE Hooks | External Hooks |
|---|---|---|
| Speed | <1ms | 100-500ms |
| Dependencies | Zero | External package |
| Type Safety | Full TypeScript | Shell strings |
| Integration | Direct API | Shell commands |
| Performance | 100-500x faster | Baseline |
Agents share state through the `aqe/*` memory namespace:
- `aqe/test-plan/*` - Test planning and requirements
- `aqe/coverage/*` - Coverage analysis and gaps
- `aqe/quality/*` - Quality metrics and gates
- `aqe/performance/*` - Performance test results
- `aqe/security/*` - Security scan findings
- `aqe/swarm/coordination` - Cross-agent coordination
Topology: hierarchical Max Agents: 10 Testing Focus: unit, integration Environments: development Frameworks: jest
Status:
The Multi-Model Router provides 70-81% cost savings by intelligently selecting AI models based on task complexity.
- ✅ Intelligent model selection (GPT-3.5, GPT-4, Claude Sonnet 4.5, Claude Haiku)
- ✅ Real-time cost tracking and aggregation
- ✅ Automatic fallback chains for resilience
- ✅ Feature flags for safe rollout
- ✅ Zero breaking changes (disabled by default)
Option 1: Via Configuration ```json // .agentic-qe/config/routing.json { "multiModelRouter": { "enabled": true } } ```
Option 2: Via Environment Variable ```bash export AQE_ROUTING_ENABLED=true ```
| Task Complexity | Model | Est. Cost | Use Case |
|---|---|---|---|
| Simple | GPT-3.5 | $0.0004 | Unit tests, basic validation |
| Moderate | GPT-3.5 | $0.0008 | Integration tests, mocks |
| Complex | GPT-4 | $0.0048 | Property-based, edge cases |
| Critical | Claude Sonnet 4.5 | $0.0065 | Security, architecture review |
Before Routing (always GPT-4):
- 100 simple tasks: $0.48
- 50 complex tasks: $0.24
- Total: $0.72
After Routing:
- 100 simple → GPT-3.5: $0.04
- 50 complex → GPT-4: $0.24
- Total: $0.28
- Savings: $0.44 (61%)
```bash
aqe routing dashboard
aqe routing report --format json
aqe routing stats ```
Status: ✅ Enabled
Real-time progress updates for long-running operations using AsyncGenerator pattern.
- ✅ Real-time progress percentage
- ✅ Current operation visibility
- ✅ for-await-of compatibility
- ✅ Backward compatible (non-streaming still works)
```javascript // Using streaming MCP tool const handler = new TestExecuteStreamHandler();
for await (const event of handler.execute(params)) { if (event.type === 'progress') { console.log(`Progress: ${event.percent}% - ${event.message}`); } else if (event.type === 'result') { console.log('Completed:', event.data); } } ```
- ✅ Test execution (test-by-test progress)
- ✅ Coverage analysis (incremental gap detection)
⚠️ Test generation (coming in v1.1.0)⚠️ Security scanning (coming in v1.1.0)
This project includes 59 specialized skills across multiple categories that agents can use:
- agentic-quality-engineering: Using AI agents as force multipliers in quality work - autonomous testing systems, PACT principles, scaling quality engineering with intelligent agents
- context-driven-testing: Apply context-driven testing principles where practices are chosen based on project context, not universal "best practices"
- holistic-testing-pact: Apply the Holistic Testing Model evolved with PACT (Proactive, Autonomous, Collaborative, Targeted) principles
- tdd-london-chicago: Apply both London and Chicago school TDD approaches - understanding different TDD philosophies and choosing the right testing style
- xp-practices: Apply XP practices including pair programming, ensemble programming, continuous integration, and sustainable pace
- risk-based-testing: Focus testing effort on highest-risk areas using risk assessment and prioritization
- test-automation-strategy: Design and implement comprehensive test automation strategies
- api-testing-patterns: Comprehensive API testing patterns including contract testing, REST/GraphQL testing, and integration testing
- exploratory-testing-advanced: Advanced exploratory testing techniques with Session-Based Test Management (SBTM), RST heuristics, and test tours
- performance-testing: Test application performance, scalability, and resilience with load testing and stress testing
- security-testing: Test for security vulnerabilities using OWASP principles and security testing techniques
- code-review-quality: Conduct context-driven code reviews focusing on quality, testability, and maintainability
- refactoring-patterns: Apply safe refactoring patterns to improve code structure without changing behavior
- quality-metrics: Measure quality effectively with actionable metrics and KPIs
- bug-reporting-excellence: Write high-quality bug reports that get fixed quickly - includes templates, examples, and best practices
- technical-writing: Create clear, concise technical documentation
- consultancy-practices: Apply effective software quality consultancy practices
- regression-testing: Strategic regression testing with test selection, impact analysis, and continuous regression management
- shift-left-testing: Move testing activities earlier in development lifecycle with TDD, BDD, and design for testability
- shift-right-testing: Testing in production with feature flags, canary deployments, synthetic monitoring, and chaos engineering
- test-design-techniques: Advanced test design using equivalence partitioning, boundary value analysis, and decision tables
- mutation-testing: Test quality validation through mutation testing and measuring test suite effectiveness
- test-data-management: Realistic test data generation, GDPR compliance, and data masking strategies
- accessibility-testing: WCAG 2.2 compliance testing, screen reader validation, and inclusive design verification
- mobile-testing: Comprehensive mobile testing for iOS and Android including gestures, sensors, and device fragmentation
- database-testing: Database schema validation, data integrity testing, migration testing, and query performance
- contract-testing: Consumer-driven contract testing for microservices using Pact and API versioning
- chaos-engineering-resilience: Chaos engineering principles, controlled failure injection, and resilience testing
- compatibility-testing: Cross-browser, cross-platform, and cross-device compatibility testing
- localization-testing: Internationalization (i18n) and localization (l10n) testing for global products
- compliance-testing: Regulatory compliance testing for GDPR, CCPA, HIPAA, SOC2, and PCI-DSS
- visual-testing-advanced: Advanced visual regression testing with AI-powered screenshot comparison and UI validation
- test-environment-management: Manage test environments, infrastructure as code, and environment provisioning
- test-reporting-analytics: Comprehensive test reporting with metrics, trends, and actionable insights
- sparc-methodology: SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) comprehensive development methodology with multi-agent orchestration
- flow-nexus-swarm: Cloud-based AI swarm deployment and event-driven workflow automation with Flow Nexus platform
- hive-mind-advanced: Advanced Hive Mind collective intelligence system for queen-led multi-agent coordination with consensus mechanisms
- swarm-advanced: Advanced swarm coordination patterns for complex multi-agent systems
- swarm-orchestration: Swarm orchestration and coordination techniques for distributed agent management
- agentdb-advanced: Master advanced AgentDB features including QUIC synchronization, multi-database management, custom distance metrics, and hybrid search
- agentdb-learning: Create and train AI learning plugins with AgentDB's 9 reinforcement learning algorithms (Decision Transformer, Q-Learning, SARSA, Actor-Critic, etc.)
- agentdb-memory-patterns: Implement persistent memory patterns for AI agents using AgentDB (session memory, long-term storage, pattern learning)
- agentdb-optimization: Optimize AgentDB performance with quantization (4-32x memory reduction), HNSW indexing (150x faster search), and batch operations
- agentdb-vector-search: Implement semantic vector search with AgentDB for intelligent document retrieval and RAG systems
- github-code-review: Comprehensive GitHub code review with AI-powered swarm coordination for automated reviews and quality checks
- github-multi-repo: Multi-repository coordination, synchronization, and architecture management with AI swarm orchestration
- github-project-management: Comprehensive GitHub project management with swarm-coordinated issue tracking and sprint planning
- github-release-management: Comprehensive GitHub release orchestration with AI swarm coordination for automated versioning and deployment
- github-workflow-automation: Advanced GitHub Actions workflow automation with AI swarm coordination and intelligent CI/CD pipelines
- reasoningbank-agentdb: Implement ReasoningBank adaptive learning with AgentDB's 150x faster vector database for trajectory tracking and pattern recognition
- reasoningbank-intelligence: Implement adaptive learning with ReasoningBank for pattern recognition, strategy optimization, and continuous improvement
- pair-programming: AI-assisted pair programming with multiple modes (driver/navigator/switch), real-time verification, and comprehensive testing
- flow-nexus-neural: Train and deploy neural networks in distributed E2B sandboxes with Flow Nexus cloud infrastructure
- flow-nexus-platform: Comprehensive Flow Nexus platform management - authentication, sandboxes, app deployment, payments, and challenges
- hooks-automation: Automated coordination, formatting, and learning from Claude Code operations using intelligent hooks with MCP integration
- performance-analysis: Comprehensive performance analysis, bottleneck detection, and optimization recommendations for Claude Flow swarms
- skill-builder: Create new Claude Code Skills with proper YAML frontmatter, progressive disclosure structure, and complete directory organization
- stream-chain: Stream-JSON chaining for multi-agent pipelines, data transformation, and sequential workflows
- verification-quality: Quality verification patterns and techniques for ensuring code quality and correctness
```bash
aqe skills list
aqe skills search "testing"
aqe skills show agentic-quality-engineering
aqe skills stats ```
```javascript // Execute a skill Skill("agentic-quality-engineering") Skill("tdd-london-chicago") Skill("api-testing-patterns") ```
All QE agents automatically have access to relevant skills based on their specialization:
- Test generators use: agentic-quality-engineering, api-testing-patterns, tdd-london-chicago
- Coverage analyzers use: agentic-quality-engineering, quality-metrics, risk-based-testing
- Flaky test hunters use: agentic-quality-engineering, exploratory-testing-advanced
- Performance testers use: agentic-quality-engineering, performance-testing, quality-metrics
- Security scanners use: agentic-quality-engineering, security-testing, risk-based-testing
All agents automatically learn from task execution through Q-learning:
```bash
aqe learn status --agent test-gen
aqe learn history --agent test-gen --limit 50
aqe learn export --agent test-gen --output learning.json ```
```bash
aqe patterns list --framework jest
aqe patterns search "api validation"
aqe patterns extract ./tests --framework jest ```
```bash
aqe improve start
aqe improve status
aqe improve cycle ```
- Agent Definitions: `.claude/agents/` - 18 specialized QE agents
- Skills: `.claude/skills/` - 59 specialized skills total:
- QE Skills: 34 (Phase 1: 17 + Phase 2: 17)
- SPARC & Development: 1
- Swarm & Orchestration: 4
- AgentDB & Memory: 5
- GitHub Integration: 5
- Intelligence & Learning: 3
- Platform & Infrastructure: 2
- Utilities: 5
- Fleet Config: `.agentic-qe/config/fleet.json`
- Routing Config: `.agentic-qe/config/routing.json` (Multi-Model Router settings)
- AQE Hooks Config: `.agentic-qe/config/aqe-hooks.json` (zero dependencies, 100-500x faster)
```javascript // Execute multiple agents concurrently Task("Test Generation", "Generate unit tests", "qe-test-generator") Task("Coverage Analysis", "Analyze current coverage", "qe-coverage-analyzer") Task("Security Scan", "Run security checks", "qe-security-scanner") Task("Performance Test", "Load test critical paths", "qe-performance-tester") ```
```javascript // Test generator stores results Task("Generate tests", "Create tests and store in memory at aqe/test-plan/generated", "qe-test-generator")
// Test executor reads from memory Task("Execute tests", "Read test plan from aqe/test-plan/generated and execute", "qe-test-executor")
// Coverage analyzer processes results Task("Analyze coverage", "Check coverage from aqe/coverage/results", "qe-coverage-analyzer") ```
- Use Task Tool: Claude Code's Task tool is the primary way to spawn agents
- Batch Operations: Always spawn multiple related agents in a single message
- Memory Keys: Use the `aqe/*` namespace for agent coordination
- AQE Hooks: Agents automatically use native AQE hooks for coordination (100-500x faster)
- Parallel Execution: Leverage concurrent agent execution for speed
```bash claude mcp list ```
```bash ls -la .claude/agents/ ```
```bash aqe status --verbose ```
```bash tail -f .agentic-qe/logs/fleet.log ```
Generated by: Agentic QE Fleet v1.3.5 Initialization Date: 2025-10-28T23:57:33.342Z Fleet Topology: hierarchical