Lab 09 · Agent Pattern Selection Workshop

Rajesh is three weeks into solutioning the Meridian Retail engagement, and every workstream lead has discovered the word "agent." The program board has forwarded him six automation requests, all tagged agentic AI, all expecting an architecture answer this sprint. The vocabulary he needs is the five composable patterns — prompt chaining, routing, parallelization, orchestrator–workers, evaluator–optimizer — plus the two honest answers the taxonomy exists to protect: "this is a plain workflow" and "this needs no LLM in the loop at all." This lab is the vocabulary drill. You will map each scenario to exactly one structure, justify it in five lines or fewer, and defend the boring answers against an AI assistant that will lobby hard for more autonomy.

Time & tier

~60 minutes hands-on · Core tier (maps to module M6). Runs at ~₹0 — this is a design-artifact lab; you need only a chat assistant (any free tier, or a local model via Ollama).

Setup

Create a working folder lab-09/ with one file, pattern-worksheet.md, containing this table skeleton:

# Meridian agent-pattern selection worksheet
| # | Scenario | Structure chosen | Justification (≤5 lines) | Blast radius if wrong |
|---|----------|------------------|--------------------------|-----------------------|
| S1 | Support triage        |  |  |  |
| S2 | Weekly report pipeline |  |  |  |
| S3 | Code migration        |  |  |  |
| S4 | Research synthesis    |  |  |  |
| S5 | Pricing approval      |  |  |  |
| S6 | Incident comms        |  |  |  |

Your structure menu, verbatim, is: prompt chaining · routing · parallelization · orchestrator–workers · evaluator–optimizer · no agent needed (plain workflow / deterministic system). One structure per scenario. Not every pattern must be used — the menu is not a bingo card.

The six scenarios, exactly as the Meridian program board wrote them (all numbers synthetic):

S1 — SUPPORT TRIAGE. Meridian's support desk receives ~4,000 tickets/day across six
fixed categories (orders, refunds, delivery, product, account, other). Each category
has its own resolution playbook and its own system of record. Today's keyword rules
misroute ~18% of tickets. Latency budget: a few seconds per ticket.

S2 — WEEKLY REPORT PIPELINE. Every Monday 06:00 IST: run last week's order metrics
(fixed SQL against the warehouse), draft a narrative summary, restate it in Meridian's
contractual report template, and produce a five-bullet exec summary. Steps and order
never change. Each intermediate output is checkable on its own.

S3 — CODE MIGRATION. ~300 legacy integration scripts (mixed Perl and Python 2) must
become Python 3 services. Scripts vary wildly in size and dependencies; subtasks
cannot be enumerated up front. Every converted script must pass its own test harness
before it counts.

S4 — RESEARCH SYNTHESIS. For each RFP, presales must assess 5 candidate platforms
across 8 fixed dimensions (identity, data residency, pricing model, quotas, ...) and
synthesize one comparison memo. The 40 sub-assessments are independent of each other.
Deadline pressure: hours, not days.

S5 — PRICING APPROVAL. Discount requests above 12% are approved against a rate
policy: deterministic thresholds by deal size, a margin floor, and competitor-match
clauses. Finance must sign above 20%. Auditors sample decisions quarterly. A
workstream lead proposes "an agent that negotiates and auto-approves within policy."

S6 — INCIDENT COMMS. During SEV-1 incidents, a status update must reach the client
every 30 minutes in a contractually fixed format, with facts taken from the incident
channel. Proposal on the table: "an agent monitors the channel and posts updates
autonomously so responders can focus."

Guided steps

Step 1 — Learn the menu in your own words (10 min)

Before touching the scenarios, write a one-line definition of each of the five patterns plus its cheapest failure mode — the way it goes wrong when applied where it doesn't belong. Example shape: "Routing — a classifier picks one specialized downstream path; fails cheaply when categories aren't actually disjoint." Do this from memory of the module material first, then ask your assistant to critique your six lines (five patterns + "no agent needed"). Fix only what you agree is wrong.

✅ Checkpoint: six one-liners exist at the top of pattern-worksheet.md, each with a named failure mode.

Step 2 — First-pass mapping, no AI (15 min)

Fill the worksheet table alone. For each scenario commit to one structure and draft the justification. Force yourself to answer two questions per row: Can the subtasks be enumerated up front? (if yes, you are in workflow territory — chaining, routing, or parallelization) and What breaks, and who pays, when the model is wrong? (that is the blast-radius column). Where you are torn between two structures, write both and star the row — Step 3 resolves stars.

✅ Checkpoint: all six rows filled; any row with two candidate structures is starred.

Step 3 — Red-team your mapping with an assistant (15 min)

Now use AI adversarially. Paste your completed worksheet with this prompt:

You are an aggressive agentic-AI vendor architect. For each of my six mappings, argue
that the scenario deserves MORE autonomy than I gave it — a fuller agent, more
tool access, less human gating. Make the strongest honest case you can, one
paragraph per scenario. Do not agree with me anywhere.

Then defend each row or concede it. This is the heart of the lab: assistants (and vendors) systematically over-recommend agency, because "agent" is never the answer that sounds under-ambitious. A concession is only legitimate if the scenario text supports it — not because the argument sounded fluent. Record one sentence per scenario: "defended because…" or "conceded because…".

✅ Checkpoint: six defend/concede sentences recorded; at least the S5 and S6 arguments have been explicitly rebutted or accepted with scenario-text evidence.

