Agentic QE Fleet API Documentation - v1.0.0

Agentic Quality Engineering Fleet

AI-Driven Quality Engineering Automation

A distributed fleet of specialized AI agents for comprehensive software testing, quality assurance, and continuous validation.

Quick Start • Documentation • Contributing • Examples

🚀 Features

Autonomous Agent Fleet

16 Specialized QE Agents: Each agent is an expert in specific quality engineering domains
Intelligent Coordination: Event-driven architecture with automatic task distribution
Scalable: From single developer projects to enterprise-scale testing infrastructure
Self-Organizing: Agents autonomously coordinate testing strategies

Comprehensive Testing

AI-Powered Test Generation: Generate comprehensive test suites automatically
Multi-Framework Support: Jest, Mocha, Cypress, Playwright, and more
Parallel Execution: Execute thousands of tests concurrently with intelligent orchestration
Real-Time Coverage Analysis: O(log n) algorithms for instant coverage gap detection

Quality Intelligence

Smart Quality Gates: ML-driven quality assessment with risk scoring
Security Scanning: SAST, DAST, dependency analysis, and container security
Performance Testing: Load testing with k6, JMeter, and Gatling integration
Visual Regression: AI-powered screenshot comparison and UI validation

Advanced Capabilities

Flaky Test Detection: Statistical analysis with automatic stabilization
API Contract Validation: Breaking change detection across versions
Test Data Generation: 10,000+ realistic records per second
Production Intelligence: Convert production incidents into test scenarios
Chaos Engineering: Controlled fault injection for resilience testing

📦 Prerequisites & Installation

Prerequisites

Before using Agentic QE, you must have:

Required

Claude Code: Install from claude.ai/code
Node.js: 18.0 or higher
npm: 8.0 or higher

Optional (Advanced Features)

Claude Flow: For advanced coordination

npm install -g @claude/flow
# or
npx claude-flow@alpha init --force

Installation Steps

Install Claude Code globally or in your workspace
Global Installation (Recommended)
```
npm install -g agentic-qe
```

Local Development

git clone https://github.com/proffesor-for-testing/agentic-qe.git
cd agentic-qe
npm install
npm run build

System Requirements

Memory: 2GB+ recommended for large test suites
OS: Linux, macOS, Windows (via WSL2)
Agent Execution: Via Claude Code's Task tool or MCP integration

⚡ Quick Start

Initialize Your Project

# Initialize AQE Fleet in your project
aqe init

What it does:

Creates .claude/agents/ with 16 specialized QE agent definitions
Creates .claude/commands/ with 8 AQE slash commands
Creates .agentic-qe/ configuration directory
Updates or creates CLAUDE.md with integration documentation
Note: Agents are executed through Claude Code's Task tool, not as standalone processes

Agent Execution Model:

Agents are Claude Code agent definitions (markdown files in .claude/agents/)
Executed via Claude Code's Task tool: Task("description", "prompt", "agent-type")
NOT standalone Node.js processes
Integration with Claude Code via MCP (Model Context Protocol)

Basic Commands

# Check fleet status
aqe status

# Generate tests for a module
aqe test src/services/user-service.ts

# Analyze test coverage
aqe coverage --threshold 95

# Run quality gate validation
aqe quality

# Execute comprehensive test suite
aqe execute --parallel --coverage

# View all commands
aqe help

Programmatic Usage

import { FleetManager, QEAgentFactory } from 'agentic-qe';

// Initialize fleet
const fleet = new FleetManager({
  maxAgents: 20,
  topology: 'mesh'
});

await fleet.initialize();

// Spawn test generator agent
const testGen = await fleet.spawnAgent('test-generator', {
  targetCoverage: 95,
  framework: 'jest'
});

// Generate tests for a module
const tests = await testGen.execute({
  sourceFile: 'src/services/user-service.ts',
  testStyle: 'property-based'
});

🤖 Agent Types

Core Testing Agents

Agent	Purpose	Key Features
test-generator	AI-powered test creation	Property-based testing, edge case detection
test-executor	Multi-framework execution	Parallel processing, retry logic, reporting
coverage-analyzer	Real-time gap analysis	O(log n) algorithms, trend tracking
quality-gate	Intelligent validation	ML-driven decisions, risk assessment
quality-analyzer	Metrics analysis	ESLint, SonarQube, Lighthouse integration

Performance & Security

Agent	Purpose	Key Features
performance-tester	Load & stress testing	k6, JMeter, Gatling, bottleneck detection
security-scanner	Vulnerability detection	SAST, DAST, dependency scanning

Strategic Planning

Agent	Purpose	Key Features
requirements-validator	Testability analysis	INVEST criteria, BDD generation
production-intelligence	Incident replay	RUM analysis, anomaly detection
fleet-commander	Hierarchical coordination	50+ agent orchestration

Advanced Testing

Agent	Purpose	Key Features
regression-risk-analyzer	Smart test selection	ML patterns, AST analysis
test-data-architect	Realistic data generation	10k+ records/sec, GDPR compliant
api-contract-validator	Breaking change detection	OpenAPI, GraphQL, gRPC
flaky-test-hunter	Stability analysis	Statistical detection, auto-fix

Specialized

Agent	Purpose	Key Features
deployment-readiness	Release validation	Multi-factor risk scoring
visual-tester	UI regression	AI-powered comparison
chaos-engineer	Resilience testing	Fault injection, blast radius

🏗️ Architecture

Core Components

