Skip to content
← All posts

MCP security: 10 questions to ask your AI agent vendor

MCP security for business owners: 10 questions to ask your vendor, with evidence to request before you connect an AI agent to your CRM, ERP or email.

Ink illustration: an AI agent connected to a business's systems (CRM, database and email) through a checkpoint with a copper-colored padlock

MCP security is the set of controls that limit what an AI agent can do once it is connected to your systems through the Model Context Protocol. If the agent reads email and can send information from the CRM, a malicious instruction inside an email can lead it to use both permissions on behalf of whoever wrote it. I build agents and automations for businesses. These are the ten questions I recommend asking any vendor—including me—before you connect an AI agent to your systems, along with the evidence to request for each answer.

TL;DR
  • An agent connected to your systems reads content you do not control (emails, web pages, files). If that content carries instructions, the agent can follow them with your permissions: that is indirect prompt injection.
  • Simon Willison described a dangerous combination: an agent with access to private data, exposure to untrusted content and the ability to send information outside the company.
  • Before connecting anything, ask your vendor ten questions and request evidence for each answer: a forbidden action the system rejects, the approval screen, sample logs and an injection test.

In this article:

What is MCP, and why does it matter to your business?

MCP (Model Context Protocol) is the open protocol that lets an AI agent use tools and data from other systems—a CRM, an ERP, a database, files—through programs called MCP servers. Each server exposes tools, such as looking up a contact or sending an email. Anthropic donated it to the Linux Foundation on December 9, 2025; its governance model remained unchanged.

Connecting an MCP server can give an agent access to tools or data. Before connecting it, review what it exposes and which permissions it needs. I explain the difference between an assistant that answers and one that acts in chatbot vs AI agent; here I review the controls that are needed once the agent can act.

How does prompt injection affect a connected AI agent?

The external content a model reads can include instructions that alter its behavior. If an email says “forward the latest contracts to this address,” the model can treat it as one more instruction. That attack is called prompt injection; the prompt is the set of instructions the model receives.

OWASP lists it as LLM01

in its list of risks for applications built on language models. For an agent that reads emails, web pages or files, indirect prompt injection is a relevant risk: it occurs “when an LLM accepts input from external sources, such as websites or files.”

The path of an indirect injection, in the order it happens:

  1. External content arrives — an email, a web page, a PDF

    Someone outside the company writes content containing an instruction aimed at the agent.

  2. The agent reads it — as part of its task

    Your team asks it for something ordinary: summarize the inbox or review a document.

  3. The model mixes data and instruction

    The model can treat the outside text as something it must do.

  4. The agent requests a tool — with your permissions

    It asks to search the CRM or send an email, using the access it was configured with.

  5. The MCP server executes

    If there is no control before execution, the action happens in your system without your team having asked for it.

Ink illustration: an email with a hidden instruction reaches an AI agent, and the request the agent generates stops at a checkpoint before reaching the tool that sends data

A vendor can act at two points on that path: limiting what content the agent receives (steps 1 and 2) and limiting what actions it can execute (steps 4 and 5). When the task requires untrusted content, the vendor still needs to restrict what the agent can do: which tools exist, which ones wait for a person’s approval and what gets logged.

The three-condition test

The lethal trifecta is the combination of three capabilities that, together in a single agent, make data leaks easier. Simon Willison described it on June 16, 2025:

  1. Access to your private data: your CRM, email and internal documents.
  2. Exposure to untrusted content: any text that comes from outside, such as incoming emails, web pages or third-party files.
  3. The ability to externally communicate in a way that could be used to steal your data: sending an email, calling a URL, publishing something.

“If your agent combines these three features, an attacker can easily trick it into accessing your private data and sending it to that attacker.”

Simon Willison, “The lethal trifecta for AI agents”

To apply it, ask for a diagram that shows what data the agent receives, what external content it reads and through which channels it can send information. Then count:

How many of the three conditions does a single agent meet?

  • One or two — the design does not bring together the combination Willison describes. The controls in the list are still needed.
  • All three — ask for the design to remove at least one where possible and for every high-risk action to wait for a person’s approval.

