---
title: Should read and write tools live on separate MCP servers?
url: https://opencontroller.lyzr.com/blog/separate-read-and-write-mcp-tools
published: 2026-11-17
updated: 2026-11-17
author: Lyzr
---

# Should read and write tools live on separate MCP servers?

**For sensitive systems, yes—or at least make read-only a separately credentialed mode. Splitting read and write tools lets you give most agents a server that physically cannot change anything, with a narrower token, simpler review and an obvious place to add approval. The cost is more servers to run. For low-risk systems, a single server with a read-only mode or tool filtering is usually enough.**

The question comes from a simple observation: most agents only need to read. Yet many MCP servers expose create, update and delete tools alongside search and get, all under one credential.

## What are the options?

There are four common designs, from weakest to strongest separation.

| Design | How it works | Separation strength | Main weakness |
|---|---|---|---|
| Annotations only | Tools marked with hints such as `readOnlyHint` or `destructiveHint` | Weak | Hints are self-declared by the server and not enforced |
| Client-side tool filtering | The host or agent config hides write tools | Medium | Write tools still exist behind the same credential |
| Server read-only mode | Server started with a flag that skips write tools | Strong if the credential is also read-only | Mode is a config setting that can be changed |
| Separate servers | A read server and a write server, each with its own credential | Strongest | More servers to deploy, patch and register |

The MCP specification itself is clear that annotations are hints. Clients should not make trust decisions based on annotations from untrusted servers. See [can you trust MCP tool annotations?](/blog/can-you-trust-mcp-tool-annotations)

## What does a real read-only mode look like?

GitHub's official MCP server is a useful example. Its [documentation](https://github.com/github/github-mcp-server) describes a `--read-only` flag; when set, write tools are skipped "even if explicitly requested via `--tools`." It also supports toolsets (for example `--toolsets repos,issues,pull_requests`), with the `GITHUB_TOOLSETS` environment variable taking precedence over the flag.

That gives you two independent levers: which domains of tools are exposed, and whether any of them can write. Pair the flag with a token that only has read scopes, and the read-only property holds even if someone changes the flag.

## Why does separation simplify governance?

1. **Least privilege becomes structural.** An agent connected only to the read server cannot write, regardless of prompt injection. This directly reduces [excessive agency](/blog/what-is-excessive-agency-in-ai-agents).
2. **Credentials match intent.** The read server holds a read-scoped token; the write server holds a write-scoped one. A leaked read token cannot change data.
3. **Review is faster.** Approving a read-only server for 40 agents is a smaller decision than approving a mixed server for the same 40.
4. **Approval has one home.** Human approval or extra policy checks can be attached to the write server only. See [human approval for high-risk agent actions](/blog/human-approval-for-high-risk-ai-agent-actions).
5. **Logs are cleaner.** Every call to the write server is a state change worth auditing.

## When is one server enough?

Splitting is not free. Consider one server with a read-only mode or filtering when:

- The system holds low-sensitivity data and writes are easily reversible.
- Only one or two agents use it, and both legitimately need write access.
- The server is local to a developer device and scoped to their own resources.

Split when any of these apply: the system holds regulated or customer data; writes are hard to undo (payments, deletes, external messages); many agents need read access but few need write; or the server will be offered across teams.

## A decision checklist

1. List the server's tools and classify each as read, write or destructive. Do not rely on annotations alone.
2. Count agents that need each class.
3. If most agents need read only, plan a read-only server or mode with a read-scoped credential.
4. Put destructive tools (delete, transfer, send externally) on the write server, or behind an explicit allowlist per agent.
5. Register both servers separately, with owners and risk ratings.
6. Enforce the per-agent allowlist on the server or gateway, not just in the agent config; see [how to limit which tools each AI agent can call](/blog/limit-which-tools-each-ai-agent-can-call).
7. Monitor write-server traffic as a high-signal audit stream.

## How Opencontroller does this

Opencontroller keeps agents, versions, tools and MCP servers in a governed registry, so you can see which agents connect to which servers and tools. Posture detection flags risky permission and configuration patterns, such as an agent connected to write tools it never uses. Policies are written as code and can be enforced in the traffic path where agent traffic flows through the Agent Gateway. See the pillar on [how to govern MCP servers](/blog/how-to-govern-mcp-servers) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Are MCP tool annotations enough to mark tools read-only?**
No. Annotations such as `readOnlyHint` are hints declared by the server. The specification says clients should not rely on them from untrusted servers.

**Does a read-only flag make a server safe?**
Only if the credential is also read-only. A flag is configuration; a read-scoped token is the control that holds if the flag changes.

**Does splitting servers double the cost?**
It adds operational overhead—two deployments, two registry entries, two credentials—but usually less than the review effort saved by giving most agents read-only access.

## Key facts

- MCP tool annotations such as readOnlyHint and destructiveHint are hints; the MCP specification says clients should not trust them from untrusted servers.
- GitHub's official MCP server has a --read-only flag that skips write tools even if requested via --tools, and supports --toolsets with GITHUB_TOOLSETS taking precedence.
- Read-only properties should be backed by a read-scoped credential, not only a server flag.
- Separate read and write MCP servers make least privilege structural and give approval a single home on the write server.
- Opencontroller provides a governed registry of agents, tools and MCP servers, Posture detection of risky permissions, and policy as code in the Agent Gateway path.
- Opencontroller pricing starts from $250K per deployment per year.

## Related

- [Can you trust MCP tool annotations like readOnlyHint?](https://opencontroller.lyzr.com/blog/can-you-trust-mcp-tool-annotations.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)
- [Which AI agent actions need human approval?](https://opencontroller.lyzr.com/blog/human-approval-for-high-risk-ai-agent-actions.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
