Domain 1 — Agentic Architecture & Orchestration (27%)

The largest domain. It is about how to structure agent work: single loop vs. multi-agent, when to decompose, when to delegate, how subagents receive context, and how parallel work is coordinated.

Subtopics to cover

1. Agentic loops and core patterns — prompt chaining, routing, orchestrator-workers, dynamic decomposition, parallel subagents.
2. Task decomposition — staged vs. monolithic; when the next step depends on findings.
3. Multi-agent orchestration — hub-and-spoke / coordinator-worker; partition-then-parallel.
4. Subagents and context passing — subagents receive only explicitly passed context.
5. Parallel execution — concurrent vs. serial tool calls; latency math.
6. State persistence — exporting structured state across a workflow.

Key concepts

• Core patterns and when each fits:
  • Prompt chaining — fixed, known-in-advance workflow steps.
  • Routing — classify input, send to the right handler.
  • Orchestrator-workers — a coordinator splits work across workers.
  • Dynamic decomposition — investigation work where the next step depends on what was just found.
  • Parallel subagents — independent, uniform work over a partition.
• The coordinator should NOT delegate when the work is small — delegation has real overhead (context restating, round trips). Do small/mechanical work directly.
• Partition-then-parallel fits independent, uniform units. Avoid it when units depend on each other or sequential output order matters.
• Subagents receive only explicitly passed context. A subagent does not inherit the parent’s conversation. The parent must restate every fact the subagent needs.
• Each subagent task needs: a concise task statement, relevant findings, sources, constraints, and the expected output shape.
• Tool distribution — give each subagent only the tools it needs, nothing more.
• For delegation in Claude Code, the Task/Agent tool must be in the parent’s allowedTools.
• Parallel execution — issue concurrent tool calls when tasks are independent; serial when one depends on another. A parallel phase wins back latency on I/O-bound work, but the slowest subtask determines total time.
• State persistence — export structured state so a workflow can resume; don’t rely on re-deriving state from a transcript.
• Provenance, time, uncertainty — pass “claim + source ID + location + date + confidence”; carry publication dates, methodology, and uncertainty language between agents.

Common pitfalls (distractor patterns)

• Using the full multi-agent pipeline for a simple fact lookup — overhead with no benefit.
• Strict one-pass research with no targeted follow-up when findings clearly warrant it.
• Passing raw, large outputs between agents instead of compressed, structured findings.
• Over-prescribing subagents with brittle, hard-coded search strings instead of a goal.
• Assuming a subagent inherits the parent’s context.
• Forgetting the Task/Agent tool in the parent’s allowedTools.

Interview / exam angle

• “A coordinator needs one number from a database — delegate to a subagent or not?” — Do it directly. Delegation overhead isn’t justified for small mechanical work.
• “When is dynamic decomposition the right pattern over prompt chaining?” — When the next step genuinely depends on what the previous step found (investigation, debugging), not when the steps are known up front.
• “A subagent keeps missing context the parent clearly has — why?” — Subagents don’t inherit the parent conversation; the parent must explicitly restate the facts, sources, and constraints in the delegated task.
• “Five independent scrapes run as parallel subagents — what determines total latency?” — The slowest single subtask, not the sum.

See also: ../03_claude_code_config_workflows/README.md (subagents in Claude Code), ../05_context_management_reliability/README.md (multi-agent handoffs).

Interview angle

• “When is an agent the wrong architecture?” - when the task is deterministic and the steps are known. A workflow with fixed steps is cheaper, faster, testable and debuggable; an agent earns its cost only when the path genuinely varies with the input.
• “Single agent or multi-agent?” - single until context or tool count makes it unreliable. Multi-agent buys parallelism and focused context per agent, and costs you coordination, latency and a much harder failure story. Say what specifically forced the split.
• “How do you keep a long-running agent from drifting?” - bound the loop with a step limit and a budget, compact context rather than letting it grow unbounded, and checkpoint so a failure resumes rather than restarting. See ../../ai_ml/10_agents_orchestration/.
• “Where does the human belong in the loop?” - at irreversible actions. Preview-then-confirm for anything that spends money, sends external communication or deletes data.