Case Study
How Wix scaled Al-native work to 5,000 employees with Willow
Read More
Idan Chetrit
Blog

7 AI Governance Myths Debunked for Enterprise Leaders

Idan Chetrit
00 min
August 31, 2026

The gateway was never the whole story.

Seven governance myths enterprise teams still believe, and the identity and action layer the agent era actually needs.

Most existing governance was built for human users. Autonomous agents present their own set of challenges. Policies that assume a person is behind every action, and model-level checks that watch inputs and outputs, do little to constrain an agent taking its own actions inside a live tool.

Through 2028, it is estimated that at least 80% of unauthorized AI agent transactions will come from internal policy violations rather than external attackers (Gartner, June 2025).

IBM scores AI governance maturity on a scale that runs from ad hoc, undocumented practices at the low end up to the two most mature tiers, systemic and innovative, where governance is built into how the company operates rather than sitting in a slide deck. Only 21% of surveyed executives report reaching those top two tiers (IBM IBV, 2024). For most, governance is still catching up to how fast agents are being deployed. 

Gartner projects that over 40% of agentic AI initiatives will be canceled before the end of 2027. The main causes include inadequate risk controls, cost, and unclear value (Gartner, 2025).

Proper AI governance is the route to successful rollouts within your organization. But seven myths still shape how most enterprises approach AI governance. Some are about the tools people already trust to handle it (like a gateway, written policy, or monitoring dashboard). 

Others are about what counts as an agent's identity. 

The rest are about timing and scope, whether governance can wait until after you scale, or applies only if you are heavily regulated.

Myth 1: "Our MCP Gateway Governs Our Agents"

Where the Gateway Stops and Governance Begins

Connection layer (the gateway)
  • Routes which agent reaches which tool
  • Caps request rate and cost budget
  • Sees the connection, not the action inside
  • Logs the API call and its status code
Action + identity layer
  • Scopes read, write, and delete per record
  • Ties every action to a governed identity, human or machine user
  • Enforces permissions at execution time
  • Records every action to an exportable audit trail

An MCP gateway (the Model Context Protocol standard that connects agents to tools) governs the connection layer. That covers which tools an agent can reach, at what rate, under what cost budget, and through which provider. 

But it does not govern the action layer (what the agent does inside each tool once the connection is established).

When an agent connects to Salesforce through an approved MCP gateway, the connection is governed. How much of what happens next is governed depends on the gateway, the MCP server, and Salesforce's own permission model, and many setups stop at the connection. 

What the agent does inside Salesforce after that point (which records it reads, whether it exports contact lists, whether it modifies or deletes objects) is below the gateway's visibility horizon.

A support agent approved to "connect to Zendesk" can often read far more tickets than its current task needs, depending on the OAuth scope and the application's own roles. A sales enrichment agent approved to "connect to Salesforce" may be able to export far more of the contact database than the workflow needs, depending on how its access is scoped.

Action-level governance answers the harder question, defining what an agent can do once inside a system like Salesforce. With action-level governance, agents can be limited to reading contacts, creating activity logs, exporting lists, or deleting records. 

