# SPOQ: Specialist Orchestrated Queuing

> SPOQ is an open-source methodology for orchestrating multi-agent AI software development through wave-based parallel execution with structured quality gates. It bridges human expertise with AI scalability, enabling teams to run parallel agent swarms while maintaining rigorous quality standards.

## What is SPOQ?

Modern AI coding assistants (Claude Code, GitHub Copilot, Cursor) operate as single-threaded helpers: one agent, one task, one file at a time. When projects grow to dozens of interdependent tasks, this sequential approach creates bottlenecks. SPOQ solves three fundamental challenges in multi-agent software development:

1. **Coordination**: How do you dispatch multiple AI agents to work in parallel without creating merge conflicts or dependency violations?
2. **Quality Consistency**: How do you maintain high code quality when work is distributed across many agents with varying capabilities?
3. **Human Oversight**: How does a human expert stay meaningfully involved when agents are executing tasks concurrently?

SPOQ addresses these challenges through a structured methodology built on three core innovations and a tiered agent hierarchy, all orchestrated through an epic-based task decomposition system.

## Core Innovations

### 1. Wave-Based Topological Dispatch

SPOQ computes parallel execution waves from task dependency DAGs (directed acyclic graphs). Rather than executing tasks one at a time, it analyzes the dependency graph and groups independent tasks into waves that can run simultaneously. Tasks within a wave have no inter-dependencies, so agents can execute them in parallel without coordination overhead. Tasks in later waves depend on outputs from earlier waves, ensuring correct execution ordering.

The dispatch algorithm performs a topological sort of the task graph, assigns each task to the earliest possible wave based on its dependencies, and launches all tasks within a wave concurrently. This approach achieves a measured 5.3x speedup over sequential execution in experimental validation.

### 2. Dual Validation Gates

SPOQ enforces quality through two distinct validation checkpoints:

**Planning Validation (Pre-Execution Gate):** Before any agent begins work, the epic plan is scored across 10 metrics: Vision Clarity, Architecture Quality, Task Decomposition, Dependency Graph Correctness, Coverage Completeness, Phase Ordering, Scope Coherence, Success Criteria Quality, Risk Identification, and Integration Strategy. The plan must achieve an average score of 95 or above with no individual metric below 90 to proceed to execution.

**Code Validation (Post-Execution Gate):** After agents complete their work, the output is scored across 10 different metrics: Syntactic Correctness, Test Existence, Test Pass Rate, Requirements Fidelity, SOLID Adherence, Security, Error Handling, Scalability, Code Clarity, and Completeness. The code must achieve an average score of 95 or above with no individual metric below 80 to be accepted.

This dual-gate approach catches planning deficiencies before they become costly implementation errors and verifies implementation quality before it enters the codebase.

### 3. Human-as-an-Agent (HaaA)

Traditional automation treats humans as supervisors who review output after the fact. SPOQ introduces the Human-as-an-Agent paradigm, where a human specialist participates as a first-class agent throughout the process:

- **Task Decomposition**: The human collaborates on breaking high-level goals into atomic tasks, applying domain expertise that AI agents lack
- **Validation Participation**: The human reviews and scores plans and code alongside automated metrics
- **Runtime Consultation**: Agents can request human input during execution when they encounter ambiguity or edge cases that require judgment

This bidirectional collaboration model amplifies human judgment through AI scalability rather than attempting to replace human expertise entirely.

## Three-Tier Agent Hierarchy

SPOQ assigns different AI models to different roles based on the complexity-cost tradeoff:

| Tier | Model | Role | Rationale |
|------|-------|------|-----------|
| Worker | Claude Opus | Complex task execution | Highest capability for nuanced implementation work |
| Reviewer | Claude Sonnet | Quality assurance scoring | Balanced capability and cost for evaluation tasks |
| Investigator | Claude Haiku | Rapid exploration and triage | Low cost and fast response for build failure diagnosis |

Workers handle the primary implementation tasks within each wave. Reviewers score completed work against the 10 code validation metrics. Investigators are dispatched when builds fail to quickly identify root causes and suggest fixes, keeping the execution pipeline flowing.

## How to Get Started

