Home / Insights / Chmltech Online Journal

Chmltech Online JournalVolume 106, Issue 10Research article

Sequential and Parallel Multi-Agent Workflows: Four Execution Patterns and Their Engineering Trade-offs

Quak Foo LeeChief Technology Officer, Chmltech Ltd.Division of Artificial Intelligence and Machine Learning · Vancouver, BC, Canada

Abstract

Multi-agent AI systems are often compared by the number of agents they employ or the sophistication of their orchestration frameworks. For production engineering, however, a more fundamental question is which tasks depend on which others, and when may they run? This paper examines four practical execution patterns: sequence, parallel, series–parallel, and parallel–series. It distinguishes execution order from organizational topology; models workflows as dependency graphs; explains fan-out, fan-in, barriers, and branch-level state; and derives latency and resource implications using simple critical-path calculations. A worked SME warehouse-management-system (WMS) assessment illustrates how the same tasks yield different completion times when their dependencies change. The analysis also covers context isolation, structured handoffs, bounded concurrency, stragglers, failure containment, observability, and authorization. The central recommendation is to choose the simplest dependency graph that preserves correctness, and to add parallelism only when independent work, reliable aggregation, and adequate operational controls justify the added complexity. A selection method and a minimum evaluation suite are proposed for teams choosing between the patterns.

Keywords: multi-agent AI; agent workflows; parallel execution; fan-out fan-in; critical path; workflow orchestration; DAG scheduling; LLM agents

1. Introduction: Execution Order Is an Architecture Decision

It is tempting to equate more concurrent AI agents with a faster or more capable AI system. That conclusion ignores the character of the work. Some operations cannot begin until a prior result exists. Others can be researched independently and combined later. Still others contain several specialized chains that may execute together but must remain sequential internally. The engineering challenge is to expose genuine independence while preserving necessary dependencies, evidence provenance, permissions, and quality checks.

Contemporary frameworks explicitly support sequential and concurrent execution. Microsoft's Agent Framework describes sequential orchestration as a pipeline in which each agent receives work from its predecessor, and concurrent orchestration as independent agents whose results are aggregated [1, 2]. OpenAI's Agents SDK documents both agent chaining and parallel execution under code-controlled orchestration [3]. LangGraph expresses the same fundamental ideas through state, nodes, edges, parallel super-steps, and reducers [4]. These abstractions are useful because the scheduling problem is not exclusive to any particular model provider.

This paper focuses on the four patterns shown in Figure 1: (1) sequence; (2) parallel; (3) series–parallel; and (4) parallel–series. The latter two are practical descriptive names for hybrid dependency shapes, not universally standardized product features. Their interpretation must therefore be made explicit in every architecture document. All four may operate within a centralized orchestrator, a hierarchy, or a more distributed agent architecture; the control topology and execution graph are separate choices [5].

The evaluation uses four questions: What must finish before another task starts? Where does information cross agent boundaries? What is the critical path for completion? What happens when a branch is wrong, late, or unavailable? The answers determine both speed and trustworthiness more reliably than the agent count alone.

2. Foundations: Tasks, Dependencies, and Data Contracts

2.1 Model the workflow as a directed graph

Represent each unit of work as a node and each required handoff as a directed edge. A node may be an LLM agent, deterministic function, database query, human review, or external service; a graph does not require every node to be autonomous. An edge indicates that an output, approval, or dependency must be available before the downstream node can proceed. When there are no intentional cycles, the workflow is a directed acyclic graph (DAG); deliberate review loops need explicit stopping rules, and LangGraph caps each run with a recursion limit on super-steps [4].

The graph distinguishes two kinds of dependency. A data dependency means that a downstream task needs a specific artifact or fact. A control dependency means that policy requires a task or gate to complete first, even if the later work could otherwise begin. For example, a WMS vendor investigation may run in parallel with process mapping, but a recommendation may require both outputs and an explicit validation step.

2.2 Define the handoff before choosing the scheduler

Each task should have a contract: task ID, objective, accepted input types, allowed tools, output schema, evidence requirements, deadline, retry budget, data classification, and owner. A structured contract prevents a parallel worker from returning an attractive narrative that the aggregation step cannot reliably use. A common execution ledger should distinguish queued, running, completed, failed, skipped, and approved states. A final answer is an artifact that passes its acceptance criteria, not merely the last message generated.

