TL;DR: Legacy SASE is failing in five ways because network enforcement cannot see browser-level intent, unmanaged devices, or shadow AI interactions, according to Island. The practical issue is not proxy tuning but shifting controls to the endpoint and browser, where modern work now happens.
At a glance
What this is: Island argues that legacy SASE fails when enforcement stays at the network layer while work, files, and AI interactions happen inside the browser.
Why it matters: IAM and security teams need to rethink where policy is enforced because browser-based work and unmanaged devices expose visibility gaps that network-centric controls cannot close.
Context
SASE was designed for an era when work flowed through managed networks, but modern work increasingly happens in the browser on SaaS apps, personal devices, and AI tools. That creates a governance gap: the network can still see packets, but it often cannot see user intent, file handling, or where data is being placed.
The identity angle is real even though this is not an IAM article in the narrow sense. Access decisions now depend on who the user is, what device they are on, and what they are trying to do inside the browser, which makes browser policy part of the broader access control model rather than a separate optimization problem.
Key questions
A: When security stops at the network layer, teams can block destinations but not govern what users do once a page loads. That leaves gaps in clipboard use, element-level controls, prompt handling, and data handling inside SaaS applications. The result is a control model that can redirect behavior but cannot consistently shape it.
Q: Why do browser-based SaaS and AI workflows expose legacy SASE gaps?
A: They move the security decision point to the browser, where the user action happens before traffic becomes just another packet flow. Legacy SASE was designed to inspect network traffic in transit, so it struggles when the real control problem is file handling, intent, and data movement inside the session.
Q: How can security teams tell if SSL inspection is no longer giving real coverage?
A: Look for growing exception lists, widespread bypasses, and business workflows that fail unless inspection is skipped. When teams are routinely trading coverage for usability, the inspection model is no longer governing the traffic path in a meaningful way.
Q: What should organisations do when unmanaged devices cannot support legacy SASE controls?
A: They should move the policy decision to a place the device cannot evade, such as the browser or endpoint interaction layer. If control depends on installing and steering a stack that the organisation does not own, enforcement will remain inconsistent and access governance will degrade.
Technical breakdown
Why network enforcement misses browser intent
Legacy SASE applies controls to traffic in transit, which means the proxy or secure web gateway can inspect connections but not the user action that created them. That matters because browser work is event-driven: clicking, uploading, copying, and submitting are application-layer actions, not packet-layer events. When enforcement sits below the browser, it can see encrypted flows and destinations, but not the file object, the DOM state, or the specific interaction that triggered risk. For modern SaaS and AI usage, that gap is structural, not a configuration issue.
Practical implication: Practitioners should treat browser-layer policy as a control plane requirement, not an add-on to network inspection.
Why SSL inspection is losing coverage
Traditional break-and-inspect depends on being able to decrypt traffic, analyse it, and re-encrypt it without breaking user experience. That model is under pressure from TLS 1.3, certificate pinning, QUIC, and application designs that resist interception. The result is either latency, exceptions, or traffic that never gets inspected at all. Once teams start bypassing decryption to keep work moving, they create blind zones that become normalised over time. The technical problem is not just visibility loss. It is the operational drift that turns exceptions into the effective policy baseline.
Practical implication: Security teams should measure inspection exceptions as a control failure, not as a performance workaround.
How browser policy changes access control for shadow AI
Shadow AI is difficult for legacy SASE because the risk occurs when a user interacts with an AI web app, often by uploading a file or pasting sensitive content. A network proxy may see the destination, but it may not reliably see the file object, the response path, or the point at which data leaves governed context. Browser-enforced policy moves that decision point closer to the user action, which lets controls evaluate the interaction itself rather than guessing from the network path. That is a material shift in control design for modern web and AI usage.
Practical implication: Teams should extend data protection controls to browser interactions if they want meaningful governance over unsanctioned AI use.
Threat narrative
Attacker objective: The practical objective is to move sensitive data or user interactions outside policy visibility and control, usually through browser-mediated workflows rather than overt network compromise.
- Entry occurs when a user reaches a SaaS app, browser workflow, or AI service from an unmanaged or lightly managed endpoint that legacy SASE was not built to govern well.
- Credential or data exposure follows when the browser session allows file uploads, copy-paste, or web socket interactions that the network layer cannot fully inspect.
- Escalation happens as blind spots, inspection bypasses, and unmanaged-device gaps let sensitive content move outside policy control without a reliable enforcement point.
- Impact is loss of visibility and data governance over browser-based work, especially where shadow AI or unmanaged devices create uncontrolled access paths.
Breaches seen in the wild
- Vercel Context.ai OAuth Supply Chain Breach: Shadow AI app Context.ai OAuth integration exposes Vercel customer data via unmanaged third-party token.
- OmniGPT breach claim 2025: A hacker claims to have leaked 34 million OmniGPT AI chat messages holding users' API keys and credentials; OmniGPT has not confirmed it.
Read and download The State of NHI & AI Agent Breach Report 2026, covering 200+ breaches impacting Non-Human Identities including AI Agents.
NHI Mgmt Group analysis
Browser enforcement is becoming part of access governance, not just security tooling. Once work happens inside SaaS and AI interfaces, the control question is no longer only how traffic is routed. It is who can do what inside the browser, on which device, and with what data handling rules. That pushes browser policy into the same governance conversation as identity, session control, and data protection.
The perfect-packet concept exposes a real control gap in legacy SASE: packet visibility is not interaction visibility. A network stack can be extensive and still miss the user action that matters. The industry mistake is treating inspection depth as equivalent to governance depth, when the actual failure is the inability to govern browser-level intent.
Shadow AI turns browser policy into an identity and NHI issue at the same time. If a user can upload data into a non-sanctioned AI app, the organisation loses control over both the human session and the downstream non-human processing path. That makes browser policy, AI governance, and identity context converge in the same enforcement decision.
Unmanaged devices are not merely a device-trust problem, they are a policy-reach problem. When controls depend on software that cannot be reliably placed on BYOD or contractor endpoints, the governance model stops at the device boundary. The better question is not how to extend the old stack further, but where the policy decision must move to remain enforceable.
Legacy SASE now creates operational drag because it tries to preserve a network-first model for a browser-first world. That mismatch multiplies tool layers, exceptions, and exceptions to exceptions. The practitioner takeaway is to reassess whether the control architecture still matches the actual work pattern, especially for SaaS, AI, and unmanaged access.
What this signals
Browser-level enforcement is now the right mental model for modern access control. Network security still matters, but it is no longer sufficient when user work, AI prompts, and data uploads all happen inside the browser. Practitioners should expect access governance, data protection, and session control to converge around the interaction layer rather than the perimeter.
Shadow AI makes the browser a governance boundary, not just a delivery surface. If an organisation cannot see what a user uploads into an AI app, it cannot claim meaningful control over that workflow. That pushes teams to align identity context, device posture, and browser policy instead of treating AI usage as a separate exception.
Legacy SASE stacks are accumulating control debt. The more teams depend on decryption, backhaul, and inspection exceptions, the more the architecture diverges from how work is actually done. The practical signal is simple: when browser behaviour drives business risk, controls must follow the browser.
For practitioners
- Map browser-enforced policy into your access architecture Define which decisions must be made at the browser layer rather than in the network path, especially for SaaS, AI, and data upload workflows.
- Inventory shadow AI interactions by user workflow Track where employees upload files, paste content, or exchange data with unsanctioned AI apps so controls can target the actual interaction points.
- Measure SSL inspection exceptions as governance debt Review how much traffic is bypassing decryption, why it is bypassed, and which business workflows now depend on those exceptions.
- Rework unmanaged-device access rules Separate device trust from policy reach so BYOD and contractor access can still be governed without relying on full network steering.
- Align browser controls with data protection policy Ensure file handling, upload blocking, and response scanning are enforced where the user action occurs, not only after traffic has entered the network.
Key takeaways
- Legacy SASE breaks down when it is forced to govern browser interactions using packet-level controls that cannot see intent or file handling.
- Shadow AI and unmanaged-device access expose a control gap that network inspection alone cannot close.
- Practitioners should shift policy enforcement closer to the browser interaction layer if they want visibility, consistency, and usable Zero Trust control.
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
OWASP API Security Top 10 addresses the attack and risk surface, while NIST CSF 2.0, NIST Zero Trust (SP 800-207), NIST SP 800-53 Rev 5 and CIS Controls v8 set the governance and control requirements practitioners need to meet.
| Framework | Control / Reference | Relevance |
|---|---|---|
| NIST CSF 2.0 | PR.AA-05 — Access Permissions, Entitlements and Authorizations | Browser-enforced policy changes how access is granted and governed at the point of use. |
| Recommendation — Apply PR.AA-05 to ensure browser-mediated access decisions reflect current device and user context. | ||
| NIST Zero Trust (SP 800-207) | 6.4 — Resource Access Policies | The article argues that trust decisions must move closer to the session and browser interaction. |
| Recommendation — Place access policy at the interaction layer so trust is evaluated where work actually occurs. | ||
| NIST SP 800-53 Rev 5 | AC-6 — Least Privilege | Legacy SASE gaps show how overbroad access becomes harder to govern when enforcement is remote. |
| Recommendation — Limit browser-mediated access to the minimum actions required for the task and context. | ||
| CIS Controls v8 | CIS-6 — Access Control Management | The post is fundamentally about where control is enforced for users and devices. |
| Recommendation — Review access control boundaries so unmanaged endpoints do not bypass governance decisions. | ||
| OWASP API Security Top 10 | API8 — Security Misconfiguration | The article describes misaligned control architecture rather than a specific API flaw. |
| Recommendation — Treat inspection bypasses and misaligned enforcement paths as security misconfigurations to eliminate. | ||
Key terms
- Browser-enforced policy: Browser-enforced policy is control that evaluates identity, content, and context at the point where a user interacts with an AI service. It is more precise than static blocking because it can distinguish safe interactions from risky ones while the session is still active.
- Shadow AI: AI agents, copilots, or connected tools operating without full visibility or governance from security teams. Shadow AI becomes an identity problem when those systems authenticate with unmanaged tokens, service accounts, or OAuth apps that can reach production resources.
- SSL Inspection: SSL inspection is the process of decrypting encrypted web traffic so security tools can inspect the contents before they are re-encrypted and forwarded. It restores visibility into HTTPS traffic, but it also adds complexity, certificate management overhead, and performance considerations that can limit deployment scope.
- Unmanaged Access: Any access to company data that does not pass through the organisation's primary control and logging stack. In practice, this includes devices, apps, or identities that can authenticate or reach data without being fully visible to IAM, MDM, or audit workflows.
Deepen your knowledge
NHI Foundation Level course, the industry's only accredited NHI security programme, covers NHI governance, secrets management, and the identity controls that underpin secure access decisions. It helps security and identity practitioners connect modern access patterns to governance models that hold up in practice.
Published by the NHIMG editorial team on August 21, 2026.
Updated on October 12, 2026.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org