DEV Community

Cover image for Securing MCP Servers: Why Tool Permissions Matter More Than Prompts

Securing MCP Servers: Why Tool Permissions Matter More Than Prompts

Abhishek Dhull on November 14, 2026

While building Sernixa AI, there's one thing I've kept coming back to. We're making it incredibly easy for AI agents to connect to tools through M...
Collapse
 
shansjl profile image
shansjl •

"Having access to a tool shouldn't mean having permission to do everything with it" is the right framing. Checking the recipient and attachments of a send_email call before it executes is much easier to reason about than hoping the prompt holds, because the prompt is exactly the part an injected email can rewrite.

I maintain an open-source video editor that Claude Code / Codex drive over MCP (disclosure: I'm the author). The stakes are lower than email, but the same split shows up: reading the timeline and making an edit are very different, and overwriting or deleting a user's project is the action I'd want gated outside the model, not described as "please be careful" in the instructions.

To your question: I lean toward a separate layer for org-wide policy (who may send what where), with the MCP server only enforcing what it alone can know, like whether the target object still exists or changed since the agent last read it. Do you see Sernixa's policy checks needing per-tool argument schemas from each server, or can they stay generic?

Collapse
 
abhishek_dhull_63 profile image
Abhishek Dhull •

Well, turns out giving an AI access to a tool doesn't magically mean it knows what it should and shouldn't do 😂

At Sernixa, we're working toward checking the actual tool arguments, target resources, and permissions rather than just tool names. That part is still being refined, especially when different MCP servers describe their tools differently.

Your video editor is actually a great example. Reading a timeline is one thing; casually deleting someone's entire project is a slightly different story. Would love to hear how you're handling that boundary!

Collapse
 
shansjl profile image
shansjl •

Mostly structurally. An agent edit goes through command_preview first, which commits nothing. command_apply then has to send the same payload plus the project revision the agent last read, so if I changed the timeline in the meantime it gets a revision conflict instead of overwriting my work. A batch of up to 32 changes lands as one undo point, so a bad agent edit is one undo away, and there's no MCP tool that deletes a project at all.

What it doesn't have is anything like the argument-level policy you're describing: once an agent holds the edit lease, it can cut whatever it previewed. That gap is exactly where a layer like Sernixa would sit.

Thread Thread
 
abhishek_dhull_63 profile image
Abhishek Dhull •

That’s a pretty smart setup, especially the revision checks and undo system. What we’re trying to do with Sernixa is add another layer before execution. Instead of just checking whether an agent can use a tool, we look at what it’s actually trying to do, which files or resources it’ll affect, and whether that specific action matches what the human authorized. If it goes beyond those permissions, it should be blocked or sent for approval.

We’re still ironing out the intent part, but your editor seems like a really interesting use case. Once we’ve got it working reliably, I’ll definitely reach out. Would you be open to testing it with your project?

Thread Thread
 
shansjl profile image
shansjl •

Thanks. Checking what the agent is actually trying to touch against what the human authorized is the piece CutVoke doesn't have, so it's a good fit to try against. When you have something you'd like to test, open an issue on the repo with how it would sit between the MCP client and the server, and I'll take a look.

Thread Thread
 
abhishek_dhull_63 profile image
Abhishek Dhull •

Btw, I’m curious about CutVoke now. What exactly does your video editor do, and how much of the editing can Claude or Codex actually handle through MCP? Sounds like an interesting project!

Collapse
 
paul_irolla_6b5ae261d0224 profile image
Paul Irolla •

@abhishek_dhull_63 We don't infer what the user meant. The gate lets through only what they explicitly approved, so a case nobody foresaw is refused, not guessed. The hard part is yours too: wording 'allowed' so the list is neither too broad nor unreadable.

Collapse
 
abhishek_dhull_63 profile image
Abhishek Dhull •

That's a fair point. I agree it's better to block something unknown than guess. The tricky part is making permissions specific without asking users to approve every tiny action. That's what we're exploring with Sernixa. Curious how you're handling that as workflows get more complex?

Collapse
 
paul_irolla_6b5ae261d0224 profile image
Paul Irolla •

@abhishek_dhull_63 Intent is the part a rule cannot carry, so I keep a human on it. The agent proposes, I read and approve, and the code refuses whatever breaks a limit I declared. A rule only has to catch what it can actually see.

Collapse
 
abhishek_dhull_63 profile image
Abhishek Dhull •

That's a sensible approach for sensitive actions. But wouldn't having a human review every uncertain action become a bottleneck when hundreds of agents are working simultaneously? The rules can enforce limits, sure, but how do you scale human approval without constantly interrupting people?

Collapse
 
paul_irolla_6b5ae261d0224 profile image
Paul Irolla •

A permission written in the instructions is trusted, not verified: the model can read the rule and still call the tool. The same rule in the server gets tested by one blocked call.

Collapse
 
abhishek_dhull_63 profile image
Abhishek Dhull •

Exactly. A rule in a prompt is basically just asking the agent to behave. The server actually enforcing it is what matters.

The part we're still figuring out at Sernixa is how to reliably tell what the user meant to allow in the first place. That's where it gets tricky.

Collapse
 
paul_irolla_6b5ae261d0224 profile image
Paul Irolla •

@abhishek_dhull_63 For the specific part, write each line as one action on one object: reply in a thread I started, not interact with posts. A broad word reads easily and then lets everything through.

Collapse
 
abhishek_dhull_63 profile image
Abhishek Dhull •

Fair point, but even “reply to a thread I started” leaves questions. Which thread? What can the agent say? How many times can it reply?

And imagine scaling this to hundreds of agents performing thousands of different actions. Writing specific permissions for everything becomes a nightmare. Even a narrow rule doesn't necessarily mean the action matches what the user actually wanted.