Every product announcement this month mentions agents. Perplexity launched an enterprise platform that completed 3.25 years of work in four weeks. JP Morgan Payments partnered with Mirakl to enable autonomous payments by AI agents. MoonPay released an AI agent secured by a hardware Ledger signer. Agents are no longer theoretical. They are transacting.

But underneath these announcements, two very different architectural decisions are being made. One is about how agents connect to the world. The other is about how agents decide what to do once connected. The industry is treating them as interchangeable. They are not.

The Model Context Protocol is an open standard created by Anthropic for connecting AI applications to external systems. The analogy from the official documentation is straightforward: MCP is USB-C for AI. A standardised port that lets any compliant application connect to any compliant data source, tool, or workflow.

The architecture follows a client-server model. An AI application (the host) creates MCP clients that each maintain a dedicated connection to an MCP server. The protocol uses JSON-RPC 2.0 for communication and exposes three core primitives: tools (executable functions the agent can call), resources (data sources that provide context), and prompts (reusable interaction templates).

The ecosystem has moved fast. Claude, ChatGPT, Visual Studio Code, Cursor, and dozens of other clients now support MCP. Servers exist for everything from file systems and databases to Sentry, Slack, and Notion. Build an MCP server once and every compliant client can use it.

This is the infrastructure layer. MCP solves the question: how does an agent reach your systems?

Skills are something else entirely. Where MCP defines what an agent can access, skills define how an agent should behave when it gets there.

A skill encodes domain knowledge, decision-making patterns, and task sequencing. It tells an agent not just that a database query tool exists, but when to query it, what to look for, and how to interpret the results in context. Stanford's OpenJarvis framework builds this into on-device agents with three components: tools for functionality, memory for context, and learning mechanisms that improve decisions over time.

OpenAI approaches it differently. Their Responses API agent runtime wraps agents in hosted containers with shell access, file persistence, and state management. The agent knows what it can do because MCP-style tool definitions tell it. The agent knows what it should do because skill-level guidance shapes its behaviour.

As MarkTechPost noted in a detailed comparison published today, MCP operates as an infrastructure layer providing standardised access to external resources. Skills function as capability enhancements that determine how models deploy the tools they have been given.

An agent with MCP connections but no skills has access to everything and judgement about nothing. It can query your database, call your APIs, and read your files. It does not know which queries are appropriate, which API calls are safe, or which files contain sensitive data. This is the equivalent of giving a new hire the admin password on their first day with no training.

An agent with skills but no MCP connections has the opposite problem. It knows exactly what it should do. It understands the domain, can reason through decisions, and follows appropriate workflows. It just cannot reach any of the systems it needs to act on. A skilled driver with no car.

The real-world consequences are visible in production. Context Gateway, an open-source project that launched on Hacker News this week, solves an infrastructure problem: agent conversations consume tokens until they hit context limits, so it compresses history in the background. That is an MCP-layer concern. But deciding what context to preserve and what to compress requires skill-layer judgement about which information matters for the task at hand.

This distinction becomes particularly sharp in financial services, where the cost of a wrong decision is measured in money, not just incorrect text.

JP Morgan Payments and Mirakl are building agentic commerce infrastructure that enables autonomous payments by AI agents. The MCP-layer problem is connection: how does an agent authenticate with payment rails, submit transactions, and receive confirmations? The skill-layer problem is judgement: when should the agent authorise a payment, what verification steps are required, and under what conditions should it escalate to a human?

MoonPay made the skill layer explicit by requiring hardware signing for every transaction its agent processes. The agent has MCP-level access to execute crypto transactions. The skill-level constraint says every transaction must be verified and signed on a physical Ledger device. Infrastructure access, bounded by behavioural rules.

Mastercard is building a virtual C-suite of AI agents for small businesses. Each agent needs connections to financial data, accounting systems, and payment networks (MCP). Each agent also needs domain expertise in its functional area, whether that is CFO-level financial planning or CMO-level marketing strategy (skills). The protocol gets them connected. The skills make them useful.

As we explored in our analysis of how agentic commerce went live, the companies moving fastest are the ones solving both layers simultaneously.

If your agents cannot reach your systems, you have an MCP problem. Start there. Define your tools, expose your data sources, and build compliant servers. The protocol is well-documented, the SDKs cover multiple languages, and the ecosystem of reference implementations is growing weekly.

If your agents can reach everything but make poor decisions, you have a skills problem. This is harder. Skills require domain expertise, careful prompt engineering, and iterative testing against real scenarios. There is no universal protocol for encoding business judgement. Stanford's OpenJarvis, OpenAI's agent runtime, and Anthropic's own Claude Code all approach it differently.

Most teams, if they are honest, have both problems. The agents cannot reach half the systems they need, and when they do reach them, the decisions are inconsistent.

As we noted in our coverage of Pagos bringing MCP to payments data, the infrastructure layer is moving fast. The skills layer is where the competitive advantage lives.

Your agents can reach your systems. But can they make good decisions once they get there?