A Claude orchestrator manages a customer service workflow with 3 subagents: order_lookup_agent, refund_processing_agent, and email_notification_agent. The orchestrator is designed with trust that all subagents return accurate results. During an incident, it's discovered that the email_notification_agent was sending confirmation emails before refund_processing_agent confirmed successful refund. The orchestrator's log shows it was calling all three agents in parallel to reduce latency. What is the correct dependency management architecture? The team wants the smallest change to the existing orchestrator, with no new messaging infrastructure, that keeps independent calls parallel.

Adding a result-validation step after the parallel batch is the smallest correct change. Order lookup and refund processing are independent, so they can still run in parallel, but the email depends on refund success. The orchestrator therefore waits for the batch, checks that the refund agent returned a CONFIRMED status, and only then calls the email agent. This matches the orchestrator-workers pattern Anthropic describes, where a central model delegates subtasks and combines results, and it lives entirely inside the existing orchestrator. Fully sequential execution also fixes the ordering but gives up the parallelism of the two independent calls, which the team explicitly wants to keep. An event-driven design with a refund-confirmed event and subscriptions would enforce the dependency, but it requires new messaging infrastructure, which the stem rules out. Optimistic sending with a later cancellation email still tells customers a refund happened when it may not have, which is unacceptable for a financial workflow. On the exam, weigh every stated constraint, since several options may enforce the dependency but only one fits all the requirements. Operationally, alert on any email sent without a matching confirmed refund record.