CLAUDE CODE AGENTS: ADVANCED ORCHESTRATION - Chapter 7, Exercise 2
Why a Constraint Vanishes by the Fourth Agent in a Point-to-Point Chain
====================================================================================

QUESTION:
A four-agent chain relies purely on point-to-point handoffs, with no shared
state. A constraint stated at the very start doesn't appear anywhere in
the fourth agent's own brief. Explain why this happened, using this
chapter's own material.

SOLUTION / EXPLANATION:

This chapter is direct that a pure point-to-point handoff chain only
carries forward whatever the immediately prior step's own output happened
to include - there is no separate mechanism keeping information from
earlier in the chain visible further downstream, unless every single
intermediate step explicitly re-states it in its own output.

The constraint stated at the very start was likely included in the first
agent's own output (or brief), and possibly even carried forward correctly
into the second agent's own handoff. But each subsequent handoff is only as
faithful as whatever that specific step's own summary or report chose to
include. If, at any single point in the chain - say, between the second and
third agent - the constraint wasn't explicitly repeated in that particular
handoff (perhaps because it seemed like "already established" information
not worth restating, or was simply omitted during distillation), it
effectively disappears from that point forward. Every later agent in the
chain only ever sees what the immediately preceding step handed it, so once
the constraint drops out at any single hop, there's no way for a later
agent to recover it - by the fourth agent, it's genuinely no longer present
anywhere in what it actually received.

This is precisely the scenario this chapter uses shared state to solve:
without a running document or object that carries the original constraint
forward explicitly and independently of each individual handoff's own
summary, a single dropped mention anywhere in the chain is enough to lose
it for every step after that point - exactly what happened here.

--------------------------------------------------------------------------
WHY THIS WORKS AS AN ANSWER:
It explains precisely how a point-to-point chain's information only
survives if every single hop re-includes it, identifies that a single
dropped mention anywhere in the chain is sufficient to lose the constraint
for everything downstream, and connects this directly to why shared state
exists specifically to prevent this failure mode.