Skills, MCP, RAG, memory: the four-layer stack that makes AI agents actually useful

01 Why a Model Alone Is Not an Agent

A large language model, on its own, is a text-in, text-out system. It can reason about a task, but it cannot read your files, call your tools, remember last week's conversation, or verify a claim against your documents. The gap between an impressive demo and a system that reliably does useful work is filled by infrastructure wrapped around the model — and in 2026, that infrastructure has settled into four recognizable layers: skills, MCP, RAG, and memory.

The four layers answer four different questions. Skills answer what an agent can do. The Model Context Protocol answers how it connects to the outside world. Retrieval-augmented generation answers what it knows beyond its training data. Memory answers what it remembers between sessions. Confuse the layers — treating retrieval as memory, or skills as tools — and you end up with systems that are brittle in exactly the places users notice first.

02 Skills: What an Agent Can Do

Skills are packaged, reusable task capabilities: discrete units of competence that an agent can invoke when a request matches. A skill might format a financial report, operate a specific piece of software, or run a quality-control checklist. The defining property is packaging — a skill bundles the instructions, examples, and validation steps needed to perform a task consistently, rather than relying on the model to improvise the procedure from a prompt each time.

The reuse property is what makes skills economically interesting. An improvised prompt that works once is a parlor trick; a skill that works a thousand times across thousands of sessions is an asset. Organizations that treat prompts as versioned, tested, packaged artifacts get agents that behave predictably, while organizations that treat prompting as folklore get agents whose quality depends on who wrote the last instruction. In practice, skills are where an agent's competence is engineered rather than assumed.

03 MCP: The USB-C Port for AI Connections

The Model Context Protocol, or MCP, is an open standard and open-source framework introduced by Anthropic in November 2024 to standardize how AI systems such as large language models integrate and share data with external tools, systems, and data sources. Per Wikipedia, it provides a standardized interface for reading files, executing functions, and handling contextual prompts. Before MCP, every integration between a model and an external system was bespoke engineering; after MCP, a tool exposes one standard interface and any capable AI system can consume it.

The USB-C analogy is worn but accurate: many different devices, one connector. MCP's decisive moment came when it was adopted by major AI providers including OpenAI and Google DeepMind, transforming it from one vendor's convenience into an industry-wide interface. For builders, that adoption decision matters more than any single feature of the protocol, because it means tooling written for MCP works across the whole frontier model landscape rather than for one provider's products only.

04 RAG: What the Agent Knows

Retrieval-augmented generation, or RAG, is the layer that keeps an agent honest about facts. Instead of answering purely from what was compressed into its parameters during training, a RAG-equipped system retrieves relevant documents at query time and grounds its answer in them. The model's role shifts from oracle to synthesizer: it reads what was retrieved and reports what the sources actually say.

RAG solves two problems training data cannot. First, freshness: a model's parameters are frozen at training time, but a retrieval index can be updated continuously. Second, provenance: answers can cite the specific documents that support them, which turns a black-box generation into a checkable claim. The trade-off is that RAG quality is only as good as retrieval quality — chunking, indexing, and ranking become the real engineering work, and a bad retrieval layer produces confident answers built on the wrong passages.

05 Memory: What the Agent Remembers

Memory is persistent state across sessions. Without it, every conversation starts from zero; with it, an agent can carry forward user preferences, project history, prior decisions, and learned corrections. Memory is what turns an agent from a service you interact with into a collaborator that accumulates context — and it is the layer with the most direct privacy implications, because what an agent remembers about you is a stored record someone must eventually govern.

Architecturally, memory splits along time scales. Working memory holds the current session's context. Long-term memory stores durable facts and preferences, often curated by the agent itself into summaries it can reload later. Episodic memory records what happened in past sessions so the agent can explain its own prior behavior. The hard engineering problem is not storage but curation — deciding what is worth remembering, what should decay, and what a user must be able to inspect and delete.

06 How the Layers Stack in Practice

Consider a concrete request: an agent is asked to reconcile this quarter's spending against the company travel policy. Memory recalls that this user's team files expenses in a particular format and that a similar reconciliation was run last quarter. RAG retrieves the current travel policy document — not a stale summary baked into training data. Skills supply a packaged reconciliation procedure rather than an improvised one. MCP connects the agent to the expense system and the document store through standard interfaces. The model coordinates the whole flow, but each layer contributed something the model alone could not.

The stack also explains a common failure pattern. When an agent gives a wrong answer, the fix is rarely a better model; it is usually the right layer. Out-of-date facts point at retrieval. Wrong-procedure execution points at skills. Failed tool calls point at MCP plumbing. Amnesia about prior interactions points at memory. Teams that can diagnose by layer fix agents in hours; teams that treat the system as an undifferentiated model re-prompt for weeks.

07 Limits and Governance

Every layer that makes an agent more capable also enlarges its attack surface and its audit surface. MCP means third-party servers are effectively supply-chain dependencies: a malicious or compromised tool server can feed a model poisoned context. RAG means retrieved documents must be trusted, access-checked, and cited — retrieval silently violates data permissions if it is not designed carefully. Memory means retention policy, deletion rights, and cross-user leakage become everyday engineering concerns. Skills carry their own weight: a packaged capability executed at agent discretion needs the same review, testing, and authorization model as production code.

The governance response is to treat the four layers as separable, accountable components rather than one opaque agent. Log which tool calls crossed which MCP boundaries. Keep retrieval citations attached to every grounded claim. Make memory inspectable and erasable. Version skills like software. None of this requires giving up capability — it requires accepting that in 2026, an AI agent is a small distributed system built around a language model, and small distributed systems live or die by the discipline of their interfaces.