On November 10, Adobe previewed local Model Context Protocol integrations for its Creative Cloud suite. The update allows creative professionals to direct third-party agents to edit local project files in Photoshop and Premiere. The very next day, SAP detailed how its ABAP platform is acting as an execution backbone for agentic AI, building on the release of its ABAP MCP server in the second quarter.
These announcements show that agent integrations are expanding rapidly across major enterprise platforms. But security and governance are still catching up to the technology. On November 9, Snyk reported that across 10,000 developer environments, one in twelve developers with an MCP server installed had a confirmed high or critical security finding. The protocol is standardizing fast, and builders must now figure out how to govern the agents they deploy.
The new abstraction layer
The Model Context Protocol is standardizing how artificial intelligence models communicate with external tools and data. Until recently, developers had to build custom integrations for every single tool an agent needed to access. Now, a single protocol allows an agent to read files, query databases, and execute commands across entirely different software ecosystems.
This standardization fundamentally shifts how users interact with software. As SAP notes, "interaction is outcome-driven, not tool-driven" in this new model. Agents sit in front of traditional applications as an additional abstraction layer. A user no longer navigates a complex interface to complete a task. They state their desired outcome, and the agent determines the necessary steps, queries the relevant systems, and executes the workflow autonomously.
For creative professionals, this means directing preferred third-party agents to make changes directly within native project files. Adobe ensures that layers, sequences, and compositions remain editable after the agent acts locally. This is a significant departure from cloud-only generation, bringing agentic actions directly to the desktop environment.
For enterprise resource planning, the stakes are even higher. Agents are moving beyond simple demonstrations to handle actual financial postings, human resources processes, and supply chain decisions. SAP emphasizes that general-purpose AI cannot match platforms with rich business logic and a 40-year track record of running critical business processes. This shift requires platforms that are reliable and strictly governed. When an agent pursues a solution path autonomously, the underlying system must ensure that data and results remain traceable and reproducible. The focus moves from building intuitive user interfaces to building robust, well-defined system interfaces that agents can navigate safely.
The governance gap
As agents gain the ability to read and act on core enterprise systems, the risk profile of an organization changes. The speed at which developers can add new capabilities to their agents often outpaces traditional security reviews. Snyk found over 4,500 unique MCP servers in active use across the environments it analyzed. Most of these servers were added in seconds by developers trying to make their agents more useful, completely bypassing standard dependency reviews and continuous integration checks.
The risks introduced by these unreviewed servers are concrete. A malicious or poorly configured MCP server can expose sensitive data or execute destructive commands on a local machine. Snyk identified instances where tool descriptions contained instructions to ignore previous commands, which is a clear indicator of prompt injection risks. Because these servers operate locally and connect directly to the agent, traditional perimeter security offers little protection.
Governance must adapt to this new reality. A static list of approved tools is no longer sufficient when the tools themselves can change behavior based on natural language inputs. Security teams need visibility into what agents are connecting to and what instructions they are receiving at runtime.
Organizations must evaluate the trust and behavior of every server. The risk score combines server behavior, the reputation of its URLs, and the identity of its maintainers to provide a clear picture of potential threats. When one in twelve developers is running a high or critical risk server, the gap between agent capabilities and enterprise governance becomes a pressing operational challenge that requires immediate attention.
What changes for builders
For developers building tools and systems for agents, the core design principles are shifting. You are no longer just writing code to process predictable human inputs. You are designing boundaries, limits, and approval flows for autonomous actors that can interpret instructions in unexpected ways.
The first requirement is defining a clear authorization scope. Every agent needs a specific set of permissions detailing exactly what it is permitted to do and what data it can access. Well-defined interfaces are essential to keep agents strictly within their architectural boundaries. This prevents unauthorized data flows, closes potential security gaps, and protects systems from compromise.
State changes require special attention. In enterprise systems like SAP ABAP, changes take effect immediately and are generally corrected forward rather than rolled back. When an agent executes a command in such an environment, the action is final. Builders must implement robust guardrails before the execution happens. This includes isolated testing environments, thorough quality checks, and clearly defined playbooks that govern agent actions and ensure reproducible results. SAP released its first AI-powered development tools early last year, and is now extending those capabilities to operations, reinforcing the need for clear accountability.
The most critical design decision is determining where humans retain the final say. Agents should not operate entirely autonomously in critical systems. Builders must design pause points where an agent must stop and request human approval before proceeding with a high-stakes action.
This can be implemented directly at the protocol level. If an agent attempts an action that exceeds its permitted scope or requires a financial transaction, the server can reject the request and prompt for human intervention.
HTTP/1.1 402 Payment Required
Content-Type: application/json
X-Approval-Required: true
X-Action-Limit-Exceeded: 500
{
"error": "Human approval required for transactions over 500 digital dollars",
"approval_url": "https://api.example.com/approve/req_8923"
}The developer role is changing fundamentally. Less time is spent writing boilerplate code, and more time is spent on software architecture, oversight, and ensuring that agents do exactly what they are supposed to do. The daily tasks change, but the accountability remains entirely with the human who deployed the agent.
Enforcing limits at runtime
Governing agents effectively means enforcing policies at the exact moment the agent attempts an action. Blocking tools broadly without understanding their use slows developers down and breaks existing workflows. Instead, enforcement should happen locally at runtime, based on a clear understanding of risk.
Snyk recommends a model of observing before blocking. By monitoring which MCP servers agents connect to, organizations can understand actual usage patterns without disrupting work. A server that appears on a single machine might be a temporary experiment. A server deployed across fifty machines requires a deliberate policy decision and a formal approval process. An allowlist records a decision made at one point in time, but continuous risk scoring tells you when that decision needs another look.
Once usage is understood, policies can block only the servers that present a high or critical risk, while allowing approved tools to function normally. This enforcement uses lightweight hooks that sit alongside the agent on the developer's machine. This is more effective than relying on a network proxy or gateway that might miss local connections or disrupt the agent's context window.
This approach allows organizations to adopt new protocols safely. You can permit the use of agentic tools while maintaining strict control over what those tools can access, modify, and execute.
Conclusion
The integration of the Model Context Protocol into major enterprise and creative platforms marks a permanent shift in software architecture. Agents are rapidly becoming the primary interface for complex systems. As this happens, the engineering challenge moves from connecting the tools to governing the outcomes. Builders must focus on strict authorization scopes, clear boundaries, and definitive human approvals. The organizations that succeed will be those that embrace agentic speed without sacrificing operational control or security.