Execution parallelism is not the same as independent judgment. Two agents using the same model, same evidence, and nearly identical prompts may produce correlated mistakes even if they execute at the same time. Parallel work can shorten latency without increasing epistemic diversity. Conversely, a sequential reviewer may add valuable independent verification if it checks primary evidence rather than paraphrasing the previous agent.

Four small dependency diagrams: a sequential chain of agents, a fan-out to parallel agents and a merge, an ordered pipeline with one parallel stage, and parallel lanes each holding an ordered chain, each labelled with when it fits and its main risk. 1 · CHAIN Sequence DEPENDENCY Each stage needs the previous result COMPLETION TIME Sum of all task times JOIN No join: one artifact passes on MAIN RISK An upstream error propagates; idle independent work 2 · FAN-OUT Parallel DEPENDENCY Tasks independent once the brief is ready COMPLETION TIME Slowest required branch plus merge JOIN All required, quorum or best-effort MAIN RISK Stragglers and silent partial results 3 · STAGED Series–parallel DEPENDENCY A serial spine with one fan-out stage COMPLETION TIME Sum over stages of the slowest branch JOIN Barrier before synthesis MAIN RISK Treating partial branch output as complete 4 · LANES Parallel–series DEPENDENCY Independent lanes; dependent steps within each COMPLETION TIME Slowest lane plus merge JOIN Merge with conflict detection MAIN RISK Artificial serial lanes; hidden cross-lane dependency
Figure 1. The four execution patterns. The figure plays through each pattern in turn, showing which tasks wait for which results; select a pattern to jump to it, or All patterns to compare them side by side. Speed and cost depend on the workload and the controls described in this paper, so no pattern is rated faster or slower in general.

3. Pattern 1 — Sequence: A Controlled Chain

A sequential workflow runs tasks in a defined order, usually A → B → C → D. Each stage consumes a validated artifact from its predecessor. A research agent might gather sources, an analyst normalize evidence, a writer prepare a draft, and a reviewer evaluate it. The main benefit is unambiguous ordering. The main limitation is that independent subtasks remain idle while the chain advances.

Appropriate conditions. A later step genuinely needs a previous result; stages have different data privileges; auditability matters; or the work is a deterministic transformation pipeline. Sequential flows are a useful baseline because they are easy to reason about and easy to compare with more complex designs. Microsoft's sequential guidance also highlights a subtle implementation choice: the next agent may receive the full previous conversation rather than only the predecessor's final response, depending on configuration [1]. That choice affects context growth, information exposure, and reproducibility.

Failure mechanisms. An upstream error propagates downstream; a slow stage delays every later one; and cumulative context may bury important instructions or source details. Agent-to-agent text transfer can also turn a malicious or incorrect upstream output into a new downstream instruction. Good handoffs use typed output, source references, and explicit separation of data from commands.

Engineering controls. Validate outputs at each boundary; retain the original artifact rather than only a summary; set clear retry versus rework policies; and reject silent substitutions when an upstream dependency is absent. A sequential reviewer should independently check claims against authoritative sources. If task B fails, task C should not begin under a false impression that B succeeded.

4. Pattern 2 — Parallel: Fan-Out and Fan-In

A parallel workflow starts two or more independent tasks after a shared input is ready. The scheduler fans work out to separate agents, and an aggregation function fans results back in. In notation, Start → {A, B, C} → Merge. This is particularly useful for retrieving distinct sources, translating into unrelated languages, analyzing independent datasets, or comparing alternative proposals. Microsoft documents a concurrent agent workflow with fan-out/fan-in edges and an aggregation barrier; OpenAI also describes parallel execution through ordinary Python primitives [2, 3].

The key condition is safe independence. Workers may share a read-only brief, but one branch should not quietly edit another branch's assumptions. Where branches update shared state, the system needs explicit merge rules. LangGraph, for example, uses reducers to define how concurrent node updates combine [4]. An aggregator should check required branch coverage, schema compliance, conflicts, provenance, and whether an incomplete result is acceptable.