These permissions work best when they are tied to a governed identity (an employee's for delegated work or a managed machine user for automation) so the agent inherits its access from that profile. 

Importantly, the policy should be enforced at execution time on each individual operation, so risky actions are caught and blocked before they happen rather than only recorded in logs.

The right architecture uses both an MCP gateway and action-level permissions tied to employee identities & permissions. 

An MCP gateway handles connection control, and an identity and access layer handles action governance. 

Where MCP gateway controls stop short is that a connection-layer gateway leaves much of what an agent does after it connects ungoverned. That is the gap an identity and access layer closes.

Myth 2: "API Keys Are a Valid Identity Layer for AI Agents"

API keys identify the application rather than the person. A shared or unmanaged service account typically has no named human behind it. It won’t automatically update its permissions when an employee changes roles or leaves. And when an auditor asks who authorized an action, there is often no clear answer.

For every human identity in the average enterprise there are 45 non-human identities, meaning service accounts, API keys, and machine credentials rather than people, and up to 144 in cloud-native environments (Cloud Security Alliance, May 2026). Every AI agent provisioned with a service account adds to that difficult-to-govern surface. 

Every era of enterprise computing got its own identity layer. On-prem had Active Directory, SaaS had Okta, and AI agents are still waiting on a mature market for their solution, which is the gap Willow fills.

When an agent inherits a real employee's identity through Willow's identity and access layer and your existing IdP (Okta, Entra ID, JumpCloud), it carries that employee's group memberships, role assignments, and permission scope into every tool it touches. Change the employee's role, and SCIM updates the agent's access automatically. Offboard the employee, and the agent loses access in the same event.

SOC 2, GDPR, HIPAA, and, for high-risk systems, the EU AI Act each push in the same direction. Each is looking for logged actions that trace to an accountable identity, though the specific obligation differs by framework. An anonymous service account cannot meet that bar. But an identity inherited from your IdP can.

Where the Gateway Stops and Governance Begins

Connection layer (the gateway)
  • Routes which agent reaches which tool
  • Caps request rate and cost budget
  • Sees the connection, not the action inside
  • Logs the API call and its status code
Action + identity layer
  • Scopes read, write, and delete per record
  • Ties every action to a governed identity, human or machine user
  • Enforces permissions at execution time
  • Records every action to an exportable audit trail
withwillow.ai

Myth 3: "A Written AI Policy Is Enough"

What a Written Policy Cannot Do

A policy document
  • States what agents should do
  • Sits in a folder, unenforced
  • Cannot block an out-of-scope action
  • Produces no audit trail for a SOC 2 review
Runtime enforcement
  • Verifies identity on every tool call
  • Checks the action against scoped permissions
  • Blocks the call before it executes
  • Records the action for the audit trail

A policy document defines intent. It might say an agent can read customer records but never export them, or open a support ticket but never close one. Maybe those rules even make their way into system prompts for AI chatbots or agents. 

But governance means enforcing that intent at the moment of execution, on every action, instead of trusting the agent to stay inside the lines of policy documentation.

Almost every enterprise has a governance framework written down somewhere. Most of those frameworks were built before agents, and 77% report that AI adoption is already outpacing their governance capabilities (IBM, June 2026).

A policy document alone will never be able to catch up to AI adoption because it cannot:

  • Produce an audit trail for a SOC 2 review.
  • Stop an agent from reading records it was never supposed to access.
  • Prevent a misconfigured workflow from writing to the wrong data objects.
  • Detect the moment a deployed agent starts behaving outside its permission profile.

To catch up, and even get ahead of AI adoption, organizations need runtime enforcement operating at the execution layer. 

When an agent makes a tool call, the governance layer verifies identity, checks the action against scoped permissions, and either approves or blocks the call before it executes rather than after the fact. 

The result is that an agent can only do what it has explicit permission to do, and that gets checked on every call rather than assumed from a document.

Policy documents belong in any governance program. They describe what an agent should and should not do. But it is the technical system that must then put that into force, checking each action as it happens and blocking anything the policy did not allow. 

When the written policy and the runtime checks match, agents stay inside the rules the policy set. 

But when the policy sits on paper with nothing enforcing it, an agent can do whatever it wants inside a live tool and no one finds out until later.

Myth 4: "Monitoring Covers Our Compliance Requirements"

Operational monitoring answers "did the agent run and complete successfully?" 

Compliance audit trails answer “What did the agent do, on which records, under whose authority, at what time?”

SOC 2, HIPAA, and (for high-risk AI systems) the EU AI Act expect audit evidence at the action level, deeper than the connection level.

A gateway log that records "Salesforce API call from Agent X at 14:32:07" does not satisfy a compliance request for "show me every customer record that agent accessed last quarter." 

An action-level audit trail records the call, specific record object, action type (read, write, delete), data scope, and the human identity that authorized the agent's session.

That question stumps most teams today. Only 28% can reliably trace agent actions to a human or system across all environments (Cloud Security Alliance / Strata Identity, February 2026). 

And the pressure to close that gap is no longer coming only from security teams. Regulators have started to demand it too. 

The EU AI Act's record-keeping duties for high-risk systems call for that same traceability to an accountable human identity, which connection-layer logs cannot produce.

Continuous compliance monitoring usually runs on infrastructure tools like Splunk, Datadog, and Grafana. Those tools are good at system-level telemetry, things like error rates, latency, and which service called which. Without an identity & access layer they cannot capture the actual work an agent did, i.e. "Agent Alpha created issue PROJ-422 in Jira as Sarah.Chen, priority High, from workflow W-0041." 

That is the detail Willow's governance and compliance layer is built to produce.

Without it, when an issue surfaces (usually at the first SOC 2 audit or regulatory inquiry after deployment) someone has to reconstruct what already happened. Every action an agent took before governance was in place must be pieced back together from connection logs that never recorded which person was behind each call. That work is slow, expensive, and sometimes simply impossible.

Monitoring vs Action Governance

willow
Requirement Monitoring and logging Action governance
What is recorded Connection-level telemetry: API calls, latency, status codes, token usage Semantic action records: which tool, which record, which operation (read, write, delete), what data scope
Identity attribution The application or agent name that made the call The real human identity whose access the agent inherited
Compliance exports Raw traffic logs that need manual reconstruction before an auditor can use them Pre-built exports formatted for SOC 2, GDPR, ISO 27001, and HIPAA reporting
Incident investigation Reconstructing what happened from fragmented logs, after the fact A queryable record of the exact action, record, and authorizing identity, available immediately
Regulatory standing Stops at infrastructure-monitoring expectations and misses action-level traceability Produces action-level, human-attributable records that teams can map to SOC 2 and EU AI Act evidence requirements

Myth 5: "We Only Need AI Governance If We're in a Regulated Industry"

Governance Is Not Just a Regulated-Industry Problem

willow
490%

year over year rise in AI-related SaaS attacks, regulated industry or not

Grip Security, 2026

Aug 2026

EU AI Act Article 50 transparency obligations apply, and the Act reaches past regulated industries

EU AI Act, Reg. 2024/1689

45:1

non-human identities for every human identity, across every industry

Cloud Security Alliance, 2026

The EU AI Act's Article 50 transparency obligations apply from August 2, 2026, and the Commission's enforcement powers over general-purpose AI providers begin the same month (EU AI Act, Regulation 2024/1689). 

The Act is not limited to regulated industries. It can reach providers and deployers inside the EU, and some outside it, when they place systems on the EU market or their output is used in the EU, with duties that depend on the system's role and risk classification. 

The law is not the only pressure. The NIST AI RMF and ISO/IEC 42001 now show up in enterprise due-diligence and procurement questionnaires, especially in financial services, healthcare, and government buying. NIST asks you to govern, map, measure, and manage AI risk across a system's life, and ISO/IEC 42001 certifies that you run a documented AI management system with owners and a review cycle. For a growing set of buyers, being able to answer for your AI governance is turning into a precondition of the deal. 

Regulation is not the only reason to care, either. The simplest and most straightforward reason to care is that improperly governed AI creates significant business risk. 

An agent running under anonymous credentials inside a mid-size SaaS company's Jira and GitHub is the same attack surface as one inside a regulated bank. If it leaks a customer list, wipes a repository, or corrupts production data, the company has a breach to disclose, costs to pay, customers to win back, and a board asking how it happened. None of which depends on being regulated.

Grip Security reports that AI-related SaaS attacks rose nearly 490% year over year (Grip Security, 2026). The weaknesses behind AI systems that are often exploited include stale credentials, over-permissioned agents, and shadow AI. These show up in companies of every kind and are not limited to regulated industries. 

Myth 6: "We'll Govern Agents After We've Scaled"

The Cost of Waiting to Govern

willow
74%

of enterprises expect at least moderate agentic AI use within two years, up from 23% today

Deloitte, 2026

35%

of executives say they could not immediately shut down a rogue AI agent

Writer, 2026

1 click

to revoke any agent or tool when you govern from day one

Willow

Almost three quarters (74%) of enterprises expect at least moderate agentic AI use within two years, up from 23% at that level today (Deloitte, State of AI in the Enterprise, 2026).

AI use is only going to grow. The cost of retrofitting governance rises with every agent deployed without it. Every ungoverned agent adds to a growing pile of credentials no one has reviewed and actions no one can fully reconstruct, with permissions that were handed out without anyone checking what the agent actually needed. 

The audit work scales with the total number of agent actions taken without attribution, not just the count of agents deployed.

When an agent misbehaves or is compromised, the organization that governed from day one can identify it, scope the blast radius, and use a kill switch to revoke any agent or tool across the org instantly. Yet 35% of executives say they could not immediately shut down a rogue AI agent (Writer, 2026). 

Governance built on identity and access lets you scale AI with confidence. Every agent inherits the permissions an employee already has, so you are not building and maintaining a separate access system or set of rules. On their own, the access controls you already trust do not reach AI agents. A governed identity for each agent, whether a delegated employee or a managed machine user, extends those controls to what the agent does.

Putting that foundation in early is a small, fast piece of work. With a platform like Willow, an agent picks up its identity from your existing IdP and its permissions are scoped before it ever runs. A complete access and permissions system, as well as full audit trail, all established from the first action. That is a modest cost at deployment, and saves the much larger one of untangling a year of ungoverned activity later. That’s not even to mention the issues and risk exposure avoided in that time. 

The practical payoff is that security can sign off once instead of reviewing every new use case. As a result, adoption speeds up and the day-to-day runs with fewer surprises. You also cut two kinds of risk at the same time, the business risk of a breach and the regulatory risk of a compliance gap.

Myth 7: "AI Governance Slows Down AI Adoption"

Governance Is How Adoption Scales

willow
3.4x

more likely to reach high governance effectiveness with a formal program

Gartner, 2026

80% vs 37%

of companies report successful AI adoption with a formal strategy versus without one

Writer, 2025

300K+

governed tool calls per week at Wix, six to ten months ahead of peers

Wix case study

Enterprise AI adoption stalls when security teams cannot say yes. An organization without action-level governance leaves security and compliance holding a question they cannot answer cleanly. How do you scope the risk of an agent when you cannot audit what it does after deployment?

The default answer becomes "not yet" or "only in this controlled environment," and the agent pipeline slows to the speed of manual approvals.

Organizations that deploy an AI governance platform are 3.4 times more likely to achieve high governance effectiveness (Gartner, 2026), and companies with a formal AI strategy report successful adoption at 80%, versus 37% without one (Writer, 2025). Governance lets AI adoption scale.

At Wix, Willow governs roughly 5,000 weekly active users across about 600 governed tools and MCPs, with 300,000+ governed tool calls per week (Wix case study). "We are six to ten months ahead of most companies in AI adoption. More code to production, fewer incidents, real outcomes," says Asaf Yonay, Head of AI Core at Wix.

The same work (identity and access) that satisfies a security review is the work that facilitates AI deployment.

How to Evaluate an AI Governance Platform

Each of the seven myths maps to one evaluation criterion below. When you assess a platform, check whether it addresses every layer. 

The questions that separate real governance from connection-only tooling all start after an agent connects to a tool. 

‍

1) What stops it from taking an action outside its task? If the answer is that the vendor logs everything for you to review later, that is detection, not enforcement. 

