MCP tools for AI agents are the actions an MCP server offers to an AI model, each with a name, a description and an input schema. In November 2026 every major agent framework can use them; the decisions that matter are which tools to expose, how many, and who approves the ones that change things.
TL;DR
An MCP tool is one action an AI agent can take through the Model Context Protocol: a name, a plain-language description and an input schema the model reads before deciding to call it. The current protocol version, 2026-07-28, made MCP stateless and added a discovery call; the project has sat with the Linux Foundation's Agentic AI Foundation since December 2025.
Every major agent framework now speaks MCP: Claude's Agent SDK and API, OpenAI's Agents SDK, Google's ADK and LangChain. The hard parts are no longer connection. They are choosing few, well-described tools, keeping tool definitions from eating the context window, and putting a human approval in front of anything that writes.
Anthropic's own docs say tool choice gets worse past 30 to 50 tools and that five common servers can use about 55,000 tokens before any work starts. Start a marketing agent with one job, three to six read-only tools and a test set of real tasks.
Short answer: MCP tools for AI agents are the standard way to give a model hands: each tool is an action, such as "get campaign report" or "create draft", that an MCP server offers and any MCP-aware agent can call. In November 2026 the protocol, the SDKs and the frameworks are mature; the decisions that matter are which tools to expose, how many, and who approves the risky ones.
This guide is for people building or commissioning agents, not for picking a ready-made connector. If you want the official Google Ads, GA4 and Meta servers, read what a marketing MCP server is. For search work, see MCP servers for SEO, and for the connectors you can switch on inside Claude today, the Claude marketing connectors catalogue. Here the focus is the tool layer itself: how it works, where the ecosystem is in November 2026, and how to design a toolset an agent can use well. If you want that built for your team, it is what my AI marketing agents service does.
What is an MCP tool, and how does an agent use one?
Short answer: a tool is a function an MCP server exposes with a name, a description and a JSON input schema. The agent's host asks the server for its tool list, the model picks a tool from the descriptions, and the host sends the call. The model never touches the API directly; the server does, with its own credentials.
MCP has three roles. The host is the app you use (Claude Code, a custom agent, an IDE). Inside it, a client keeps a connection to each server, and each server wraps one system, such as an ad platform, a CRM or a folder of files. Servers can offer three kinds of thing, and the difference matters when you design an agent.
| Primitive | Who decides to use it | Marketing example |
|---|---|---|
| Tools | The model | get_campaign_report, create_draft_email |
| Resources | The app or user | A brand guidelines file, a product feed |
| Prompts | The user | A saved "weekly report" template |
Tools are the only primitive the model chooses to run, which is why they carry the risk and get most of the attention. Several hosts support only tools: Anthropic's MCP connector for the Claude API says plainly that only tool calls are supported.

What changed in MCP in 2026?
Short answer: the current protocol version is 2026-07-28. It removed sessions and the start-up handshake so every request stands alone, added a required server/discover call, moved long-running tasks into an extension, and deprecated Roots, Sampling and Logging. Governance moved to the Agentic AI Foundation in December 2025.

The full list is in the spec's key changes for 2026-07-28. The ones an agent builder notices:
| Change | What it means for your agent |
|---|---|
| Stateless requests | Easier to host servers behind load balancers |
server/discover required | Check versions before the first call |
| Deterministic tool order | Better prompt cache hits |
| Cache hints on lists | Fewer repeated tools/list calls |
| Tasks moved to an extension | Long jobs return a handle you poll |
| Roots, Sampling, Logging deprecated | Pass files and logs another way |
On governance, Anthropic donated MCP to the Agentic AI Foundation, a fund under the Linux Foundation co-founded with Block and OpenAI, on 9 December 2025. Optional features now arrive as official extensions: MCP Apps (interactive UI inside a chat) is stable, while Tasks, Skills over MCP and Server Cards are in beta.
Where do you find MCP servers and tools?
Short answer: start with the vendor's own documentation, then the official MCP Registry, which lists public servers with verified namespaces but is still in preview and does not security-scan code. Client directories such as Claude's add their own review. Treat any community server as code you are choosing to trust.

