Study guide
10.5 Agentic Customization: Built-in Tools, Custom Tools, Skills & MCP
Claude Certified Developer - Foundations CCDV-F
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: Core Messages API & Streaming
1.1 Messages API Fundamentals & Request Lifecycle 1.2 Streaming & Server-Sent Events (SSE) 1.3 Thinking: Adaptive Mode, Effort & Reasoning Budgets
2 Chapter 2: Optimization & Asynchronous Batches
2.1 Prompt Caching Mechanics & Breakpoints 2.2 Message Batches API & Asynchronous Workloads
3 Chapter 3: Structured Outputs, Documents & Files API
3.1 Structured Outputs & JSON Extraction 3.2 Files API, Document Blocks & Citations
4 Chapter 4: Application Design, Resilience & Delivery Life Cycle
4.1 API Resilience, Error Handling & Retries 4.2 Production Backend Architecture & State Management 4.3 Requirements Analysis & Claude Application Design 4.4 The Claude Application Life Cycle & Configuration Management
5 Chapter 5: LLM Fundamentals, Model Selection & Versioning
5.1 LLM & Technical Fundamentals: Tokens, Context Windows & Sampling 5.2 Claude Model Family Selection 5.3 Model Versioning, Snapshot Pinning & Migration 5.4 Latency & Throughput Optimization
6 Chapter 6: Cost Engineering & Context Management
6.1 Production Cost Optimization Strategies 6.2 Context Window Management & Compaction
7 Chapter 7: Foundations of Workflows & Deterministic Patterns
7.1 Agent vs. Workflow Architectural Foundations 7.2 Workflow Patterns: Prompt Chaining & Routing 7.3 Workflow Patterns: Parallelization & Voting
8 Chapter 8: Autonomous Agents & Multi-Step Systems
8.1 Workflow Patterns: Orchestrator-Workers & Evaluator-Optimizer 8.2 Agent Loop Implementation & State Tracking 8.3 Agent Frameworks & Human-in-the-Loop (HITL)
9 Chapter 9: Prompt and Context Engineering
9.1 System Prompt Design & Role Framing 9.2 XML Tags & Structural Prompt Delimiters 9.3 Few-Shot Prompting & In-Context Learning 9.4 RAG Context Injection & Document Formatting
10 Chapter 10: Tool Calling & Model Context Protocol (MCP)
10.1 Tool Schema Design & Parameter Validation 10.2 Tool Execution, Multi-Tool Calls & Error Handling 10.3 MCP Architecture & Core Primitives 10.4 MCP Transports & Client/Server Integration 10.5 Agentic Customization: Built-in Tools, Custom Tools, Skills & MCP
11 Chapter 11: Security, Safety & Governance
11.1 Direct & Indirect Prompt Injection Defenses 11.2 Tool Permissions, Sandboxing & Least Privilege 11.3 Data Privacy, Redaction & Audit Logging 11.4 Identity, Secrets & API Key Management
12 Chapter 12: Claude Code Developer Tooling
12.1 Claude Code Architecture & Project Configuration 12.2 Permissions, Modes & Hooks
13 Chapter 13: Evaluation, Testing & Production Observability
13.1 Evaluation Design & Golden Datasets 13.2 Production Observability, Tracing & Debugging
10.5 Agentic Customization: Built-in Tools, Custom Tools, Skills & MCP
Key Takeaways Explain This Topic AI
Server tools such as web search, web fetch, code execution, the advisor tool, and the tool search tool execute on Anthropic's infrastructure and need no handler code in your application.
Anthropic-schema client tools including bash, text editor, memory, computer use, and browser use are defined by Anthropic but execute in your environment, so you own the sandboxing.
An Agent Skill is a SKILL.md procedure Claude reads rather than a function it calls, and progressive disclosure keeps only the description in context until the Skill is invoked.
CLAUDE.md holds persistent facts needed every turn while a Skill holds procedures needed occasionally; the moment content is only sometimes relevant it belongs in a Skill.
Every declared tool costs input tokens on every request plus an automatic tool-use system prompt (286 tokens on Claude Opus 5.5, Claude Sonnet 5.5, and Claude Haiku 5.5 with tool_choice auto; 354 on the legacy Claude Sonnet 5), and changing any tool definition invalidates the entire prompt cache.
Last updated: October 2026
Agentic Customization: Built-in Tools, Custom Tools, Skills & MCP
Exam Blueprint Focus: Agentic Customisation (4.1%) is the largest sub-skill in the Tools and MCPs domain — bigger than MCP Server Development at 2.1%. It tests one decision: given a capability you want Claude to have, which extension mechanism do you reach for? Five mechanisms exist, they overlap, and choosing the wrong one is the failure mode the exam probes.
The Five Mechanisms
- Mechanism Who writes it Where the code runs Loaded
- Server tools Anthropic Anthropic's infrastructure Declared in tools
- Anthropic-schema client tools Anthropic defines the schema Your application Declared in tools
- Custom tools You (schema and handler) Your application Declared in tools
- Agent Skills You (markdown + scripts) N/A — instructions, not code On demand
- MCP servers You or a third party A separate process or service Connected at startup
- 1. Server tools — Anthropic executes them
- Declared by type and returned with results already filled in. Your application writes no handler code : {
- "model": "claude-opus-5-5",
- "max_tokens": 1024,
- "tools": [{ "type": "web_search_20260209", "name": "web_search" }],
- "messages": [{ "role": "user", "content": "What's the latest on the Mars rover?" }]
- }
The server-tool family covers web search (cited results, $10 per 1,000 searches), web fetch (full page and PDF retrieval, no additional charge beyond tokens), code execution (sandboxed Python and bash, billed by container time beyond 1,550 free hours per organization per month, and free when used alongside web_search_20260209 or web_fetch_20260209 ), the advisor tool (a faster executor model consults a higher-intelligence advisor mid-generation), and the tool search tool (discover and load tools on demand when you have thousands of them).
Choose a server tool when Anthropic already provides the capability. Writing your own web-search tool to reimplement web_search is the classic wasted effort.
2. Anthropic-schema client tools — Anthropic defines, you execute
Anthropic publishes the schema and trains Claude on it, but the code runs in your environment and you return the tool_result . This family covers the bash tool , the text editor tool , the memory tool (store and retrieve across conversations in files you control), the computer use toolset , and the browser use toolset .
The advantage over a custom tool is that Claude has been trained on the exact schema, so calling reliability is higher than for a tool you invent. The obligation is that you sandbox the execution: a bash tool call is a real shell command in your infrastructure.
3. Custom tools — you define both
A tool with a name , description , and JSON input_schema . Use these for anything specific to your domain or systems: lookup_customer_record , issue_refund , search_internal_wiki . Add strict: true to guarantee that Claude's tool calls match your schema exactly.
4. Agent Skills — instructions, not code
A Skill is a folder containing a SKILL.md file with YAML frontmatter and a markdown body, optionally alongside reference material and executable scripts. Skills are not tools: they add no entry to the tools array and Claude does not call them with arguments the way it calls a function. A Skill is a procedure Claude reads. ---
- name: release-verification
- description: Verifies a release candidate before tagging - use when preparing a release
- allowed-tools: Bash(pnpm test:*) Bash(git tag *)
- --
## Steps
1. Run the full test suite and confirm zero failures.
2. Check the changelog covers every merged PR since the last tag.
3. Verify the version bump matches the change type.
The defining mechanic is progressive disclosure : only the description sits in context so Claude knows the Skill exists, and the body loads only when the Skill is invoked — automatically when the description matches the request, or manually as /release-verification . That is what makes a 400-line procedure affordable when the same content in CLAUDE.md would be paid for on every turn of every session.
Skills live in .claude/skills/<name>/SKILL.md (project, committed) or ~/.claude/skills/<name>/SKILL.md (personal). Useful frontmatter fields: allowed-tools pre-approves tools for that turn, disable-model-invocation: true makes a Skill manual-only, user-invocable: false makes it Claude-only, paths limits when it auto-activates, and context: fork runs it in an isolated subagent.
5. MCP servers — capability as a separate service
An MCP server exposes tools, resources, and prompts over stdio or Streamable HTTP. The point is reuse across clients : one Jira MCP server serves Claude Code, your own Messages API application, and any other MCP client, without any of them importing your code. From the Messages API you can reach a remote MCP server through the MCP connector without building a client yourself.
The Decision Table
- Situation Reach for
- Anthropic already provides it (search the web, fetch a page, run Python) Server tool
- You need shell or file editing, and you will sandbox it Anthropic-schema client tool
- A single application needs one action against your own system Custom tool
- Several different clients need the same integration MCP server
- A repeatable procedure , not a function call Agent Skill
- The procedure is long and needed only occasionally Agent Skill (progressive disclosure)
- Instructions needed on literally every turn CLAUDE.md
Instructions needed only for certain file paths .claude/rules/ with paths:
An action must be blocked no matter what the model decides Hook or permissions.deny
Two distinctions the exam leans on:
Skill vs. tool. A tool is a function Claude calls with structured arguments and gets a result from. A Skill is a procedure Claude reads and then follows, using whatever tools it already has. "Check the weather" is a tool. "How this team ships a release" is a Skill.
Skill vs. CLAUDE.md. Both are instructions. CLAUDE.md is always in context and should hold persistent facts; a Skill is on demand and should hold procedures. The moment a CLAUDE.md section is only relevant sometimes, it belongs in a Skill.
Managing Tool Sprawl
Every tool in tools costs input tokens on every request — name, description, and full JSON schema — plus the automatic tool-use system prompt (286 tokens on Claude Opus 5.5, Claude Sonnet 5.5, and Claude Haiku 5.5 with tool_choice auto ; 354 on the legacy Claude Sonnet 5). Forty tools is not just a token bill; it also degrades selection accuracy, because near-duplicate descriptions make the choice genuinely ambiguous.
Three mitigations:
Dynamic registration. Attach only the tools the current user's role and the current task can use. A read-only user never sees issue_refund .
The tool search tool. When you genuinely have thousands, let Claude discover and load them on demand instead of declaring them all up front.
Cache the tool definitions. tools sits first in the cache prefix ( tools → system → messages ), so a stable tool array reads back at the cache-read rate (0.1x base input or less). The corollary is the trap: changing any tool definition invalidates the entire cache , including system and message breakpoints.
Common Traps
Reimplementing a server tool. Writing a custom search_web handler when web_search exists.
Modelling a procedure as a tool. A "run our release checklist" tool with a free-text argument is a Skill wearing a costume.
Putting an occasional procedure in CLAUDE.md . It loads every session, spends tokens every turn, and dilutes adherence to everything else in the file.
Building an MCP server for a single application. MCP's value is reuse across clients; for one app a custom tool is less machinery.
Declaring every tool the organisation owns. Token cost on every request plus worse tool selection.
Forgetting that Anthropic-schema client tools still execute in your infrastructure. bash and text_editor need the same sandboxing as any tool you wrote yourself.