Who Watches the Connectors? The Governance Gap in Agentic Integration
Photo: Raimond Spekking, CC BY-SA 4.0, via Wikimedia Commons
A new integration layer, assembled quietly
Over the past two years, the Model Context Protocol has moved from a developer convenience to a default plumbing standard for connecting AI agents to enterprise systems. It offers a common way for a model to discover tools, read data, and take actions across applications. That is its appeal. It is also the reason a new integration surface is forming outside the controls that enterprises spent a decade building around APIs.
Traditional API governance assumes a human or a known service calls an endpoint with a defined scope. MCP changes the shape of the interaction. An agent may call several tools in sequence, interpret the results, and decide what to do next. The connector — the MCP server that exposes a system's capabilities — becomes a delegation point. Whoever configures that connector decides, in practice, what the agent can see and do.
The anatomy of MCP sprawl
Sprawl rarely announces itself. It begins with a pilot: a team connects an agent to a ticketing system, then to a document store, then to a CRM. Each connector is easy to stand up, often with a few lines of configuration and a service account. Because the work happens inside application teams rather than the central platform group, it bypasses the architecture review that a new API integration would trigger.
Three patterns follow. First, unmanaged endpoints: MCP servers running on developer laptops, in side projects, or in cloud accounts outside the approved landing zone. Second, permission creep: connectors granted broad service-account scopes because narrowing them takes time, leaving an agent able to read more than its task requires. Third, shadow connectors: third-party or open-source MCP servers installed without review, sometimes wrapping internal systems in ways nobody has documented.
Three failure modes worth naming
The risks are not hypothetical. Prompt injection through tool output remains the most cited: a malicious document or record causes the agent to take an unintended action using the connector's credentials. Credential leakage is the second: an MCP server configured with a long-lived token becomes an attractive target. The third is quieter — audit gaps. If an agent acts through a connector, can the organization reconstruct what happened, on whose behalf, and with what data? Traditional API logs may capture the call but not the reasoning chain that produced it.
A lightweight governance checklist
The answer is not to ban MCP. The protocol is becoming too useful, and prohibition will simply push usage further underground. The answer is to extend existing integration governance to cover it.
Discovery. Maintain a registry of MCP servers and connectors, including owner, purpose, systems exposed, and environment. Automated scanning can find running endpoints; a lightweight registration requirement catches the rest.
Approval. Require a short review before a connector touches production data. The review should cover the tools exposed, the credentials used, the data classification, and the human accountable for the agent's behavior.
Least privilege. Issue scoped, short-lived credentials per connector rather than shared service accounts. Where possible, bind permissions to the initiating user's identity rather than a superuser token.
Monitoring. Log tool calls with the agent identity, the initiating user, the connector, and the data touched. Alert on anomalous sequences, not just volume.
Kill switches. Every connector should be revocable without taking down the underlying system. Test the revocation path before you need it.
The governance question is an ownership question
The deeper issue is organizational. MCP connectors sit between application teams, security, and platform engineering. If no group owns the registry, sprawl is the default. Assigning a product owner for the connector layer — someone who maintains the catalog and the review process — is more effective than a policy document.
Enterprises that treated APIs as products eventually built gateways, catalogs, and lifecycle management. The agentic integration layer deserves the same discipline, applied with a lighter touch. The alternative is a growing set of connectors that nobody can enumerate, permissioned more broadly than anyone intended, acting on behalf of agents that nobody is watching.