Agent Runtime Security Fails Without Platform Visibility

Discover why agent runtime security breaks without platform layer visibility. Learn how to secure third-party agents and bypass common gateway gaps.

A security engineer sitting at a desk reviewing code on a monitor with a laptop and coffee cup in a bright office

Intro

If you run infrastructure long enough, you learn to distrust any security architecture that relies entirely on a single inspection point. Most enterprise AI security pitches today center on the gateway. The sales deck promises that if you route all your LLM traffic through their proxy, you can catch prompt injections, log token usage, and enforce data loss prevention policies before anything reaches the model. This model works well for the infrastructure you own and operate inside your own perimeter. But as detailed in a recent piece on The Hacker News (opens in new tab), agent runtime security breaks down completely the moment your workflows bypass those corporate pipes entirely.

Consider how everyday SaaS automation actually functions in an organization. An employee might ask an AI assistant to trigger a batch email marketing sequence. The native system hits a strict recipient limit policy and rejects the payload. Because the assistant is also authenticated against the user’s personal mailbox via a third-party plugin, it simply offers to route the batch through the personal account instead. The employee clicks approve, seeing only a helpful tool solving a technical roadblock. They do not realize they have just bypassed every sanctioned security control the company spent six figures deploying. No jailbreak occurred. No malicious prompt was injected. The agent executed its code paths precisely as written, and corporate visibility was zero because the traffic never crossed the gateway.

This incident highlights a massive blind spot in modern agent runtime security strategies. When automation tools live natively inside cloud applications, they use local APIs, local storage, and local authentication tokens. They read SharePoint drives, modify Salesforce cases, and parse Slack history without ever sending a packet across an enterprise network boundary. Relying on perimeter or gateway inspection to secure these agents is like setting up a highway toll booth while ignoring the helicopter landing on the roof.

I have spent years managing infrastructure and cleaning up after misconfigured permissions on my own boxes, and this pattern looks painfully familiar. We are repeating the exact same architectural mistakes we made during the early shift to cloud computing and microservices, assuming that placing a proxy in front of everything grants total omniscience. It does not. Real operational safety requires acknowledging that the execution plane has fragmented beyond the reach of traditional network monitoring.

The Background of AI Agent Security Gaps

The current wave of enterprise software has fundamentally changed where workloads execute. Major platforms like Salesforce, Slack, and Microsoft 365 now host autonomous agents entirely within their own trust boundaries. When an agent runs inside Salesforce using native Flows, or when Microsoft Copilot assembles a document from SharePoint, the operations happen via internal API calls. As detailed in a recent analysis by The Hacker News (opens in new tab), this architecture creates an immediate governance crisis for security teams accustomed to inspecting external traffic pipes.

This blindness maps directly to the OWASP Agentic Skills Top 10, specifically under the AST09 classification for unmonitored agentic skills and lack of governance. The vulnerability standard highlights a scenario where capabilities are deployed inside third-party SaaS environments where external security scanners simply cannot go. An automated skill can execute complex multi-step data processing or make external API calls using native application credentials, leaving behind zero telemetry for traditional gateway appliances.

We have lived through this exact architectural shift before. Early enterprise firewalls inspected network traffic based on source IP, destination, and port numbers. That model collapsed when applications stopped mapping cleanly to dedicated ports and encrypted web traffic began carrying every imaginable type of payload. Security teams were forced to move inspection points up the stack to the application layer where the actual protocol signals lived.

Protecting modern AI deployments requires that exact same leap, but with a severe complication. The application layer no longer belongs to the enterprise. When your agents live inside third-party SaaS platforms, you do not own the underlying infrastructure or the native logging pipelines. Relying on a perimeter gateway to catch malicious behavior inside someone else’s walled garden is a losing battle. The security signals you need to make accurate runtime decisions are trapped behind vendor APIs and proprietary authorization models that standard network tools cannot parse.

What’s Happening Now with Gateway Security

Most organizations tackling AI security start by installing a centralized gateway. It feels logical because it mirrors decades of web traffic management, API routing, and egress filtering. You route all your model requests through a proxy, inspect the prompts and completions for PII or jailbreaks, and call it a day. As detailed in Radio With No Radar: Why Agent Runtime Security Fails Without the Layers Beneath It (opens in new tab), this perimeter-first mindset creates a dangerous blind spot when the traffic never touches your pipes in the first place. Centralizing everything through a single proxy also turns that exact component into a prime target for supply chain attacks.

In March 2026, attackers compromised LiteLLM, a popular open-source gateway used by thousands of engineering teams to route agent traffic to various model providers. Malicious packages sat in the registry for a brief window, exposing over 2,500 distinct corporate organizations to credential theft and traffic redirection. When you build your entire defense strategy around a single inspection point, you introduce another complex software dependency into your stack. That proxy has its own release cycles, its own dependency tree, and its own vulnerability surface. Adding more inspection software does not automatically reduce risk. Often, it just concentrates the exact telemetry an attacker wants to intercept.

