---
title: Should MCP access be authorised per server or per tool?
url: https://opencontroller.lyzr.com/blog/mcp-server-level-vs-tool-level-authorization
published: 2026-11-18
updated: 2026-11-18
author: Lyzr
---

# Should MCP access be authorised per server or per tool?

**You need both, but most enterprises start with server-level access because it is what gateways and clients support today. Server-level control decides who can reach an MCP server at all. Tool-level control decides which actions they can take once connected, and it is the only layer that separates "read a ticket" from "delete a repository".**

This question comes up in almost every security review of an MCP rollout. The honest answer is that the two layers stop different failures, and you should know which one you actually have before you approve a server.

## What is the difference between server-level and tool-level authorisation?

An MCP server exposes a list of tools. A single server often mixes harmless and dangerous ones. A source-control server might offer `search_code`, `create_issue` and `delete_branch` side by side.

- **Server-level authorisation** answers: may this user or agent open a session with this server? It is usually enforced with a credential (an OAuth token or a gateway-issued key) that the server or a gateway checks on connect.
- **Tool-level authorisation** answers: may this caller invoke this specific tool, with these arguments, right now? It needs a policy check on every `tools/call` request, not just on connect.

The MCP authorization specification defines how clients obtain OAuth 2.1 access tokens for a server. It does not define a per-tool permission model. Servers can map OAuth scopes to tools themselves, but many do not, so per-tool control usually has to come from the server's own configuration or from something sitting in the path.

## What does each layer actually stop?

| Risk | Server-level only | Tool-level added |
|---|---|---|
| Unknown user connects to an internal server | Stopped | Stopped |
| Approved user calls a destructive tool by mistake | Not stopped | Stopped |
| Prompt-injected agent calls a write tool | Not stopped | Stopped if the tool is denied for that agent |
| Agent exfiltrates data through a read tool | Not stopped | Partly (argument checks, rate limits) |
| Unapproved server added by a developer | Stopped only if traffic passes a gateway | Same |
| Audit question: who called which tool | Session-level answer | Call-level answer |

The pattern is clear. Server-level control is an entry gate. It does nothing once a session is open, and agent incidents almost always happen after the session is open.

## What can you do if you only have server-level control today?

Tool-level authorisation is still uneven across MCP clients, servers and gateways. Until you have it end to end, these interim controls close most of the gap:

1. **Split servers by risk.** Run a read-only instance and a write instance of the same integration, and grant the write one to fewer people and agents. See [separate read and write MCP tools](/blog/separate-read-and-write-mcp-tools).
2. **Use the server's own tool filters.** Some servers let you start them with a restricted toolset or a read-only flag. GitHub's official MCP server, for example, supports toolset selection and a read-only mode.
3. **Limit tools in the client or agent definition.** Most agent frameworks let you pass an explicit tool list rather than everything the server advertises. See [limit which tools each AI agent can call](/blog/limit-which-tools-each-ai-agent-can-call).
4. **Scope the downstream credential.** If the server acts with a token, make that token read-only where possible. The tightest MCP policy cannot beat an over-scoped API key behind it.
5. **Log every tool call.** Even without enforcement, call-level logs let you detect misuse and prove what happened.
6. **Write the gap down.** Record in the risk register that tool-level control is pending, which servers it affects, and the compensating controls above.

## How should you decide which servers need tool-level control first?

Rank servers by the worst tool they expose, not the average one.

- **Tier 1 (tool-level required before production):** any server that can write to systems of record, send external messages, move money, change permissions or delete data.
- **Tier 2 (server-level plus logging acceptable for now):** servers that read internal but non-sensitive data.
- **Tier 3 (server-level fine):** servers over public data, such as documentation search.

A practical rule: if a single tool on the server could trigger an incident report, the server is Tier 1.

## How Opencontroller does this

Opencontroller keeps a governed registry of agents, tools and MCP servers, so every server and the tools it exposes are recorded with an owner. Traffic routed through the Agent Gateway lets you apply policy as code in the path, and per-agent Block and Quarantine controls cut off an agent that misuses a server. How deep enforcement goes depends on the connector and the traffic path: registration is not the same as runtime takeover. Read more in [how to govern MCP servers](/blog/how-to-govern-mcp-servers), or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Does the MCP specification include per-tool permissions?**
No. The specification covers how clients get OAuth access tokens for a server. Mapping scopes or policies to individual tools is left to servers, clients and gateways.

**Are MCP tool annotations like readOnlyHint enough to authorise tools?**
No. Annotations are hints supplied by the server. They help with display and approval prompts but should not be trusted as a security boundary, especially for third-party servers.

**Is it acceptable to go live with server-level access only?**
For read-only, low-sensitivity servers, usually yes, with call-level logging. For servers with write or destructive tools, add tool filtering, split servers or scoped credentials first.

## Key facts

Server-level MCP authorisation controls who can open a session with an MCP server; tool-level authorisation controls which tools a caller can invoke per tools/call request. The MCP authorization spec defines OAuth 2.1 token acquisition for a server but no per-tool permission model. Interim controls when only server-level exists: split read and write servers, server toolset filters (e.g. GitHub MCP server read-only mode), explicit tool lists in agent definitions, read-only downstream credentials, call-level logging. Prioritise tool-level control for servers with write, send, payment, permission or delete tools.

## Related

- [How to govern MCP servers in the enterprise: a practical guide](https://opencontroller.lyzr.com/blog/how-to-govern-mcp-servers.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)
- [Should read and write tools live on separate MCP servers?](https://opencontroller.lyzr.com/blog/separate-read-and-write-mcp-tools.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
