TL;DR: The Model Context Protocol (MCP) is an open protocol for connecting AI applications to the systems where work happens: your CRM, ERP, ticketing and document stores. A server exposes tools (actions), resources (data) and prompts (templates), and any compatible AI assistant can use them. The current specification is dated 2026-07-28 and makes the protocol stateless, and MCP has been governed under the Linux Foundation's Agentic AI Foundation since December 2025. Connecting an assistant to business systems is now easy; connecting it safely is the work. The specification's own rules give you the starting point: OAuth 2.1-style authorisation with tokens issued for your server and nothing else, no token passthrough, tool descriptions treated as untrusted, and a human able to deny tool calls. Add least-privilege scopes, read-only defaults, approval for anything that changes money or customer records, and an audit trail of every call.
What MCP is, in one paragraph
Before MCP, every pairing of an AI assistant and a business system needed its own integration. MCP standardises that connection. An MCP server wraps a system, say your CRM, and describes what it offers. An MCP client inside a host application (a desktop assistant, an IDE, your own chat interface or agent) discovers those capabilities and lets the model use them. Messages are JSON-RPC, carried over one of two transports: stdio, for a local server launched as a subprocess, or Streamable HTTP, where each message is an HTTP POST to a single endpoint. The older HTTP+SSE transport is deprecated.
The building blocks
| Primitive | What it is | CRM or ERP example |
| Tools | Functions the model can call | search_contacts, create_quote_draft, check_stock |
| Resources | Context and data the application can read | An account record, a price list, an open purchase order |
| Prompts | Templated messages and workflows offered to users | "Summarise this account before a renewal call" |
| Elicitation (client) | A way for a server to ask the user for missing input | Asking which of three matching customers was meant |
What changed in 2025 and 2026
MCP has moved quickly, and a lot of tutorials describe an older version. The points that matter for a business integration:
- 2025-06-18 classified MCP servers as OAuth resource servers, required clients to use Resource Indicators (RFC 8707) so a token is bound to the server it is meant for, added structured tool output and elicitation, removed JSON-RPC batching, and added a Security Best Practices page.
- 2025-11-25 made OAuth Client ID Metadata Documents the recommended way for clients to register, added incremental scope consent and URL-mode elicitation, and introduced experimental tasks for long-running work.
- 2026-07-28, the current version, made the protocol stateless: it removed the
initialize handshake and protocol-level sessions (including the Mcp-Session-Id header) and added a server/discover request. Tasks moved into an official extension. Roots, sampling and logging were deprecated, and Dynamic Client Registration (RFC 7591) was deprecated in favour of Client ID Metadata Documents. The authorisation rules were tightened with issuer validation (RFC 9207). A deprecation policy now promises a minimum twelve-month window before deprecated features are removed.
Statelessness is good news for business systems: an MCP server can sit behind an ordinary load balancer like any other stateless API, and each request carries what it needs to be authorised on its own.
Governance: who owns MCP now
Anthropic introduced MCP as an open standard in November 2024. On 9 December 2025 the Linux Foundation announced the Agentic AI Foundation (AAIF), with MCP as one of its founding projects alongside Block's goose and OpenAI's AGENTS.md. Changes to the protocol go through Specification Enhancement Proposals (SEPs), public design documents that move through review to acceptance; standards-track SEPs need conformance tests before they become final. The official MCP Registry, a catalogue of publicly available servers, launched in preview in September 2025 and was still a preview, with possible breaking changes, when we checked. Treat any registry, official or not, as a discovery tool, not a statement that a server is safe.
Designing an MCP server for a CRM or ERP
Start from tasks, not tables
The quickest MCP server is a thin wrapper that exposes every API endpoint as a tool. It is also the riskiest and usually the least useful: models choose better between a few well-described, task-shaped tools than between dozens of generic ones. Design tools around the jobs people actually ask for: "find an account and its open opportunities", "draft a quote for these items", "show overdue invoices for this customer". Each tool should have a narrow input schema, validated server-side, and return only the fields the task needs.
Separate reading from writing
Give read and write operations different tools and different scopes. A sales assistant may only ever need to read. When it does need to write, prefer tools that create drafts (a draft quote, a draft email, a proposed journal entry) that a person confirms in the business application, over tools that commit changes directly. Reserve direct writes for low-impact, reversible actions.
MCP lets servers annotate tools with hints such as readOnlyHint, destructiveHint, idempotentHint and openWorldHint. Set them accurately on your own servers, because clients use them to decide when to ask for confirmation. The defaults are cautious (a tool is assumed to be not read-only and potentially destructive). But the schema is explicit that these are hints, and that clients should never make tool-use decisions based on annotations received from untrusted servers.
Authorisation: the rules the specification already sets
For HTTP-based servers, MCP builds on OAuth. Authorisation is optional in the protocol, but any server exposing business data needs it. When implemented, the specification's requirements include:
- A protected MCP server acts as an OAuth 2.1 resource server and must publish Protected Resource Metadata (RFC 9728) so clients can find its authorisation server.
- Clients must include the
resource parameter (RFC 8707) in authorisation and token requests, binding the token to that server.
- Servers must validate that access tokens were issued specifically for them as the intended audience, and must not accept or pass on any other tokens.
- Tokens must not be put in URL query strings.
- Local stdio servers should not use this flow and should take credentials from their environment instead.
The Security Best Practices page adds that token passthrough is explicitly forbidden. An MCP server that simply forwards the token it received to your CRM's API breaks audience validation, makes audit trails meaningless and lets a stolen token be replayed. Instead, the server should exchange or hold its own credentials for the downstream system, acting on behalf of the authenticated user with that user's permissions. Note that OAuth 2.1 itself is still an IETF draft, not a final RFC; the MCP specification references a specific draft version.
Least privilege in practice
- User-level, not service-level, access. The assistant should see exactly what the signed-in user could see in the CRM or ERP, enforced by the business system's own permission model, not by instructions in a prompt.
- Narrow scopes. The specification's scope-minimisation guidance warns against wildcard or omnibus scopes such as
*, all or full-access. Define scopes like crm.contacts.read and erp.quotes.draft, and request more only when a task needs it (incremental consent).
- Short-lived tokens and a way for administrators to revoke a client's access.
- Tenant isolation checked on every call in multi-tenant systems, using server-side identity rather than any tenant ID the model supplies.
Prompt injection through data
Anything the model reads can contain instructions: an email body synced into the CRM, a supplier's note on a purchase order, a support ticket. If the same session can also call write tools, injected text can try to steer it into exporting data or changing records. OWASP lists prompt injection as the first risk in its Top 10 for LLM Applications. In May 2025, Invariant Labs showed an assistant connected to GitHub through MCP being led by a malicious public issue to leak data from private repositories, and called this kind of attack a "toxic agent flow". The defence is architectural: limit what a session that has read untrusted content can do next, and require human approval for sensitive actions, rather than hoping the model will refuse.
In April 2025 Invariant Labs described tool poisoning attacks: malicious instructions hidden in a tool's description, invisible to users but read by the model. A related rug pull is a server that changes its tool descriptions after a user has approved it. A malicious server can also "shadow" tools from a trusted server by describing how they should be used. The specification's answer is to treat tool descriptions and annotations as untrusted unless they come from a trusted server. In practice: only connect servers you control or have reviewed, pin versions, alert when a tool's description changes, and do not mix untrusted third-party servers into a session that holds CRM or ERP write access.
Ordinary software vulnerabilities
MCP tooling has had serious bugs of the familiar kind. CVE-2025-49596 was a remote code execution flaw in MCP Inspector before version 0.14.1, caused by missing authentication between its client and proxy. CVE-2025-6514 was an OS command injection in the mcp-remote package when connecting to untrusted servers. Both are rated critical in the US National Vulnerability Database. Keep MCP clients and servers patched, and for local servers, check what command will actually run: the specification requires clients to show the exact command without truncation before running a local server.
Other risks on the list
The Security Best Practices page also covers confused-deputy attacks on OAuth proxies (which must obtain per-client consent), server-side request forgery when clients run on servers and follow metadata URLs, and hijacking of state handles, which must never be treated as authentication. OWASP's MCP Top 10 project, still in beta, groups the risks into ten categories, from token mismanagement and scope creep to tool poisoning, shadow MCP servers and a lack of audit and telemetry.
Human approval and audit
The tools section of the specification says there should always be a human in the loop with the ability to deny tool invocations, and servers must validate inputs, implement access controls, rate-limit invocations and sanitise outputs. For CRM and ERP integrations, turn that into concrete policy:
- Approval tiers. Reads run freely within the user's permissions; drafts need the user to confirm in the host; changes to money, stock, prices or customer master data need confirmation in the business system itself, ideally with the business system's own approval workflow.
- An audit log per call. Record the user, the client application, the tool, its arguments, the result summary, and whether a person approved it. Store it where the AI client cannot alter it.
- Limits. Rate limits and maximum result sizes per tool, so a looping agent cannot export the customer table one page at a time.
- Monitoring. Alert on unusual patterns: bulk reads, writes outside working hours, new tools appearing, or descriptions changing.
A rollout plan
- Pick one workflow with a clear owner and a measurable baseline, such as preparing account briefings or answering stock questions.
- Build a read-only server first, with task-shaped tools and user-level OAuth.
- Threat-model it: what untrusted content can reach the model, which tools could cause harm, and what happens if a token leaks.
- Add drafts, then writes, one at a time, each behind approval and with an audit record.
- Allow-list clients and servers in your organisation, and keep a register of who connected what.
- Review monthly: usage, denied calls, incidents and specification changes.
For the wider design of agents that use tools like these, see our guide to AI agents for business.
How ApexlyTech can help
We build CRM and ERP systems, including Apex CRM and Apex ERP, and integrate AI assistants with business data. We can design and build MCP servers with task-shaped tools, OAuth-based access that respects your existing permissions, approval workflows and audit logging. See our AI and automation and custom software services, or contact us.
Frequently asked questions
What is the current MCP specification version?
2026-07-28. It made the protocol stateless by removing the initialize handshake and protocol-level sessions, moved tasks into an extension, and deprecated roots, sampling, logging and Dynamic Client Registration.
Who governs the Model Context Protocol?
MCP is a founding project of the Agentic AI Foundation under the Linux Foundation, announced on 9 December 2025. Changes go through public Specification Enhancement Proposals.
Can an MCP server pass the user's token on to our CRM API?
No. The specification forbids token passthrough. A server must only accept tokens issued for itself, and should use its own credentials for downstream systems while enforcing the user's permissions.
An attack in which malicious instructions are hidden in an MCP tool's description, which the model reads but the user usually does not. Connect only servers you trust, pin versions and watch for description changes.
Should an AI assistant be allowed to change ERP records?
Only for low-impact, reversible actions, or through drafts that a person approves. Changes to money, stock, prices or master data should go through the business system's own approval workflow, with every call logged.
Sources