Agentic Workflow Patterns | Synapxe Use Case Deep Dive

🧭 Four Shapes You Can Compose Anything From

In From Chatbots to Agents you saw what an agent is. This module is about how you structure its work. Almost every agentic workflow — however complex — is built from just four reusable patterns: chaining, parallelisation, routing and orchestration. Learn to recognise them and you can design an agent for a task you own, and describe it clearly to the DNA / IT team.

🎯

You don't need to build these yourself. The goal here is recognition — spotting which shape fits each part of your process, so your Agent Design Canvas becomes a precise brief.

👔 Why This Matters When You Own a Use Case

When your DNA / IT team proposes an automation, they'll describe it using these four patterns. Knowing them helps you:

🎯

Ask Better Questions

"Is this a chaining or an orchestration problem?" tells you a lot about complexity and timeline.

⚖️

Weigh Speed vs Cost

Parallel work is faster but uses more of the model; chaining is cheaper but slower. You decide the trade-off.

🛡️

Set Governance Boundaries

Orchestration puts humans at the decision gates. You define where a person must approve.

📋

Spot Automation Candidates

Match your team's manual processes to the right pattern — that's your automation roadmap.

🔀 The Four Patterns — Pick One to Explore

Each pattern answers one question about your task. Click a card to see it animated, with a real healthcare-admin example.

01⛓️

Chaining

"Does each step depend on the last?" Sequential — the output of one step feeds the next.

📐 Predictable🔍 Auditable

Explore Chaining →

02⚡

Parallelisation

"Are the sub-tasks independent?" Fan the same input out to several reviewers at once, then combine.

⚡ Fast👀 Many lenses

Explore Parallelisation →

03🚦

Routing

"Do different inputs need different paths?" Classify first, then send each item to the right handler.

🗂️ Mixed inputs💸 Efficient

Explore Routing →

04🎼

Orchestration

"Is the plan decided as it runs?" A coordinator spawns sub-tasks and manages human approval gates.

🧠 Adaptive👥 Sub-agents

Explore Orchestration →

Pattern 01

⛓️ Prompt Chaining

Sequential steps — the output of one becomes the input of the next, like an assembly line where each station does one job well. It's the most predictable, easiest-to-audit pattern. The trade-off is speed: every step adds a little time. Click a node to explore it, or press auto-play to watch the whole chain run.

💪 Strengths & When to Use It

Easy to understand & debug Each step testable on its own Preserves context across steps A natural place for human review

✅ Use chaining when…

The task splits into 3–7 clear, ordered steps
Each step refines or transforms the previous output
Auditability matters more than raw speed
You want a clear point to insert a human check

❌ Avoid when…

The sub-tasks are independent (parallelise instead)
The plan must change based on what a step finds (orchestrate)
The chain runs past ~8–10 steps — errors compound
The same step repeats many times

🏥 Grounded Example — Leave Request Processing

An HR officer receives a childcare-leave request. The agent produces a decision draft, grounded in the staff guideline — ready for the officer to approve. Each step must run in order, and each is checkable.

ExtractRead the leave form — staff ID, leave type, dates, days requested, reason.

ValidateCheck the request against the staff guideline (the same synthetic document used in the F3 build) — is childcare leave applicable, within notice period, correctly documented?

Check balanceLook up remaining entitlement and confirm the requested days are within the balance.

Draft decisionDraft an approval or a hold note, citing the exact guideline clause — and say "refer to HR" if the case isn't covered.

Log & outputRecord the decision draft and the reasoning for audit; the officer reviews and approves.

🔗

Why chaining fits: you can't draft the decision before knowing the balance, and you can't check the balance before validating the request. The order is the logic — and every step leaves an auditable trace.

Under the hood — how DNA / IT would build it A sequence of model calls with a validator between steps. On AWS: AWS Step Functions chaining Bedrock calls, with a deterministic check (Lambda) between steps to catch bad output early. On AgentSea today: expressed as one grounded agent whose system prompt walks these steps in order, with the officer verifying the result.