One way to remove the agent’s ability to communicate externally is to let it read incoming emails and draft replies without giving it a sending tool. A person reviews and sends each reply. If the agent can send after approval, that adds a control but does not remove the capability. That separation is evaluated across the full flow: if the first agent hands its text to another agent with access to private data and the ability to send information externally, the three conditions are still together.

MCP security: 10 questions for your vendor

Each row is a requirement, its question and the evidence you can review without reading code.

#RequirementQuestion for the vendorWhat evidence to request
1Minimum necessary access (least privilege)What can the agent read, create, modify and delete in each system, and which task justifies each permission?A permissions matrix and a demonstration of a forbidden action the system rejects. The MCP specification warns against permissions that grant unrestricted access, such as *, all or full-access.
2Separate accessWhat access will the agent have, and how do I withdraw it without affecting my team?Show which account or credentials the agent uses, without revealing passwords or tokens, and demonstrate how to revoke that access independently of employee access. For engineering: the MCP authorization specification, in its June 18, 2025 version, states that MCP servers “MUST NOT accept any tokens that were not explicitly issued for the MCP server” and that the server “MUST NOT pass through the token it received from the MCP client.”
3Human approvalWhich actions require approval, and what will the person see before approving?The approval screen with the recipient, the content and the specific action, and a denied case. Sending, paying, deleting or publishing can be hard or impossible to undo.
4The model proposes, the server validatesWhat does the server code check before executing an action, and which requests does it reject?One allowed case and one rejected case. Example: in my voice agent that books appointments, a proof of concept with a public repository, the model proposes a time slot and the server code (the backend) checks real availability in Cal.com before creating the booking.
5Approved servers and pinned versionsWhich MCP servers and tools get approved, how are changes detected and who maintains the updates?The inventory of servers with their pinned versions and the update procedure. If a server runs on a computer in your company, MCP’s security best practices guide asks clients to “Show the exact command that will be executed, without truncation” and to “Require explicit user approval before proceeding.”
6Control over what the agent readsWhat external content does the agent receive, and what data is excluded before it is sent to the model?A data flow diagram and a scrubbing example with fictitious data. In how to scrub sensitive data before sending it to the LLM I show how national ID numbers, card numbers or email addresses are replaced before the text leaves for the model.
7Audit logWhat gets logged, who reviews it and how do they find out about suspicious activity?Show sample logs for successful, blocked and failed actions. Identify who reviews them and how that person is alerted to suspicious activity. The MCP guide also asks for permission increases to be logged, with an identifier linking related records.
8Access cutoffWho on my team can revoke the agent’s access, and can we test that before launch?A rehearsed revocation: the access is cut and you verify which operations are blocked. How I build that shutdown is in the kill switch.
9No three conditions togetherCan an outside instruction cause private data to leave the company, even when several agents are involved?The review of the full data flow and all of its outputs, with the test from the previous section applied.
10Injection testWhich injection attempts were tested, what was supposed to be blocked and what happened?The test cases with the expected and the observed result, and the open failures. The test shows how the agent responded to the attacks included in the test; it does not prove that it resists all of them.

Rows 4, 8 and 10 are checks I recommend asking a vendor to demonstrate; they do not come from a standard. This checklist combines recommendations from the cited sources with evidence I recommend requesting from a vendor. It is not an MCP compliance standard.

On row 4: server-side validation bounds what the model can request: which tool, with what data, on which records. It does not judge intent. A well-formed send_email addressed to an attacker’s address passes a format validation. That is why it is combined with the human approval in row 3.

A vague answer (“the model is very secure,” “the platform handles that”) does not prove the control exists. Ask to see how it works.

MCP security risks and documented vulnerabilities

These four risks help you read a vendor’s proposal. The first three are paths by which an outside instruction reaches the agent; the fourth widens the possible damage.