Latency is constrained by the slowest required branch, not by the average worker. Parallel starts are not always simultaneous in practice: model API limits, tool quotas, queueing, or unavailable resources can serialize work. Tail latency also matters because large fan-outs increase the chance that at least one worker responds unusually slowly, a general distributed-systems issue examined by Dean and Barroso [6]. Anthropic reports using parallel subagents and parallel tool calls for complex research, while also noting that poor delegation can duplicate work and waste resources [7].

Engineering controls. Set maximum concurrency and per-branch deadlines. Keep the shared brief immutable during a run. Define whether the join is all required, minimum quorum, or best-effort, with different policies for safety-critical and optional outputs. Record partial failures explicitly; do not silently interpret a missing branch as a negative finding. Google Cloud Workflows documents concurrency limits and careful handling of shared variables as part of parallel workflow design [8].

5. Pattern 3 — Series–Parallel: Ordered Stages with Parallel Work Inside

The term series–parallel is used here for a workflow that has a serial structure at the top level, with one or more stages containing independent parallel tasks. A typical shape is Intake → {Research, Technical Assessment, Risk Review} → Synthesis → Approval. The initial stage establishes a common baseline. A fan-out stage then distributes distinct work packages. A barrier requires selected outputs before downstream synthesis proceeds.

This shape is common in business and engineering analysis because it preserves an accountable end-to-end process while shortening its broad investigation phase. A single intake package can establish the client objectives, scope, constraints, and source inventory. Specialist agents work from that package, produce artifacts, and return evidence to a lead that reconciles contradictions and prepares the result. The orchestrator may remain centralized throughout; it is the execution graph that contains parallelism.

The difficult point is the join. Suppose vendor screening finishes quickly, but integration risk assessment identifies an unknown data-migration interface. Should the recommendation be blocked, published with a limitation, or sent for additional evidence? The join policy must answer that before execution. A barrier that treats all branch outputs as equivalent can falsely imply that an uncertain branch has passed. AWS Step Functions models a Parallel state and documents its failure semantics: an unhandled failure in any branch fails the entire Parallel state; the underlying external task may still need its own cancellation or cleanup logic [9].

Advantages. A clean global sequence; local concurrency only where dependencies permit; natural synthesis points; easier review of shared assumptions. Limitations. Barrier-induced waiting, duplicated searches, mismatched evidence quality, and possible overloading of the aggregation agent. A late or flawed branch can become the critical path even when most specialists have completed useful work.

6. Pattern 4 — Parallel–Series: Concurrent Specialist Pipelines

The term parallel–series is used here for two or more parallel lanes, each containing an internally sequential chain. A schematic form is Start → {A1 → A2; B1 → B2; C1 → C2} → Merge. For example, a commercial lane may research vendors and then score business fit; a technical lane may inspect system interfaces and then assess implementation risk; an operational lane may map processes and then test workflow scenarios. All lanes begin from the same approved scope, but the steps inside each lane have meaningful dependencies.

This configuration is valuable when specialist work packages naturally contain several ordered activities. It isolates each lane's context, tool permissions, and intermediate artifacts. It also allows a technical supervisor to improve a lane without redesigning every other lane. But lane construction imposes constraints: assigning two independent tasks to one serial lane can unnecessarily increase the completion time, while dividing a genuinely dependent task across lanes can create a race or a hidden cross-lane dependency.

Advantages. Dedicated domain pipelines, predictable ownership within each lane, and opportunities for parallel throughput at the program level. Limitations. Branch-level error propagation, more complicated scheduling and progress tracking, and the risk that a critical dependency is discovered too late. A lane may appear finished while its assumptions conflict with another lane. The final merge therefore needs explicit conflict detection and issue ownership.

Unlike a staged series–parallel workflow, a parallel–series design can preserve multiple independent chains over the lifetime of the work. These are descriptive models, not mutually exclusive categories: a large application can nest both shapes at different levels. Figure 2 makes the dependency difference explicit. The companion paper on stage-gate orchestration (Vol. 106, Issue 11) treats feedback loops in greater depth; loops should be added with pass/fail conditions and maximum iteration budgets, not as open-ended self-correction.