Pattern 02

⚡ Parallelisation

The same input fans out to several agents at once, then their answers fan back into one result — like sending a document to three reviewers simultaneously instead of waiting for each in turn. Use it when the sub-tasks are independent. The win is speed: three reviews finish at the pace of the slowest, not the sum of all three. Click a node, or press auto-play.

💪 Strengths & When to Use It

Much faster than one-by-one Several lenses on the same input Each branch is independent An aggregator resolves conflicts

✅ Use parallelisation when…

Sub-tasks are independent — none needs another's output
You want several expert views on the same document
Wall-clock speed matters
An aggregation step can combine the results sensibly

❌ Avoid when…

Steps depend on each other (chain them instead)
Cost is tighter than time — parallel uses more of the model at once
There's no clean way to merge the outputs
The task is a single, simple step

🏥 Grounded Example — Vendor Proposal Review

A vendor proposal arrives. Three reviews that don't depend on each other run at the same time on the same document, then an aggregator assembles one comparison — exactly how a procurement team already splits work across Compliance, Finance and Risk, but in seconds.

Compliance / SLACheck the proposal against your SLA targets and mandatory clauses — flag anything missing or below target.

Commercial / costExtract pricing, totals and payment terms; check the line items add up and compare against budget.

Risk reviewScan for risk clauses — indemnity, liability caps, exit terms — and rate the exposure.

∑

AggregateCombine the three into a single comparison table with an overall recommendation and the flags that need a human decision.

⚡

Why parallelisation fits: the three reviews don't need each other — compliance doesn't wait for cost. Running them together is faster, and the aggregator is where conflicts get resolved before a person reviews.

Under the hood — how DNA / IT would build it Independent model calls launched together, then merged. On AWS: a Step Functions Parallel state (or Lambda fan-out) over Bedrock calls, with a final aggregation step. On AgentSea today: run as separate passes and combine, or as a single agent that produces all three sections — with true parallel multi-agent as a roadmap concept.

Pattern 03

🚦 Routing

Classify the input first, then send it down the right path — like a smart mailroom where each type of document gets its own optimised workflow automatically. It replaces the "which pile does this go in?" decision, so staff focus on the actual processing. Click a node, or press auto-play to watch an item get classified and routed.

💪 Strengths & When to Use It

Handles diverse inputs automatically Each path optimised for its type Scales to many categories Cuts manual triage effort

✅ Use routing when…

Different inputs need genuinely different handling
Your team spends time sorting before processing
You have a mix of request types arriving together
Each category has its own best workflow

❌ Avoid when…

Every input takes the same path anyway
There are only one or two categories
Misclassification is high-risk with no human check
The classification itself needs deep multi-step reasoning

🏥 Grounded Example — Correspondence & Query Triage

A shared inbox receives a steady mix — leave queries, invoices, a new MOH circular, IT-access requests. A router classifies each item by topic and sends it to the right specialised workflow, so nothing sits in the wrong pile.

ClassifyRead each incoming item and label it by topic — HR, Finance, Governance, IT / data-handling.

DispatchSend each to its own workflow: HR queries to the leave/claims assistant, a circular to the compliance workflow, invoices to Finance.

Escalate the unsureWhen confidence is low, route to a human instead of guessing — the safe default.

🚦

Why routing fits: the items are genuinely different and each deserves its own path. The classifier removes the manual triage, and the "when unsure, ask a human" rule keeps it safe.

Under the hood — how DNA / IT would build it A lightweight classifier model call picks the path. On AWS: Bedrock with tool-use, or a small router model, dispatching to different downstream flows. On AgentSea today: a system prompt that classifies then applies the matching instructions — a clean fit for a single agent.

Pattern 04

🎼 Orchestration