| Source | What you get | Trust check |
|---|---|---|
| Vendor docs | The maker's own server | Strongest; check scopes |
| Official MCP Registry | Metadata for public servers | Namespace verified, code not scanned |
| Client directories | Servers a host has listed | Host review varies |
| Reference servers repo | Examples to learn from | Not production products |
| Community lists | Thousands of options | Read the code first |
The registry page says it delegates security scanning to package registries such as npm and PyPI and to downstream marketplaces. That is a sensible design, but it means a listing proves who published a server, not that the server is safe.
Which agent frameworks can use MCP tools?
Short answer: all the main ones. Claude's Agent SDK and API, OpenAI's Agents SDK, Google's Agent Development Kit and LangChain can each connect to MCP servers, and each has a way to limit which tools the model sees. Check the transport each supports: the Claude API connector, for example, reaches only public HTTPS servers.
| Framework | How it connects | Tool limits and approval |
|---|---|---|
| Claude Agent SDK | stdio, HTTP, in-process | allowedTools; tool search on by default |
| Claude API MCP connector | Remote HTTPS only (beta) | Allowlist, denylist, pinned tool list |
| OpenAI Agents SDK | Hosted, Streamable HTTP, stdio | tool_filter, require_approval |
| Google ADK | McpToolset, stdio or HTTP | tool_filter |
| LangChain | langchain.mcp (beta, v1.4+) | Pick tools per agent |
Two details from those docs are easy to miss. In the Claude Agent SDK, a tool result over 25,000 tokens is saved to a file instead of being passed to the model, so tools that return whole reports need paging. And the Claude API's newest connector header can pin a server's tool list, because, in Anthropic's words, a server "can change its tools at any time".
How many tools can an agent handle?
Short answer: fewer than most people connect. Anthropic's docs say Claude's tool choice degrades past 30 to 50 tools and that five common servers can use about 55,000 tokens of definitions before work starts. Past that, load tools on demand with tool search, or have the agent call tools from code.

Every tool definition sits in the model's context, the working memory it reads on each turn. Too many definitions crowd out the actual task and make similar tools easy to confuse. The MCP project's own client best practices suggest switching to on-demand loading once definitions pass about 1 to 5 percent of the context window.

| Approach | Use it when | Trade-off |
|---|---|---|
| Load all tools | Under 10 tools, small definitions | Simple; breaks as you grow |
| Tool search | 10+ tools or 10k+ tokens | A search step can miss |
| Code execution | Big data passing between tools | Needs a secure sandbox |
| Separate agents | Distinct jobs, distinct tools | More moving parts |
Anthropic's code execution post reports one example falling from 150,000 tokens to 2,000 when the agent wrote code to move data between tools instead of passing it through the model. That is a single example, not a benchmark, and the post is clear that running model-written code needs sandboxing and monitoring.
How do you design a good MCP tool for a marketing agent?
Short answer: build a few tools around jobs, not one tool per API endpoint. Name them with a service prefix, describe when to use each in plain words, return short summaries by default with paging, mark read-only tools as such, and test them on real tasks before you trust them.
Anthropic's guide to writing tools for agents (September 2025) puts it bluntly: more tools do not always lead to better outcomes. The usual mistake in marketing is wrapping every endpoint of an ad platform's API and handing the model 40 near-identical options.
| Weak tool design | Better tool design |
|---|---|
| One tool per API endpoint | One tool per job: ads_weekly_summary |
| Returns every row | Summary first, paging for detail |
| "Gets data" | "Use when you need spend and conversions for a date range. Not for changes." |
| Raw IDs only | Names next to IDs |
| Read and write in one tool | Separate tools; write needs approval |
| No annotations | readOnlyHint: true on read tools |
The spec's tools page adds structure you can use: an optional outputSchema so results come back as checked data, and annotations such as readOnlyHint and destructiveHint. The same page warns that clients must treat annotations as untrusted unless the server is trusted, so a "read-only" label is a hint, not a lock.
I am building an MCP server for a marketing agent that reports on [ad platform / CRM]. The agent's one job is: [job in one sentence]. Propose no more than 6 tools. For each tool give: a name with a service prefix, a description that says when to use it and when not to, the input schema with plain parameter names, what it returns by default (a short summary) and how to page for detail, and whether it is read-only. Do not include any tool that changes, sends or deletes anything unless I ask. Then list 10 realistic test requests a marketer would make, with the tool calls you expect for each.
How do you keep MCP tools safe?
Short answer: keep a human able to deny any tool call, start read-only, give each server the narrowest login it needs, treat every tool result as untrusted text, and pin or review tool lists so a server cannot quietly change what your agent can do. The MCP spec says there should always be a human in the loop.