┌─────────────────────────────────────────────┐
│           Fleet Manager                      │
│  (Central Coordination & Task Distribution) │
└─────────────────────────────────────────────┘
                    │
        ┌───────────┼───────────┐
        │           │           │
   ┌────▼────┐ ┌───▼────┐ ┌───▼────┐
   │ Agent 1 │ │ Agent 2│ │ Agent N│
   │  Pool   │ │  Pool  │ │  Pool  │
   └────┬────┘ └───┬────┘ └───┬────┘
        │          │          │
   ┌────▼──────────▼──────────▼────┐
   │        Event Bus               │
   │  (Event-Driven Communication)  │
   └────┬──────────────────────┬────┘
        │                      │
   ┌────▼────┐           ┌────▼────┐
   │  Memory │           │Database │
   │  Store  │           │(SQLite) │
   └─────────┘           └─────────┘

Event-Driven Architecture

EventBus: Real-time communication between agents
Task Queue: Priority-based task scheduling
Memory Store: Shared context and learning
Persistence: SQLite for state, metrics, and audit trails

📖 Documentation

Getting Started

User Guides

Advanced Topics

Commands Reference

🔧 Configuration

Environment Variables

Create a .env file in your project root:

# Fleet Configuration
FLEET_ID=my-project-fleet
MAX_AGENTS=20
HEARTBEAT_INTERVAL=30000

# Database
DB_TYPE=sqlite
DB_FILENAME=./data/fleet.db

# Logging
LOG_LEVEL=info
LOG_FORMAT=json

# API (optional)
API_PORT=3000
API_HOST=localhost

Fleet Configuration

Create config/fleet.yaml:

fleet:
  id: "my-project-fleet"
  name: "My Project QE Fleet"
  maxAgents: 20
  topology: mesh

agents:
  test-executor:
    count: 3
    config:
      frameworks: [jest, cypress, playwright]
      maxParallelTests: 8
      timeout: 300000

  coverage-analyzer:
    count: 2
    config:
      targetCoverage: 95
      optimizationAlgorithm: sublinear

  quality-analyzer:
    count: 2
    config:
      tools: [eslint, sonarqube, lighthouse]
      thresholds:
        coverage: 80
        complexity: 10
        maintainability: 65

🧪 Examples

Test Generation

import { Task, TaskPriority } from 'agentic-qe';

// Generate comprehensive test suite
const generateTests = new Task(
  'test-generation',
  'Generate Tests for User Service',
  {
    sourceFile: './src/services/user-service.ts',
    framework: 'jest',
    coverage: 95,
    testTypes: ['unit', 'integration', 'property-based']
  },
  {},
  TaskPriority.HIGH
);

await fleet.submitTask(generateTests);

Quality Analysis

const qualityAnalysis = new Task(
  'quality-analysis',
  'Comprehensive Quality Check',
  {
    sourcePath: './src',
    tools: ['eslint', 'sonarqube', 'lighthouse'],
    thresholds: {
      coverage: 80,
      complexity: 10,
      security: 90
    }
  },
  {},
  TaskPriority.MEDIUM
);

Security Scanning

const securityScan = new Task(
  'security-scan',
  'SAST & DAST Security Analysis',
  {
    sourcePath: './src',
    scanTypes: ['sast', 'dast', 'dependency', 'container'],
    severity: 'high',
    compliance: ['OWASP-Top-10', 'CWE-Top-25']
  },
  {},
  TaskPriority.HIGH
);

More examples in examples/

🐳 Docker Deployment

Quick Start

# Start with SQLite (development)
docker-compose up -d

# Start with PostgreSQL (production)
docker-compose --profile postgres up -d

Production Deployment

# Configure production environment
cp .env.example .env.production
# Edit .env.production with secure credentials

# Deploy
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d

Docker Compose Configuration

version: '3.8'
services:
  agentic-qe:
    image: agentic-qe:latest
    environment:
      - FLEET_ID=prod-fleet
      - MAX_AGENTS=50
      - DB_TYPE=postgres
    volumes:
      - ./config:/app/config
      - ./data:/app/data
    ports:
      - "3000:3000"

🚀 Development

Setup

# Clone repository
git clone https://github.com/proffesor-for-testing/agentic-qe.git
cd agentic-qe

# Install dependencies
npm install

# Build
npm run build

# Run tests
npm test

Available Scripts

Script	Description
`npm run build`	Compile TypeScript to JavaScript
`npm run dev`	Development mode with hot reload
`npm test`	Run all test suites
`npm run test:unit`	Unit tests only
`npm run test:integration`	Integration tests
`npm run test:coverage`	Generate coverage report
`npm run lint`	ESLint code checking
`npm run lint:fix`	Auto-fix linting issues
`npm run typecheck`	TypeScript type checking

Project Structure

agentic-qe/
├── src/
│   ├── agents/          # 16 agent implementations
│   ├── core/            # Core fleet management
│   │   ├── FleetManager.ts
│   │   ├── Agent.ts
│   │   ├── Task.ts
│   │   ├── EventBus.ts
│   │   └── MemoryManager.ts
│   ├── cli/             # Command-line interface
│   ├── mcp/             # Model Context Protocol server
│   ├── types/           # TypeScript type definitions
│   └── utils/           # Shared utilities
├── tests/               # Comprehensive test suites
│   ├── unit/
│   ├── integration/
│   ├── e2e/
│   └── performance/
├── examples/            # Usage examples
├── docs/                # Documentation
├── .claude/             # Agent & command definitions
│   ├── agents/          # 16 QE agent definitions
│   └── commands/        # 8 AQE slash commands
└── config/              # Configuration files