Two flow diagrams: in the first, intake fans out to research and technical-check branches that join at a synthesis barrier before a quality gate; in the second, two lanes of two ordered steps each run side by side and merge into a cross-lane check before the verified output.Two different hybrid dependency graphsSame idea of concurrency; different placement of serial dependenciesA SERIES–PARALLELSequential stages; one stage fans out to independent workersIntakeshared briefResearchbranch 1Technical checkbranch 2Synthesisjoin & reconcileAssurequality gateBarrier: both branches requiredB PARALLEL–SERIESParallel lanes; each lane performs an ordered internal chainStartapproved briefVendor searchlane 1 · step 1Vendor scoringlane 1 · step 2Data reviewlane 2 · step 1Risk analysislane 2 · step 2Mergecross-lane checkOutputverified
Figure 2. Two hybrid dependency graphs with different scheduling meaning. Series–parallel places concurrent tasks inside an ordered stage; parallel–series places ordered steps inside concurrent lanes. Arrows show required dependencies; task names and layouts are illustrative.

7. Performance Engineering: Latency, Cost, and Critical Paths

7.1 Idealized latency equations

Let ti be the processing time of task i, o the orchestration and communication overhead, and tm the time required to reconcile concurrent results. Under a simplifying assumption of deterministic runtimes, unlimited capacity, and no failures, the patterns have useful lower-bound relationships:

for a sequential chain, Eq. (1); for a single parallel block, Eq. (2); for series–parallel, summing over stages s, Eq. (3); and for parallel–series, taking the slowest lane ℓ, Eq. (4):

\[T_{\text{seq}} = \sum_i t_i + o\](1)
\[T_{\text{par}} = \max(t_1, t_2, \ldots, t_n) + t_m + o\](2)
\[T_{\text{SP}} = \sum_{s} \max_{i \in s} t_i + o\](3)
\[T_{\text{PS}} = \max_{\ell} \sum_{i \in \ell} t_i + t_m + o\](4)

These are illustrative scheduling equations, not measured benchmarks or provider-specific guarantees. For a general DAG, the minimum completion time under unlimited resources is the duration of its critical path, the longest directed sequence of dependent tasks. Actual latency exceeds the idealized value when model calls queue, context transfer consumes time, external tools throttle, branches retry, or a reviewer rejects an artifact. Two workflows with identical tasks can have very different completion times depending on which edges are necessary.

7.2 Speedup is not free

Define speedup relative to a correct sequential baseline as in Eq. (5):

\[S = \frac{T_{\text{seq}}}{T_{\text{candidate}}}\](5)

where Tcandidate is the completion time of the schedule being compared. A value above 1 indicates reduced elapsed time in that illustrative scenario. It does not necessarily mean lower cost: parallel agents may each consume model tokens, repeat retrievals, maintain separate contexts, or require more coordination. Likewise, a faster response is not better when it bypasses verification or uses incomplete evidence. Report both latency and accepted-output quality, preferably with a cost-per-accepted-artifact measure.

7.3 Stragglers, tails, and saturation

A parallel join often waits for the slowest required branch. Adding workers can reduce average processing time for a divided workload, yet increase exposure to a late straggler or rate limit. Dean and Barroso described how tail behavior becomes significant as distributed requests touch more components [6]. In agent workflows, repeated web searches, heterogeneous model speeds, tool unavailability, and slow human approvals can all create tails. Controls include per-branch deadline budgets, queuing, conservative fan-out, preapproved fallback paths, and separating mandatory outputs from optional enhancements.

8. Worked Example: SME WMS Assessment Using the Same Work Packages

Consider a hypothetical Vancouver SME preparing to select a warehouse-management system. The engineering objective is a source-backed recommendation, not an automatic purchasing decision. Six work packages are estimated with illustrative elapsed times (Table 1). The numbers are chosen for clarity and are not measurements from a client, product, benchmark, or deployed agent system.

Table 1. Hypothetical work-package inventory.
TaskWork packageDuration (minutes)Must follow
AIntake and requirement normalization4Start
BVendor capability analysis10A
CIntegration and migration assessment8A
DOperations and risk review6A
EEvidence synthesis and option scoring5B, C, D
FIndependent recommendation verification4E

These task dependencies are assumed for the case study. Durations omit dispatch, queueing, communication, retries, model cost, and human waiting time.