| Risk | What it looks like | Control |
|---|---|---|
| Prompt injection | A web page or email tells the agent to act | Approval on writes; results are data |
| Over-broad login | A reporting agent can edit budgets | Read-only roles and scopes |
| Tool list changes | A server adds a new write tool | Pin or review tool lists |
| Token passthrough | A server forwards your token elsewhere | Use servers that follow the spec |
| Local server compromise | An installed package runs bad code | Vendor servers; read the code |
The MCP project's security best practices cover the technical attacks in detail, including confused deputy problems and scope minimisation. For a marketing team the practical rule is simpler: nothing that spends money, publishes or contacts a customer runs without a person saying yes.
What should a first marketing agent's toolset look like?
Short answer: one job, one or two servers, three to six read-only tools, an approval step for anything else, a log of every call, and a test set of 10 to 20 real requests you check by hand for two weeks. Add tools only when the agent fails a test because a tool is missing.
- Write the job in one sentence, with what good output looks like: "Every Monday, summarise last week's paid search spend and conversions by campaign and flag anything that moved more than 20 percent."
- List the questions it must answer, then the smallest set of tools that answers them.
- Connect read-only. Use a reporting role on the ad account, not an admin login.
- Test on real requests and compare with your own check. The thresholds in this example are yours to set, not a standard.
- Fix descriptions before adding tools. Most wrong picks come from overlapping descriptions.
- Add a write tool last, behind an approval prompt, and log what it changed.
In my own setup a thinking model plans and a separate agent executes, and nothing goes live on a client account before a person approves it. That habit matters more than which framework you pick.
When the agents multiply, the questions change from tools to coordination; my guide on managing multiple AI agents covers roles, handovers and checks.
How big is the MCP ecosystem now?
Short answer: large and still growing. Monthly npm downloads of the official TypeScript SDK rose from about 35 million in November 2025 to about 296 million in October 2026, and Anthropic counted more than 10,000 active public servers when it handed MCP to the Linux Foundation.

