Skip to lesson

AnthropicClaude Certified Architect – Professional2026-100 Prerequisites

Trace authority across the data flow

Completed by the knowledge check

Learning objective

Trace data flow and trust boundaries among users, application code, the model, tools, and external systems, separating trusted from untrusted content.

Core idea

A data-flow map describes what moves between components. A trust-boundary map adds a second question: whose authority does each component accept? For an architect designing a Claude system, tracing both lets you distinguish useful evidence from permission to act.

A document can be reliable evidence about an invoice while remaining untrusted as an instruction to transfer money. Trust is specific to a purpose; it does not travel automatically with a string through the system.

How it works

Start with five participants: the user, application code, the model, the tool executor, and the external system. Record each transfer’s content, source, destination, and permitted purpose. Include the return path: external results enter model context, model output reaches the application, and the application presents an answer or requests an action.

The user supplies a goal and input. Application code assembles the request and applies its policies. The model produces text or proposes a tool call. For client tools, Anthropic documents that the application executes the structured call; for server tools, Anthropic executes it. Do not draw every tool as an application-owned process. See 0.4 for the interface vocabulary and 1.2.2 for execution and system-of-record ownership.

A trust boundary is a point where the receiver must reassess the source’s authority. An uploaded file, retrieved page, or external tool response can carry instructions planted by someone other than the requesting user. Anthropic calls this indirect prompt injection; a malicious user’s own instruction is a direct attack.

For third-party content, Anthropic’s guidance places it in tool_result blocks rather than system prompts or plain user text blocks, and identifies its origin through the tool’s description or result structure. These are content-placement mechanisms, not grants of access. See 5.1.4 for the mitigation design and 2.2.2 for prompt-template separation.

Your map should also mark where an output becomes consequential: a search result becomes context, a proposed account identifier becomes a database lookup, or a proposed payment becomes a write. Those transitions need an authority decision, even if the preceding component returned well-formed data. See 3.2.2 for resource scoping and 5.1.3 for pre-execution gates.

External results return to model context, while a requested action passes an authority decision first.

External results return to model context, while a requested action passes an authority decision firstThe user supplies a goal and input to application code, which sends the request to the model. The model proposes a tool call back to the application, which requests an action. A requested action passes an authority decision before the tool executor. The dotted path carries external results back into model context, where the receiver must reassess the source's authority.goal and inputproposes a tool callrequests an actionexternal resultsUserApplication codeModelAuthority decisionTool executor

Key distinctions and trade-offs

Trusted instruction versus untrusted evidence: Application-controlled policy defines permitted behavior. Retrieved content supplies facts to consider; its embedded commands do not inherit that policy’s authority.

Tool origin versus content origin: A trusted tool can fetch an attacker-controlled page. Knowing which tool ran does not establish who authored its result.

Data flow versus control flow: Information reaching the model does not authorize an external action. Showing both flows makes the handoff from information to action visible; see 5.1.3 for the gate that enforces it.

Architecture / decision scenario

A financial-services team builds an invoice assistant that must draft payment recommendations while treasury retains approval. A user uploads a supplier invoice; application code sends it through an extraction tool, the model reads the result, and a payment tool connects to the ledger.

Map the invoice and extraction result as supplier-controlled evidence. An embedded “approve immediately” instruction remains untrusted after extraction. Map the model’s payment proposal separately from treasury’s authorization and the ledger write. You assign application and tool owners to the enforcement points and keep the ledger’s response on the return path.

The team proposes relying on a system instruction to ignore commands embedded in invoices. That instruction addresses content handling, but cannot stand in for treasury approval: the map exposes supplier-controlled text on the payment path, so you retain a separate approval step before the ledger write. See 5.1.4 for the injection controls.

Common exam traps

  • Treating an authenticated user’s uploaded document as a trusted instruction.
  • Assuming content returned by an internal tool has an internal author.
  • Drawing the model’s proposed action as an already authorized write.

What to remember

Trace content in both directions and mark where authority changes. Preserve origin and purpose; a valid format or trusted transport does not make embedded instructions authoritative.

Knowledge check

References