‍

2) Whose identity does the agent act under? An agent on its own service account has no tie to a real person, so when that person changes roles or leaves, its access keeps running untouched. What you want instead is an agent bound to an employee's identity through your IdP, with access that ends the moment the employee is offboarded.

‍

The remaining questions are about proof and reach. A platform built for this can produce an action-level audit export for SOC 2, GDPR, ISO 27001, and HIPAA on request, rather than leaving you to pull and format raw connection logs. It should also hold up outside SaaS, keeping its full feature set self-hosted, on-prem, or air-gapped, and its discovery should reach past the agents and MCP servers you already know about to the skills and plugins you do not. 

Connection-Only vs Action and Identity

willow
Criterion Connection-only (gateway) Action + identity layer
Identity API key or service account Real employee identity via IdP (Okta, Entra ID, JumpCloud)
Permission scope Tool-level (can the agent reach this tool) Action-level (what can the agent do inside this tool)
Audit depth Connection logs (HTTP calls, status codes) Semantic action records (agent, action, record, identity, timestamp)
Lifecycle Manual credential rotation Automated via SCIM: agent loses access when the employee offboards
Compliance output Traffic logs Pre-built SOC 2, GDPR, HIPAA, ISO 27001 exports
Shadow AI detection Tools you already know about Browser extension plus endpoint sensors surface unapproved agents, rogue MCP servers, and unapproved skills or plugins
Deployment SaaS only SaaS, self-hosted (AWS, GCP, Azure), on-prem, or fully air-gapped

‍
How far down the table you need to go depends on what you have to answer for. If you only route model or tool traffic, connection-layer tooling is enough. The moment you need to say what an agent did inside a tool, on which data, and under whose authority, you need the action and identity layer.

The right buying criterion is whether the platform closes the action-governance gap, the distance between "can this agent connect to our tools" and "can this agent be held accountable for what it does inside them."

Willow: The Identity and Access Layer for AI Agents

Willow, the Agentic Access Platform, was built to answer every one of those questions with a yes.

