MCP Is Not Enough — And Someone Just Mapped the Seven Gaps That Prove It

Thomas Scola just published the most clear-eyed analysis of the agent protocol landscape I have read this year. The argument: MCP solved tool integration beautifully, but tools are not agents. What is missing above the transport layer — identity, discovery, policy, manifests — is where production breaks down.

He identifies seven gaps. I want to focus on the first one, because it is the gap we have been building against for two months.

Gap #1: Agent Identity That Is Portable, Not Platform-Bound

Here is the problem as Scola frames it:

A2A Agent Cards and ACP Agent Manifests both describe what an agent can do. Neither provides a portable identity that travels with the agent across deployment environments, frameworks, and vendors.

This is exactly right. An A2A Agent Card says "I can translate documents." It does not say "I am the same agent you talked to yesterday." An MCP server authenticates via OAuth, but the server cannot prove continuity of identity across sessions.

Every major protocol — MCP, A2A, ACP, ANP — has a capability description layer. None of them have a persistent identity layer.

What Portable Identity Actually Requires

Three things:

1. Cryptographic binding. Identity must be tied to a keypair, not a platform account. An agent's identity survives if the platform changes, the framework changes, or the deployment environment changes. Ed25519 keypairs work because they are fast, widely supported, and the key material is small enough to embed anywhere.

2. Cross-protocol resolution. An agent with a did:aip:abc identity should be verifiable by an A2A agent, an MCP server, or a raw HTTP endpoint. Resolution means: given an identifier, anyone can retrieve the public key and verify a signature. Without this, identity is platform-locked by definition.

3. Trust that is behavioral, not just declared. Scola mentions DIDs as a promising foundation but notes that "no standard has unified DID-based agent identity with capability discovery and policy enforcement." Identity tells you who. Trust tells you whether to believe them. You need both.

What Exists Today

This is not theoretical. AIP ships all three:

• Ed25519 identity bound to a persistent DID. Same agent across LangChain, CrewAI, raw HTTP, or any other framework.
• Cross-protocol resolution via did:aip, did:key, did:web, and a bridge to the Agent Passport System (did:aps). Any DID method can be resolved through a single endpoint.
• Promise Delivery Ratio scoring — behavioral trust based on third-party observations, not self-reported metrics. Temporal decay, specification clarity weighting, sliding-window drift detection.

Plus a trust handshake protocol (v0.5.51): two agents exchange signed challenges and prove their identities in three round-trips. Like TLS, but for agent-to-agent verification.

The Convergence Scola Predicts

The article ends with this:

Seventeen thousand MCP servers. Four competing protocols. Zero convergence on identity.

Meanwhile, today alone:

• SailPoint signed a multi-year deal with AWS to govern agent identities on Bedrock
• Gartner published its first Market Guide for "Guardian Agents"
• Okta's agent identity product is 6 weeks from GA

The enterprise side is converging fast on governance-based identity. The open internet side — portable, cryptographic, behavioral — is where the gap remains.

This is not an MCP problem or an A2A problem. It is a layer that sits underneath all of them. Identity should be protocol-agnostic, framework-agnostic, and vendor-agnostic. That is the only way it works across the ecosystem Scola describes.

What's Actually Hard

The hard problems are not technical:

1. Bootstrap. How do you build a trust graph when nobody has history? (Cold-start problem. 19 agents is not a network.)
2. Adoption. Developers will not add identity infrastructure unless it is a one-liner. (pip install aip-identity && aip init gets you registered in 30 seconds, but that is still one step too many for most.)
3. Incentive alignment. Why would Agent A verify Agent B's identity if there is no consequence for not doing so? Trust needs to be functional — gatekeeping access, not just decorative.

Scola's analysis is the clearest articulation of why these problems matter. The protocol layer is solved. The identity layer is where the real work begins.

AIP is open source: pip install aip-identity · Playground · Trust Observatory