Workflow Examples - Documentation

Learn from complete workflow examples. Each example shows the logical flow and technical implementation for a specific orchestration pattern.

Interactive: Technical Design Review

You respond at every step. Each agent asks questions, gathers insights, and produces output for the next agent.

Logical Flow
Technical Implementation

Architect

Asks you about requirements, constraints, and tradeoffs.

Input

User Answers + Project context

Steps (Chained Prompts)

Deep-dive analysis through Q&A → User → Complete system architecture design

Output

architecture.md = {architecture}

User

Review the architecture analysis. Answer follow-up questions.

Security Expert

Asks you about security concerns and compliance needs.

Input

{architecture}

Steps (Chained Prompts)

Threat modeling and attack surface analysis → User → Security controls and mitigation strategy

Output

security-review.md = {security_review}

User

Review the security assessment. Answer follow-up questions.

Senior Engineer

Asks you about implementation preferences and team constraints.

Input

{architecture} + {security_review}

Steps (Chained Prompts)

Feasibility analysis → User → Final design incorporating all feedback

Output

final-design.md

User

Review the final design. Confirm everything looks good or request changes.

technical-design-review.workflow.js

export default {
  name: 'Technical Design Review',
  autonomousMode: 'never',

  steps: [
    separator('Architecture'),
    resolveStep('architect', { interactive: true }),

    separator('Security Review'),
    resolveStep('security-expert', { interactive: true }),

    separator('Final Design'),
    resolveStep('senior-engineer', { interactive: true }),
  ],
};

Key patterns:

autonomousMode: 'never' - User controls every step, can’t toggle to auto
interactive: true - Each agent waits for user input before proceeding

interactive: true is the default. If not specified, steps are interactive automatically.

Autonomous: Greenfield Project Build

Controller agent runs agents on your behalf. You brief the controller, then review results instead of managing the process.

Autonomous mode is in beta. Behavior may change as we refine controller-agent coordination.

Logical Flow
Technical Implementation

User → Controller

Brief the controller with your project idea, constraints, goals, and the full workflow structure.

Refines requirements and creates product specification.

Input

Controller’s project brief + Constraints

Steps (Chained Prompts)

Requirements gathering → Controller → Product specification

Output

prd.md = {prd}

Controller

Reviews PRD. Proceeds or adjusts.

Architect

Designs system architecture based on requirements.

Input

{prd} + Controller’s Instructions

Steps (Chained Prompts)

System design → Controller → Architecture decisions

Output

architecture.md = {architecture}

Controller

Reviews architecture. Proceeds or adjusts.

Developer

Implements the code based on architecture.

Input

{prd} + {architecture} + Controller’s Instructions

Steps (Chained Prompts)

Implementation → Controller → Code review

Output

