Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallMCP resources, tools, and prompts are three different interfaces between a server and an agent. Resources supply context the application can read, tools expose actions the model can ask to run, and prompts package reusable interaction patterns. None of the three is a token-saving feature on its own. An agent’s input size changes according to what gets loaded into each request and when it gets loaded. The 114K-to-27K drop in this article is one author-reported result from one setup. It is a useful case study in selective loading, but it is not evidence that MCP reduces tokens by a fixed amount.
The three primitives as interfaces to an agent
Each primitive answers a different question for the agent: what information is available, what can be done, and which reusable pattern should frame the work.
As an Amazon Associate I earn from qualifying purchases.
| Primitive | What it gives the agent | Who decides when it is used | Typical example |
|---|---|---|---|
| Resources | Contextual data such as file contents, database records, or API responses | The client discovers and reads resources; the application decides how the data is used | A database schema description the app pulls in when a question needs it |
| Tools | Callable operations such as queries, API calls, or computations | The model can discover tool metadata and request a call; the client and server handle execution | A query tool that runs a read against a database |
| Prompts | Named, reusable message templates, optionally with arguments and examples | A user or the application selects a named prompt and receives its messages | A template with few-shot examples for writing reports |
The architecture documentation for the Model Context Protocol, in its 2026-07-28 revision, uses a database server to illustrate all three: a query tool, a schema resource, and a prompt containing few-shot examples. The tools and resource specification pages are versioned 2025-06-18. Check the revision your implementation uses before copying field names or behavior.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsHow each primitive behaves
Resources: information the application can make available
A resource is data the server exposes so the client can read it. Its contents enter a model request only when the application places them there. That control is the main reason resources matter for token use: a resource that is listed but never read costs little, while a large resource body pasted into every request costs a lot. Resources are a good fit for schemas, documents, and records that a task needs only sometimes.
#1 Best Overall
Tools: functions the model can ask to run
The MCP tools specification states that servers can expose tools that language models invoke. Each tool has a name, a description, and an input schema. Tool results can contain text, structured content, and resource links. Because the model reads tool metadata to decide what to call, every registered tool occupies space in the request whether or not it is used.
Tools can also cause side effects, such as writing data or calling an external service. The specification calls for a human to be able to deny invocations and for operations to be signaled to the user or confirmed. Those controls matter regardless of any token savings.
Prompts: packaged starting patterns
A prompt is a named template that can accept arguments and return messages. In the architecture example, a prompt carries few-shot examples so the model sees the expected pattern before it starts work. A user or application chooses the prompt, so prompts give control over framing rather than over data access or actions.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Rank #2
Where the tokens actually go
When people report large input counts for agents, the cause is usually one of these components, which travel in different parts of the request:
- Tool definitions registered with the request, including names, descriptions, and schemas.
- Resource contents inserted into the conversation.
- Prompt messages, including any examples they contain.
- Accumulated conversation history from earlier turns.
- Tool results returned to the model.
AWS Prescriptive Guidance (2026) makes the tool-definition case concrete. It notes that registering every discovered tool makes context use grow as the tool set expands, and gives an illustrative estimate of 250 to 500 tokens for a typical tool definition, or 5,000 to 10,000 tokens for 20 definitions. These are that guidance’s example figures, not benchmarks across MCP clients. Actual schemas, model wrappers, and serialization change the numbers.
Reducing tokens without breaking tool use
- Register only the tools a task needs. Where the client and server support it, filter tools by task category or use semantic search to expose a smaller relevant subset at runtime.
- Keep descriptions short but usable. A name and description must still let the model choose the right tool and build correct arguments. Shortening past that point saves tokens and produces wrong calls.
- Return pointers and summaries instead of bodies. A URI, a summary, or a targeted read often answers a task that a full resource dump would overload.
- Keep metadata stable and ordering deterministic. This can help clients cache tool lists. Caching is an implementation behavior, not a promise of lower billed tokens on every request.
- Measure everything together. Track task success, tool selection, latency, and actual input usage. A lower count is a gain only if the agent still completes the work.
What a 2026 study found about tool descriptions
The preprint Model Context Protocol (MCP) Tool Descriptions Are Smelly! (2026) analyzed 856 tools across 103 MCP servers. It reported that 97.1% of the descriptions had at least one identified quality problem, and that 56% did not state the tool’s purpose clearly. The paper’s findings come from its own sample and scoring method, so they should not be generalized to every agent.
The same study measured trade-offs when descriptions were improved:
| Change tested | Benefit reported | Cost or risk reported |
|---|---|---|
| Full description augmentation | Median task-success improvement of 5.85 percentage points; 15.12% improvement in partial-goal completion | 67.46% increase in execution steps; regressions in 16.67% of cases |
| Compact description variants | Reduced token overhead (size of the reduction not stated in the summary reviewed) | Effect on task success not stated in the summary reviewed |
The lesson is a trade-off rather than a rule: richer descriptions can help the model choose correctly while adding steps, and compact descriptions can save input while weakening selection.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Measuring input tokens accurately
OpenAI’s Help Center article “Understanding and counting tokens” (updated 2026) states: “The same text can produce different token counts depending on the model, its encoding, and the language.” It also notes that a plain-text count can leave out request structure, tool definitions, schemas, images, and files. API responses report actual input and output token usage, using field names that differ by endpoint. For a reliable figure, read the usage values the API returns, or count the full request with a method that matches the model, rather than estimating from character counts.
A before-and-after comparison is only meaningful if it follows these steps:
- Fix the model and its exact version, and keep sampling and other settings unchanged between runs.
- Define the metric: full request input tokens, tool-definition tokens alone, or cumulative conversation tokens. Report only one per comparison, or label each separately.
- Record the tokenizer or API endpoint used, and the field name it reports input usage under.
- Run the same user task before and after each change.
- Change one primitive or setting at a time, so each effect can be attributed.
- Report cached input and reasoning tokens separately, and state how each was handled.
- Record task completion, output quality, and latency alongside the token count.
What the 114K-to-27K result does and doesn’t show
The 114,000 and 27,000 figures come from one author’s own setup. No independent source reports the same before-and-after result. The difference is 87,000 tokens, or about 76% of 114,000, which is arithmetic on the reported numbers. The table lists the details that determine what those numbers mean. For this result, the details are not part of the reported figures:
| Detail needed to interpret the figures | Status in this report |
|---|---|
| Model and exact version | Not stated |
| Tokenizer or API endpoint used to count | Not stated |
| What the counts measure (full request input, tool definitions only, or cumulative conversation tokens) | Not stated |
| Whether messages, schemas, resource contents, output, cached input, and reasoning tokens are included | Not stated |
| Same task and model settings before and after | Not stated |
| Effect of each of the three changes, isolated | Not stated |
| Task success, output quality, and latency after the change | Not stated |
What the figures can support is narrow: in this setup, reducing what was loaded into each request lowered input size. They do not show that MCP itself cuts tokens by 76%, and they do not predict the same change for another agent, model, or task. A reader who wants the same gain should start with the measurement steps above and let the numbers from their own requests decide.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
