Skip to lesson

AnthropicClaude Certified Architect – Professional2026-103.8 Evaluate progressive discovery vs. monolithic context strategy

Connect the four disclosure paths

Completed by the knowledge check

Learning objective

Apply progressive disclosure mechanisms: Skill metadata, deferred tool loading, file-system navigation, and resource catalogs.

Core idea

Skill descriptions and resource catalogs provide orientation before detail. At Professional level, the task is to combine those surfaces with tool discovery and file navigation while preserving a clear answer to who selects, fetches, and includes each piece.

These mechanisms disclose different things. A Skill supplies procedural knowledge, deferred loading supplies a callable tool’s definition, file navigation finds local content, and a resource catalog supplies addresses for host-managed context. None automatically replaces the others. A discovered tool may still need a procedure, and a discovered document does not grant permission to execute its instructions.

How it works

Use Skill metadata to route procedures

The Agent Skills overview describes three disclosure levels: name and description metadata, the SKILL.md instructions when triggered, and bundled resources or code as needed. Design the metadata around the task’s trigger and outcome, then put detailed references behind the procedure’s own directions. See 2.5.3 for package delivery across runtime surfaces.

The delta is how these levels cooperate with other loaders. A reconciliation Skill can explain when to inspect a schema catalog and which directory holds transformation examples without embedding every schema and example. Maintain those references as part of the procedure release. Otherwise the Skill triggers successfully but sends the investigation toward absent material.

Choose the runtime explicitly. In Claude Code, project Skills live under .claude/skills/; in the Messages API, selected Skills are supplied through container.skills, with type, skill_id, and optional version, and require code execution. Local installation is not an API upload. For an API workflow, the supported model must also support the required code execution tool.

Defer definitions rather than requests

With Messages API tool search, deferred definitions stay in tools with defer_loading: true; discovery loads definitions, not the records behind them. See 3.1.3 for configuration, search controls, and model and platform support.

Release the deferred operation and the Skill that explains its use as a tested pair. The Skill’s procedure must refer to the operation’s intended purpose and accepted inputs, while the definition must remain discoverable from the task language that triggers the procedure. A procedure release can be correct in isolation yet fail when deployed against a definition whose name or arguments changed.

The integration owner should retain the Skill revision and tool-registry release used in each combined test. Include a case where the Skill needs an operation that was not initially loaded: verify that discovery exposes the intended definition and that the procedure can use its result. Also test a mismatched pair deliberately. Repair the references or release them together rather than compensating by copying the entire registry into the Skill body.

In Claude Code, ENABLE_TOOL_SEARCH=false loads MCP tools up front. ENABLE_TOOL_SEARCH=auto loads tools that would otherwise be deferred up front while their definitions total less than 10% of the context window, then defers them at that threshold. The unset default defers MCP tools on supported deployments. A server configuration with alwaysLoad: true keeps its tools up front. Azure-hosted Microsoft Foundry deployments reject tool search, so Claude Code loads their MCP tools up front instead.

Anthropic’s context-engineering guidance describes a hybrid that combines supplied context with glob and grep navigation. In an Agent SDK filesystem workflow, the corresponding built-in tools include Glob, Grep, and Read. Use the directory structure to identify a collection, search for a relevant passage, and read the necessary file or portion.

Give the procedure a concrete starting path. An example such as catalog/returns/ communicates a narrower search scope than asking Claude to inspect the entire repository. Paths and names are metadata, not proof of content: a filename suggesting a refund exception still requires a read before the assistant relies on it.

This route fits local, inspectable material whose structure helps exploration. It avoids maintaining a second semantic index for every file, but introduces navigation steps. Assign ownership of directory conventions and references so a reorganisation does not silently break the procedure.

Connect resource catalogs through the host

For a resource-backed collection, the host discovers addresses through resources/list or resources/templates/list and obtains content through resources/read with a uri. The architecture can include a compact catalog first and fetch detail later. Assume the resource interface; the decision here is which host path makes it usable during the workflow.

Claude Code’s resource attachments and host-provided list/read tools supply the resource path; the integration must connect that path to the procedure’s decision about which detail it needs.

A direct Messages integration needs its own MCP resource client for this path. The API’s MCP connector supports tool calls only; it is beta and requires anthropic-beta: mcp-client-2025-11-20. Do not connect a resource-only server through that connector and expect its catalog to appear. See 3.7 for integration selection.

Key distinctions and trade-offs

Assign each loader a specific job:

NeedDisclosure pathTeam-owned quality concern
Select a procedureSkill name and descriptionTrigger coverage and correct references
Find an operationDeferred tool definitionSearchable operation semantics
Inspect local detailGlob, Grep, ReadNavigable structure and bounded access
Include URI-addressed contextHost resource clientCorrect selection and complete acquisition

Combining loaders is useful when their jobs differ. Making Claude search for a tool, then search for a catalog, then search for the obvious procedure adds serial work. Preload a small shared starting reference when it removes that repeated navigation.

Architecture / decision scenario

A retailer’s returns platform has a four-person integration team, 70 tools, versioned calculation examples in a repository, and supplier policies exposed as MCP resources. It must handle supplier-specific exceptions without packaging each daily policy edit into a Skill release.

One proposal copies every policy and tool definition into the reconciliation Skill. Another connects the resource server through the Messages MCP connector alone. The architect rejects both: the first duplicates volatile policy, and the second has no resource-reading path.

The team keeps the procedure in a versioned Skill whose metadata identifies exception reconciliation. Its body points to the local examples, reached through Glob, Grep, and Read, and explains when supplier detail is required. Approved specialist operations use deferred tool search. The host’s MCP resource client reads the compact supplier catalog and requested policy URI.

The integration owner tests a case requiring all four paths: the correct Skill triggers, a deferred adjustment tool is found, a local calculation example is read, and the supplier exception is fetched. Passing only the tool-search test would leave half the context strategy unverified.

Common exam traps

  • Treating deferred definitions as omitted request payload.
  • Using tool search to retrieve the records behind a tool.
  • Treating a Skill body as a synchronized copy of every external source.
  • Assuming a Skill release refreshes the volatile policy it points to.
  • Expecting the API MCP connector to expose resources.
  • Assuming Claude Code settings establish API or cloud-platform support.

Where the exam guide differs

Note:

The exam guide names no MCP revision and was written while revision 2025-11-25 was published. This Bite cites revision 2026-07-28, a later revision. Its resource list, template, and read interfaces preserve the disclosure distinction taught here; that revision also replaces resource subscription methods with subscriptions/listen. Read an exam item’s catalog as an orientation surface, then implement against the negotiated protocol rather than assuming one notification interface.

What to remember

Use Skills to discover procedures, tool search to discover definitions, file navigation to inspect local detail, and a host resource client to include URI-addressed context. Test the complete acquisition path across those interfaces.

Knowledge check

References