TL;DR: OpenAPI-to-MCP gateways can rapidly turn existing APIs into agent-callable tools, but they do not define delegated authority, approval boundaries, or audit requirements, according to PermitIO. Without endpoint-level policy, teams create broad tool reach faster than they create control over what agents may actually do.
At a glance
What this is: NHI Mgmt Group's analysis, drawing on PermitIO's blog post: OpenAPI-to-MCP translation expands agent reach faster than most authorization models can govern, making endpoint-level policy the real control point.
Why it matters: IAM and NHI teams need to treat tool exposure as an authorisation problem, because turning endpoints into tools without per-call policy creates ungoverned delegated access.
Context
OpenAPI-to-MCP translation is the process of turning documented API operations into agent-callable tools. The security gap appears when teams treat that translation as authorisation, because schema-to-tool generation expands reach but does not decide who may act, under what business intent, or with what approval.
For NHI governance, the issue is not whether the endpoint exists. It is whether the generated tool inherits a defined delegated authority model, a resource boundary, and a durable audit trail before an agent can invoke it.
That distinction matters because a read-only API and a destructive API can look equally callable once surfaced as tools. The article's core claim is that tool discovery needs policy attached at the endpoint level, not only transport or OAuth controls.
Key questions
Q: What breaks when OpenAPI endpoints are exposed as MCP tools without endpoint policy?
A: The control that breaks is delegated authority. The agent can see and chain callable operations, but the organisation has not defined which principal may use them, for what intent, or with what approval. That creates broad reach without corresponding decision rights, which is a governance failure, not just a technical one.
Q: Why do endpoint filters and runtime policy solve different problems for MCP tools?
A: Endpoint filters decide what the agent can discover at build time, while runtime policy decides whether a specific call is allowed in the current context. Filters reduce obvious exposure, but only policy can account for delegator identity, resource scope, intent, and approval requirements. Teams need both, but they are not interchangeable.
Q: What do security teams get wrong about MCP and tool governance?
A: They often review each integration in isolation and miss the combined permission path. Two legitimate tools can create a new capability that neither one should have alone. Governance has to assess the full chain of action, because risk emerges from composition as much as from individual access rights.
Q: Should teams expose every OpenAPI operation as an MCP tool by default?
A: No. Teams should start with explicit allow-listing and risk classification, then add runtime policy for higher-risk actions. Auto-exposure is attractive because it is fast, but it routinely pulls in admin, destructive, or data-moving endpoints that were never meant for autonomous use.
Technical breakdown
How OpenAPI-to-MCP tool generation changes the control plane
An OpenAPI-to-MCP gateway parses an API specification into callable tools, then presents them through an MCP server so an agent can discover and invoke them. That move is useful for integration speed, but it also converts a static API surface into a live tool catalog. The governance problem starts when the catalog is built from method names and schemas alone, because semantics such as destructive action, customer-impacting action, or exfiltration-sensitive action are not automatically encoded in the spec. In identity terms, the gateway is translating discoverability, not deciding delegated authority.
Practical implication: Treat tool generation as exposure plumbing, not authorisation.
Why endpoint filtering is not the same as runtime authorisation
Endpoint filtering removes tools from the catalog before the agent can see them. Runtime authorisation decides whether a specific invocation is allowed in the current context. Those are different controls. Filtering can hide obviously unsafe endpoints such as admin or transfer operations, but it cannot answer who delegated the action, whether the current intent matches policy, or whether a high-risk call now needs approval. For generated tools, that distinction matters because the same endpoint can be acceptable for one principal and forbidden for another. Static hiding alone leaves the dangerous decision point inside the execution path.
Practical implication: Use build-time filtering only as a pre-screen, not as the final control.
Why auditability must include delegated authority and intent
Generated tools need more than request logs. To govern agent action, the record has to show the human delegator, the MCP session or agent identity, the exact OpenAPI operation invoked, the target resource, the policy version, and the approval status if one was required. That is what makes a tool call attributable and reviewable after the fact. Without those fields, the organisation can see that an action occurred but cannot prove why it was allowed or which principal accepted the risk. For NHI governance, that gap turns the agent into an opaque executor rather than a controlled delegate.
Practical implication: Log authority, intent, and policy decision data with every tool call.
Threat narrative
Attacker objective: The objective is to convert broad tool exposure into unauthorised destructive or exfiltration-capable action through a permissive agent execution path.
- Entry occurs when an entire OpenAPI surface is auto-published as MCP tools, making high-risk actions discoverable to an agent alongside harmless reads.
- Escalation follows when the agent can chain mixed-risk tools, such as read, create, delete, export, or transfer operations, without a per-call policy gate.
- Impact appears when destructive or data-moving calls execute under weak delegation controls, leaving the organisation unable to prove who authorised the action or why it was permitted.
Breaches seen in the wild
- Moltbook AI agent keys breach: Moltbook breach exposed 1.5M AI agent keys.
Read and download The State of NHI & AI Agent Breach Report 2026, covering 200+ breaches impacting Non-Human Identities including AI Agents.
NHI Mgmt Group analysis
Endpoint-level policy, not API connectivity, is the governing unit that matters. OpenAPI-to-MCP translation turns interface description into agent execution, but execution still needs a decision boundary. The article shows why capability exposure is easy and delegated authority is hard, which is exactly where identity governance has to sit. Practitioners should stop treating tool publication as an access decision.
Tool catalogs create an identity blast radius when semantics are flattened into schemas. Once GET, POST, DELETE, export, and transfer operations sit in the same generated surface, the agent sees executable capability rather than business risk. That is a governance failure because risk is no longer visible at the moment of invocation. The named concept here is endpoint-level policy debt: the longer the control is deferred, the larger the reach becomes before the organisation can classify it.
Human delegator context is the missing accountability layer in generated agent tools. Without it, actions are attributable only to 'the agent', which is not a governing principal. That breaks role-based and relationship-based decisions for support, finance, and customer-data workflows. The implication is that delegated authority must be explicit before tool execution, not reconstructed after the fact.
OAuth and transport controls remain necessary, but they are not sufficient for agent authorisation. The article correctly separates connectivity from decision-making, and that distinction matters for both NHI and agentic AI governance. A secure token exchange does not determine whether a destructive tool should be callable in the present context. Practitioners need to align authentication with per-action policy, approval, and audit semantics.
Generated MCP tooling is moving authorisation closer to the code path, not away from it. That shift validates a broader market direction: identity controls are becoming runtime controls for machine action, not only directory controls for users. Teams that do not re-evaluate endpoint policy now will accumulate invisible privilege in the tool layer. The practical conclusion is simple: govern the invocation, not just the connection.
From our research library:
- 24,008 unique secrets were exposed in MCP configuration files in 2025 alone, the protocol's first year of widespread adoption, according to the State of Secrets Sprawl 2026.
- AI-related credential leaks surged 81.5% year-over-year in 2025, with the surrounding AI infrastructure leaking 5x faster than core LLM providers, according to the State of Secrets Sprawl 2026.
- Read next: MCP Security Guide
What this signals
Endpoint-level policy debt: once OpenAPI operations are auto-published as tools, the organisation accumulates exposure faster than it accumulates decision rights. That means the security team has to govern the invocation path, not just the API surface, or the tool catalog becomes a standing privilege problem.
Access review processes are a poor fit for high-churn agent tooling because the control point is not who has a role in the directory, but which generated action can execute in the moment. That pushes practitioners toward per-call policy, approval, and short-lived credential issuance, especially where destructive or export-capable operations exist.
For practitioners
- Apply endpoint risk classification Classify generated tools by method and business effect before exposing them to agents, with read, create, and destructive actions placed in distinct trust bands.
- Require runtime policy checks Evaluate every tool call at execution time against delegator identity, target resource, intent, and approval status instead of relying on static exposure rules.
- Remove high-risk endpoints from default exposure Keep delete, revoke, export, and transfer operations out of the initial tool catalog unless a specific business case and governance path exist.
- Log delegated authority with each call Capture delegator identity, MCP session identity, operationId or path, policy version, approval metadata, and execution outcome in one audit record.
- Issue short-lived credentials only after policy approval Use server-side credential injection so the model never receives raw secrets, and scope any issued token to the approved action only.
Key takeaways
- OpenAPI-to-MCP translation expands agent capability faster than most authorisation models can explain or control.
- The main risk is not connectivity, but broad delegated reach without policy, approval, and audit attached to each call.
- Practitioners should classify generated tools, gate runtime execution, and preserve an audit record that ties actions back to a human delegator.
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
OWASP Non-Human Identity Top 10 and OWASP Agentic AI Top 10 address the attack and risk surface, while NIST CSF 2.0 sets the governance and control requirements practitioners need to meet.
| Framework | Control / Reference | Relevance |
|---|---|---|
| OWASP Non-Human Identity Top 10 | NHI-04 — Insecure Authentication | The article centers on delegated tool access and runtime authorisation for generated MCP calls. |
| NHI-05 — Overprivileged NHI | Auto-generated tools can expose far more capability than an agent should be allowed to invoke. | |
| Recommendation — Enforce runtime authorisation before tool execution and bind each call to a scoped delegated principal. Trim generated tool exposure to the minimum set of approved actions and deny high-risk defaults. | ||
| OWASP Agentic AI Top 10 | ASI03 — Identity & Privilege Abuse | The article describes agent action paths that need per-call privilege control rather than open tool reach. |
| ASI02 — Tool Misuse | Generated tools can be chained into unintended destructive or data-moving operations without policy. | |
| Recommendation — Apply per-action privilege checks before an agent can invoke sensitive tools. Restrict sensitive tool combinations and block unsafe chained execution paths. | ||
| NIST CSF 2.0 | PR.AA-05 — Access Permissions, Entitlements and Authorizations | The core issue is whether generated agent actions are authorised at the moment of execution. |
| Recommendation — Review entitlements for generated tools and require contextual authorisation for each sensitive call. | ||
Key terms
- Endpoint-Level Policy: Authorization logic that evaluates a specific API or tool action at the moment of execution rather than only at exposure time. It can account for delegating identity, resource scope, intent, and approval state, which is essential when one tool catalog contains mixed-risk actions.
- Delegation authority: Delegation authority is the right for one identity to act on behalf of another within a defined scope. For agents, it must be explicit, time-bound, and auditable because the system may initiate actions independently once granted access.
- Tool Catalogue: A tool catalogue is the list of actions, connectors, or capabilities an AI client can discover through an MCP server. When exposed without authentication, it can reveal internal structure, system names, and possible targets, giving attackers reconnaissance value before any direct compromise occurs.
- Runtime Authorisation: Runtime authorisation is the practice of deciding access while a task is in progress, rather than only at provisioning time. It matters for NHIs because credentials and entitlements can change risk mid-session, especially when automation or AI agents interact with sensitive systems.
Deepen your knowledge
NHI governance, agentic AI identity, and machine identity lifecycle are core topics in our NHI Foundation Level course, the industry's only accredited NHI security programme. If you are building or maturing an IAM programme, it is worth exploring.
Published by the NHIMG editorial team on June 24, 2026.
Updated on October 11, 2026.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org