A purely sequential schedule executes A–B–C–D–E–F in 37 minutes. A series–parallel design executes A, fans out B/C/D, waits for all three, then runs E and F: 4 + max(10, 8, 6) + 5 + 4 = 23 minutes. A parallel–series design can preserve the same logical requirements but place B→D within one technical/commercial lane and C in another lane, followed by E and F: 4 + max(10 + 6, 8) + 5 + 4 = 29 minutes. This second hybrid intentionally serializes B and D for workflow ownership; the constraint is a design choice, not an intrinsic requirement of the task. Table 2 compares the three schedules and Figure 3 draws them on a common time axis.

Table 2. Ideal completion time of one schedule per pattern.
Scheduling choiceIdeal completion timeRelative speedupPrincipal trade-off
All tasks in sequence37 min1.00×Simple, but independent activities wait
Series–parallel (B, C, D concurrent)23 min1.61×Faster; join waits for the 10-minute branch
Parallel–series (B→D in lane 1; C in lane 2)29 min1.28×Clear lane ownership, but extra serial dependency

Derived from the Table 1 assumptions with zero orchestration overhead. The comparison describes one plausible schedule for each pattern, not a universal ranking.

Interpretation. The lowest theoretical latency comes from the schedule that removes unnecessary dependencies. The optimal production design may still choose a slower path if it improves source control, independent review, or accountability. In every case, E must verify that the vendor, integration, and operations findings use the same scope and currency; F must check evidence completeness, unsupported claims, and decision constraints. No procurement action is authorized by this workflow alone.

Three horizontal timelines of six colored task bars on a common minutes scale: a sequential schedule ending at 37 minutes, a series–parallel schedule ending at 23 minutes, and a parallel–series schedule ending at 29 minutes.Hypothetical WMS assessment: same tasks, different schedulesIllustrative minutes; idealized execution, without queueing, retries, or orchestration overhead0510152025303540Elapsed time (minutes)1. SEQUENTIALEverything in a single queueAB VendorC IntegrationD RiskEF37 min2. SERIES–PARALLELIntake → parallel B/C/D → E → FAB VendorC IntegrationD RiskEF23 min3. PARALLEL–SERIESIntake → (B→D) alongside C → E → FAB VendorD RiskC IntegrationEF29 minWork packages:IntakeVendorIntegrationRiskSynthesisVerification
Figure 3. The same six work packages scheduled three ways. Completion times follow from the dependency assumptions in Table 1 and exclude runtime overhead and failures; colour marks the work package, not a rating.

9. Reliability, Security, and Failure Handling

Branch-level state and retries. Every parallel unit should have a durable identity and result status. Retrying a report-generation task may be harmless, while retrying a real email send, database write, or payment may cause duplicates unless the action is idempotent or guarded with a transaction key. AWS Step Functions documents retriers, catch handlers, backoff, and error propagation; equivalent controls must be designed when using raw Python or custom orchestrators [10].

Table 3 summarizes the failure modes and their controls. Join contracts. Specify whether the merge requires every output, a subset, or a policy-defined quorum. Check that each input is a complete, valid artifact rather than a partial chat response. A branch can be completed but unacceptable because it lacks evidence, exceeds scope, or conflicts with required constraints. The aggregation agent should not infer missing data from a successful sibling branch.

Context and prompt-injection boundaries. Source documents, web pages, and other agents' outputs can carry instructions masquerading as evidence. Treat such text as data, restrict tool permissions by branch, and enforce authorization in the downstream service rather than relying on a model to police itself. OWASP's Excessive Agency guidance specifically calls for minimum functionality, minimum privileges, and approval for high-impact actions [11]. A concurrent system often expands the number of untrusted inputs the lead agent reads, making this discipline particularly important.

Recovery and human review. Persist a run ID, task ledger, artifact versions, and the set of completed dependencies. On resume, re-run only what is safe or necessary, and preserve the source context for audits. Reserve human approval for externally consequential actions such as procurement commitments, public publication, client outreach, or changes to plant operations. NIST's AI RMF emphasizes testing, documented evaluation measures, production monitoring, and recovery planning [12].