A central orchestrator decides the plan as it runs — spawning sub-tasks as needed, coordinating them, and pausing at human approval gates for the decisions that matter. It's the most flexible pattern and the most complex, and it's the shape behind "multiple specialists working together." Click a node, or press auto-play.

💪 Strengths & When to Use It

Handles complex, conditional work Spawns sub-tasks dynamically Human-in-the-loop at decision gates Adapts to what the data reveals

✅ Use orchestration when…

The plan can't be fully known in advance — it emerges from the data
The work needs several specialists coordinated
There are clear points where a human must approve
The process has "if X then Y, else Z" branches

❌ Avoid when…

The plan is fixed and known (chain or parallelise instead)
The task is simple — orchestration adds overhead
You can't yet define where humans must stay in control
Full transparency of every step is a hard requirement

🏥 Grounded Example — Policy & Circular Compliance

A new MOH circular lands. The orchestrator decides what to do based on what the circular contains — it can't know the plan up front, because it depends on which policies are affected.

PlanThe orchestrator reads the circular and decides which internal policies and SOPs might be affected.

Spawn sub-tasksIt launches specialists as needed: retrieve the relevant SOPs, run a gap analysis against the new requirements, draft the policy updates — grounded in the actual documents.

Human gateHigh-impact changes stop at a human approval gate — a compliance officer signs off before anything is finalised.

SynthesiseThe orchestrator assembles the approved pieces into one compliance brief with citations.

🎼

Why orchestration fits: you can't script the steps in advance — how many SOPs, how big the gaps, and which need sign-off all depend on the circular. The orchestrator decides at runtime, and the human gate keeps control where it matters.

Under the hood — how DNA / IT would build it A coordinator model that plans and calls sub-agents, with approval gates. On AWS: Bedrock AgentCore Runtime or Strands sub-agents, with grounding via a Bedrock Knowledge Base. On AgentSea today: this is the roadmap direction — multi-agent coordination and a visual Workflow Builder with approval nodes are concepts subject to platform readiness; today you'd design it and build the pieces as single grounded agents.

👥 This Is Where Multi-Agent Lives

Orchestration is the shape behind multiple AI agents working together — a coordinator plus specialists, each grounded in real data. It's powerful, but it's also where trade-offs bite: less transparency, more latency, and a mandatory human in the loop.

🔭

Going deeper: the multi-agent case study takes exactly this — one healthcare problem (keeping policies in step with MOH circulars) solved end-to-end by cooperating agents grounded in factual documents. Orchestration is the pattern it's built on.

🧩 Real Workflows Combine Patterns

You rarely use just one. Most real processes chain two or three patterns together. Here's the Vendor Proposal Evaluation end-to-end — it routes by proposal type, runs the checks in parallel, then chains to a decision. Click a node, or press auto-play to watch all three work together.

🧭 Quick Decision Guide

Match the shape of your process to the right pattern.

If your process looks like…	Use this pattern	Healthcare-admin example
Do A, then B, then C — in order	⛓️ Chaining	Leave request: extract → validate → check balance → draft
Get several views on the same thing	⚡ Parallelisation	Vendor proposal: compliance + cost + risk at once
Sort first, then handle differently	🚦 Routing	Shared inbox: classify HR / Finance / Governance → right queue
Complex, with "if / then" decisions	🎼 Orchestration	New MOH circular: plan → sub-tasks → human gate
Several of the above	🧩 Combine	Vendor eval: route → parallel checks → chain to decision

📐 Your Next Step — Label Your Canvas

Don't force everything into one pattern. Identify which pattern fits each part of your process, then combine them.

✍️

When you design your agent on the Agent Design Canvas, label each step with its pattern (chain / parallel / route / orchestrate). That labelled flow becomes your brief to the DNA / IT team — precise, buildable, and honest about where a human stays in the loop.

🧠

Leader's takeaway

AI handles the routine; humans handle the exceptions. The patterns are your vocabulary for deciding where automation ends and judgement begins — and for setting the governance gates before anything goes live.