Getting started with SPOQ requires Claude Code (Anthropic's CLI tool) and a project repository:

1. **Install Claude Code**: Follow the installation instructions at https://docs.anthropic.com/en/docs/claude-code
2. **Bootstrap SPOQ**: Run the initialization script to set up the SPOQ directory structure, skills, and configuration in your repository
3. **Plan an Epic**: Use the `/epic-planning` command to decompose a high-level goal into atomic tasks with dependency relationships
4. **Validate the Plan**: Run `/epic-validation` to score the plan against 10 quality metrics and confirm it meets the 95/90 threshold
5. **Execute with Agents**: Launch `/agent-execution` to dispatch parallel agent swarms organized into dependency-respecting waves
6. **Verify the Output**: Run `/agent-validation` to score completed code against 10 quality metrics and confirm it meets the 95/80 threshold

The Quickstart guide at https://spoqpaper.com/quickstart/ walks through this entire process in approximately 5 minutes.

## Key Experimental Results

SPOQ has been experimentally validated on real software development projects:

- **5.3x speedup** over sequential single-agent execution through wave-based parallelism
- **Quality maintained above 95** average score across all validation metrics
- **Reduced rework cycles** through pre-execution planning validation that catches architectural issues before implementation begins
- **Consistent output quality** across different agent instances through structured validation gates

These results demonstrate that parallel multi-agent execution can achieve substantial throughput gains without sacrificing code quality, provided that adequate coordination and validation mechanisms are in place.

## Pages

- [Home](https://spoqpaper.com/): Overview of SPOQ methodology, key innovations (wave-based dispatch, dual validation, HaaA), agent hierarchy, and design principles
- [Quickstart](https://spoqpaper.com/quickstart/): 5-minute setup guide covering prerequisites, installation, first epic walkthrough, and command reference
- [Methodology](https://spoqpaper.com/methodology/): Technical deep-dive into wave-based topological dispatch algorithms, dual validation gate scoring rubrics, and Human-as-an-Agent collaboration patterns
- [Comparison](https://spoqpaper.com/comparison/): Side-by-side comparison of SPOQ vs CrewAI, LangGraph, and AutoGen across execution model, quality gates, human involvement, and cost
- [Benchmarks](https://spoqpaper.com/benchmarks/): Full experimental results with 1.3-5.3x speedup range, token costs, quality scores, and methodology details across case studies
- [Use Cases](https://spoqpaper.com/use-cases/): Real-world examples including feature sprints, website redesigns, API migrations, and test suite expansion with measured speedup results
- [Pricing](https://spoqpaper.com/pricing/): Cost breakdown for LLM API tokens by model tier (Opus, Sonnet, Haiku), example cost estimates by epic size, and cost optimization tips
- [Resources](https://spoqpaper.com/resources/): Research paper (arXiv), GitLab repository link, and coding agent documentation
- [Glossary](https://spoqpaper.com/glossary/): Definitions for SPOQ terminology including epics, waves, tasks, HaaA, validation gates, and dependency graphs
- [About](https://spoqpaper.com/about/): Background on the SPOQ methodology and its creator Royce Carbowitz
- [Changelog](https://spoqpaper.com/changelog/): Version history and release notes tracking new features, improvements, and research milestones
- [Research Paper (arXiv)](https://arxiv.org/abs/2606.03115): Full academic paper with formal methodology description, experimental evaluation, and supplementary appendices

## About

SPOQ was created by Royce Carbowitz to bridge the gap between human software engineering expertise and AI agent scalability. The methodology emerged from practical experience orchestrating multi-agent development workflows and observing that unstructured parallel execution leads to quality degradation, dependency violations, and wasted compute. By introducing structured task decomposition, dependency-aware dispatch, and rigorous quality gates, SPOQ enables teams to harness the throughput benefits of multiple AI agents while preserving the quality standards that professional software development demands.

## Citation

If referencing SPOQ in academic or technical writing:

- Title: SPOQ: Specialist Orchestrated Queuing
- Author: Royce Carbowitz
- Year: 2026
- Repository: https://gitlab.com/Durban-Designer/spoq
- Website: https://spoqpaper.com
- License: MIT

## Key Facts

- Author: Royce Carbowitz
- License: MIT
- Repository: https://gitlab.com/Durban-Designer/spoq
- Website: https://spoqpaper.com
- Speedup: 5.3x over sequential execution (experimentally validated)
- Planning Validation: 10 metrics, 95 average minimum, 90 per-metric minimum
- Code Validation: 10 metrics, 95 average minimum, 80 per-metric minimum
- Agent Tiers: Worker (Opus), Reviewer (Sonnet), Investigator (Haiku)
- Task Structure: Epics decomposed into atomic tasks with dependency DAGs dispatched in parallel waves