End-to-End Architecture Design (Input to Feedback Loop).

An architect-level design task is never just "the prompt in the middle" - it is the full pipeline: how input arrives (a user turn, a webhook, a batch file, a tool result), how it is processed (a single augmented LLM call, a workflow, or an agent loop), how output is delivered (structured, streamed, or gated by a human), and, critically, how the system learns from what happened (evaluator feedback, logged corrections, retrained prompts or examples).

Anthropic's building-effective-agents framework is explicit that the augmented LLM is the basic building block every end-to-end design composes from, and that workflows and agents are compositions of that block with defined control flow around it, not replacements for thinking through the full loop.

The augmented LLM is the atomic unit. Retrieval, tools, and memory augment a single LLM call; both the workflow and agent patterns are built by composing multiple augmented-LLM calls with control flow layered on top, not by inventing something more exotic underneath.

The feedback stage has more than one valid mechanism - evaluator-optimizer is one option, not the canonical answer. Evaluator-optimizer (one LLM call generates a response while a second LLM call evaluates it and feeds back critique in an iterative loop, until a quality bar is met) is Anthropic's best-known named pattern for closing a feedback loop programmatically, and it fits well when there are clear evaluation criteria an evaluator can check against. But it is not the only mechanism an end-to-end design can use for feedback: a human-correction channel (a person reviews output and their edits get folded back into prompts or examples), structured production monitoring (logged stop_reasons, error rates, or eval-suite regressions that trigger a design revisit), and automated eval-suite regression checks on every prompt change are all equally valid feedback mechanisms - which one (or combination) fits depends on whether the quality bar is something a second LLM call can check, something only a human can judge, or something that only shows up in aggregate production behavior.

Orchestrator-workers handles output aggregation in more complex designs. A central LLM dynamically breaks a task down, delegates to worker LLMs, and synthesizes their results back into one output - this is the named pattern for the output stage whenever multiple parallel results need to become one coherent deliverable.

Human-layer feedback is architectural, not a bolt-on, and often the mechanism that matters most. Designing where a human reviews output, and how that review feeds back into prompt or example revision, is part of the end-to-end shape - a contract-review system whose evaluator-optimizer pass checks extraction quality but never routes a human legal reviewer's edits back into the few-shot examples has only closed part of its feedback loop, regardless of how well-tuned the evaluator-optimizer pass itself is.

The whole design is a hypothesis, not a final artifact. Anthropic's enterprise implementation guidance frames production rollout as inherently iterative - the initial architecture, all four stages included, is expected to be revised from real usage feedback, not shipped once and left alone.