What is the difference between RAG and agent memory?

The difference is where the knowledge comes from. RAG retrieves documents that people deliberately wrote and indexed, such as manuals or runbooks. Agent memory holds what the agent learned from earlier tasks, such as the real cause of a past error, and it can write new entries back.

What are agent skills?

Agent skills are packaged instructions for one kind of task, sometimes with code attached. They list steps and the judgment around them, such as when to stop and escalate. The agent loads a skill only when the task needs it, which keeps the context window small.

Do I need MCP if I already use RAG?

They solve different problems. RAG retrieves stored documents, while MCP is a standard way for an agent to call outside systems such as logs, metrics or APIs. In practice a RAG index is often exposed through an MCP server, so the two work together rather than replacing each other.

All video notes

Video notes · Agent memory

Skills vs MCP vs RAG vs Memory: What AI Agents Need to Know

Video by IBM Technology on YouTube · 9 min · uploaded September 2026

Notes and analysis by BrainTube, written from the video. Not affiliated with IBM Technology. Watch on YouTube

In short

The video sorts four ways of giving an agent knowledge by what each one supplies: skills give a procedure, MCP gives access to live systems, RAG gives documents people wrote, and memory gives lessons the agent learned itself. That rule of thumb is sound and easy to remember. It treats the four as separate boxes, though, when in practice they stack, and it says nothing about the risks of letting an agent write its own memory.

The argument

The argument starts from a failure mode. Faced with a 500 error on a checkout page, the instinct is to paste runbooks, dashboards and customer history into the context window and let the agent sort it out. The presenter says this lets the agent wander into dead ends or act in a generic way that ignores how this system really works. The alternative is to give the agent each kind of knowledge through the mechanism built for it, and only when the task needs it. A triage skill says what to check first and when to stop. MCP lets the agent read the logs and metrics the skill points to. RAG brings in documentation such as dependency maps. Memory brings back what happened the last time this error appeared, and records the fix when it is solved. Each covers a gap the others leave.

Key ideas, with timestamps

0:48
Why stuffing the context fails
The starting point is a checkout page returning a 500 error. Dumping runbooks, dashboards and customer history into the context window seems thorough, but at 1:35 he says it leaves room for the agent to get lost or behave in a generalised way that does not match this page.
2:19
Skills: a procedure plus judgment
A skill is a set of instructions for one kind of task, sometimes with code attached. The agent loads it only when the task calls for it, which he calls progressive disclosure. That keeps unused procedures out of the context.
2:53
The triage skill
His example skill says to check the error rate first and then the status of recent deployments. At 3:19 he adds that a good skill also says when to stop poking around and escalate to a person, which is knowledge no model has from training data.
3:47
Where skills stop
A skill can tell the agent to check the error rate, but it cannot read the dashboard. He uses this gap to introduce MCP, so each mechanism is defined partly by what the previous one cannot do.
4:22
MCP: reach into live systems
He describes the agent as the MCP host and each system it talks to as sitting behind an MCP server. The logging stack's server knows how to query that backend and exposes it as something the agent can call. At 5:08 the agent pulls logs and metrics and reads the real error rate.
5:55
RAG: documents people wrote
Retrieval augmented generation pulls in only the relevant chunks when needed, instead of loading everything up front. For the checkout error he points it at manuals and dependency maps, retrieved by semantic search from a vector database.
7:03
Memory: what the agent learned
Memory looks like RAG but differs in source. RAG reads documents a person put there on purpose. Memory holds what the agent picked up itself, such as the real cause of this error last time, which was never in the runbook. At 7:59 the agent writes the new fix back for next time.
8:17
The rule of thumb
Written-down knowledge is RAG. Knowledge from experience is memory. A repeatable procedure is a skill. Looking something up in the outside world is MCP. It fits in one sentence, and that is its main strength.

What it gets right

