DEVOPSdigest

Since Anthropic released the Model Context Protocol (MCP) to give agents a standardized way to interact with third-party tools, we've seen a surge in adoption.

But connectivity is only half the equation.

Once you've connected your agents to Salesforce, Jira, Slack, and dozens of other systems, a more difficult set of questions emerges:

Which agents accessed what data?

Whose credentials did they use?

Where did that data move?

And who or what prompted the agent to make the tool call?

We've gathered feedback from hundreds of teams who were deploying agents in production. We consistently heard that MCP connects their agents, but it doesn't help them manage those connections at scale.

The Governance Gap

Most MCP implementations use broad API keys that grant blanket access to sensitive systems. When you need to rotate credentials, enforce least-privilege access, or revoke permissions for a specific user, you're stuck with manual processes that don't scale past a handful of agents.

Tool-calling observability is another blind spot. Traditional application monitoring tracks API latency and error rates, but it tells you nothing about whether an agent called the right tool, passed valid parameters, or accessed data it shouldn't have. When an agent inadvertently exposes customer PII or repeatedly hits an expensive API due to a logic error, you discover it when customers report the problem, not when it happens.

Compliance teams face similar challenges. Regulations like GDPR and CCPA require that you know what data you're processing and who has access to it. When agents process customer data across multiple systems, you need to demonstrate appropriate controls. That means logging every tool call with enough context to trace actions back to specific users, detecting when sensitive data moves between systems, and proving that you enforced access policies.

What Production Deployments Actually Need

The solution isn't just better logging or more granular API keys. What's needed is an orchestration layer that sits between your agents and the tools they access. This layer should handle credential management, enforce access policies, redact sensitive data before it reaches the agent, and provide full audit trails for every tool interaction.

Some teams are building this themselves. They're layering monitoring tools, implementing custom auth flows, and writing code to inspect and redact data in real time.

But implementing and maintaining all of this infrastructure and processes can be time and resource consuming. And it takes your engineers away from their core work, which includes improving your agents. So, in some cases you may want to adopt purpose-built platforms that handle these requirements out of the box.

Regardless of your approach, if you can execute it effectively, the governance problem won't keep you and your engineers up at night.