Table 3. Failure modes and recommended controls.
Failure or ambiguityWhere it appearsRecommended response
Upstream error is reused as a factSequential chainValidate stage outputs; preserve original evidence
One branch is missing at the joinParallel / series–parallelBlock or publish explicit incompleteness under a defined policy
Two branches write conflicting valuesShared-state parallelismUse typed reducers, version checks, or issue resolution
Slow branch governs all completionParallel joinBudget deadlines; label required vs optional work
External action repeats after retryAny patternEnforce idempotency, transaction keys, and tool-specific safeguards
Agents exchange malicious instructionsAny multi-agent handoffTreat peer output as untrusted data; enforce least privilege

Engineering recommendations adapted from workflow, security, and operational guidance [4, 8–12].

10. Implementation Blueprint: A Bounded Series–Parallel Workflow

Example 1 is illustrative pseudocode in Python. It shows execution shape, validation, and bounded waiting without claiming to implement a specific framework's complete production API. It deliberately separates work execution from approval of side effects.

Example 1. Illustrative bounded series–parallel workflow in Python: shape, validation and bounded waiting, not a framework's production API.
import asyncio

async def assess_wms(request):
    scope = await intake_agent(request)
    validate_scope(scope)

    # Independent specialists share an approved, read-only scope.
    async with asyncio.timeout(90):
        vendor, integration, operations = await asyncio.gather(
            vendor_agent(scope),
            integration_agent(scope),
            operations_agent(scope),
        )

    # The join is a validation point, not just string concatenation.
    for artifact in (vendor, integration, operations):
        validate_schema_sources_and_scope(artifact, scope)

    draft = await synthesis_agent(scope, vendor, integration, operations)
    review = await verifier_agent(scope, draft)
    if not review.passed:
        return {"status": "needs_revision", "issues": review.issues}

    return {"status": "ready_for_human_approval", "draft": draft}

The example assumes the caller also handles cancellations, retries, tool authentication, data classification, persistent state, rate limits, and observability. asyncio.gather is not an authorization or reliability framework; it is a concurrency primitive. A production service should make its failure semantics explicit and avoid assuming that cancellation of a waiting coroutine guarantees termination of external side effects. Graph-based frameworks can express the fan-out/fan-in dependencies explicitly and can checkpoint state at defined boundaries [4, 9, 13].

10.1 Handoff contract and trace structure

A useful branch output might include task ID, scope version, status, claim, evidence references, confidence basis, known gaps, runtime, and cost. A join operation should reject an artifact with a mismatched scope version, absent evidence, or an unsupported status. Use a trace ID across the whole request, with span IDs for each agent/tool call and a separate event for each validation result. OpenTelemetry describes spans, trace IDs, and parent–child relationships; the OpenAI Agents SDK also provides workflow and agent tracing [14, 15].

10.2 A minimum evaluation suite

Before releasing a workflow, evaluate it on representative inputs with easy, ambiguous, conflicting, and incomplete evidence. Record (a) accepted-output rate, (b) p50 and p95 end-to-end latency, (c) tokens and tool spend per accepted output, (d) branch failure and retry rate, (e) evidence traceability, and (f) reviewer intervention. A schedule should not be declared superior on latency alone. Compare to a single-agent or deterministic baseline, because additional agents are not automatically necessary [5, 7].

11. Pattern-Selection Method

Start by drawing the true dependency graph without assigning agent names. Remove dependencies that are conveniences rather than requirements; keep those imposed by source validity, safety, approval, and data availability. Estimate each node's runtime, variability, tool cost, permissions, and failure probability. Mark which outputs are mandatory for synthesis. Table 4 turns these questions into a selection heuristic. Only then choose how many agents to instantiate and whether to implement the graph with code, a workflow engine, or an agent platform.

Table 4. Practical selection heuristic.
Engineering questionPattern that may fitAvoid this mistake
Must every stage consume a predecessor's result?SequencePassing unchecked full transcripts as facts
Can independent tasks use one stable brief?ParallelSpawning workers without a merge/acceptance rule
Is there a clear initial gate, parallel investigation, then synthesis?Series–parallelTreating partial branch outputs as complete
Do specialist domains need multi-step internal pipelines?Parallel–seriesCreating artificial serial lanes for independent tasks
Are results consequential or disputed?Add an explicit review gateAssuming more agents means better assurance

Hybrid shapes can be nested and adjusted as task dependencies become better understood.