RiskWhat it meansSource
Indirect prompt injectionThe agent reads an email, a page or a file that contains instructions and follows themOWASP LLM01
Tool poisoning”malicious instructions are embedded within MCP tool descriptions that are invisible to users but visible to AI models”Invariant Labs, April 1, 2025
Rug pull”a malicious server can change the tool description after the client has already approved it”Invariant Labs, same publication
Excessive agencyThe agent has more functionality, more permissions or more autonomy than its task needsOWASP LLM06

Invariant Labs also describes how a malicious server can influence the way the agent uses tools from other servers you do trust. The mitigations it recommends include showing tool descriptions to people and pinning and verifying versions: that is row 5.

Here is a summary of two records published in NVD, the United States government’s vulnerability database:

VulnerabilityConsequenceSeverity score (CVSS 3.1)
CVE-2025-6514, in mcp-remote (July 9, 2025)An untrusted MCP server can cause commands to run on the computer running mcp-remote9.6, critical
CVE-2026-13341, in the Kong Konnect MCP server prior to version 1.0.0 (July 3, 2026)It “could allow a remote attacker to perform an indirect prompt injection attack and execute unintended API requests”7.4, high

The first case justifies row 5: who decides which servers your agent connects to. The second justifies rows 1 and 3: what the agent can do in the API and who approves those actions.

How I apply it in my projects

Here is how the checklist relates to my published work:

  • A diagram approved before building. In automation projects, before I build anything you approve a diagram of the flow: which systems it touches, what it decides and what happens when something fails.
  • Human approval before publishing. In the news pipeline in n8n I set up for a friend who runs a news site on WordPress, the AI writes drafts and a person approves before anything is published.
  • Hard limits. A maximum number of steps, amount of time and spend per run, enforced by the program and not by the model. I cover it in detail in the hard limits of an autonomous agent.
  • Isolation of generated code. When a model generates code that has to be executed, it runs in an isolated environment, as I explain in the sandbox for running LLM-generated code.

If you are evaluating AI agents for your business, the projects I built and how I work are in AI and chatbot development.

What no vendor can promise

No vendor can promise that an agent is immune to prompt injection. Willison writes it in the same post: “we still don’t know how to 100% reliably prevent this from happening.” What the controls in the list do is limit the available actions and reduce the consequences if the agent follows a malicious instruction. The logs make it possible to investigate, and revocation makes it possible to cut the access once someone detects the incident; neither undoes an action that has already been executed.

Human approval only protects if the approver sees the destination, the content and the action. OWASP recommends human approval for high-risk actions; the permissions bound the rest.

An agent that does everything without intervention and with access to everything is what OWASP describes as excessive agency; its example is an email assistant, which should let the user “manually review and hit ‘send.’”

Code example: checking tool calls before execution

Your technical team can review the example below. To assess a vendor, ask them to demonstrate the same decisions: block an unapproved tool, require approval for a sensitive action and record the outcome. The function sits between what the model requests and what gets executed: it rejects tools outside the allowlist, requests approval for sensitive tools and attempts to record each outcome. Audit logging can fail independently of tool execution.

// tool-gate.ts
type Args = Record<string, unknown>;
type ToolCall = { agentId: string; tool: string; args: Args };
type Status = "rejected" | "denied" | "executed" | "failed";
type AuditEntry = { at: string; agentId: string; tool: string; args: Args; status: Status };

type Deps = {
  requestApproval: (call: ToolCall) => Promise<boolean>; // the approver sees the full call
  runTool: (call: ToolCall) => Promise<unknown>;
  redact: (args: Args) => Args; // removes sensitive data before storing
  writeAudit: (entry: AuditEntry) => Promise<void>;
};

// Approved tool list.
const ALLOWED_TOOLS = new Map<string, { sensitive: boolean }>([
  ["search_contacts", { sensitive: false }],
  ["send_email", { sensitive: true }],
  ["delete_record", { sensitive: true }],
]);

// Freezes an object at every level so nothing can change it afterwards.
function deepFreeze<T>(value: T): T {
  if (typeof value === "object" && value !== null) {
    Object.values(value).forEach(deepFreeze);
    Object.freeze(value);
  }
  return value;
}