The single running example is the best choice in the video. Showing all four mechanisms on one incident makes the point that they are complementary, not competing. Most comparisons pick a winner. This one shows why a real agent needs several.

The source-based split between RAG and memory is also useful. Asking who wrote the knowledge, a person on purpose or the agent from experience, is a clearer test than the storage technology, since both can sit in a vector database.

The point about judgment in skills is easy to miss and correct. A runbook that only lists steps leaves the agent to guess when it has done enough. A line about when to escalate is often the most valuable part of the skill.

What it leaves out

The four overlap in practice. MCP is a transport, not a kind of knowledge. A RAG index or a memory store is often exposed to the agent as an MCP tool, and MCP prompts can carry procedures much like skills. The rule of thumb tells you what kind of knowledge you have; it does not tell you how it reaches the agent.
Agent-written memory can be wrong. If the agent records a fix that worked by accident, it will repeat the mistake with confidence next time. Memory needs review, a way to correct or expire entries, and a record of where each entry came from. The video presents write-back only as a benefit.
People write memory too. Not every useful memory comes from the agent. A user's notes, saved articles and past research are knowledge a person collected for themselves, not documentation for a team. They fit neither box cleanly, and they are often the most useful context for personal work.
Retrieval is not only semantic. He describes RAG as semantic search over chunks. Exact strings such as error codes, service names and version numbers often match better with keyword search, and many systems combine the two. See semantic vs keyword search.
Access control. An MCP server that can read production logs, plus a memory the agent writes to, is a real security surface. The video does not mention scoping what each server can see or do.

How this applies to memory across AI tools

The video assumes one agent with one memory. Most people now use several assistants, and each keeps its own memory, so a lesson learned in one is missing in the next. The fix is to keep knowledge outside any single assistant and let each one reach it the same way. In the video's own terms, MCP becomes the delivery route for RAG and memory, not a separate box.

That is the idea behind an AI memory layer. BrainTube is one example for the knowledge you collect yourself: it saves YouTube videos with their transcripts, articles, PDFs and podcasts into one compiled knowledge base and exposes it as an MCP server, so Claude, ChatGPT, Cursor and other MCP clients can search it. Whatever tool you use, apply the video's test first: decide whether a piece of knowledge is a procedure, a document, a live lookup or a learned lesson, then store it where that kind belongs.

Who should watch it

Watch it if you are designing an agent and want a quick mental model for where each kind of knowledge should live. It is nine minutes and fully watchable, but 8:17 to 8:52 gives the whole rule of thumb if you are short on time, and 7:03 is the clearest part on how memory differs from RAG. Skip it if you want implementation detail. There is no code, no specific products and no discussion of how to build or govern any of the four.

Frequently asked

What is the difference between RAG and agent memory?: The difference is where the knowledge comes from. RAG retrieves documents that people deliberately wrote and indexed, such as manuals or runbooks. Agent memory holds what the agent learned from earlier tasks, such as the real cause of a past error, and it can write new entries back.
What are agent skills?: Agent skills are packaged instructions for one kind of task, sometimes with code attached. They list steps and the judgment around them, such as when to stop and escalate. The agent loads a skill only when the task needs it, which keeps the context window small.
Do I need MCP if I already use RAG?: They solve different problems. RAG retrieves stored documents, while MCP is a standard way for an agent to call outside systems such as logs, metrics or APIs. In practice a RAG index is often exposed through an MCP server, so the two work together rather than replacing each other.

Keep videos like this one searchable

BrainTube saves YouTube videos with their transcripts into one compiled knowledge base that Claude, ChatGPT, Cursor and other MCP clients can search.

Start free

Skills vs MCP vs RAG vs Memory: What AI Agents Need to Know

In short

The argument

Key ideas, with timestamps

Why stuffing the context fails

Skills: a procedure plus judgment

The triage skill

Where skills stop

MCP: reach into live systems

RAG: documents people wrote

Memory: what the agent learned

The rule of thumb