The full MCP stack: Tools, resources, and prompts

AI agents need more than a way to call actions. To work reliably across enterprise systems, agents need executable capabilities, trusted context, and reusable instructions.

That is why the Model Context Protocol, or MCP, defines three core primitives: tools, resources, and prompts.

Celigo supports all three through MCP servers, giving teams a governed way to expose actions, read-only context, and reusable instruction templates to compatible AI agents and MCP clients. Usage is tracked when each capability is invoked, helping teams understand consumption as agent workflows scale.

What the MCP protocol actually defines

MCP is not just tool calling with a different name. It defines three different ways for AI agents and applications to interact.

Tools: actions the agent can invoke

Tools are executable capabilities. They let an agent take an action, such as looking up data, triggering a process, running a transformation, or calling a defined integration operation.

Tools are model-controlled, meaning the model decides when to call the tool and what arguments to provide based on the task.

Resources: context the agent can read

Resources are read-only context that an agent or MCP client can use to ground its work. They can include reference files, schemas, policies, configuration details, or documentation.

Resources are application-controlled, meaning the host application determines what is exposed and when it is made available.

Prompts: reusable instruction templates

Prompts are reusable instruction patterns that guide how an agent approaches a task. Instead of starting every interaction from a blank instruction, teams can define consistent prompts for common workflows.

Prompts are user-controlled, meaning a person selects or invokes them intentionally.

Together, these three primitives help move AI agents beyond basic tool calling. Tools let agents act. Resources give agents trusted context. Prompts help teams standardize how agents approach repeatable work.

Tools: executable actions for AI agents

Tools are often the first MCP primitive teams adopt because they let an agent do something useful.

In Celigo, tools package defined logic as callable capabilities. A tool can represent a lookup, transformation, import, workflow step, or other reusable operation with defined inputs and outputs.

Through Celigo MCP servers, those tools can be exposed to compatible AI agents and MCP clients. That gives teams a way to make approved business capabilities available to agents without turning every workflow into a one-off script or custom integration.

Why tools matter

Tools give agents a controlled way to act across enterprise systems.

Instead of giving an agent broad access to an application, teams can expose specific capabilities with defined inputs, outputs, and boundaries. That helps agents take action while keeping the execution path structured and governed.

Example use cases

An MCP tool can help an agent:

• Look up an order status
• Retrieve account details
• Trigger a defined workflow
• Run a transformation
• Create or update a supported business record
• Check the status of an integration process
• Execute a reusable integration operation

The goal is not to give agents unrestricted access. The goal is to expose the right action, in the right way, through a governed MCP server.

Resources: trusted context agents can read

Tools let an agent act, but action without context can create risk.

Resources give agents a trusted source of reference material. In Celigo, MCP resources are read-only files from Celigo file storage that can be exposed through an MCP server. Agents can discover and read those resources at runtime.

That gives teams a way to ground agent behavior in approved context, such as:

• Policy documents
• Process documentation
• Data schemas
• Reference tables
• Configuration files
• Static documentation
• Business rules

Why resources matter

Resources help agents answer the question: “What should I know before I act?”

A resource is context the agent can consult. It is not a write channel. It does not trigger side effects. It gives teams a safer way to make approved reference material available to agents without building a custom integration for every file or source of context.

This matters in production because different agents should not operate from different assumptions. When teams expose approved resources through an MCP server, agents can ground their work in the same reference material.

Prompts: reusable instruction templates

Prompts help teams standardize how agents approach work.

Instead of relying on users to rewrite instructions every time, teams can define reusable prompt templates for common tasks. A prompt can guide an agent through a known process, structure the expected response, or apply an approved approach to a repeatable workflow.

Through Celigo MCP servers, prompts can be made available to compatible MCP clients and agents.

Why prompts matter

Prompts help turn ad hoc agent interactions into repeatable patterns.

A prompt can define how an agent should:

• Summarize operational status
• Investigate an issue
• Review a workflow
• Prepare a handoff
• Follow a policy
• Use specific context before responding
• Apply a standard format to a response

This gives teams more consistency. Instead of asking every user or agent to improvise, teams can publish reusable prompts that reflect approved ways of working.

Why tools, resources, and prompts work better together

Each MCP primitive solves a different problem.

A tool lets the agent act. A resource gives the agent context. A prompt gives the agent a repeatable approach.

Used together, they help create more reliable agent workflows — the integration capabilities to support the development and orchestration of AI agents, not just a callable API surface.

For example, an agent investigating a fulfillment issue might use a resource to read the approved troubleshooting guide, follow a prompt that structures the investigation, and call a tool to check the current order status.

That is the difference between an agent that simply calls functions and an agent workflow that is grounded, repeatable, and easier to govern.

Usage tracking across the MCP stack

Governance needs visibility.

Celigo tracks MCP usage across tools, prompts, and resources. An MCP call is counted each time one of these capabilities is invoked through an MCP server.

This helps teams understand how MCP capabilities are being used as agent adoption grows.

Usage tracking helps teams answer questions like:

• Which MCP capabilities are being invoked?
• How often are tools, prompts, and resources being used?
• Which capabilities are driving the most consumption?
• Is agent usage increasing over time?
• Do teams need to plan for additional capacity?

For enterprise AI implementation, this matters because unmanaged agent usage and costs can grow quickly. Usage tracking gives teams a clearer way to monitor consumption and plan for scale.

Governed AI agent workflows need all three

Basic tool calling can help an agent take action. But enterprise AI workflows need more than action.

They need context. They need repeatability. They need visibility. They need governance.

By supporting MCP tools, resources, and prompts through MCP servers, Celigo gives teams a stronger foundation for building AI agent workflows across enterprise systems.

Tools expose approved actions. Resources provide trusted context. Prompts standardize how agents approach common tasks. Usage tracking helps teams monitor how those capabilities are being consumed.

Together, they help teams move from experimental agent workflows toward governed AI implementation.