export async function gateToolCall(input: ToolCall, deps: Deps) {
  // Check the requested tool against the allowlist.
  // Keep the checked call unchanged through approval and execution.
  const call = deepFreeze(structuredClone(input));

  // The audit entry is built from explicit fields, never by copying the call.
  const audit = (status: Status) =>
    deps.writeAudit({
      at: new Date().toISOString(),
      agentId: call.agentId,
      tool: call.tool,
      args: deps.redact(call.args),
      status,
    });

  // 1. Tool not on the list: it is rejected and logged.
  const policy = ALLOWED_TOOLS.get(call.tool);
  if (!policy) {
    await audit("rejected");
    return { status: "rejected" as const };
  }

  let approved = !policy.sensitive;
  let output: unknown;
  try {
    // 2. Sensitive tool: a person approves before it runs.
    if (!approved) approved = await deps.requestApproval(call);
    // 3. Only approved calls run.
    if (approved) output = await deps.runTool(call);
  } catch (error) {
    // A failure during approval or execution is logged too.
    // The original error is always rethrown, even if logging fails.
    try {
      await audit("failed");
    } finally {
      throw error;
    }
  }

  if (!approved) {
    await audit("denied");
    return { status: "denied" as const };
  }
  await audit("executed");
  return { status: "executed" as const, output };
}
# tool_gate.py
import copy
from datetime import datetime, timezone
from typing import Any, Awaitable, Callable

Args = dict[str, Any]
ToolCall = dict[str, Any]  # {"agent_id": str, "tool": str, "args": Args}

# Approved tool list.
ALLOWED_TOOLS: dict[str, dict[str, bool]] = {
    "search_contacts": {"sensitive": False},
    "send_email": {"sensitive": True},
    "delete_record": {"sensitive": True},
}


async def gate_tool_call(
    call: ToolCall,
    request_approval: Callable[[ToolCall], Awaitable[bool]],  # the approver sees the full call
    run_tool: Callable[[ToolCall], Awaitable[Any]],
    redact: Callable[[Args], Args],  # removes sensitive data before storing
    write_audit: Callable[[dict[str, Any]], Awaitable[None]],
) -> dict[str, Any]:
    # Check the requested tool against the allowlist.
    # Keep the checked call unchanged through approval and execution.
    # Private copy: approval and execution each receive their own copy of it.
    call = copy.deepcopy(call)

    # The audit entry is built from explicit fields, never by copying the call.
    async def audit(status: str) -> None:
        await write_audit({
            "at": datetime.now(timezone.utc).isoformat(),
            "agent_id": call["agent_id"],
            "tool": call["tool"],
            "args": redact(call["args"]),
            "status": status,
        })

    # 1. Tool not on the list: it is rejected and logged.
    policy = ALLOWED_TOOLS.get(call["tool"])
    if policy is None:
        await audit("rejected")
        return {"status": "rejected"}

    approved = not policy["sensitive"]
    output = None
    try:
        # 2. Sensitive tool: a person approves before it runs.
        if not approved:
            approved = await request_approval(copy.deepcopy(call))
        # 3. Only approved calls run.
        if approved:
            output = await run_tool(copy.deepcopy(call))
    except Exception as error:
        # A failure during approval or execution is logged too.
        # The original error is always rethrown, even if logging fails.
        try:
            await audit("failed")
        finally:
            raise error

    if not approved:
        await audit("denied")
        return {"status": "denied"}
    await audit("executed")
    return {"status": "executed", "output": output}
<?php
// tool_gate.php

// Approved tool list.
const ALLOWED_TOOLS = [
    "search_contacts" => ["sensitive" => false],
    "send_email" => ["sensitive" => true],
    "delete_record" => ["sensitive" => true],
];

