Task statement 8.3 · Tools and MCPs
8.3 · Agentic Customization
Shelfwise, the course example, gives its agent one capability beyond the model: stock_lookup, served by its own MCP server. Agentic customization is choosing that shape on purpose from built-in tools, custom tools, Skills and MCP servers, by what each one costs and who else needs it.
share
The tempting design gives every capability its own MCP server, or pastes every instruction into the prompt. A server built for one application adds a process to deploy and secure that nobody else uses. Instructions that only some requests need cost context on every request. Both designs overlook a built-in tool that may already do the job.
KnowledgeBuilt-in tools, custom tools and MCP servers
Built-in tools ship with the platform, so you enable them instead of writing them. Claude Code and the Agent SDK provide tools such as Read, Edit, Bash and WebFetch (1.2), and the Claude API offers server tools such as web search and web fetch, which Anthropic runs (8.1). They are general-purpose, so none of them knows your private systems' operations, credentials or rules: Bash could call an internal API, but nothing describes or maintains that access. A custom tool is an action your own code performs, described to Claude by a name, a description and a schema. On the Claude API it is a user-defined client tool. In the Agent SDK you write it with @tool and serve it with create_sdk_mcp_server, which builds an MCP server inside your own process.
A standalone MCP server is a separate program that any MCP client can connect to, such as Claude Code, Claude Desktop, the Agent SDK or the MCP connector (8.2). It suits a capability that several applications or people need, maintained in one place, and its price is a process to deploy, secure and version. Every tool definition costs context on each request, although Claude Code and the Agent SDK defer MCP tool schemas through tool search (8.1) by default.
KnowledgeSkills
A Skill adds know-how rather than access. It is a folder holding a SKILL.md file of instructions, with optional scripts and reference files, and it loads in stages. Its name and description, about 100 tokens, sit in context from the start, so Claude can match a task to it. The body loads only when Claude or a user invokes the Skill, and other files load only when read. A script runs through the session's own tools, and only its output enters context. A Skill is therefore a cheap home for a procedure or reference that some requests need, and instructions that every request needs belong in the system prompt instead (6.2). Each surface finds Skills in its own way, and custom Skills do not sync between surfaces:
Folders in .claude/skills/ (project) or ~/.claude/skills/ (personal). Each also runs as /name, and command files now work as Skills. disable-model-invocation: true keeps a Skill's description out of context until someone types it.
Read from the same folders through setting_sources, or from a path through the plugins option, and invoked with the built-in Skill tool, so an explicit tools list must name "Skill". The skills option limits which ones Claude may invoke.
Named by skill_id in the request's container, beside the code execution tool, whose container has no network. Anthropic ships pptx, xlsx, docx and pdf; custom Skills upload to the workspace through the Skills API.
KnowledgeChoosing for a use case
Choosing the appropriate approach for a use case starts from what Claude is missing. When the platform already does the job, enable the built-in tool, because nothing is cheaper to maintain. When Claude lacks a procedure or reference that only some tasks need, write a Skill. When Claude must act on your code or systems, write a tool, and let the number of clients decide where it lives: inside one application as a custom tool, or in an MCP server once other applications or Claude Code sessions need it. In the guide's example, an internal inventory service with a REST API must be reusable across several Claude applications and maintained apart from each, so an MCP server exposes its operations as tools and each application connects to it. The options also combine, and the docs pair an MCP server, which provides the connection, with a Skill that teaches Claude how to use it well.
Interactive · four ways to add a capability
Choose an option to read its column.
Built-in tool: the platform already has the action, so you enable it and write nothing. Claude Code and the Agent SDK ship tools such as Read, Edit, Bash and WebFetch, and the Claude API's server tools, such as web search, run on Anthropic's side. None of them knows your private systems. Shelfwise enables none: tools=[] keeps every built-in definition out of Claude's context.
Custom tool: your own code runs the action, described by a name, a description and a schema. In the Agent SDK, @tool and create_sdk_mcp_server serve it inside your process, so only that application can call it. Shelfwise did not build stock_lookup this way, because engineers also need the tool in Claude Code.
MCP server: a separate program that any MCP client can connect to, so applications and Claude Code sessions share one maintained copy, at the cost of a process to deploy and secure. Shelfwise's stock_mcp serves stock_lookup to the service and to each engineer's Claude Code.
Skill: a SKILL.md folder of instructions, scripts and reference files. About 100 tokens of name and description stay in context, and the body loads when the Skill is invoked. It adds know-how, not access. Shelfwise loads none: setting_sources=[] skips .claude/skills/, and every staff question needs the stock rules, which stay in the system prompt.
KnowledgePlugins: the packaging layer
A plugin (2.5) installs Skills, subagents, hooks and MCP servers as one unit, which is how a choice made in one repository reaches others. Writing one means a directory, usually with a manifest at .claude-plugin/plugin.json, whose required name becomes the prefix of each Skill, as in /release-kit:notes. The components sit at the plugin root, beside .claude-plugin/, never inside it. You load it for one session with claude --plugin-dir ./release-kit, check it with claude plugin validate, and publish it through a marketplace. 2.5 covers installing plugins and their scopes. A plugin that needs another plugin lists it under dependencies (2.6).
release-kit/ ├── .claude-plugin/plugin.json # {"name": "release-kit", "version": "1.2.0"} ├── skills/notes/SKILL.md # runs as /release-kit:notes ├── hooks/hooks.json # hooks on lifecycle events └── .mcp.json # MCP servers started with the plugin
SkillWorked example: the stock rules as a Skill?
An engineer proposed moving Shelfwise's stock rules out of the system prompt into a stock-rules Skill, to slim the cached ≈6,000-token prefix. The team priced the idea on paper and rejected it. Every staff question is a stock question, so each chat would load the Skill through an extra Skill tool call. Its body would then arrive as a tool result inside that chat, not in the prefix that every chat reads from the cache. Claude also decides whether to invoke a Skill, so a chat could be answered without the rules. The service could not load or invoke it anyway, as its options show:
ClaudeAgentOptions(
system_prompt=STOCK_RULES, # every request needs them: kept, cached
tools=[], # no built-in tools, so no Skill tool
setting_sources=[], # .claude/skills/ is never read
mcp_servers={"stock": STOCK_MCP}, # the one custom tool
allowed_tools=["mcp__stock__stock_lookup"])
The decision table above also explains stock_mcp. An in-process @tool would serve only the service, but each engineer also runs the server in Claude Code (8.2), so a separate stdio server is the one place where stock_lookup lives.
More precise than the guide. "Built-in tools" is the Claude Code and Agent SDK name for the tools that ship with the harness, such as Read, Bash and WebFetch (as of 2026-10-05). The Messages API docs sort tools by who runs them instead, as the box in 8.1 shows. Exam answer: a built-in tool is one the platform provides ready-made, so you enable it instead of writing it.
- In the Agent SDK a custom tool is an MCP server that runs in your process:
@toolpluscreate_sdk_mcp_server, with nothing else to deploy. - A Skill brings no new access: its name and description cost about 100 tokens from the start, its body loads when invoked, and its scripts run through the session's own tools.
- A plugin is the packaging layer:
.claude-plugin/plugin.jsonnames it, and that name prefixes its Skills (2.5).