Willow provides the identity and access layer, where each agent carries a governed identity through your existing IdP (an employee's for delegated work or a managed machine user for automation), draws on a governed marketplace of 1,000+ integrations, gets action-level permissions scoped per tool, and leaves a full audit trail.

Its shadow-AI discovery reaches past unapproved agents and rogue MCP servers to the unapproved skills and plugins where shadow AI increasingly hides. That works through endpoint sensors and a browser extension that surface agents, MCP servers, skills, and personal API keys at the point of use, approved or not, so teams can review or block them before they reach production data.

That browser extension, Willow for Chrome, is also where much of the everyday governance happens. It can block an unapproved tool inline and strip PII from a page before an agent reads it. 

With Willow, governance is not one more console someone has to remember to open. Approvals for human sign-off reach people wherever they already work, in Slack, in the Chrome extension, or in-app.

Willow holds SOC 2 Type II, SOC 1, GDPR, and ISO 27001 certifications, plus pre-built HIPAA compliance exports. It can be run self-hosted, on-prem, or air-gapped. 

Willow starts free for up to five users and runs $15 per seat on the Startup tier (Willow pricing).

‍

  • IBM IBV AI Governance Report, 2024: https://www.ibm.com/thought-leadership/institute-business-value/en-us/report/ai-governance
  • IBM AI Control-Gap Study, June 2026: https://newsroom.ibm.com/2026-06-08-new-ibm-study-finds-cios-and-ctos-face-growing-ai-control-gap-as-enterprise-deployment-scales
  • Gartner Agentic AI Projects Forecast, Jun 2025: https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027
  • Gartner AI Governance Market, Feb 2026: https://www.gartner.com/en/newsroom/press-releases/2026-02-17-gartner-global-ai-regulations-fuel-billion-dollar-market-for-ai-governance-platforms
  • Cloud Security Alliance, The Non-Human Identity Governance Vacuum, May 2026: https://labs.cloudsecurityalliance.org/research/csa-whitepaper-nonhuman-identity-agentic-ai-governance-v1-cs/
  • Cloud Security Alliance / Strata Identity, Securing Autonomous AI Agents, February 2026: https://cloudsecurityalliance.org/press-releases/2026/02/05/cloud-security-alliance-strata-survey-finds-that-enterprises-are-in-time-to-trust-phase-as-they-build-ai-autonomy-foundations
  • Grip Security 2026 SaaS + AI Security Report: https://www.grip.security/blog/ai-governance-statistics
  • Writer 2025 Enterprise AI Adoption Survey: https://writer.com/blog/enterprise-ai-adoption-survey/
  • Deloitte State of AI in the Enterprise, 2026: https://www.deloitte.com/us/en/what-we-do/capabilities/applied-artificial-intelligence/content/state-of-ai-in-the-enterprise.html
  • EU AI Act, Regulation 2024/1689: https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:32024R1689
  • NIST AI Risk Management Framework: https://www.nist.gov/itl/ai-risk-management-framework
  • ISO/IEC 42001: https://www.iso.org/standard/42001

‍

Blog

Why Official MCP Servers Fall Short for Enterprise

Idan Chetrit
00 min
September 10, 2025

The official MCP servers look solid on paper. Pre-built integrations for GitHub, Slack, Google Drive—everything you need to connect AI agents to your SaaS tools. Plug and play, right?

In practice, they collapse under enterprise needs.

The problem isn't that official MCP servers are poorly built. It's that they're solving the wrong problem. They're optimized for breadth—supporting as many use cases as possible—when enterprises need depth: the exact endpoints, parameters, and authentication flows that match how your organization actually uses these tools.

The Reality of Enterprise API Integration

In the SaaS API integration world, every platform exposes hundreds of endpoints. GitHub alone has 500+ endpoints per API version. Each organization uses a different subset of these capabilities, configured in their own way:

  • Which endpoints you actually need (you're not using all 500)
  • What parameters matter for your workflows
  • How to map request bodies and responses to your data model
  • How to test against your specific environment and edge cases
  • What to monitor based on your reliability and compliance requirements

Now imagine asking an AI agent to handle all of this variability. The agent needs precise tooling—tools that know exactly which GitHub endpoints your org uses, what the expected parameters look like, and how to authenticate properly.

Official MCP servers can't provide this. They're too generic by design.

Case Study: GitHub's Official MCP Server

Take GitHub's official MCP server as a concrete example. It's one of the most polished official servers available, and it still has critical gaps:

Missing Critical Capabilities

The server exposes a subset of GitHub's API, but misses capabilities that many organizations rely on:

  • No support for GitHub Apps or fine-grained personal access tokens
  • Limited repository automation (no workflow dispatch triggers)
  • Missing organization-level operations (member management, security policies)
  • No support for GitHub Projects, Discussions, or Packages

If your AI workflow needs any of these—and most enterprise workflows do—you're stuck.

No Built-in OAuth Support

Here's where it gets painful: the official server requires personal access tokens (PATs) instead of implementing OAuth flows.

Try explaining to your CISO why your AI agents need personal tokens with broad repository access, instead of properly scoped OAuth apps with audit trails. That's a non-starter for most security teams.

Enterprise organizations need:

  • OAuth flows with user consent
  • Token scoping per user and application
  • Audit logs showing which user authorized which action
  • Automatic token refresh and revocation

None of this comes out of the box with official servers.

Already Hitting Tool Limits

The MCP protocol has practical limits on how many tools a single server can expose before performance and usability degrade. GitHub's official server is already approaching these limits—and it only covers a fraction of the API surface.

When you need to add custom endpoints, workflows, or organization-specific logic, there's no room left to extend.

Why This Pattern Repeats Across SaaS Platforms

The GitHub example isn't unique. The same issues appear with every major SaaS platform:

Salesforce: Needs custom objects, validation rules, and approval processes specific to your CRM setup

Jira: Requires custom fields, workflows, and project configurations that vary by team

Slack: Depends on workspace-specific channels, user groups, and custom app integrations

Official MCP servers can't anticipate these variations. They provide the least common denominator—the API operations that most organizations might use—but not the specific combination your organization actually uses.

The Path Forward: Build Your Own MCP Servers

If you're serious about AI adoption in your organization, you'll need to build custom MCP servers. This isn't a nice-to-have. It's a requirement for making AI agents actually useful.

What This Means in Practice

1. Map Your Integration Requirements

Start by documenting which SaaS endpoints your organization actually needs:

  • Which operations do your workflows depend on?
  • What data transformations are required?
  • What error handling is specific to your setup?

Don't try to mirror the entire API. Focus on the 20% of endpoints that drive 80% of your value.

2. Implement OAuth Properly

Build OAuth flows into your custom MCP servers from the start:

  • Use the OAuth 2.0 authorization code flow
  • Store tokens securely (encrypted at rest, never in logs)
  • Implement token refresh logic
  • Add proper error handling for expired or revoked tokens

This is more work upfront, but it's non-negotiable for enterprise security.

3. Add Organization-Specific Logic

Layer in the customization that makes the integration actually useful:

  • Map API responses to your internal data model
  • Add validation rules specific to your governance policies
  • Implement retries and fallbacks based on your reliability requirements
  • Build monitoring that alerts on your critical paths

4. Treat It as Infrastructure

Custom MCP servers aren't one-off scripts. They're infrastructure that needs:

  • Version control and code review
  • Automated testing (unit tests for business logic, integration tests for API calls)
  • Deployment pipelines with staging environments
  • Monitoring, logging, and incident response playbooks

The Trade-Off You're Making

Building custom MCP servers is expensive. You need engineering resources, ongoing maintenance, and security review processes. There's no way around it.

But here's the alternative: continue relying on official servers that almost work, watching your AI adoption stall because the integrations aren't quite right. Teams lose confidence in the AI tools, security teams block deployments, and you never get past the proof-of-concept phase.

The cost of building custom MCP servers is high. The cost of not building them—in terms of failed AI adoption—is higher.

Where Official Servers Still Make Sense

Official MCP servers aren't useless. They work well for:

  • Prototyping and demos: Quick way to show what's possible
  • Low-stakes workflows: Where security and customization matter less
  • Learning the protocol: Good reference implementations to study

But if you're deploying AI agents that touch production systems, handle customer data, or integrate with critical business processes, plan to build your own.

The Question for Your Organization

Is your organization still betting on official MCP servers—or are you already rolling your own?

If you're in the "build" phase, you're making the right call. It's harder, but it's the only path to AI adoption that actually scales across your organization.

If you're still relying on official servers, ask yourself: what happens when you hit the limits described above? Do you have a plan to transition to custom implementations, or are you hoping someone else will solve these problems for you?

The enterprises that successfully adopt AI won't be the ones with the best official integrations. They'll be the ones who understood early that real integration requires real engineering work.

Blog

MCP: Nice-to-Have or Must-Have? The Adoption Gap Explained

Idan Chetrit
00 min
October 10, 2025

"I don't get the hype around MCP. It just feels like a nice-to-have."

That was a CEO and founder of an AI-centric company speaking. Not a skeptic from outside the AI world—someone building AI products for a living.

Right now, the tech world is split into two camps: those who agree with him, and those convinced he's missing something fundamental. Both camps have valid points, but the real story is more nuanced than either side admits.

The Gap Between Promise and Reality

Here's what makes MCP compelling on paper: it's a standardized protocol that lets AI agents connect to your internal tools—GitHub, Jira, Slack, your databases, your APIs—in a structured, predictable way. Instead of building custom integrations for every AI tool and every data source, you implement the protocol once and everything connects.

The promise is real. When it works, teams see transformative results:

Development workflows: Read your current Jira sprint, break down tasks into implementation steps, and open pull requests for new tickets—all triggered from a Slack command. No context switching, no manual coordination.

Support operations: Automatically scan issues reported in support channels, correlate them with recent code commits, and alert the right engineering team with full context. The time from "customer reports bug" to "right engineer is investigating" drops from hours to minutes.

Operations and incident response: Monitor alerts from Grafana or Datadog, match them to recent deployments from your CI/CD system, and surface potential root causes based on historical patterns. Instead of manually correlating logs across five different systems, the AI agent does the detective work.

Sales enablement: Give sales reps a real-time, complete customer view—recent tickets, product usage patterns, billing history, technical health metrics—synthesized into a coherent context in seconds. No more "let me check five different systems and get back to you."

These aren't theoretical possibilities. They're real workflows that work when properly implemented.

So why does it still feel like a nice-to-have for most organizations?

Why MCP Feels Theoretical

The gap between MCP's promise and reality comes down to a simple question: How many enterprises actually allow—and actively encourage—all their employees to use MCP-powered AI agents end-to-end?

I personally know of just one: a leading Israeli tech company that's fully committed to MCP-based AI adoption across their entire engineering organization. They're seeing measurable productivity gains. I'll share their specific use case if there's interest (comment if you want the details).

For everyone else, MCP adoption is stalled by predictable enterprise constraints:

Security Review Overhead

Connecting AI agents to your internal systems means those agents can read from and write to production databases, create pull requests, modify tickets, access customer data. Your security team rightfully asks hard questions:

  • Which agents have access to what data?
  • How do we audit what actions were taken and by whom?
  • What happens if an agent makes a mistake or is compromised?
  • How do we enforce least-privilege access at the agent level?

Most organizations don't have good answers yet. So MCP stays in the "promising but blocked" category.

Governance Gaps

Beyond security, there are operational governance questions that don't have established patterns:

  • Who approves new MCP server deployments?
  • How do we manage versioning and breaking changes?
  • What's the rollback plan if an integration goes wrong?
  • Who owns the integration when it breaks—platform team or product team?

Without clear governance frameworks, even organizations that want to adopt MCP end up moving slowly.

Integration Complexity

The MCP protocol is well-designed, but implementing it properly requires real engineering work. You need to:

  • Build or customize MCP servers for your specific tools and workflows
  • Handle authentication and authorization correctly
  • Implement proper error handling and retry logic
  • Set up monitoring and observability
  • Train agents on when and how to use each tool

This isn't a weekend project. It's infrastructure work that competes with product roadmaps for engineering resources.

The Result: Theoretical But Not Practical

For most enterprises, MCP remains in a proof-of-concept state. Small teams experiment with it. Pilot projects show promise. But organization-wide adoption—where every engineer, every support rep, every sales person has MCP-powered AI agents as part of their daily workflow—that's still rare.

When the CEO said "it feels like a nice-to-have," he wasn't wrong about the current state. For organizations that haven't solved the security, governance, and integration challenges, MCP is indeed nice-to-have but not must-have.

Why That Perspective Is Also Very Wrong

William Gibson famously said: "The future is already here — it's just not evenly distributed."

That's exactly where we are with MCP adoption.

The Early Movers Are Winning

The small number of organizations that have solved the implementation challenges—proper security models, clear governance, solid integration infrastructure—aren't seeing incremental improvements. They're seeing double-digit productivity gains.

When an engineer can query their entire codebase, check ticket status, review recent commits, and open a PR without leaving their AI chat interface, the time savings compound. What used to take 20 minutes of context gathering and tool switching now takes 2 minutes.

When a support team can automatically correlate customer issues with system health metrics and code changes, they resolve issues faster and escalate to engineering with better context. Customer satisfaction improves. Engineering firefighting decreases.

These aren't marginal gains. They're fundamental workflow improvements.

It's Still Early Days

We're at the very beginning of the MCP adoption curve. The protocol launched less than a year ago. Most enterprises are still figuring out their AI strategy in general, let alone their MCP implementation strategy.

The teams solving these problems now are building competitive advantages that will compound over time. They're not just deploying a tool—they're learning how to integrate AI agents into their actual work processes, which is much harder to copy than installing software.

The Competitive Advantage Is Massive

Here's what happens when your organization adopts MCP end-to-end while your competitors are still debating whether it's a nice-to-have:

Your engineers ship faster because they spend less time on coordination overhead and context gathering.

Your support team resolves issues faster because they have better tools for diagnosis and escalation.

Your sales team closes deals faster because they can provide immediate, accurate answers to customer questions.

Your operations team prevents incidents faster because they can spot patterns and correlations that would otherwise go unnoticed.

The organization that moves faster, resolves issues faster, and serves customers better doesn't win by a small margin. They win decisively.

The Question for Your Organization

Is MCP a nice-to-have or a must-have? The honest answer is: it depends where you are on the adoption curve.

If you haven't solved the implementation challenges yet, it's fair to say MCP is nice-to-have. You have more pressing priorities, and the theoretical benefits don't outweigh the real costs of implementation.

If you've solved security, governance, and integration, MCP becomes must-have. The productivity gains are too large to ignore, and your competitors who haven't figured this out yet are falling behind.

If you're somewhere in the middle—experimenting with MCP, running pilot projects, working through the governance questions—the real question is: how fast can you move from nice-to-have to must-have?

What It Actually Takes to Get There

Based on conversations with organizations at various stages of MCP adoption, here's what separates the teams seeing real value from those stuck in pilot purgatory:

Executive commitment: Someone in leadership needs to own AI adoption as a strategic priority, with budget and headcount to match. This isn't a side project for a few engineers to tackle in their spare time.

Security partnership: Your security team needs to be involved from day one, not brought in at the end to approve or block. The organizations succeeding with MCP have security leaders who see AI adoption as a strategic advantage worth solving for, not just a risk to mitigate.

Infrastructure investment: You need to build proper MCP infrastructure—gateway services, authentication layers, monitoring systems. This is platform engineering work that pays dividends across every AI use case.

Governance frameworks: Clear policies on who can deploy MCP servers, how to handle data access, what approvals are required. This sounds bureaucratic, but it's what allows you to move fast at scale.

Bottom-up adoption: The best implementations start with high-value use cases for specific teams, prove the value, then expand. Organization-wide rollouts from the top rarely work.

The Real Divide

The tech world isn't divided into people who think MCP is nice-to-have versus must-have. It's divided into organizations that have solved the implementation challenges versus those that haven't.

The CEO who called MCP "just a nice-to-have" isn't wrong about where most organizations are today. But the organizations that figure out implementation first will make his statement look very wrong very quickly.

So what's your take? Is your organization treating MCP as a nice-to-have experiment, or as a must-have competitive advantage? And more importantly: what would it take to move from one to the other?

‍

Blog

MCP Security: 10 Risks to Review After Patching

Idan Chetrit
00 min
November 26, 2025

CISOs and IT leaders are being asked to approve MCP servers, agent workflows, and internal AI tools while business teams are already testing them through unofficial paths. The hard part isn’t deciding if Model Context Protocol (MCP) is useful, but proving that useful agents won’t take valid credentials and perform the wrong action.

A patched MCP server can still expose the business if an agent is authorized to call a tool, reads malicious context, and executes an action the user never intended. MCP security therefore requires both secure software and controls over the operations that agents can perform.

Key Takeaways

  • Patching addresses known software vulnerabilities. Secure configuration and authorization address additional risks.
  • Prompt injection can influence tool selection and arguments without compromising the MCP server itself.
  • Server provenance, credential scope, tenant isolation, and execution controls require separate review.
  • Visibility alone does not create accountability because agent actions need identity, scope, approval, and audit at runtime.
  • Willow’s Agentic Access Platform combines governed MCP access, identity-linked permissions, runtime controls, shadow AI discovery, and audit.

What MCP Security Must Protect

Model Context Protocol gives agents a standard way to discover context, call tools, and interact with external systems, but enterprise-grade access control, approval flows, least privilege, and audit trails require deliberate implementation.

The MCP architecture describes a host, client, and server model where applications connect to external data sources and tools through MCP servers. Implementations must follow the security requirements applicable to their transport and authorization design.

MCP PrimitiveWhat It DoesSecurity Considerations
ResourceProvides contextual data to an application.Retrieval permissions, sensitive-data exposure, and untrusted content.
ToolExposes callable operations, including queries and changes.Argument validation, operation permissions, execution boundaries, and destinations.
PromptProvides a reusable interaction template.Template provenance and untrusted instructions or embedded content.

Risk here depends on capability and data sensitivity. A read-only resource containing credentials can be more consequential than a tool that creates a low-impact ticket. Additionally, a tool’s schema describes its inputs and behavior, but it is not a separate MCP primitive.

10 MCP Security Risks to Assess

The following risks overlap, but require different controls. Make sure to assess their priority against the deployment’s capabilities, data, exposure, and business impact.

1. Over-Permissioned Tools and Excessive Agency

A tool gets broad API keys, excessive permissions, or a service account with more access than the agent’s task requires. The agent then calls that tool after reading poisoned context, following an indirect prompt injection, or chaining into another workflow.

Confused-deputy attacks are related but distinct: a privileged component is induced to misuse its authority for another party. Excessive permissions alone do not establish that attack.

Here’s an example: an employee asks an agent to summarize a customer issue. The agent then reads a ticket that contains malicious instructions telling it to “sync the full customer table for validation.” If the connected tool has broad database permissions, the action can look legitimate at the infrastructure layer because the agent used valid credentials.

To safeguard against this, we recommend limiting permissions by task, resource, and environment. Additionally, make sure to enforce operation-specific authorization in the target system or a mandatory mediation path, with approval for designated actions.

2. Prompt Injection and Context Manipulation

Prompt injection is the MCP risk that turns trusted access into unsafe execution. In direct prompt injection, a user supplies malicious instructions. In indirect prompt injection, the agent reads malicious instructions from a document, ticket, webpage, email, repository, or other external context.

The MCP-specific failure mode is the jump from reading to doing:

  1. The agent retrieves context through a resource or tool.
  2. The context contains malicious instructions.
  3. The agent treats those instructions as part of the task.
  4. The agent calls a tool with valid credentials.
  5. The downstream system accepts the operation because its authorization checks permit it.

This is why prompt filtering alone is incomplete. Instead, MCP security needs runtime guardrails that evaluate tool calls after context has influenced the agent instead of only before the agent begins work.

3. Rogue MCP Servers and Supply Chain Attacks

Rogue MCP servers introduce supply chain risk at the integration layer. Here, teams may connect public MCP servers, internal prototypes, open-source packages, or vendor-provided servers before security has been able to review how they handle credentials, tool definitions, logging, and outbound calls.

This risk appears in several forms:

  • Slopsquatting: An attacker publishes a malicious package under a name that an AI model invents or recommends despite no legitimate package existing under that name.
  • Rug-pull attacks: A server starts clean, gains adoption, then changes behavior after users depend on it.
  • Credential harvesting: A server asks for tokens or API keys, then stores or forwards them unsafely.
  • Tool impersonation: A server presents a familiar tool name while routing calls to a different backend.
  • Dependency compromise: A safe MCP server imports a compromised package that changes execution behavior.

A reliable governance strategy should include server provenance, code review for internal servers, approved registries, dependency scanning, scoped secrets, and runtime checks on tool behavior.

4. Tool Poisoning and Schema Manipulation

Tool poisoning places malicious or misleading instructions in the descriptions or metadata an agent uses to select and invoke tools. Tool shadowing, on the other hand can influence selection by impersonating or competing with trusted capabilities.

Agents rely on tool names, descriptions, argument schemas, and examples to decide what a tool does. If those details are poisoned, the agent may make a dangerous call while believing it is performing a routine action.

The trouble here is that a description or schema alone cannot prove what the backend actually does. Instead, you need to review implementation behavior and permissions alongside advertised metadata.

Useful controls here include:

  • Versioning approved tool schemas.
  • Detecting schema drift before execution.
  • Restricting tool selection by role, department, and task.
  • Recording approved tool versions or schema identifiers for investigation.
  • Requiring re-approval when a tool adds destructive or external-transmission capability.

5. Insufficient Sandboxing and Local Code Execution

MCP servers often sit close to sensitive execution environments. Their permissions may expose developer machines, CI systems, internal networks, local files, or shell access to connected workflows.

That proximity raises the risk of command injection and remote code execution. A prompt-injected coding agent might call a local tool that runs shell commands. Alternatively, a data workflow might pass attacker-controlled input into a script.

And while sandboxing and isolation can reduce the blast radius, they don’t solve the full governance problem. In some cases, a sandboxed tool can still exfiltrate allowed data, mutate allowed records, or trigger allowed workflows if its permissions are too broad.

We recommend applying these three complementary controls instead:

  • Execution boundaries: Restrict process privileges, filesystem mounts, and access to production credentials.
  • Network boundaries: Limit outbound destinations and review URL-fetching capabilities for access to internal services.
  • Operation boundaries: Separate retrieval from mutation and apply production authorization wherever local tools can reach production.

Tip: Local does not mean low risk. If a local server can execute commands, read secrets, or invoke internal APIs, it needs the same governance discipline as a production integration.

6. Token Theft and Session Hijacking

Token theft and session hijacking become more damaging when MCP tools can act across SaaS apps, databases, developer environments, and internal workflows. A stolen credential can then expose every resource and operation within its scope.

To combat this, validate tokens for the intended resource, restrict their permissions and lifetime, and do not pass through credentials issued for another service. Also, you should check implementation details against the protocol version being deployed.

Common token and session risks include:

  • Long-lived API keys embedded in MCP server configuration.
  • Tokens shared across agents, users, or teams.
  • Service accounts with broad scopes.
  • Session tokens exposed through logs or local storage.
  • OAuth grants that outlive the original business need.

Machine users and service accounts need clear ownership, limited scope, rotation, and action-level policy. OAuth supports authorization, but additional policy may be needed to constrain an operation by task, environment, resource, and approval status.

7. Cross-Tenant Data Exposure

Cross-tenant data exposure is a high-impact MCP risk for any server that brokers access across customers, departments, workspaces, repositories, or environments. The core issue is simple: an agent asks for context or calls a tool, and the server returns data from the wrong tenant or scope.

This can happen through weak tenant isolation, cached context, mis-scoped credentials, shared service accounts, or tool calls that do not bind the request to the initiating user.

Examples include:

  • A support agent retrieving data from the wrong customer account.
  • A coding agent indexing repositories outside the assigned project.
  • A shared MCP server reusing cached context across workspaces.

A good approach here is to derive tenant and user scope from validated identity and enforce it server-side for every retrieval and operation. Additionally, bind caches and credentials to the appropriate scope – do not trust an agent-supplied tenant identifier as authorization.

8. Unmanaged Apps and Servers

MCP makes integration easy enough for unofficial apps to connect to real systems before governance catches up. Shadow AI can include employee-built apps, local servers, browser workflows, and agent-to-agent connections outside approved oversight.

Vibe-coded apps can typically bypass normal controls through five common paths:

  • They connect directly from endpoints instead of managed gateways.
  • They use personal tokens or copied API keys.
  • They call public MCP servers without provenance review.
  • They run local tools that touch internal files or code.
  • They create agent-to-agent flows that security teams can’t see.

For best results, make sure to combine proactive shadow AI discovery with ownership, review, and an approved path for useful workflows. Next, provide sanctioned toolkits, scoped identities, and clear onboarding requirements, then restrict unmanaged access paths where needed.

9. Context Leakage

Context leakage happens when an agent receives or reveals more information than the task requires. In MCP, resources and tools can return documents, tickets, repositories, emails, logs, or database records that enter model context or a downstream workflow.

PII redaction helps, but redaction alone is not enough as confidential information also includes material that does not match PII patterns.

To account for context leakages, make sure to ask these three questions:

  1. Does this user have permission to retrieve this context?
  2. Does this agent need this context for this task?
  3. Can this context be sent to the selected model, tool, or destination?

Then, check authorization before retrieval and apply output controls before restricted information reaches an unauthorized model, tool, or recipient.

10. Incomplete Agent Audit Trails

Logging that shows “user called API” is not enough for MCP security. Audit records should instead connect the initiating user or workload, executing agent, tool operation, target resource, policy decision, and result.

An agentic audit trail should therefore capture:

  • Initiating identity and accountable owner.
  • Agent identity and version, where available.
  • MCP server, tool, and relevant schema or version identifier.
  • Target resource and tenant scope.
  • Approval status, policy decision, and guardrail result.
  • Final action outcome and correlation identifiers.

Here, make sure to record relevant context references where available, rather than indiscriminately copying sensitive payloads into logs. Also apply redaction, access controls, and retention limits.

Tip: When agents delegate work, always preserve lineage across the calls as these records can then support the reconstruction of observable events.

Applying Controls Across the MCP Execution Path

Traditional Identity and Access Management (IAM) remains essential. After all, Okta, Entra, Active Directory, and JumpCloud still anchor workforce identity, SSO, lifecycle management, and policy enforcement for human users.

IAM can also enforce granular authorization, while DLP, endpoint controls, and network restrictions serve to protect supported data and execution paths.

A practical rollout can start with these four steps:

  1. Record owners, provenance, connected systems, and where enforcement applies.
  2. Read-only retrieval, external transmission, record mutation, code execution, and administrative actions should not share one approval model.
  3. Every agent, machine user, and service account needs a human owner, scoped permissions, and lifecycle controls.
  4. Confirm that prohibited operations fail through every available access route, while legitimate workflows still complete.

How Willow supports MCP governance

Willow is the agentic access platform for enterprise AI governance. Our enterprise MCP gateway combines governed tool access, identity-linked permissions, runtime guardrails, approval workflows, and audit.

We extend existing identity infrastructure as well, helping you evaluate which integrations and execution paths are covered, how identity reaches downstream systems, and which bypass routes require endpoint or network restrictions.

Ensure a Secure MCP Beyond the Software Update

Patching MCP servers is crucial as dependency scanning, secure coding, OAuth hygiene, sandboxing, and server provenance all reduce real risk. They work alongside permissions, execution controls, data boundaries, and audit to constrain what agents can do with legitimate access.

However, you need to test those controls against the operations agents can actually perform. An approved server or valid credential should not become permission for unrestricted retrieval, changes, or external transmission.

If you need a ready-made solution, start free with Willow to explore governed MCP access, and review enterprise plans for identity integration, action-level permissions, and runtime guardrails.

Frequently Asked Questions

Does deleting an MCP server configuration revoke its access?

Not necessarily. Removing the configuration does not automatically revoke API keys, OAuth grants, or credentials copied elsewhere. Make sure to review and revoke the underlying access through the systems that issued it instead.

What should happen if the policy service is unavailable?

Ensure to define failure behavior before deployment. For protected operations, deny or pause execution when authorization cannot be established, record the failure, and use a controlled escalation process rather than silently allowing access.

Can a tool stay within its permissions and still cause disruption?

Yes. Repeated allowed operations can exhaust API quotas, overload a database, or generate excessive messages and costs. To combat this, apply rate limits, concurrency limits, execution budgets, and interruption controls alongside permissions.