Step 4 — Finalize the worksheet (15 min)

Rewrite each justification to its final ≤5-line form. A justification that survives review has three ingredients: the structural fact that selects the pattern (fixed categories → routing; unenumerable subtasks → orchestrator–workers), the verification gate you will attach (every pattern needs one), and the blast-radius line (worst plausible failure and who absorbs it). For any scenario you marked "no agent needed," state what the deterministic system is and where, if anywhere, an LLM still earns a seat as a drafting aid.

✅ Checkpoint: every row ≤5 lines, names a verification gate, and has a non-empty blast-radius entry.

Step 5 — Score yourself (5 min)

Open the answer key below. Score 1 point per matching structure, and for the two "no agent needed" scenarios, half a point extra each if your justification named the same core reason as the key.

✅ Checkpoint: score recorded at the bottom of the worksheet, with one sentence on your biggest miss.

Verification

• Coverageall six scenarios mapped to exactly one structure each; no row hedges between two.
• Restraintat least two scenarios resolved to "no agent needed," each with a stated deterministic alternative.
• Gatesevery mapped pattern names its verification gate (test harness, human sign-off, checkable intermediate, source check).
• Adversarial passthe red-team transcript exists and at least four of six vendor arguments were explicitly rebutted with scenario-text evidence.

Completion artifact

pattern-worksheet.md — the pattern-selection worksheet with justifications, blast-radius notes, and the defend/concede log. Self-grading rubric (pass = 8/10):

• Structure accuracy (0–4): matches the answer key on ≥5 of 6 scenarios = 4; 4 of 6 = 3.
• No-agent defenses (0–2): both boring answers argued from irreversibility/determinism, not vibes = 2.
• Verification gates (0–2): every chosen pattern carries a concrete, checkable gate = 2.
• Red-team quality (0–2): concessions and rebuttals cite scenario facts, not assistant fluency = 2.

Client-safe variant

The scenarios here are synthetic, so any assistant is fine. When you run this workshop on a real engagement: extract the client constraint register first (what the MSA allows into external AI tools — usually not workload descriptions with volumes and system names), run the mapping step with redacted scenario cards or inside the client-approved tenancy, and keep the red-team step — it works identically on a local Ollama model. The worksheet format itself is client-shareable; it contains decisions, not data.

Stuck?

• •
  Every scenario feels like orchestrator–workers: you are diagnosing from ambition, not structure — re-ask "can I enumerate the subtasks up front?" for each; if yes, it is not orchestrator–workers.
• •
  The assistant convinced you S5 needs an agent: re-read the scenario — the policy is deterministic thresholds; ask what an LLM adds to a rules lookup except audit risk.
• •
  You used all five patterns exactly once: suspicious symmetry — the scenarios were not built as a bingo card; recheck against the answer key logic.
• •
  Justifications keep exceeding 5 lines: cut everything except structural fact, gate, blast radius — adjectives are not evidence.

Answer key (don't read before attempting)

1. 1S1 — Routing. Six fixed, disjoint categories with per-category playbooks is the routing signature: one classifier, six specialized handlers, seconds-level latency. The orchestrator–workers temptation fails the structure test — subtasks are enumerable and static. Gate: confidence threshold below which tickets fall to the human queue; track misroute rate against the 18% baseline.
2. 2S2 — Prompt chaining. Fixed steps in fixed order, each output independently checkable — chain the calls and put a programmatic gate between links (SQL results non-empty, template fields all filled, exec summary numbers match the source table). An "autonomous report agent" adds nondeterminism to a task whose entire value is repeatability.
3. 3S3 — Orchestrator–workers. Subtasks cannot be enumerated up front — script size and dependencies vary, so an orchestrator must decompose dynamically and dispatch workers per script. The per-script test harness is the built-in verification gate; a worker's output that fails its harness loops (an evaluator–optimizer inner loop is a legitimate composition here, not a competing answer).
4. 4S4 — Parallelization. Forty independent sub-assessments under hours-level deadline is sectioning: fan out per platform×dimension, aggregate into the memo. The mandatory gate is this track's signature discipline — every quota, price, and limit claim in the fan-out is verified against vendor docs before the memo ships, because parallel generation parallelizes hallucination too.
5. 5S5 — No agent needed. The policy is the system: deterministic thresholds, a margin floor, clause lookups, and a finance signature above 20% — that is a rules engine plus an approval workflow, both auditable line by line. An "agent that negotiates and auto-approves" converts a quarterly-audited deterministic control into a probabilistic one, and the blast radius is revenue plus audit findings. Legitimate LLM seat: drafting the justification memo a human attaches to an exception request — advisory, never deciding.
6. 6S6 — No agent needed. The send path must be boring: a scheduler, a contractually fixed template, and a human publish button, because a wrong fact sent to a client mid-SEV-1 is contractual damage you cannot retract. Reliability during incidents is exactly when you spend your determinism budget. Legitimate LLM seat: drafting the update text from the channel for the responder to approve — the same division as S5: AI drafts, deterministic system delivers, human owns publish.

Deliberate asymmetries you should have noticed: evaluator–optimizer is never the primary answer (it appears only as S3's inner loop — a menu item going unused is a feature of honest diagnosis), and both no-agent scenarios share one fingerprint: the cost of a wrong output is borne outside the team, irreversibly. When you see that fingerprint, autonomy is the last thing you add, not the first.