Est.

The Business Unit Leader's Mandate for AI Agent Access That Doesn't Route Through IT

Business units can adopt AI agents safely without waiting on IT.

· 8 min read
Cover illustration for “The Business Unit Leader's Mandate for AI Agent Access That Doesn't Route Through IT”
AI Change Management · November 18, 2026 · 8 min read · 1,906 words

Enterprise AI agent enablement for non-technical employees needs a governed self-service model. Business units should be able to give staff access to agents through a central platform that has identity, limited permissions, approved tools, and audit records built in. The mandate is to remove IT as a middleman without removing it as a safeguard.

Why the enterprise intake process was never built to see an AI agent

A product team builds a customer-onboarding agent that connects to Salesforce, DocuSign, and a payment processor. Every SaaS connection is already approved, so the intake checklist does not call for a security review. The agent goes live with OAuth tokens, API keys, and write access to production systems. Nobody opens a security ticket for the deployment. The checklist has no category called “AI agent,” so it never asks anyone to assess what those connections let the agent do together.

That is a classification failure. Agents arrive through software release pipelines, low-code platforms, and SaaS integrations that look like ordinary engineering work. They get the lighter review used for those familiar paths, even though they can act across systems and need to be assessed differently. Neither the business unit nor IT needs to deliberately evade a rule for this gap to appear. The process recognizes the individual tools but misses the actor being given access to them.

What agents actually do that makes the missing category dangerous

An agent does more than receive data behind a login. It can initiate outbound connections, execute code, and retain credentials after the task that required them has ended. It can also read, write, send communications, trigger workflows, and invoke other agents. A compromised agent therefore gives an attacker more than a place to retrieve information. It can provide a means to act across the business.

That access tends to grow with use. As an agent becomes part of daily work, granting another permission becomes easier than interrupting the workflow to reconsider its scope. When teams are under pressure to deliver, they give broad access for tasks they expect the agent to do and plan to narrow it later. That tightening rarely happens. A single over-permissioned agent can then offer access that would otherwise require compromising many human accounts.

Obsidian Security’s cases show enterprises with hundreds of agents that are missing from inventory records. The danger is not just the number. Without an inventory, the missing intake category carries the added cost of losing a reliable link between each agent’s growing permissions and its intended task. To reduce that risk, governance has to reach the technical layer where agents get access.

MCP as the connective tissue business units are deploying without a framework for governing

The Model Context Protocol, or MCP, is the standard integration layer between AI agents and enterprise tools. Rather than requiring a separate custom connection for every agent-and-tool pairing, it provides a common interface. Anthropic open-sourced MCP in November 2024 and donated it to the Linux Foundation’s Agentic AI Foundation in December 2025. That standardization makes it easier to connect agents to business systems. It also makes MCP infrastructure that needs governing.

The concentration of access is the important part. An MCP server can hold credentials for multiple enterprise systems behind one interface, so a compromised server can affect every system it touches. A business unit deploying an MCP-connected agent is therefore doing more than adding another SaaS connection. It is opening an access path to the tools for which that server holds credentials. Without governance and logging at that layer, the organization lacks an audit trail of what the agent accessed or why.

The five threat classes that materialize when MCP goes ungoverned

Tool poisoning puts malicious instructions inside tool descriptions that users may never see but agents treat as authoritative. Instructions can also enter through content a tool retrieves. Invariant Labs demonstrated that distinction against Claude Desktop, using a malicious GitHub Issue to steer the agent into leaking private repository data through the official GitHub MCP server. That was indirect prompt injection.

Runtime-gated behavior, sometimes called a rug pull, defeats a clean first impression. A server behaves normally during review, then changes its instructions after enough calls. The “Deadbugz” campaign in August 2026 spread a malicious server called “productivity-suite” through public GitHub pull requests. After three ordinary tool calls, it instructed the agent to locate SSH keys, AWS credentials, shell history, and Kubernetes configuration. It also told the agent to conceal that activity from the user.

Over-scoped permissions turn a narrow task into broad authority. A “read my calendar” agent may receive write access, while a “summarize this repo” agent may be able to create branches and open pull requests. MCP tools tend to expose the maximum permissions their underlying APIs allow, leaving the integrator to narrow them. When that work is skipped, the agent can do more than its task requires.

OWASP’s MCP Top 10 project names unapproved or unsupervised servers outside formal security governance as a threat category. Such deployments leave the organization without the oversight applied to its approved infrastructure. Their absence from the governed inventory is itself a gap, even before malicious instructions enter the picture.

Lateral movement lets an attack cross from one agent to another. Cisco’s State of AI Security 2026 report describes a compromised research agent inserting hidden instructions into output consumed by a financial agent. The next agent becomes a new route for the attack. Conventional web application firewalls, API gateways, and data loss prevention tools were not built to judge what these calls are meant to do. Legitimate HTTPS traffic and valid tool invocations can therefore conceal the dangerous behavior.

