Workflow Series (01): Foundations — Three Execution Models and Anthropic's Five Patterns

Traditional Workflow (Airflow / n8n):
  Node             = Python function / API call (deterministic)
  Branch condition = x > 0 (boolean expression)
  Failure handling = try/except (predefined exception types)
 
Agent Workflow:
  Node             = LLM + tools (non-deterministic output)
  Branch condition = confidence ≥ 95% (semantic judgment)
  Failure handling = retry + human escalation + semantic fallback

Examples: Airflow, n8n, GitHub Actions
Use case: data pipelines, ETL, scheduled jobs
 
Properties:
  → Structure is visualizable, execution order is transparent
  → No cycles (retry logic requires workarounds)
  → Right for deterministic data processing, wrong for AI tasks requiring dynamic branching

Examples: LangGraph, custom workflows with JSON state files
Use case: business processes with branching, retries, and human approval gates
 
Properties:
  → System state is serializable at any moment (supports interrupt and resume)
  → Cycles are native (retry = state rollback)
  → workflow_state.json is the state file; approval gates are waiting-for-event states

States: analyzing / fixing / reviewing / waiting_human / done / failed
Events: analyze_done / fix_passed / human_approved / timeout
Transitions:
  analyzing + analyze_done      → fixing
  fixing    + fix_passed        → reviewing
  reviewing + human_approved    → done
  reviewing + timeout           → waiting_human (escalate)

Examples: Temporal, AWS Step Functions, Apache Kafka Streams
Use case: long-running workflows (> 1 hour), enterprise-grade transactions
 
Properties:
  → Nodes are loosely coupled — independently deployable and scalable
  → Built-in persistence and Durable Execution guarantees
  → High operational complexity; not right for fast iteration

Data pipeline, deterministic nodes      → DAG
Branching / retries / approval gates    → State Machine
Runtime > 1 hour, strong consistency    → Event-Driven

A → B → C
each step's output is the next step's input

Example: Bug fix workflow main chain
  Phase 1 (gather info) → Phase 2 (log analysis) → Phase 3 (root cause)
  → Phase 4 (code fix) → Phase 5 (submit) → Phase 7 (notify)

Input → Classifier → [type A] → Agent A
                  → [type B] → Agent B
                  → [default] → Agent C

## Routing design example (Workflow Markdown format)
 
After Phase 3, route based on root cause confidence:
 
- confidence ≥ 95%         → proceed to Phase 4 (code fix)
- 60% ≤ confidence < 95%  → trigger Gate A (human confirms root cause)
- confidence < 60%         → retry Phase 3 (different angle, max 3 times)
- still < 60% after 3 tries → escalate to human

         → B1 →
A → split → B2 → merge → C
         → B3 →

# Fan-out: run 3 fix candidates concurrently
from concurrent.futures import ThreadPoolExecutor, as_completed
 
candidates = ["candidate_a", "candidate_b", "candidate_c"]
 
with ThreadPoolExecutor(max_workers=3) as executor:
    futures = {
        executor.submit(run_fix_candidate, c, bug_info): c
        for c in candidates
    }
    results = {}
    for future in as_completed(futures):
        candidate = futures[future]
        results[candidate] = future.result()
 
# Fan-in: select the best passing candidate
best = max(
    (r for r in results.values() if r["passed"]),
    key=lambda r: r["test_coverage"],
    default=None,
)

Orchestrator (main Agent)
  ├── spawn Subagent A (isolated session)
  ├── spawn Subagent B (isolated session)
  └── collect results → make decision

Principle 1: Input completeness
  The task prompt contains everything the subagent needs.
  It cannot depend on "implicit context from the main Agent."
 
Principle 2: Output contract strictness
  Output must conform to the declared JSON schema.
  {"passed": bool, "result": {...}, "error": str | null}
 
Principle 3: Structured failure output
  Even on failure, write {"passed": false, "error": "specific reason"}.
  A missing output file looks like a timeout to the main Agent.

Generator → Evaluator → [score ≥ threshold] → output
                ↓
         [score < threshold] → feedback → Generator (retry)
                                          max_retries = 3

# Evaluation loop definition in workflow YAML
phase_4_fix:
  generator: write-android-code
  evaluator: run-unit-tests
  quality_threshold:
    min_test_coverage: 80%
    all_tests_passed: true
  on_fail:
    max_retries: 3
    feedback_to_generator: true   # pass failure reason back to generator
  on_max_retries_exceeded:
    action: human_escalation      # escalate after 3 tries, never infinite loop

Overall structure:    Prompt Chaining (main chain, Phase 1→7)
 
Phase 3 internally:   Evaluator-Optimizer (root cause analysis, max 3 retries)
 
Phase 3→4 transition: Routing (route by confidence score)
 
Phase 4 internally:   Parallelization (3 candidates concurrently)
                      + Evaluator-Optimizer (test each candidate)
 
Phase 5/7 writes:     Routing (human approval gate = special routing branch)
 
Overall control:      Orchestrator-Subagents (main Agent runs the state machine,
                      spawns a subagent for each Phase)