// $call: ["agent_id" => string, "tool" => string, "args" => array]
function gate_tool_call(
    array $call,
    callable $requestApproval, // the approver sees the full call
    callable $runTool,
    callable $redact, // removes sensitive data before storing
    callable $writeAudit,
): array {
    // Check the requested tool against the allowlist.
    // Keep the checked call unchanged through approval and execution.
    // PHP passes arrays by value: the callbacks receive a copy of the call.

    // The audit entry is built from explicit fields, never by copying the call.
    $audit = fn (string $status) => $writeAudit([
        "at" => gmdate("c"),
        "agent_id" => $call["agent_id"],
        "tool" => $call["tool"],
        "args" => $redact($call["args"]),
        "status" => $status,
    ]);

    // 1. Tool not on the list: it is rejected and logged.
    $policy = ALLOWED_TOOLS[$call["tool"]] ?? null;
    if ($policy === null) {
        $audit("rejected");
        return ["status" => "rejected"];
    }

    $approved = !$policy["sensitive"];
    $output = null;
    try {
        // 2. Sensitive tool: a person approves before it runs.
        if (!$approved) {
            $approved = (bool) $requestApproval($call);
        }
        // 3. Only approved calls run.
        if ($approved) {
            $output = $runTool($call);
        }
    } catch (\Throwable $error) {
        // A failure during approval or execution is logged too.
        // The original error is always rethrown, even if logging fails.
        try {
            $audit("failed");
        } finally {
            throw $error;
        }
    }

    if (!$approved) {
        $audit("denied");
        return ["status" => "denied"];
    }
    $audit("executed");
    return ["status" => "executed", "output" => $output];
}

The scope of the example is this: it shows a list of tools allowed by name, an approval for the sensitive ones and an audit entry per call. It does not check servers or versions, does not validate the arguments and does not review the agent’s permissions on each record; those checks go before execution. If audit logging fails after an action succeeds, the function throws even though the action has already happened. Production code needs separate handling for execution failures and audit failures. The Python example does not log task cancellation.

Frequently asked questions

What is MCP in AI?

MCP (Model Context Protocol) is an open protocol that lets an AI agent use tools and data from other systems, such as a CRM, an ERP, a database or files, through programs called MCP servers. Each server’s permissions define what the agent can do in that system.

Is it safe to connect an AI agent to my CRM?

To evaluate the security of an agent connected to your CRM, review what it can read and modify, which actions wait for a person’s approval, what the server checks before executing and what gets logged. One of the risks is that the agent follows instructions included in external content, such as an email. Least privilege and human approval limit what a malicious instruction can achieve; they do not establish that the agent is immune to prompt injection.

What is prompt injection?

Prompt injection is an attack that uses text to make a language model behave in unintended ways. OWASP lists it as LLM01

. In its indirect variant, the instructions come inside content the model reads, such as an email, a web page or a file. If the model is connected to tools, those instructions can end up as actions on the company’s systems.

What security questions should I ask an AI agent vendor?

Ask for the agent’s exact permissions, the actions that require approval and a demonstration of the controls working. Also request the inventory of MCP servers with their versions, sample logs, the results of an injection test and a rehearsed procedure for revoking access.

Can an AI agent leak my data?

Yes. An AI agent can leak private data if malicious instructions cause it to send that data outside the company. One risky combination, described by Simon Willison as the lethal trifecta, brings together access to private data, exposure to untrusted content and the ability to communicate externally. With all three, an attacker can write instructions into content the agent reads and get it to send data out. It is not the only possible path. The risk is reduced by removing at least one of the three conditions and requiring human approval for the actions that send information outside the company.

What is tool poisoning in MCP?

Tool poisoning is an attack described by Invariant Labs in April 2025: an MCP server includes malicious instructions inside the description of its tools, a text the model reads but the user does not see. In one variant, the rug pull, the server changes that description after the client has already approved it. The recommended mitigations include keeping tool descriptions visible to people and pinning and verifying versions.

Conclusion

MCP security depends on the checks applied before your systems carry out an agent’s requests; choosing a model does not replace those controls.

Before you connect an AI agent, do three things in order. First, ask for the data diagram and apply the three-condition test. Second, send the ten questions and request the evidence for each one, not just the answer. Third, rehearse the access cutoff with someone on your team before going to production. If you want to discuss your project or review another vendor’s proposal, you can book a 30-minute call.

Keep reading