Agentic Quality Engineering Fleet

What AQE Does For You

• Generates comprehensive tests automatically — unit, integration, property-based, and BDD scenarios for your codebase with framework-specific output (Jest, Vitest, Playwright, Cypress, pytest, JUnit, Go, Rust, Swift, Flutter, and more)
• Finds coverage gaps and prioritizes what to test — risk-weighted analysis identifies the most impactful untested code paths
• Detects and fixes flaky tests — ML-powered detection with root cause analysis and stabilization recommendations
• Learns your codebase patterns over time — remembered patterns are reused across sessions and projects, improving with every interaction
• Coordinates 60 specialized QE agents — from test generation to security scanning to chaos engineering, orchestrated by a central coordinator
• Reduces AI costs with intelligent routing — automatically routes tasks to the right model tier (fast/cheap for simple tasks, powerful for complex ones)
• Works with your existing tools — integrates with 11 coding agent platforms and your existing CI/CD pipeline

Quick Start

# Install
npm install -g agentic-qe

# Initialize your project (auto-detects tech stack, configures MCP)
cd your-project && aqe init --auto

# That's it — MCP tools are available immediately in Claude Code
# For other clients: aqe-mcp

After init, your coding agent can use AQE tools directly. For example in Claude Code:

"Generate tests for src/services/UserService.ts with 90% coverage target"
"Find coverage gaps in src/ and prioritize by risk"
"Run security scan on the authentication module"
"Analyze why tests in auth/ are flaky and suggest fixes"

Windows install

agentic-qe runs on Windows, but several of its performance-oriented native dependencies (hnswlib-node for HNSW search, @ruvector/gnn for graph neural networks, @ruvector/rvf-node for the RVF pattern store) ship as optional native modules. hnswlib-node in particular has no prebuilt binaries and compiles from source via node-gyp. npm install does not fail when these modules can't build — they're declared optional and AQE falls back to JavaScript paths at runtime.

Important caveat about the fallback. The pure-JavaScript HNSW fallback (ProgressiveHnswBackend) is correct but degrades to O(N) brute-force search when neither hnswlib-node nor @ruvector/gnn is available. That's fine for small projects but unsuitable for large indexes (tens of thousands of vectors and up). If you plan to run AQE against a sizeable codebase on Windows, install the native build toolchain so hnswlib-node compiles:

• Python 3 (added to PATH), and
• Visual Studio 2022 Build Tools with the Desktop development with C++ workload — works with any node-gyp version, or
• Visual Studio 2026 with the same workload plus an upgraded npm (npm install -g npm@latest — VS 2026 detection requires npm ≥ 11.6.3, shipped via node-gyp ≥ 12.1.0). Node 22 LTS still ships npm 10.x by default, which cannot detect VS 2026; either upgrade npm globally or use VS 2022 Build Tools instead.

If the native dep fails to build you'll see a node-gyp warning during install (e.g. gyp ERR! find VS); the install itself completes. To verify which backend is active:

aqe health
# Look for "HNSW backend: native" (hnswlib-node) or "HNSW backend: js"
# (ProgressiveHnswBackend — see caveat above).

Linux and macOS users: no extra setup required. The native binary compiles out of the box.

Claude Code Plugin (Alternative Install)

If you only need a slim, scoped fleet inside Claude Code — without the full aqe init setup — install the agentic-qe-fleet plugin. It bundles 11 specialized QE agents, 9 slash commands, 9 skills, and auto-registers the MCP server.

Install from a local checkout

git clone https://github.com/proffesor-for-testing/agentic-qe.git
claude --plugin-dir ./agentic-qe/plugins/agentic-qe-fleet

Install from the marketplace

In any Claude Code session:

/plugin marketplace add proffesor-for-testing/agentic-qe
/plugin install agentic-qe-fleet

What you get

Bundled agents: qe-test-architect, qe-coverage-specialist, qe-flaky-hunter, qe-chaos-engineer, qe-fleet-commander, qe-quality-gate, qe-security-scanner, qe-performance-tester, qe-regression-analyzer, qe-tdd-specialist, qe-requirements-validator.

Bundled skills: qe-test-generation, qe-coverage-analysis, qe-test-execution, qe-chaos-resilience, qe-quality-assessment, chaos-engineering-resilience, mutation-testing, risk-based-testing, tdd-london-chicago.

Use it

After loading the plugin, the slash commands and agents are available immediately:

/aqe-fleet-status                 # health and metrics
/aqe-generate src/services/Auth.ts
/aqe-analyze src/                 # coverage gap analysis

Or invoke an agent through the Task tool:

"Use qe-test-architect to generate tests for src/services/PaymentService.ts"
"Use qe-flaky-hunter to find and stabilize flaky tests in tests/integration/"
"Use qe-chaos-engineer to inject network partitions into the order workflow"

Plugin vs aqe init — which to use?

You can run both — the plugin's MCP server uses the same agentic-qe package, so installing both gives you the full fleet via aqe init and the slash-command shortcuts via the plugin.

Platform Support

AQE works with 11 coding agent platforms through a single MCP server:

# Set up all platforms at once
aqe init --auto --with-all-platforms

# Or add a platform later
aqe platform setup cursor
aqe platform list       # show install status
aqe platform verify cursor  # validate config