src/*

Controller

Reviews implementation. Proceeds or adjusts.

Tester

Writes tests for the implementation. Examines codebase using tools.

Input

{prd} + {architecture}

Steps (Chained Prompts)

Test planning → Controller → Test implementation

Output

tests/*

greenfield-project.workflow.js

export default {
  name: 'Greenfield Project Build',
  controller: controller('project-controller'),
  autonomousMode: 'always',

  steps: [
    separator('Requirements'),
    resolveStep('pm', { interactive: false }),

    separator('Architecture'),
    resolveStep('architect', { interactive: false }),

    separator('Implementation'),
    resolveStep('developer', { interactive: false }),

    separator('Testing'),
    resolveStep('tester', { interactive: false }),
  ],
};

Key patterns:

controller() - Defines the controller agent that orchestrates the workflow
autonomousMode: 'always' - Controller drives everything, user can’t toggle to manual
All steps are interactive: false - Controller approves transitions, not user

Both controller and step agents must have MCP configured for workflow-signals. Step agents propose completion, controller approves or rejects.

Agent MCP configuration:

main.agents.js

module.exports = [
  // Controller - Approves/rejects step transitions
  {
    id: 'project-controller',
    name: 'Project Controller',
    role: 'controller',
    promptPath: path.join(promptsDir, 'controller', 'main.md'),
    mcp: [
      {
        server: 'workflow-signals',
        only: ['approve_step_transition', 'get_pending_proposal'],
      },
    ],
  },

  // Step agents - Propose completion
  {
    id: 'pm',
    name: 'Product Manager',
    promptPath: path.join(promptsDir, 'pm', 'main.md'),
    mcp: [
      {
        server: 'workflow-signals',
        only: ['propose_step_completion'],
      },
    ],
  },

  // ... other step agents with same MCP config
];

Continuous: Adding APIs

Auto-advance with zero interaction. You provide a specification file upfront, then agents run to completion.

Logical Flow
Technical Implementation

Specification File

Define the APIs you need: endpoints, methods, schemas, validation rules.

Workflows with specification: true won’t start until this file is provided.

Input

specification.md = {specification}

API Designer

Designs endpoint contracts and schemas from spec.

Input

{specification}

Steps (Chained Prompts)

Parse spec → Design contracts → Generate schemas

Output

api-design.md = {api_design}

Developer

Implements the API endpoints. Examines codebase using tools.

Input

{specification} + {api_design}

Steps (Chained Prompts)

Implement endpoints → Add validation → Wire routes

Output

src/api/*

Tester

Writes tests for the API. Examines codebase using tools.

Input

{specification} + {api_design}

Steps (Chained Prompts)

Test planning → Write unit tests → Write integration tests

Output

tests/api/*

api-forge.workflow.js

export default {
  name: 'API Forge',
  specification: true,
  autonomousMode: true,

  steps: [
    separator('Design'),
    resolveStep('api-designer', { interactive: false }),

    separator('Implementation'),
    resolveStep('developer', { interactive: false }),

    separator('Testing'),
    resolveStep('tester', { interactive: false }),
  ],
};

Key patterns:

specification: true - Requires a spec file before starting
autonomousMode: true - Defaults to auto, but user can toggle to manual with Shift+Tab
All steps are interactive: false - Auto-advances through all steps
No controller needed - spec file provides all the context

Hybrid: Bug Fix Pipeline

Mix interactive and auto-advance agents in the same workflow. Key decisions need you, routine steps don’t.

Logical Flow
Technical Implementation

Triage (Interactive)

Asks you about the bug: What’s the issue? Which device? Steps to reproduce?

Input

User Answers

Steps (Chained Prompts)

Gather symptoms → User → Reproduction steps → User → Environment details

Output

bug-report.md = {bug_report}

User

Review bug report. Confirm details are correct.

Reproducer (Auto)

Reproduces the bug with gathered insights. Examines codebase using tools.

Input

{bug_report}

Steps (Chained Prompts)

Set up environment → Reproduce steps → Confirm bug exists

Output

reproduction.md = {reproduction}

Investigator (Auto)

Finds root cause. Examines codebase using tools.

Input

{bug_report} + {reproduction}

Steps (Chained Prompts)

Trace execution → Identify root cause → Document findings

Output

investigation.md = {investigation}

Discuss & Plan (Interactive)

Discusses findings with you. Plans the fix together.

Input

{bug_report} + {reproduction} + {investigation}

Steps (Chained Prompts)

Present findings → User → Discuss options → User → Agree on approach

Output

fix-plan.md = {fix_plan}

User

Review the plan. Approve or request changes.

Developer (Auto)

Implements the fix. Examines codebase using tools.

Input

{investigation} + {fix_plan}

Steps (Chained Prompts)

Implement fix → Self-review → Refine

Output

src/*

Tester (Auto)

Writes tests for the fix. Examines codebase using tools.

Input

{bug_report} + {fix_plan}

Steps (Chained Prompts)

Write regression test → Write edge case tests → Verify fix

Output

tests/*

bug-fix-pipeline.workflow.js

export default {
  name: 'Bug Fix Pipeline',
  autonomousMode: true,

  steps: [
    separator('Triage'),
    resolveStep('triage'),  // Interactive - gathers bug details

    separator('Investigation'),
    resolveStep('reproducer', { interactive: false }),
    resolveStep('investigator', { interactive: false }),

    separator('Planning'),
    resolveStep('planner'),  // Interactive - discuss fix approach

    separator('Implementation'),
    resolveStep('developer', { interactive: false }),
    resolveStep('tester', { interactive: false }),
  ],
};

Key patterns:

autonomousMode: true - Defaults to auto, but user can toggle to manual with Shift+Tab
Mix of interactive and non-interactive steps
Interactive steps: triage, planner - where decisions matter
Auto steps: reproducer, investigator, developer, tester - routine work
User can take control anytime by toggling to manual mode

Sub-Agents: Blueprint Orchestration

Main agents can delegate specialized tasks to sub-agents. The orchestrator coordinates multiple sub-agents to build a complete solution.

Logical Flow
Technical Implementation

Analyst

Analyzes requirements and creates a specification.

Input

User requirements + Project context

Output

specification.md = {specification}

Blueprint Orchestrator

Coordinates sub-agents to design the architecture. Runs sub-agents in parallel for different domains.

Input

{specification}

Sub-Agents

data-architect → Database schema designapi-architect → API contract designui-architect → Component structure design

Output

blueprint.md = {blueprint} (merged from all sub-agents)

Developer

Implements the code based on the blueprint.

Input

{specification} + {blueprint}

Output

src/*

Workflow file:

blueprint-orchestration.workflow.js

export default {
  name: 'Blueprint Orchestration',
  autonomousMode: true,

  steps: [
    separator('Analysis'),
    resolveStep('analyst', { interactive: true }),

    separator('Architecture'),
    resolveStep('blueprint-orchestrator', { interactive: false }),

    separator('Implementation'),
    resolveStep('developer', { interactive: false }),
  ],

  subAgentIds: [
    'data-architect',
    'api-architect',
    'ui-architect',
  ],
};

Both agent-coordination MCP on the main agent and subAgentIds in the workflow must be configured for sub-agent orchestration to work.

Main agent with agent-coordination MCP:

main.agents.js

{
  id: 'blueprint-orchestrator',
  name: 'Blueprint Orchestrator',
  description: 'Coordinates architecture sub-agents',
  promptPath: path.join(promptsDir, 'orchestrator', 'main.md'),
  mcp: [
    {
      server: 'agent-coordination',
      only: ['run_agents', 'get_agent_status', 'list_available_agents'],
      targets: ['data-architect', 'api-architect', 'ui-architect'],
    },
  ],
}

Sub-agents definition:

sub.agents.js

module.exports = [
  {
    id: 'data-architect',
    name: 'Data Architect',
    description: 'Designs database schema and data models',
    mirrorPath: path.join(promptsDir, 'sub-agents', 'data-architect.md'),
  },
  {
    id: 'api-architect',
    name: 'API Architect',
    description: 'Designs API contracts and endpoints',
    mirrorPath: path.join(promptsDir, 'sub-agents', 'api-architect.md'),
  },
  {
    id: 'ui-architect',
    name: 'UI Architect',
    description: 'Designs component structure and UI patterns',
    mirrorPath: path.join(promptsDir, 'sub-agents', 'ui-architect.md'),
  },
];

Key patterns:

subAgentIds in workflow - Declares which sub-agents are available
agent-coordination MCP - Enables the orchestrator to run sub-agents
targets - Restricts which sub-agents can be invoked (security)
only - Limits MCP tools available to the agent
Sub-agents run in parallel for faster execution

Choosing a Pattern

Pattern	User Involvement	Best For
Interactive	Every step	Tasks needing judgment, exploration, Q&A
Autonomous	Brief controller, review results	Long-running tasks, clear objectives
Continuous	None (spec upfront)	Repeatable, proven workflows
Hybrid	Key decisions only	Most real-world workflows

Most workflows end up being Hybrid — you want control where it matters and speed everywhere else.

Build Workflows

Configuration

Share Workflows

​Interactive: Technical Design Review

Input

Steps (Chained Prompts)

Output

Input

Steps (Chained Prompts)

Output

Input

Steps (Chained Prompts)

Output

​Autonomous: Greenfield Project Build

Input

Steps (Chained Prompts)

Output

Input

Steps (Chained Prompts)

Output

Input

Steps (Chained Prompts)

Output

Input

Steps (Chained Prompts)

Output

​Continuous: Adding APIs

Input

Input

Steps (Chained Prompts)

Output

Input

Steps (Chained Prompts)

Output

Input

Steps (Chained Prompts)

Output

​Hybrid: Bug Fix Pipeline

Input

Steps (Chained Prompts)

Output

Input

Steps (Chained Prompts)

Output

Input

Steps (Chained Prompts)

Output

Input

Steps (Chained Prompts)

Output

Input

Steps (Chained Prompts)

Output

Input

Steps (Chained Prompts)

Output

​Sub-Agents: Blueprint Orchestration

Input

Output

Input

Sub-Agents

Output

Input

Output

​Choosing a Pattern

​Next Steps

Build Your First Workflow

Advanced Workflows

Interactive: Technical Design Review

Autonomous: Greenfield Project Build

Continuous: Adding APIs

Hybrid: Bug Fix Pipeline

Sub-Agents: Blueprint Orchestration

Choosing a Pattern

Next Steps