Stage-Gated Pipelines in agent-tasks: Complete Workflow and Configuration Guide

The agent-tasks plugin implements a rigorous stage-gated pipeline that moves tasks sequentially through seven defined phases—backlog, spec, plan, implement, test, review, and done—requiring explicit human or automated approvals at configurable gates before allowing progression to the next stage.

The agent-tasks plugin, hosted within the anthropics/claude-plugins-community repository, provides AI coding agents with a structured workflow system that enforces quality control through stage-gated pipelines. This architecture ensures that tasks cannot advance without satisfying specific gate conditions, creating reliable audit trails and maintaining artifact integrity across the entire development lifecycle. Teams implementing stage-gated pipelines in agent-tasks gain precise control over automated coding workflows while preserving the ability to intervene at critical decision points.

How the Stage-Gated Pipeline Workflow Functions

The pipeline operates as a linear state machine where each task moves through a fixed sequence of stages. According to the source code in .claude-plugin/marketplace.json (lines 630-637), the workflow supports dependency tracking, approval workflows, artifact versioning, and threaded comments to ensure full traceability.

The Seven Pipeline Stages

Tasks progress through the following immutable sequence:

• backlog – Initial state where tasks await prioritization and entry into the active workflow.
• spec – Requirements definition phase requiring human approval before proceeding.
• plan – Technical design and architecture phase that typically runs automated validation.
• implement – Active coding phase where AI agents generate solutions.
• test – Automated validation and verification stage.
• review – Final human approval gate before completion.
• done – Terminal state indicating successful task completion.

Gate Types and Approval Mechanisms

Each stage transition is controlled by a gate that determines how the task advances:

• "gate": "human" – The task pauses indefinitely until a human reviewer explicitly approves the stage output. This is typically configured for the spec and review stages to ensure quality control.
• "gate": "auto" – The task proceeds automatically once the previous stage completes successfully and meets predefined validation criteria. Used for backlog, plan, implement, test, and done stages.

The underlying MCP (Multi-Channel Platform) server orchestrates these transitions, storing stage definitions and managing multi-agent collaboration in real time.

Configuring Stage-Gated Pipelines in agent-tasks

Pipeline behavior is defined through JSON configuration objects that specify stages, gates, and artifact storage. Below is a minimal configuration example that establishes a standard workflow:

{
  "taskId": "12345",
  "pipeline": [
    { "stage": "backlog",   "gate": "auto" },
    { "stage": "spec",      "gate": "human" },
    { "stage": "plan",      "gate": "auto" },
    { "stage": "implement", "gate": "auto" },
    { "stage": "test",      "gate": "auto" },
    { "stage": "review",    "gate": "human" },
    { "stage": "done",      "gate": "auto" }
  ],
  "artifacts": {}
}

In this configuration, the task requires human intervention only during specification and final review, while allowing automated progression through implementation and testing. The artifacts object stores versioned outputs from each stage, enabling rollback capabilities and historical audit trails.

Querying Pipeline Status Programmatically

Agents and external systems can interact with the pipeline through the MCP server API to check current stage status and gate conditions. The following Python example demonstrates how to query the active stage for a specific task:

import requests

def get_stage(task_id):
    resp = requests.get(
        f"https://agent-tasks.mcp/api/tasks/{task_id}/status"
    )
    resp.raise_for_status()
    return resp.json()["currentStage"]

print(get_stage("12345"))   # → "spec"

This endpoint returns the current stage identifier and gate status, allowing automated systems to determine whether a task requires human attention or can proceed automatically.

Source Code Architecture and Implementation

The core stage-gated pipeline functionality is declared in the anthropics/claude-plugins-community repository at .claude-plugin/marketplace.json (lines 630-637), where the marketplace entry describes "Pipeline-driven task management for AI coding agents" with configurable stages and dependency tracking.

For complete implementation details, API documentation, and advanced configuration options, refer to the dedicated agent-tasks repository at https://github.com/keshrath/agent-tasks. The MCP server implementation handles the orchestration logic, while a real-time Kanban dashboard provides visualization of task states, gate blockers, and approval queues.

Summary

• Stage-gated pipelines in agent-tasks enforce a seven-phase workflow: backlog → spec → plan → implement → test → review → done.
• Dual gate mechanisms support both automated progression ("auto") and mandatory human approvals ("human") at configurable transition points.
• Artifact versioning and dependency tracking ensure that outputs from early stages (like specifications) remain accessible and auditable throughout the pipeline.
• JSON configuration allows flexible pipeline definitions per task, while the MCP server API enables programmatic status monitoring.
• Source definitions reside in .claude-plugin/marketplace.json (lines 630-637) of the Claude Plugins Community repository.

Frequently Asked Questions

What are the seven stages in an agent-tasks pipeline?

The seven stages are backlog, spec, plan, implement, test, review, and done. Tasks must traverse these stages sequentially, with each stage producing versioned artifacts that subsequent stages can reference. The spec and review stages typically require human approval, while intermediate stages often run automated gates.

How do human gates differ from auto gates in agent-tasks?

Human gates halt task progression until an authorized user manually reviews and approves the stage output, creating a mandatory checkpoint for quality control. Auto gates use programmatic validation to determine stage completion, allowing tasks to flow through implementation and testing phases without manual intervention as long as automated checks pass.

Where is the stage-gated pipeline feature defined in the source code?

The feature definition and high-level description appear in .claude-plugin/marketplace.json at lines 630-637 within the anthropics/claude-plugins-community repository. This marketplace entry documents the pipeline-driven task management capabilities, including stage configuration, dependency tracking, and approval workflows. The actual implementation logic resides in the separate agent-tasks repository maintained by keshrath.

Can I customize the stages and gates in an agent-tasks pipeline?

Yes, the pipeline is fully configurable through the JSON task configuration object. While the default workflow follows the seven-stage sequence, you can adjust which stages use human versus automated gates by modifying the gate property for each stage entry. The MCP server reads this configuration to orchestrate the appropriate approval workflows for each specific task.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}