For detailed per-platform instructions, see Platform Setup Guide.

Usage Examples

Generate Tests

claude "Use qe-test-architect to create tests for PaymentService with 95% coverage target"

Output:

Generated 48 tests across 4 files
- unit/PaymentService.test.ts (32 unit tests)
- property/PaymentValidation.property.test.ts (8 property tests)
- integration/PaymentFlow.integration.test.ts (8 integration tests)
Coverage: 96.2%
Pattern reuse: 78% from learned patterns

Full Quality Pipeline

claude "Use qe-queen-coordinator to run full quality assessment:
1. Generate tests for src/services/*.ts
2. Analyze coverage gaps with risk scoring
3. Run security scan
4. Validate quality gate at 90% threshold
5. Provide deployment recommendation"

The Queen Coordinator spawns domain-specific agents, runs them in parallel, and synthesizes a final recommendation.

TDD Workflow

claude "Use qe-tdd-specialist to implement UserAuthentication with full RED-GREEN-REFACTOR cycle"

Coordinates 5 subagents: write failing tests → implement minimal code → refactor → code review → security review.

Security Audit

claude "Coordinate security audit:
- SAST/DAST scanning with qe-security-scanner
- Dependency vulnerability scanning with qe-dependency-mapper
- API security with qe-contract-validator
- Chaos resilience testing with qe-chaos-engineer"

60 QE Agents

The fleet is organized into 13 domains, coordinated by the qe-queen-coordinator:

Plus 7 TDD subagents (red, green, refactor, code/integration/performance/security reviewers) and the fleet-commander for large-scale orchestration.

75 QE Skills

Agents automatically apply relevant skills from the skill library. Skills are rated by trust tier:

How It Works

Agent Coordination

The Queen Coordinator orchestrates agents across all 13 domains. When you ask for a quality assessment, the Queen decomposes the task, spawns the right agents, coordinates their work in parallel, and synthesizes results. Agents communicate through shared memory namespaces and use consensus protocols for critical quality decisions.

Pattern Learning

AQE learns from every interaction. Successful test patterns, coverage strategies, and defect indicators are stored and indexed for fast retrieval. When generating tests for a new service, AQE searches for similar patterns from past sessions — even across different projects. Patterns improve over time through experience replay and dream cycles (background consolidation).

aqe learning stats      # view learning statistics
aqe learning dream      # trigger pattern consolidation
aqe brain export        # export learned patterns for sharing

Intelligent Model Routing

TinyDancer routes tasks to the right model tier to minimize cost without sacrificing quality:

Quality Gates

Anti-sycophancy scoring catches hollow tests. Tautological assertions (expect(true).toBe(true)) are rejected. Edge cases from historical patterns are injected into test generation. See Loki-mode features.

CLI Reference

aqe init [--auto]              # Initialize project
aqe agent list                 # List available agents
aqe fleet status               # Fleet health and coordination
aqe learning stats             # Learning statistics
aqe learning dream             # Trigger dream cycle
aqe brain export/import        # Portable intelligence
aqe platform list/setup/verify # Manage coding agent platforms
aqe health                     # System health check

# Code intelligence
aqe code index src/                  # Index codebase into knowledge graph
aqe code index src/ --incremental    # Incremental index (changed files only)
aqe code index . --git-since HEAD~5  # Index files changed in last 5 commits
aqe code search "authentication"     # Semantic code search
aqe code impact src/                 # Change impact analysis
aqe code deps src/                   # Dependency mapping
aqe code complexity src/             # Complexity metrics and hotspots

LLM Providers

AQE Fleet's LLM-enhanced analysis (ADR-043, ADR-051) routes through a HybridRouter that picks providers based on routing rules and your env config. Set one or more API keys and Fleet auto-detects what's available:

export GEMINI_API_KEY="..."  # or any supported provider
aqe init --auto

Persistent config (aqe llm config --set writes to .agentic-qe/llm-config.json):

aqe llm config --set mode=cost-optimized
aqe llm config --set defaultProvider=gemini
aqe llm config           # show current effective config

API keys are env-only — aqe llm config --set apiKey=... is refused to keep secrets out of project-committed config.

Opting out

To run Fleet without any LLM calls (deterministic-only mode):

export AQE_LLM_ROUTER_DISABLED=1   # env-only kill-switch

Or programmatically: new QEKernelImpl({ llmRouter: { enabled: false } }).

Documentation

Development

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

Contributing

We welcome contributions! Please see CONTRIBUTING.md for details.

Support

• Documentation: docs/
• Issues: GitHub Issues
• Discussions: GitHub Discussions

License

MIT — see LICENSE.

Contributors

@proffesor-for-testing Project Lead	@fndlalit QX Partner, Testability	@shaal Core Development	@mondweep Architecture

View all contributors | Become a contributor

Support the Project

If you find AQE valuable, consider supporting its development:

View sponsorship details

Acknowledgments

• Claude Flow by @ruvnet — Multi-agent orchestration and MCP integration
• Agentic Flow by @ruvnet — Agent patterns and learning systems
• Built with TypeScript, Node.js, and better-sqlite3
• Compatible with Jest, Cypress, Playwright, Vitest, Mocha, pytest, JUnit, and more