Why the standard IT response — slow the rollout, centralize approval — does not solve the problem

Routing every deployment through IT adds a queue to a process whose checklist cannot classify agents. Approval can leave the same gaps in place unless the review changes what it requires for identity, permissions, and audit records. An approved deployment is not automatically a governed one.

The delay also creates pressure to find another route. Business units under pressure to meet deadlines can deploy through personal accounts, shadow MCP servers, or API keys that never go into the corporate credential store. This follows the same pattern as shadow SaaS, but the agents can also act on their own. Making IT teams manually mediate every request leaves the missing controls unaddressed and the business without a workable path to adoption.

How to give non-technical staff AI agent access without overwhelming IT

A governed self-service model needs four connected controls, namely identity at every action, just-in-time credentials, enforced tool allowlists, and tamper-proof audit records. Human confirmation adds a safeguard for high-stakes actions. These are criteria for judging an enterprise agent platform before rollout. Staff should be able to use the platform without understanding how those controls work underneath.

Every tool call must be tied to the agent, the user who invoked it, and the policy that allowed it, rather than disappearing into a shared service account. Single sign-on and SCIM integration with the enterprise identity provider form the foundation. Enterprise-Managed Authorization for MCP, launched June 18, 2026, lets IT provision third-party integrations through that provider and revoke access centrally. Because MCP authorization itself is optional, the platform must enforce its authorization requirements.

Just-in-time issuance gives an agent the permissions it needs when it needs them, with automatic expiry. This replaces persistent broad credentials that can accumulate authority as the agent gains more work. For a business user, the benefit is access without having to manage keys by hand. For the organization, it is a narrower permission scope and a shorter period of exposure.

Per-agent tool allowlists specify which MCP tools it may invoke, while a central gateway blocks calls beyond that scope. A poisoned agent cannot simply decide to ignore the restriction. High-stakes or irreversible actions, including financial approvals, credential issuance, and production data writes, should also require explicit human confirmation before execution. Routine access does not need the same treatment as an action that cannot readily be undone.

Evidence requires more than a record that an agent ran. A tamper-proof log must record each invocation, including the agent, tool, parameters, returned result, and authorizing policy. This makes self-service activity reviewable after the fact and supports record-keeping obligations such as Article 12 of the EU AI Act for high-risk systems. These controls put the safeguard in the platform’s foundation. IT enables access through that foundation rather than standing between every employee and every deployment.

How the self-service model changes the role IT and security teams actually play

IT’s work shifts from individual approvals to operating the shared access layer. The platform team defines the approved MCP server registry, sets credential-scoping policies, configures identity binding, and monitors audit records for anomalies. Those responsibilities remain central to safe deployment. What disappears is the need to repeat the same access decision in a ticket for every business unit. IT governs the conditions under which teams can act.

Security can see what agents do without having to route every request. The control layer gives it records of agents, tool calls, and credentials across the enterprise, rather than only the deployments someone remembered to submit. Built-in logs, oversight mechanisms, and access records also provide evidence for compliance work. The evidence no longer depends on a separate effort to reconstruct activity after deployment, though each deployment still needs to be assessed for compliance.

Staff select from approved MCP servers and use built-in credential handling without needing to understand OAuth or manage keys. The practical test is speed as well as control. A leader should be able to deploy a governed agent in the same time it takes to deploy an ungoverned one. If the governed route is slower, the incentive to bypass it remains. The right way must also be the easy way.

The concrete steps a business unit leader can take before the governance platform is fully in place

Start by inventorying every agent running in the business unit, including those on low-code platforms, personal API accounts, and SaaS integrations. The Obsidian cases show why the inventory cannot stop at formally approved deployments. Work with IT to add “AI agent” as an explicit intake category. This makes new deployments visible even when every underlying SaaS connection is already approved.

Then audit the credentials those agents hold. Treat existing API keys and OAuth tokens as though they may be over-permissioned, work out what each task needs, and rotate broad credentials into replacements scoped to that task. Prioritize agents with service-role privileges for systems they only need to read. This directly reduces the authority available if an agent is redirected by malicious instructions. It also starts the work needed for eventual just-in-time access.

Identify the MCP servers behind those agents as well. Scan for active endpoints and keep discovery going across shadow deployments and SaaS-embedded agents, rather than treating inventory as a one-time exercise. Make sure every deployment sends tool-invocation logs to one central place, even before the full governance platform is ready. A team must be able to answer what an agent did last Tuesday. Without that record, review becomes guesswork.

Finally, find the high-stakes actions in each workflow and require human confirmation before they run. Financial approvals, production data writes, and external communications need this bridging control while automated policy enforcement is being built. These steps establish the inventory, boundaries, and evidence on which governed self-service can be built.

Sources

  1. Shadow AI Apps: The Enterprise Attack Surface That Outpaces Monitoring

More in AI Change Management