Engineering recommendation. For source-based SME advisory or technical research, a series–parallel workflow is often a strong initial design: a common scoping step; independent specialist investigation; explicit synthesis; and an independent quality gate. Use parallel–series when specialist work naturally contains several dependent steps that can be owned and tested together. Preserve a sequential baseline for benchmarking and keep a single-agent option for simple tasks. These recommendations are design judgments, not measured claims of universal superiority.

12. Conclusion

Multi-agent workflow design begins with dependencies, not agent count. Sequence creates a straightforward chain; parallel execution shortens truly independent work through fan-out and fan-in; series–parallel combines controlled stages with concurrent work; and parallel–series coordinates multiple specialist pipelines. The hybrid names are valuable only when the architecture specifies precisely what they mean.

Engineering performance is governed by critical-path duration, queueing, synchronization and error handling—not by the nominal degree of parallelism. Reliability depends on structured handoffs, validated joins, bounded retries, source provenance, observability, and appropriately placed human approvals. The practical goal is a workflow that produces a verifiably acceptable result with reasonable latency and cost. The companion paper on stage-gate orchestration (Vol. 106, Issue 11) extends these principles with formal stage-gate loops, rework paths, acceptance criteria, and termination conditions.

References

  1. Microsoft. (n.d.). Agent Framework: Sequential orchestration. learn.microsoft.com/en-us/agent-framework/workflows/orchestrations/sequential
  2. Microsoft. (n.d.). Agent Framework: Concurrent orchestration. learn.microsoft.com/en-us/agent-framework/workflows/orchestrations/concurrent
  3. OpenAI. (n.d.). Agents SDK: Agent orchestration. openai.github.io/openai-agents-python/multi_agent/
  4. LangChain. (n.d.). Graph API overview. LangGraph documentation. docs.langchain.com/oss/python/langgraph/graph-api
  5. Lee, Q. F. (2026). Multi-Agent AI Systems: Architectures, Coordination Patterns and Failure Modes. Chmltech Online Journal. www.chmltech.com/post/multi-agent-ai-systems-architectures-coordination-and-fail
  6. Dean, J. & Barroso, L. A. (2013). The Tail at Scale. Communications of the ACM 56, 74–80. research.google/pubs/the-tail-at-scale/
  7. Hadfield, J., Zhang, B., Lien, K., Scholz, F., Fox, J., & Ford, D. (2025, June 13). How we built our multi-agent research system. Anthropic Engineering. www.anthropic.com/engineering/multi-agent-research-system
  8. Google Cloud. (n.d.). Workflows: Parallel steps. docs.cloud.google.com/workflows/docs/reference/syntax/parallel-steps
  9. Amazon Web Services. (n.d.). Step Functions: Parallel workflow state. docs.aws.amazon.com/step-functions/latest/dg/state-parallel.html
  10. Amazon Web Services. (n.d.). Step Functions: Handling errors in workflows. docs.aws.amazon.com/step-functions/latest/dg/concepts-error-handling.html
  11. OWASP. (n.d.). LLM06:2025 — Excessive Agency. genai.owasp.org/llmrisk/llm062025-excessive-agency/
  12. National Institute of Standards and Technology. (2023). AI RMF Core (AI RMF 1.0, NIST AI 100-1 excerpt). NIST Trustworthy and Responsible AI Resource Center. airc.nist.gov/airmf-resources/airmf/5-sec-core/
  13. Microsoft. (n.d.). Agent Framework: Workflow concepts. learn.microsoft.com/en-us/agent-framework/concepts/workflows/
  14. OpenTelemetry. (n.d.). Traces. OpenTelemetry documentation. opentelemetry.io/docs/concepts/signals/traces/
  15. OpenAI. (n.d.). Agents SDK: Tracing. openai.github.io/openai-agents-python/tracing/

How to cite this article

Lee, Q. F. (2026). Sequential and Parallel Multi-Agent Workflows: Four Execution Patterns and Their Engineering Trade-offs. Chmltech Online Journal, 106(10). https://www.chmltech.com/post/sequential-and-parallel-multi-agent-workflows-four-execution-patterns-and-their-engineering-trade-offs

Chmltech Online Journal · Vol. 106, Issue 10

Download the PDF

Sequential and Parallel Multi-Agent Workflows: Four Execution Patterns and Their Engineering Trade-offs

We use your details to record this request and may follow up about it. See our privacy notice.