---
title: Which agent APIs let you require approval before an MCP tool runs?
url: https://opencontroller.lyzr.com/blog/mcp-tool-approval-settings-in-agent-apis
published: 2026-11-17
updated: 2026-11-17
author: Lyzr
---

# Which agent APIs let you require approval before an MCP tool runs?

**OpenAI's Responses API and Microsoft Foundry Agent Service both let you require approval before a remote MCP tool call executes, using a `require_approval` setting and an approval request/response loop. Anthropic's MCP connector in the Messages API has no built-in approval step; it gives you per-tool allow and deny lists, so a confirmation step has to be built in your own code.**

When an agent API calls a remote MCP server for you, the tool call happens on the provider's side. If you want a human or a policy engine to see the call before it runs, the API itself has to pause. Here is what each one offers today.

## How do the three APIs compare?

| Capability | OpenAI Responses API | Microsoft Foundry Agent Service | Anthropic MCP connector |
|---|---|---|---|
| Approval before execution | Yes, `require_approval` | Yes, `require_approval` | No built-in step |
| Default | Approval requested before data is shared with a connector or remote MCP server | `always` | Tools run when Claude calls them |
| Per-tool approval | `{"never": {"tool_names": [...]}}` | `{"never": [...]}` or `{"always": [...]}` | n/a |
| Restrict which tools load | `allowed_tools` | `allowed_tools` (empty list = all tools) | `default_config` + `configs` with `enabled` |
| Credentials | `authorization` sent on every request, not stored | Project connection (`project_connection_id`) | `authorization_token` per server |
| Data retention note | Review and log data sent to servers | Review, log and check provider retention | Not eligible for ZDR |

## How does approval work in the OpenAI Responses API?

You set `require_approval` on the `mcp` tool to `"always"`, `"never"`, or a filter that skips approval only for named tools. When the model wants to call a tool that needs approval, the response contains an `mcp_approval_request` item with the server label, tool name and arguments. You send back an `mcp_approval_response` with the request ID and `approve: true` or `false`, chained with `previous_response_id` or by passing the earlier output as input.

Each approval covers one tool call. `allowed_tools` limits which tools are imported at all, which OpenAI notes also reduces cost and latency. The `authorization` value is not stored, so it must be sent on every request.

## How does approval work in Foundry Agent Service?

Foundry's MCP tool defaults to `require_approval: "always"`. You can set `"never"`, or give lists of tools that never or always need approval. The approval loop mirrors OpenAI's: an `mcp_approval_request` output item, then an `mcp_approval_response` in the same conversation.

Two Foundry-specific gotchas:

1. **An empty `allowed_tools` list allows every tool.** Microsoft's docs state it explicitly: `[]` means all tools the server exposes, not zero. Always give a non-empty list.
2. **Credentials live in project connections,** with auth types including custom keys, OAuth2, user Entra token, project managed identity and agentic identity. Microsoft also states it does not test or verify non-Microsoft MCP servers.

## What does Anthropic's MCP connector offer instead?

The connector (beta header `mcp-client-2025-11-20`, or the newer `mcp-client-2026-09-15` that adds tool-list pinning) defines servers in `mcp_servers` and exposes them through an `mcp_toolset` in `tools`. Each tool has `enabled` and `defer_loading` options:

- **Allowlist:** set `default_config: {"enabled": false}` and enable named tools in `configs`.
- **Denylist:** leave tools enabled and disable destructive ones, such as a delete tool.

Anthropic's docs recommend denylisting write or destructive tools when you want a human confirmation step before state changes. In practice that means routing write tools through your own client-side tool path, where your code can pause. The connector supports only MCP tool calls, requires a public HTTPS server, and is not eligible for zero data retention.

## Which approach should you choose?

1. **Read-only tools:** skip approval, but restrict to an explicit allowlist in every API.
2. **Write tools with low impact:** per-tool approval, or a policy engine that auto-approves within limits.
3. **High-impact actions** (payments, deletes, external email): require approval in OpenAI or Foundry; with Anthropic, disable them in the connector and implement them as your own tools.
4. **Log every approval decision** with who approved, the arguments and the outcome. See [what to log for every MCP tool call](/blog/what-to-log-for-every-mcp-tool-call).

API-level approval only covers agents that use that API. Agents on other platforms, coding agents with local MCP servers, and in-house frameworks each need their own controls. The [MCP governance pillar](/blog/how-to-govern-mcp-servers) covers the full picture, and [human approval for high-risk agent actions](/blog/human-approval-for-high-risk-ai-agent-actions) covers designing the approval step itself. To limit tools at the agent level, see [limiting which tools each AI agent can call](/blog/limit-which-tools-each-ai-agent-can-call).

## How Opencontroller does this

Opencontroller keeps a governed registry of agents, versions, tools and MCP servers, so you can see which agents use which servers across platforms. Policy as code applies across the estate, and the Agent Gateway puts control in the path (allow, route, redact, block). Opencontroller Edge extends this to local MCP servers on developer devices. Opencontroller does not provide a human-approval hold workflow in its gateway; for that, use the API-level approval described above. [Book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Does an empty allowed_tools list block all MCP tools in Foundry?**
No. In Foundry Agent Service, omitting `allowed_tools` or passing `[]` lets the agent use every tool the server exposes. Pass a non-empty list to restrict it.

**Can I approve one MCP call and auto-approve the rest?**
Yes in OpenAI and Foundry: set approval per tool so low-risk tools skip it. Each approval response still applies to exactly one tool call.

**Is MCP traffic through Anthropic's connector covered by zero data retention?**
No. Anthropic's docs state the MCP connector is not eligible for ZDR, and tool definitions and results follow standard retention.

## Key facts

- OpenAI Responses API mcp tool: require_approval "always", "never", or {"never":{"tool_names":[...]}}; emits mcp_approval_request items, answered with mcp_approval_response (approve true/false); each approval covers one call; allowed_tools limits imported tools; authorization is not stored and must be sent each request.
- Microsoft Foundry Agent Service MCP tool: require_approval defaults to "always"; supports "never" and per-tool always/never lists; allowed_tools omitted or [] means all tools; credentials via project connections; Microsoft does not test or verify non-Microsoft MCP servers.
- Anthropic MCP connector (beta mcp-client-2025-11-20; mcp-client-2026-09-15 adds tool-list pinning): mcp_toolset with default_config/configs enabled and defer_loading; no built-in approval step; only tool calls supported; not ZDR-eligible.
- Opencontroller does not ship a human-approval hold workflow in its gateway; it provides a registry of agents, tools and MCP servers, policy as code and Agent Gateway enforcement. Pricing starts from $250K per deployment per year.

## Related

- [Which AI agent actions need human approval?](https://opencontroller.lyzr.com/blog/human-approval-for-high-risk-ai-agent-actions.md)
- [How do you limit which tools each AI agent can call?](https://opencontroller.lyzr.com/blog/limit-which-tools-each-ai-agent-can-call.md)
- [What should you log for every MCP tool call?](https://opencontroller.lyzr.com/blog/what-to-log-for-every-mcp-tool-call.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