@modelcontextprotocol/sdk, from the npm downloads API, fetched 18 November 2026.Downloads include automated builds and packages that depend on the SDK, so they overstate the number of people building. The direction is the useful part: the protocol is now a safe bet for the tool layer. There are official SDKs in 10 languages, with TypeScript, Python, C#, Go, Rust and Ruby in the top tier on the SDK page.
What people say on X and Reddit
Short answer: builders agree the problem has moved from connecting tools to having too many of them. The common fixes they report are tool search, clearer "use this when" descriptions, prefixed names and splitting tools into profiles.
| Who | What they said | Take it as | Link |
|---|---|---|---|
| A Claude Code engineer at Anthropic | Tool search is now in Claude Code (14 Jan 2026) | Vendor | X post |
| A developer advocate | With tool search on, MCP tools fell from 25% to 14% of the context window (23 Jan 2026) | First-hand | X post |
| An AI startup founder | Progressive tool disclosure belongs in the agent, not in an MCP server (18 Dec 2025) | Opinion | X post |
| A product newsletter writer | Every connected server loads its full tool descriptions, slowing responses (2 Mar 2026) | Opinion | X post |
| A developer | Too many tools cause "paradox of choice" and eat the context window (2 Jul 2025) | Opinion | X post |
| r/mcp | Wrong picks get common past 20 to 30 tools; overlap hurts more than count; "use this when" descriptions help (4 Nov 2026) | First-hand | Thread |
| r/mcp | 11 servers and 128+ tools in an IDE hit a client limit; replies suggest project profiles (28 Apr 2026) | First-hand | Thread |
| r/mcp | Token and latency problems when agents carry too many tools (20 Mar 2026) | Question | Thread |
| r/mcp | A security vendor says it found 90 prompt-injection issues in 44 public servers (7 Nov 2026) | Vendor claim | Thread |
Tool counts in these threads depend heavily on the model and client, so read them as experience reports. Several replies come from people selling gateways or proxies.
Videos worth watching
Short answer: AWS's video is the best short guide to when MCP is the wrong choice, Red Hat's is a demo of agent apps built on it, and the third explains Anthropic's tool search fix for context bloat.
Made by AWS Developers, 11 August 2026. Vendor channel, but the topic is when not to use MCP, which is rarer and useful.
Made by Red Hat, 26 January 2026. A vendor demo of building agent apps on MCP; expect Red Hat's own platform in it.
Made by the Prompt Engineering channel, 15 January 2026, the day after tool search reached Claude Code. An independent explainer of the context bloat problem and the fix.
| Video | Channel | Date | What it covers |
|---|---|---|---|
| MCP: When to Use It (And When You Shouldn't) | AWS Developers | 11 Aug 2026 | When MCP fits |
| Building Agentic AI apps with Model Context Protocol | Red Hat | 26 Jan 2026 | Agent app demo |
| Anthropic Just Fixed MCP's Biggest Problem | Prompt Engineering | 15 Jan 2026 | Tool search |
| Anthropic's New MCP Blog Post is Huge | An AI tutorial channel | 6 Nov 2025 | Code execution with MCP |
| BeSA Workshop Walkthrough: Building GenAI Tools with MCP | BeSA Cloud Academy | 21 Mar 2026 | Building tools, workshop |
Where this advice is weak
Short answer: the protocol changed in July 2026 and SDKs adopt versions on their own schedules, tool limits depend on the model, and I have no published benchmark of tool counts for marketing agents.
- The 30 to 50 tool figure comes from Anthropic's docs for Claude. Other models and clients behave differently, and the Reddit numbers vary widely.
- The 150,000 to 2,000 token example is one case from Anthropic, not a general result.
- Some framework MCP features, including the Claude API connector and LangChain's
langchain.mcp, are labelled beta on 18 November 2026. - Download counts overstate real usage; treat the chart as a trend.
Want help building a marketing agent with the right tools?
Short answer: I design small, read-first marketing agents: the job, the toolset, the approvals and the tests, then hand them over with notes your team can run.
My AI marketing agents service covers reporting, research and campaign-check agents built on MCP tools, with permissions set so nothing changes without a person's yes. Rates are on the pricing page.
Sources
| Source | What it supports | Date | Link |
|---|---|---|---|
| MCP versioning | Current version 2026-07-28 | Read 18 Nov 2026 | modelcontextprotocol.io |
| MCP key changes 2026-07-28 | Stateless, discover, deprecations | 28 Jul 2026 | modelcontextprotocol.io |
| MCP tools specification | Human in the loop, annotations, schemas | 2026-07-28 | modelcontextprotocol.io |
| MCP client best practices | Progressive discovery, 1 to 5 percent | Read 18 Nov 2026 | modelcontextprotocol.io |
| MCP security best practices | Attacks and mitigations | Read 18 Nov 2026 | modelcontextprotocol.io |
| MCP extensions | Apps, Tasks, Skills, Server Cards | Read 18 Nov 2026 | modelcontextprotocol.io |
| MCP Registry | Preview, namespaces, no scanning | Read 18 Nov 2026 | modelcontextprotocol.io |
| MCP SDKs | 10 official SDKs and tiers | Read 18 Nov 2026 | modelcontextprotocol.io |
| Anthropic news | Agentic AI Foundation, 10,000+ servers | 9 Dec 2025 | anthropic.com |
| Claude tool search docs | 55k tokens, 30 to 50 tools, 85 percent | Read 18 Nov 2026 | platform.claude.com |
| Claude API MCP connector | Tools only, HTTPS, pinning | Read 18 Nov 2026 | platform.claude.com |
| Claude Agent SDK MCP | Transports, allowedTools, 25,000 tokens | Read 18 Nov 2026 | code.claude.com |
| OpenAI Agents SDK MCP | Transports, filters, approvals | Read 18 Nov 2026 | openai.github.io |
| Google ADK MCP tools | McpToolset, tool_filter | Read 18 Nov 2026 | adk.dev |
| LangChain MCP | langchain.mcp in beta | Read 18 Nov 2026 | docs.langchain.com |
| Anthropic: writing tools | Tool design principles | 11 Sep 2025 | anthropic.com |
| Anthropic: code execution | 150,000 to 2,000 tokens example | 4 Nov 2025 | anthropic.com |
| npm downloads API | SDK download chart | Fetched 18 Nov 2026 | api.npmjs.org |
| X and Reddit posts | Practitioner reports | Jul 2025 to Nov 2026 | Linked in the table above |
This article expands on my post on LinkedIn ↗.
FAQ
What are MCP tools for AI agents?
MCP tools are actions an MCP server offers to an AI agent, each with a name, a plain-language description and an input schema. The agent's host lists them, the model picks one from the descriptions, and the server runs it with its own credentials.
What is the difference between MCP tools, resources and prompts?
Tools are actions the model decides to call, such as fetching a report. Resources are data the app or user chooses to attach, such as a brand guidelines file, and prompts are saved templates the user picks. Only tools are run on the model's own decision.
What is the current MCP version?
The current Model Context Protocol version is 2026-07-28. It made requests stateless, added a required server/discover call, moved long-running tasks into an extension and deprecated Roots, Sampling and Logging.
How many MCP tools can an AI agent handle?
Anthropic's documentation says Claude's ability to pick the right tool degrades once you exceed 30 to 50 tools. Past that point, use tool search to load tools on demand, split work across agents, or group tools into profiles.
Which agent frameworks support MCP?
The Claude Agent SDK, the Claude API MCP connector, the OpenAI Agents SDK, Google's Agent Development Kit and LangChain all connect to MCP servers. Each lets you limit which tools the model sees, and some, such as the Claude API connector, are still labelled beta.
Are MCP tool annotations like readOnlyHint reliable?
No, not on their own. The MCP specification says clients must treat tool annotations as untrusted unless they come from trusted servers, so a read-only label is a hint. Enforce read-only access with the account role and login scopes as well.
Where can I find MCP servers?
Start with the tool vendor's own documentation, then the official MCP Registry, which lists public servers with verified namespaces. The registry is in preview and does not scan server code, so check community servers before you install them.
Who owns the Model Context Protocol now?
Anthropic donated MCP to the Agentic AI Foundation, a fund under the Linux Foundation co-founded by Anthropic, Block and OpenAI, on 9 December 2025. The specification is developed in the open through proposals on GitHub.
How do I make MCP tools safe for marketing data?
Start read-only with a reporting role, give each server the narrowest login, require a person to approve anything that spends, publishes or contacts a customer, and log every tool call. The MCP specification says there should always be a human able to deny tool calls.






