The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →An AI agent can be equipped in four distinct ways. Skills give it reusable procedures for a kind of task. MCP (Model Context Protocol) gives it a standard way to connect to tools and data. RAG (retrieval-augmented generation) pulls relevant passages from a document collection into a response at answer time. Memory carries selected state forward beyond the current context window. Each solves a different problem, and production agents often combine several of them.
Treat “learn” in the title as a practical metaphor. Each mechanism works by changing what the model sees, can reach, or can recall at run time. Nothing in the vendor documentation covered here shows these mechanisms updating a model’s weights, so this article does not assume that they do.
As an Amazon Associate I earn from qualifying purchases.
Skills: reusable procedures the agent loads when relevant
Anthropic’s Agent Skills are packaged as a directory. The core file is SKILL.md, which carries metadata that can be made available first. When a task calls for it, the agent loads the full instructions and any linked files. Anthropic calls this progressive disclosure: the agent sees enough to identify a useful skill, then pulls deeper detail only when it needs it.
The result is task-specific procedures, standards, and supporting material that stay out of the context until they matter. A skill works like a job-specific playbook the agent consults. It is not a connector protocol, and it does not retrain the model.
#1 Best Overall
Two limits matter. First, the format described here is Anthropic’s implementation. Other platforms may package or load procedural instructions differently, so do not assume a skill written for one will behave identically on another. Second, a skill tells the agent how to work; it does not give the agent access to a system. That access comes from tools, which is where MCP enters.
MCP: a standard connection between an agent and its tools and data
Anthropic’s MCP documentation defines the protocol this way: “MCP is an open protocol that standardizes how applications provide context to LLMs.” In practice, MCP sits between an AI application and servers that expose capabilities such as tools or data. The point is interoperability. A server built to the protocol can be reached by any client that speaks it, instead of each integration being written from scratch.
OpenAI’s Agents SDK documentation describes several integration modes for reaching MCP servers, including hosted MCP, Streamable HTTP, SSE, and stdio. These are different ways of hosting and connecting, not different kinds of capability. Which modes are available depends on the SDK version and the server.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
MCP does not provide a knowledge base, does not make answers correct, and does not tell the agent how to carry out a domain procedure. A server that exposes a search endpoint is offering a tool, and the quality of what comes back depends on the system behind that server.
RAG: retrieving corpus knowledge at answer time
Retrieval-augmented generation gives the model access to a body of documents while it answers. The pipeline Anthropic describes runs in four steps:
- Split the documents into chunks.
- Embed the chunks and index them.
- Use the incoming query to retrieve the most relevant chunks.
- Add the selected chunks to the prompt, and generate the response from them.
Retrieval comes in two common flavors. Semantic retrieval matches meaning, so it can find a passage that discusses a concept even when it uses different words. Lexical methods such as BM25 score exact term overlap, which helps when a product code, error string, or clause number matters. Semantic similarity alone can miss exact matches, which is why retrieval designs often combine both. Retrieval quality therefore depends on the corpus and on how retrieval is built, not only on the model.
Google Cloud’s comparison describes RAG’s primary goal as retrieving relevant information from a knowledge base before generation. It contrasts this with MCP, which standardizes interaction with tools and sources. RAG is a technique, not a protocol or product, so two RAG systems can differ widely in how they index, rank, and restrict access to their content.
Memory: keeping selected state across context resets and sessions
In agent design, memory usually means selected information stored outside the active context and recalled later. Anthropic’s documentation discusses structured note-taking, progress files that let an agent resume a long task, and a file-based memory tool. Each addresses the same problem: when the context window resets or a task spans many steps, the agent needs a way to keep what matters.
Memory is not the same as retrieving from a large reference corpus. Memory holds what has been established in the course of work, such as decisions made, open items, or stated preferences. RAG brings in passages from documents written for reference. The boundary can blur, because a system may store memories as files and search them, but the purpose differs: memory supports continuity, while RAG supports coverage of a body of knowledge.
Rank #4
“Memory” is not one standardized feature. A product’s memory tool has its own storage, scope, and controls, and the general pattern can be built on any storage layer. When you evaluate one, separate the pattern from the product that implements it.
How the four differ
| Question | Skills | MCP | RAG | Memory |
|---|---|---|---|---|
| Core purpose | Reusable procedural know-how for a task type | Standardized connection to tools and data | Relevant passages from a corpus, added at answer time | Selected state preserved beyond the active context |
| Where the information lives | Skill directory: SKILL.md plus linked files |
A connected MCP server or the service behind it | An indexed corpus of chunked, embedded documents | Persisted notes or files; storage depends on the product |
| When it enters the context | Metadata first; full instructions when relevant | When the agent invokes a tool or reads data the server exposes | On each query, as retrieved chunks | When recalled later |
| Can it take actions? | Not directly; it guides how the agent works with tools it already has | Yes, if the server exposes callable tools | Not directly; it adds information to the prompt | Not directly; it retains information that can shape later actions |
| Typical failure | An outdated or ill-fitting procedure gets loaded | Over-broad tool permissions, or a server returning poor data | A relevant passage is never retrieved; exact terms are missed by semantic-only search | Stale or wrong notes persist and keep being recalled |
| Freshness and governance | Depends on who maintains the files; the Anthropic overview does not prescribe a method | Set by the server and service; the protocol overview does not prescribe a method | Depends on index refresh schedule and on whether retrieval respects document permissions | Depends on the product’s write, retention, and deletion controls |
Where the lines blur
- An MCP server can expose retrieval. If a server offers a search tool over a document index, the agent is doing RAG through MCP. The protocol carries the call; it does not turn the index into a RAG pipeline.
- Memory can be stored and searched like RAG. Notes saved as files and retrieved by search look like a retrieval system. What separates memory is what gets written and why: the agent’s own working state, not reference material.
- Skills can link supporting files. The agent may read those files and then use tools it already has to act on the procedure. The skill itself remains instructions.
Putting them together: a returns-desk example
This is an illustrative design, not a prescribed architecture. Imagine an agent that handles product returns for an online store.
- Skill: the returns procedure, including eligibility checks, the order in which they run, and the format of the case note. It loads when a return request begins.
- MCP: a connection to the order system that can look up an order and, where permitted, submit a refund.
- RAG: a searchable index of current policy documents, so the agent can quote the exact clause on return-window exceptions.
- Memory: a note that this customer asked for an exception last month and was declined, so the agent does not reopen the question without new facts.
Each piece answers a different question: how to proceed, what the system allows, what the policy says, and what has already happened. Remove the memory and the agent can still process a return, but it loses continuity with earlier cases. Remove the MCP connection and it can explain the policy but cannot act on it.
Best Value
When combining them makes sense
- The agent lacks a how-to for a recurring task. Add a skill, and keep it procedural: steps, standards, and checklists.
- The agent must read or change a live system. Add MCP, and scope each tool’s permissions to what the task requires.
- The answer depends on a large body of documents that will not fit in the prompt. Add RAG. If the reference material is small enough to include directly, retrieval adds moving parts without a clear benefit.
- Work must persist across context resets or sessions. Add memory, and define in advance what gets written and how it is removed.
Stop adding layers once a single mechanism covers the need. A one-off question answered from a short document needs none of the four. A long, multi-session task that also edits a system will often need several. The test is which capability is missing, not how many features are available.
Checks before you build on these mechanisms
Vendor documentation on these topics changes quickly. The core MCP definition above comes from Anthropic’s MCP documentation, which may trail current releases, and the Agent Skills format is specific to Anthropic. Confirm version-specific details against the live documentation before writing integration code.
Quick Recap
- Confirm which MCP specification version your client and servers support, and which connection modes each one uses.
- Check whether your platform’s skill format matches the one described here before porting any skill.
- Establish who can write memory, how long entries are kept, and how a user or operator can delete them.
- For RAG, confirm when the index refreshes and whether retrieval enforces the permissions on each document.
- For MCP, confirm the authentication method and whether any tool can take a consequential action without a confirmation step.
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.