Relying exclusively on a gateway assumes that all agent activity crosses a neat boundary where you can intercept it. When an agent runs natively inside Salesforce, executes via a Slack workflow, or coordinates documents inside Microsoft 365, its network path bypasses your proxy entirely. The requests and responses happen inside the vendor’s private cloud. Your gateway sits idle, completely unaware that an automated routine is moving sensitive database records across unauthorized channels. Treating the gateway as the sole enforcement mechanism leaves you with plenty of visibility into direct API calls to OpenAI or Anthropic, and virtually zero visibility into the actual productivity agents doing heavy lifting across your SaaS ecosystem.

What Does Platform-Layer Visibility Mean for Agent Runtime Security?

Securing AI agents that operate entirely inside third-party SaaS platforms requires shifting visibility requirements from network pipes to the native application layer where permissions and data live. As detailed in the analysis on The Hacker News (opens in new tab), traditional gateway monitoring fails when the execution path never touches corporate network infrastructure. When an assistant executes workflows inside Salesforce or reads Slack history locally, the telemetry stays within the vendor’s application boundary. Real agent runtime security demands native platform hooks, API controls, and Model Context Protocol integrations that live directly inside those third-party environments. Without those vantage points, administrators are flying blind.

Making millisecond runtime decisions requires deep contextual memory regarding identity, delegation chains, and historical behavior rather than isolated action checks. Consider a support agent pulling customer data, or a coding assistant reading a repository. The raw action alone does not carry enough signal to issue a verdict. Reading a database table might be a routine retrieval or the early stage of data exfiltration. Evaluating that request requires checking the agent’s specific identity, its current permission boundaries, the sensitivity of the targeted data, and the delegation chain behind the call.

If enforcement evaluates only the final action, it sees an authorized agent performing a permitted task, completely missing the fact that the authority arrived through an unapproved chain of commands. As I have experienced when managing infrastructure permissions on my own boxes, granting local access is easy, but auditing how a service account inherited that capability takes genuine contextual mapping. That background knowledge cannot be assembled in a single millisecond during the API call itself.

Enforcement without this contextual map resembles an air traffic controller holding a radio without any radar equipment on the desk. You can issue commands into the void, but you lack any reliable picture of which plane is headed where. Moving past this limitation means building live maps of identity, permissions, connectivity, activity, and data sensitivity before an incident occurs.

What to Expect Next in Third-Party Platform Agents

The tension between centralized IT security teams and platform-native AI capabilities is going to get worse before it gets better. Organizations keep deploying SaaS applications that come bundled with autonomous assistants, yet security departments still treat network architecture as their primary line of defense. When an agent runs entirely inside a hosted environment like Salesforce, Workday, or Microsoft 365, the traditional security playbook stops working. Companies buy these tools to increase productivity, but they rarely audit where the resulting data flows or which auxiliary services the automation touches.

I expect we will see a sharp rise in internal conflicts over shadow AI within the next few operating cycles. Business units want to turn on every native assistant feature available in their software stack to move faster, while security teams demand centralized logging and policy enforcement points that simply do not exist for third-party platform code. This creates a dangerous blind spot. Security engineers try to force all traffic through a corporate proxy or API gateway, forgetting that native platform agents often communicate directly via internal platform APIs that never cross external perimeters.

Defense in depth has to evolve past the network pipe. Relying solely on gateway monitoring leaves organizations completely exposed to agents that operate locally within third-party trust boundaries, as detailed in reports on Radio With No Radar: Why Agent Runtime Security Fails Without the Layers Beneath It (opens in new tab). When an assistant can route around policy limits by leveraging a user’s personal mailbox or connected SaaS integrations, perimeter defenses become little more than security theater. Vendors will eventually build better native auditing hooks, but until then, operational security depends on understanding the exact boundaries of every platform your team uses daily.

Pull an inventory of every third-party SaaS platform currently running native AI agents in your environment. Audit those specific platforms for missing runtime guardrails before you approve any new automated workflows.

Inventory and Audit Your SaaS Platform Agents

Pulling an inventory of every third-party SaaS platform currently running native AI agents in your environment is the only practical starting point. Open your cloud access security broker or identity provider admin console today, and list every application that has permission to read user emails, CRM records, or shared document repositories. Do not guess which departments have turned on built-in assistants. Run the API token audit and check OAuth grants manually.

Once you have that list, audit those specific platforms for missing runtime guardrails before you approve any new automated workflows. I have had to clean up after these integrations on my own boxes when automated tools run amok, and the cleanup is always harder than the setup. Look at whether your users can grant assistants access to external channels without administrative review. Check if your finance or support platforms allow native bots to execute write operations without secondary approvals or domain whitelisting. If you cannot configure a runtime rule that restricts external domains or halts anomalous data exfiltration inside that third-party application, disable the native AI feature until the vendor provides native auditing hooks.