
You want Claude to search your inbox and Cursor to read the issue tracker, and you want neither of them to change a thing. Then you read one more thread about an agent that deleted data it was only meant to look at, and "read access" starts to sound like a phrase that needs a lawyer.
Read-only MCP access means nothing can be written. At its strongest, every write and destructive tool is hidden, so the model never sees it, and you've proved it with one test. "Ask me first" isn't read-only, and "please don't" is a wish, not a control. Arc0 publishes this blog, and Arc0 is the worked example later on, but the levels and client settings apply whatever you use.
Why read-only is the right default, and what it doesn't cover
Let a new assistant read before you let it act. MCP, the Model Context Protocol, is how assistants plug into outside apps, and each thing a server offers (search messages, create an issue) is a tool. Give it only the reading tools and the assistant can search, summarize, and find the thing you lost, but it can't send, edit, or delete anything until you've seen how it behaves.
The MCP spec leans the same way: there should always be a human in the loop who can deny a tool call. Read-only is you doing the denying in advance, once, instead of all afternoon.
What read-only doesn't do is keep your data in place. A read tool returns your private data into the model's context, because that's its job. Prompt injection, text inside something the assistant reads that tries to give it orders, can then steer it to carry your data out through any other tool that talks to the outside world.
Simon Willison named the dangerous combination the lethal trifecta in June 2025: access to private data, exposure to untrusted content, and a way to communicate externally. His advice is to avoid putting all three in one assistant, and he says he still doesn't know how to prevent the attack 100% reliably.
Picture an issue comment in your repo that says, politely, to fetch a link with the repo's settings attached. The read that surfaced it was allowed. The fetch is the problem.
Read-only stops the damage. It doesn't stop the leak. Plan for both.
Three levels of control, plus a hard block
There are three ways to keep an assistant from writing, and they aren't equal.
- Never shown. The write tool isn't in the list the model gets. It can't call what it can't see.
- Asks first. The tool is listed, and every call waits for your click.
- Told not to. The tool is listed, and an instruction says not to use it.
Level 1 is read-only, the strongest kind. Levels 2 and 3 aren't read-only at all: level 2 is a habit, and by mid-afternoon the habit is clicking Approve without reading. Level 3 is a wish.
Then there's the hard block at the call, which is read-only too, one step below level 1. The tool is listed, but a check outside the model refuses every write call, so nothing gets written and there's no click for you to wear down. The model may still try, which is why you'll want a log of the calls.
You might assume readOnlyHint makes a tool read-only. It doesn't.
A server can label a tool with readOnlyHint (it doesn't modify anything) or destructiveHint (it may delete or overwrite). Unlabelled, readOnlyHint defaults to false and destructiveHint to true, so a tool with no labels is assumed able to write and to do damage.
The spec is blunt about what those labels are. Every annotation is a hint that isn't guaranteed to describe the tool faithfully, and clients must treat annotations as untrusted unless the server is trusted. OpenAI's guidance for app builders says the same from the server side: annotations don't replace server-side authorization or confirmation for consequential actions.
So clients use annotations to decide when to prompt you, which is level 2. The spec's advice to clients runs the same way: confirm sensitive operations, show tool inputs before the call, and log tool use. All good practice. But if the write tool is in the list and only a prompt stands in its way, it isn't read-only.
The four levers, and who controls each
Four places can stop a write, and a different party holds each one.
- Client settings. You hold these, separately in each client. What's on offer varies a lot, as the next section shows.
- Server flags. If your MCP server offers a read-only mode, turn it on, then confirm it with the test below. It's per server, so every server you add is one more flag to remember.
- OAuth scopes. The provider holds these. A scope is a named permission an app asks for on the provider's consent screen.
- A policy check between the client and your apps. You hold this once, and it covers every client and app that goes through it.
A narrow scope is the hardest guard there is, but your client can end up with a broader grant than you meant. The scope works because the provider enforces it: a token without write permission can't write, whatever the assistant decides. The MCP spec asks servers to name scopes by least privilege and clients to request only the scopes they need. When a server names none, the spec tells clients to request every scope in scopes_supported. A call that needs more than the token holds gets a 403 with insufficient_scope. The client may then try to step up to a broader grant.
The catch is the provider's menu. Plenty of consent screens offer a single checkbox that covers reading and writing together, and you can't decline the half you didn't want. Client settings can only narrow what that grant already allows; as Claude's help puts it, restricting actions never grants more access than the source system permits.
Use the narrowest scope whenever it exists. Most of the time it won't split read from write, and then you need a check above it.
Set it per client
Each client puts the switch somewhere different, and the strongest switch often belongs to an admin.
Claude (claude.ai and Desktop)
As of November 2026, Claude's connector settings live at Customize > Connectors, then the connector, then Tool permissions. Each permission category, or each individual permission, can be set to Always allow, Needs approval, or Blocked, and the tools are grouped by type, such as read-only tools and write/delete tools.
Blocked is level 1, and it travels: Claude Code filters a blocked tool out before Claude sees it, and the desktop app and claude.ai chat apply the same setting. Needs approval is level 2.
The help article documents this for owners on Team and Enterprise plans, who set it for the whole organization, and individual users can't override it. Enterprise roles add Custom, so an owner can set each tool separately under Organization settings > Roles > Connectors. If you're on Team, the strongest switch in your own client may be a polite email to your owner.
On a personal plan, the article doesn't document a per-tool setting, so open Customize > Connectors in your own account and check what yours offers. Setup steps are in Arc0 MCP for Claude.
Claude Code
Claude Code gives you a strong built-in option, and it's one you control yourself: deny rules in a settings file. As of November 2026, a rule names one tool as mcp__<server>__<tool> or a whole server as mcp__<server>__*. Put rules in .claude/settings.json for one project or ~/.claude/settings.json for all of yours; managed settings, if your company uses them, sit above both and can't be overridden.
For a hypothetical issue-tracker server named tracker, a read-only setup denies each write tool by name, and leaves the reads alone:
{
"permissions": {
"deny": [
"mcp__tracker__create_issue",
"mcp__tracker__update_issue",
"mcp__tracker__add_comment",
"mcp__tracker__delete_issue"
]
}
}Deny is checked first, then ask, then allow, and an allow rule can't carve an exception out of a deny. Run /permissions to see every rule and the file it came from.
Typos in MCP deny rules fail silently. Claude Code warns at startup about a rule that matches no known tool, but names containing _ or * are exempt, and every MCP rule starts with mcp__. So check each name by hand, and let the test below catch what you miss.
Two naming details catch people. A server name with a dot or a space becomes an underscore, so my.server is written mcp__my_server__*. Connectors you added in claude.ai show up as mcp__claude_ai_<server>__<tool>.
A deny rule that names a whole tool, or a whole server with *, removes the tool from Claude's context, so Claude never sees it. That's a real hide, level 1. It's also a list you keep by hand: every write tool of every server, updated whenever a server adds one, and none of it carries over to your other clients.
Cursor
As of November 2026, Cursor asks for approval before it runs MCP tools by default, and the arrow next to a tool's name shows the arguments it's about to send. The run mode under Settings > Agents > Approvals & Execution decides how far that holds: Auto-review, Allowlist, or Run Everything.
In Allowlist, MCP calls that aren't on your allowlist need approval. In Auto-review, allowlisted calls run at once and the rest go to a classifier. In Run Everything, MCP calls run with no prompt at all.
Don't pick that last one for an account you care about.
Cursor's docs describe switching a whole server on or off from Customize in the sidebar; a disabled server doesn't load or appear in chat. Per-tool allowlists are an enterprise admin feature under Team Settings > MCP Configuration, and they decide which tools run automatically, not which ones exist.
So for an individual, Cursor is level 2 at best for a server you keep on, and level 1 only for a server you switch off entirely, reads included. Read those arguments before you click; the arrow is there for a reason. Setup steps are in Arc0 MCP for Cursor.
ChatGPT
As of November 2026, ChatGPT's answer depends on your plan. Full MCP, read and write, is on Business and Enterprise/Edu, while Pro can connect custom MCP servers with read/fetch permissions only. That Pro limit is the nearest thing to a built-in read-only mode in any of the four clients, though your plan sets it, not you.
With full MCP, ChatGPT may ask for confirmation on write or modify actions, depending on the app's permissions and the action's context. "May" is level 2 on a good day. Enterprise and Edu admins and owners can enable or disable app actions after an app is published.
If you can't find "connectors" in ChatGPT, look for "plugins": the workspace permission is called Create plugins with MCPs. OpenAI also warns that unsafe or untrusted MCP servers raise your exposure to prompt injection. Setup steps are in Arc0 MCP for ChatGPT.
| Client | Setting | Level | Who can set it |
|---|---|---|---|
| Claude | Tool permissions: Blocked (or Needs approval) | 1 (2) | Team and Enterprise owners, org-wide |
| Claude Code | permissions.deny rules | 1 | You, per project or for your user |
| Cursor | Run mode, plus the server on/off toggle | 2 (1 only with the server off) | You; per-tool allowlists are enterprise admins |
| ChatGPT | Plan: Pro is read/fetch only; full MCP may confirm writes | Read-only by plan on Pro; 2 elsewhere | Your plan; Enterprise and Edu admins |
One rule for every client, with Arc0
The general fix is a single check between every client and every app that knows which actions write. Client settings live in four places and, for individuals, mostly prompt rather than hide. Arc0 is our worked example: the agent searches a short list of the actions it's authorized to use rather than loading every tool, and the same switches and rules apply whichever client is asking.
One limit first, plainly: the free Personal plan gives you Choose apps and Ask me on destructive actions, with no Ask on each write and no action switch per assistant (Personal docs). Per-assistant rules come with the Build plan, which is free too (pricing).
-
Connect your apps once and add one MCP URL to each assistant. The Personal plan is free and gives you one MCP URL with scopes set per assistant (Arc0 for individuals).
-
Check the grades. Every action is already graded read, write, or destructive (scopes and actions). Listing Slack channels is a read; deleting a Salesforce record is destructive.
-
Choose apps per assistant. Use Choose apps to give each assistant only the apps it needs. The assistant that reads your issues doesn't need your CRM.
-
Switch off the writes no agent should use (any plan). In the Actions tab, an action you switch off disappears from what any agent can see or call, which is level 1 in every client. The switch is project-wide, so it applies to every assistant at once.
-
Deny writes per assistant with a policy (Build). Policies set Allow, Ask, or Deny per scope and per agent. For Stripe, two rules deny every write and destructive action for that assistant:
stripe:write~deny stripe:destructive~denyA Deny rule refuses the call, so nothing gets written. For other apps, look up the app's rule in the policies docs before you write it.
Want a held approval instead of a flat no? Write
stripe:write~ask. Approvals hold the exact request for a person, and the agent can't approve its own request. -
Check the audit log. Every plan has an audit log, kept 7 days on Personal and 30 on Build, and it records your assistant's calls through Arc0.
For most read-only setups, Choose apps plus the project-wide switches covers it; add a Deny policy when one assistant needs less than the rest.
Hiding the action beats prompting for it.
Switch refunds off, then ask an assistant to refund a charge, and it should tell you it can't find an action for that, which may be the most reassuring thing an assistant ever says. Under a Deny rule, the refund call is refused instead.
Calls run server-side and credentials never reach the agent or the model, which protects your tokens (security). It doesn't change what a read returns, and it can't govern tools you've added to the assistant from elsewhere.
If you live in Claude Code, keep its deny rules too. Two locks are fine; Arc0 grades the actions for you, and its switches and rules apply in every client, so you aren't maintaining four lists.
Test it: ask it to create something
A setting you haven't tested is a guess. The test is short, and you run it in each client.
- Open a fresh chat or session.
- Ask for something that writes: draft an email, create a ticket, or comment on an issue.
- Read the answer.
- If the tool is hidden, it says it has no tool for that, or offers you the text to paste yourself.
- If a rule refuses the call, as an Arc0 Deny rule does, nothing gets created, so that's a pass too.
- If approval is on, it asks you first. Decline.
- If it just does it, the setting didn't apply. Delete whatever it created, then check which setting didn't hold.
- Look for the tool. In a client that lists each server's tools directly, ask it to list them: a hidden write tool isn't there; one it merely promised not to use is. Through Arc0 the tool list stays the same small set (
search_actionsamong them) whatever you've set, so ask it to search for the action instead, say a refund, and compare the answer with the Actions tab. - Check the log. In Claude Code,
/permissionsshows which rules loaded; in Arc0, the audit log records the call.
Re-run it after a client update and after you add a server. The server you added last week brought its own write tools, and nobody told your deny list.
Read-only checklist
Shorter than most consent screens, and more honest about writes.
- Write and destructive tools are never shown (level 1) or stopped by the hard block, not just prompted (level 2).
- Each assistant has only the apps it needs.
- No client runs in a no-prompt mode against real accounts.
- Every grant uses the narrowest scope the provider offers.
- No send-capable or browsing tool sits beside private data in the same assistant.
- The create-something test passed in every client since its last update.
- There's a log, and reading it is on your calendar.
Arc0 is our pick for read-only MCP access because you set it once and it holds in every client. Actions come graded, one switch hides an action from every agent, and a Deny rule on Build refuses it for one assistant. All of it, the audit log included, is on free plans. Get a free personal MCP URL, connect one app, and add the URL to your assistant with the MCP client setup guide. Then ask it to create something. The right answer is a polite no.