Sequential Execution

Execute tasks in order when dependencies exist between steps.

When to Use

Use sequential execution when:

• Tasks have dependencies (Task B needs Task A's output)

• Order matters for correctness

• Tasks modify shared state or files

• Workflow has clear sequential stages (e.g., commit → push → PR)

• Later tasks need results from earlier tasks

Parameters

• tasks: Ordered list of task descriptions

• dependencies: Map of task dependencies (which tasks depend on which outputs)

How Sequential Execution Works

Step 1: Identify Dependencies

Map out which tasks depend on others:

• Task A produces output X

• Task B needs input X to proceed

• Task C needs output from Task B

Step 2: Execute in Order

Execute tasks one at a time, passing outputs forward:

• Execute Task A, store output

• Execute Task B with output from A

• Execute Task C with output from B

Step 3: Track Progress

Use todo list to track sequential progress:

• Mark current task as in-progress

• Mark completed tasks as completed

• Keep upcoming tasks as not-started

Sequential Patterns

Pattern 1: Linear Pipeline

A → B → C → D

Each task depends on the previous task's output.

Pattern 2: Staged Workflow

Stage 1: Setup → Stage 2: Processing → Stage 3: Cleanup

Clear phases that must happen in order.

Pattern 3: Conditional Sequencing

A → (if success) → B → (if failure) → C

Execution path depends on previous results.

Pattern 4: Accumulator Pattern

Start with initial state, each task transforms and passes to next:

• Task 1: Initialize state

• Task 2: Transform state

• Task 3: Enhance state

• Task 4: Finalize state

When to Use Sequential vs Parallel

Scenario Execution Type Reason

B needs A's output Sequential Dependency

Multiple independent analyses Parallel No dependencies

Commit → Push → PR Sequential Order matters

Analyze multiple files Parallel Independent

Build → Test → Deploy Sequential Must happen in order

Review multiple perspectives Parallel Independent views

TodoList Integration

Track sequential progress clearly:

{ "todos": [ { "id": 1, "title": "Fetch PR details", "status": "completed" }, { "id": 2, "title": "Run tests", "status": "in-progress" }, { "id": 3, "title": "Review comments", "status": "not-started" }, { "id": 4, "title": "Merge PR", "status": "not-started" } ] }

Common Sequential Workflows

Git Workflow

• Make changes → 2. Commit → 3. Push → 4. Create PR → 5. Merge

PR Processing

• Fetch PR → 2. Analyze → 3. Address comments → 4. Run checks → 5. Merge

Build Pipeline

• Install dependencies → 2. Build → 3. Test → 4. Package → 5. Deploy

Code Review

• Read code → 2. Identify issues → 3. Write comments → 4. Submit review

Error Handling

In sequential execution:

• If step N fails, steps N+1 onwards cannot proceed

• Decide whether to:

• Retry failed step

• Skip to error handling flow

• Abort entire sequence

• Continue with partial results

Best Practices

• Make dependencies explicit: Clearly document what each task needs

• Pass data forward: Each task receives output from previous task

• Track progress: Update todo list after each step

• Handle errors: Plan for failures at each stage

• Validate inputs: Ensure each task has what it needs before starting

• Log intermediate results: Useful for debugging and resuming

Quick Reference

WHEN TO USE: ✓ Tasks have dependencies ✓ Order matters ✓ Shared state modifications ✓ Must wait for previous results

PATTERNS: Linear: A → B → C → D Staged: Setup → Process → Cleanup Conditional: A → (check) → B or C Accumulator: Transform state through stages

TODOLIST:

• Mark current step as in-progress
• Keep future steps as not-started
• Mark completed steps as completed

ERROR HANDLING:

• Stop on failure
• Retry step
• Fallback flow
• Abort sequence