Skills, MCP and RAG: understanding the three layers of a business AI agent

Building a business AI agent involves more than choosing a capable language model. An agent may need company knowledge, access to external systems and clear instructions for completing a task. RAG, MCP and skills can address these needs, but they solve different problems. RAG helps an agent retrieve relevant information, MCP can connect it to external tools and data while skills teach it how to perform specific workflows. Marketplaces such as Agensi add a discovery layer by making reusable SKILL.md skills available for compatible AI agents.

What is the difference between skills, MCP and RAG?

The simplest distinction is to think about three questions. What does the agent need to know? What does it need to access? How should it perform the task?

RAG primarily addresses the first question by retrieving relevant information from a knowledge source. MCP addresses the second by providing a standard way for agents to interact with external tools and services. Skills address the third by supplying reusable instructions for particular tasks. Agensi’s own material makes the distinction between skills and MCP explicit: MCP concerns what an agent can access while skills concern how the agent approaches a task.

These layers can work separately, but combining them becomes particularly interesting when an agent needs to complete a real business workflow.

RAG gives an agent access to relevant knowledge

A language model’s existing knowledge is rarely enough for business use. Companies have internal policies, customer information, technical documentation, contracts and product data that an agent may need before it can provide a useful answer.

Retrieval-augmented generation, usually shortened to RAG, allows an application to retrieve relevant information from an external knowledge source and provide that information as context for the model. A typical implementation can involve document processing, chunking, embeddings, vector search, metadata and access controls.

Consider an internal HR agent answering a question about parental leave. The model may understand parental leave generally, but the employee needs an answer based on the company’s current policy. RAG can retrieve the relevant section before the agent responds.

RAG therefore improves what information is available to the agent. It does not, by itself, define a complete operational procedure for what the agent should do with that information.

MCP gives an agent tools it can use

Some workflows require more than retrieving documents. An agent might need to query a database, read a pull request, create an issue or interact with another business application.

Model Context Protocol, or MCP, provides a way to connect agents with external services and tools. The Agensi source material describes MCP connections as complementary to skills: an MCP connection can provide access to a pull request while a code review skill can tell the agent how that pull request should be reviewed.

This difference becomes important when defining agent architecture. Giving an agent access to a CRM does not teach it how a sales qualification workflow should operate. Access creates a capability. The procedure for using that capability still needs to be defined.

Skills tell the agent how to perform a task

Skills address that procedural layer. A SKILL.md skill is a structured instruction file that teaches a compatible AI agent how to handle a particular type of work. It is not executable code and it does not independently connect the agent to another service. Instead, the agent reads the instructions and follows them when the skill is relevant.

This makes skills different from one-off prompts. A team may repeatedly tell an agent to check code for security issues, follow specific testing conventions and report findings in a particular format. Those instructions can instead be captured in a reusable skill.

A skill can define elements such as:

• The steps the agent should follow
• The standards it should apply
• The checks it should perform
• The format expected for the result
• The circumstances in which the workflow is relevant

The result is an agent that can approach recurring work more consistently without requiring users to reconstruct the same detailed prompt each time.

Do all business AI agents need all three layers?

No. Architecture should follow the workflow rather than adding every available AI component.

A simple writing agent may only need a skill that defines the required writing process. An internal knowledge assistant could primarily depend on RAG because its main job is retrieving and explaining company information. An operational agent may need MCP when it has to interact with external systems.

A useful starting point is:

1. Use RAG when the agent needs specific or changing knowledge: examples include policies, manuals and internal documentation.
2. Use MCP when the agent needs to interact with external tools or services: examples include databases, development platforms and business applications.
3. Use skills when the task needs a repeatable method: examples include code review, testing, research or documentation workflows.

A more complicated agent may combine all three.

Scenario 1: an internal customer support agent

Imagine a support agent that handles questions about products, orders and company policies. RAG could retrieve approved support documentation so the agent answers using current information rather than relying solely on the model’s training.

If the agent also needs to check an order or create a ticket, it needs access to the relevant systems. An appropriate tool connection can provide that capability.

A support skill could then define the procedure. It might instruct the agent to identify the request, retrieve the necessary information, check defined conditions and escalate cases that fall outside its permitted scope. The three layers now serve separate functions inside one workflow.

Scenario 2: a software development agent

The distinction is even clearer in software development. A developer might want an agent to review a pull request according to the team’s standards.

The agent could use a connection to GitHub to access the pull request. Relevant project documentation could provide additional context about architecture and conventions. A code review skill could specify which security, logic and style issues should be checked and how findings should be reported.

Skills can also be shared at project level. Agensi’s material describes project-level SKILL.md files as a way for teams to standardise procedures such as code review, testing, architecture decisions and Git workflows. This means the procedural layer can become part of the team’s development environment rather than remaining in individual prompts.

Scenario 3: a sales research agent

A sales research agent may need current account information before preparing outreach. The workflow could retrieve internal knowledge about products, access CRM information through connected tools and use a specialised research or outreach skill to determine how the task should be performed.

Human oversight still matters. The agent might be allowed to research an account and prepare a draft while an employee approves external communication. Separating knowledge, access and procedure makes it easier to determine where those controls belong.

Why this separation matters for AI agent development

Thinking in layers can prevent teams from solving the wrong problem. A weak workflow is not always fixed by switching to a stronger model. The missing component may be information, tool access or procedural guidance.

Before adding functionality, development teams can ask three questions:

• Does the agent have the information required to make a useful decision?
• Does it have access to the systems required to complete the task?
• Does it have clear instructions for how the workflow should be performed?

The answers help identify whether the architecture needs RAG, MCP, skills or a combination.

This approach can also make testing more precise. If an agent retrieves the wrong policy, teams can investigate the retrieval layer. If it cannot perform an action, they can inspect tool access and permissions. If it has the right information and tools but follows the wrong process, the procedural instructions deserve attention.

More capabilities require clearer boundaries

Connecting these layers can make an agent more capable, but greater capability also increases the importance of permissions and human approval. An agent that only searches documentation has a different risk profile from one that can modify customer records or trigger financial actions.

Businesses should therefore decide which information an agent may retrieve, which tools it may use and which workflows require approval. The objective is not unlimited autonomy. It is enough autonomy to complete the intended task within defined boundaries.

Business AI agents are becoming modular systems

The architecture of an AI agent is increasingly easier to understand when its components are treated as separate layers. The model provides general reasoning capabilities. RAG can provide relevant business knowledge. MCP can expose tools and services. Skills can encode reusable procedures for completing specific work.

That modular approach also creates more flexibility. A business can change a knowledge source without redesigning every workflow or give two agents different skills while allowing them to access the same tools. Instead of trying to build one agent that somehow knows and does everything, development teams can assemble capabilities around the actual job the agent needs to perform.