Zero trust was the right correction to a genuinely bad assumption.
For years, enterprise networks worked like a building with a strict front desk and no interior locks. Get past the perimeter and you were treated as legitimate everywhere. Attackers understood this better than defenders did, and lateral movement became the most reliable technique in the catalogue.
Zero trust network access fixed that. Verify explicitly, assume breach, grant least privilege, authenticate every connection regardless of origin. It closed a real hole, and the enterprises that adopted it are meaningfully harder to attack.
It also has a boundary that is not discussed enough, and autonomous AI has walked straight into it.
Table of contents
- What zero trust network access actually verifies
- The gap after the door opens
- Why autonomous attacks fit through it
- Machine identity makes it wider
- The adversary ZTNA was never designed to see
- Verification plus continuous enforcement
- Frequently asked questions
Key takeaways
- Zero trust network access verifies identity and posture at connection time and grants least-privilege access to specific resources.
- Verification is a decision at a moment; it does not evaluate what a session does after it is established.
- Autonomous attacks frequently arrive with valid credentials, so they satisfy verification rather than defeating it.
- Machine identities widen the gap because they hold standing permissions granted quickly and reviewed rarely.
- Continuous enforcement and quantum-safe encryption belong at the same control point that performs verification.
What zero trust network access actually verifies
It is worth being precise, because zero trust network access does its job well and the criticism here is about scope rather than quality.
ZTNA replaces network-level access with application-level access. Instead of placing a user on the network and trusting them to behave, it authenticates the identity, evaluates device posture, applies policy and brokers a connection to one specific resource. The user never reaches the network itself.
The principles are set out in NIST Special Publication 800-207, which frames zero trust as a set of architectural principles rather than a product category: verify explicitly, use least-privilege access, and assume breach.
The result is a substantial reduction in lateral movement. An attacker who compromises one account reaches what that account was authorised for, not the network it sits on. That is a real improvement and nothing below undoes it.
The gap after the door opens
Here is the boundary.
Zero trust network access makes an access decision. It is an extremely good access decision, identity-aware, posture-aware, policy-driven, least-privilege. But it is a decision made at connection time, and its output is a permitted session.
What happens inside that session is a different question, and ZTNA is not architected to answer it continuously. Once the connection is brokered, the traffic flowing through it is authorised traffic. The system verified who was at the door and what door they were allowed to open. It does not watch what they do in the room.
For human users this was an acceptable trade. People act slowly and their behaviour within a session is broadly predictable. Periodic re-authentication and session policy covered most of the residual risk.
Zero trust asks who is at the door. It does not ask what happens after the door closes.
Why autonomous attacks fit through it
Autonomous attacks do not generally break authentication. They satisfy it.
The most common route into an enterprise is still valid credentials, phished, purchased, inherited from a compromised integration, or belonging to a machine identity that should have been retired. An autonomous attacker presenting valid credentials on a compliant device is a legitimate session by every measure ZTNA applies.
What differs is what happens next, and the speed at which it happens.
A human attacker inside an authorised session moves slowly. They orient, test, and adapt over hours or days, which leaves time for a behavioural control to notice and for someone to respond. An autonomous attacker enumerates every available path in parallel, discards failures in milliseconds, and pursues whatever holds. The objective is reached in seconds to minutes.
Against that, the enterprise response path, detect, queue, triage, escalate, decide, act, is not slow. It is irrelevant. It completes after the event regardless of how well it is staffed.
Zero trust network access verified correctly. It simply had nothing to say about the ninety seconds that followed.
Machine identity makes it wider
The gap widens considerably once the identities involved are not people.
Machine identities now substantially outnumber human ones in most enterprises, service accounts, API credentials, workload identities, and the fast-growing population of AI agents. Each was created for a purpose, scoped to make something work, and in most cases never reviewed again.
They are also a poor fit for the compensating controls that make session-time verification tolerable for humans. There is no step-up authentication for a service account. Device posture is not meaningful for a workload. Anomaly detection tuned to human working patterns produces noise against a system that legitimately runs at 3am.
So the population with the broadest standing permissions is the one where verification is weakest after the connection is made. Autonomous attacks are drawn to exactly that combination.
The adversary ZTNA was never designed to see
There is a second attacker that zero trust network access has no visibility into whatsoever, because it does nothing to your systems at all.
Nation-state actors are capturing encrypted enterprise traffic in transit and storing it, not to read now, but to decrypt once quantum computing matures enough to break the public-key cryptography protecting it. Harvest now. Decrypt later. Exploit forever.
ZTNA raises no alert for this, and correctly so. Nothing anomalous happens on the enterprise side. Every session was verified, authorised and encrypted according to policy. The exposure is that the encryption protecting those sessions is classical, and classical encryption is a temporary state.
CNSA 2.0 mandates post-quantum compliance from 2027, with Canada, the EU, the UK and the UAE following comparable timelines, and the replacement algorithms are already standardised through the NIST post-quantum cryptography project. Every zero-trust-verified session carrying long-lived confidential data over classical cryptography is being added to an archive that becomes readable later.
Verification plus continuous enforcement
The conclusion is not that zero trust network access was a mistake. It is that verification and enforcement are different functions, and most architectures implement only the first.
What closes the gap is a control point that does both: verifies the connection, then stays in the path. Every connection passing through one place, evaluated continuously rather than once, with the ability to block inline rather than escalate.
That is what the Conux cybersecurity gateway is for. Five agents run the loop, one detects, one blocks and writes the rule, one hardens the surface, one logs the evidence, one orchestrates the rest. Detect. Block. Adapt. Prove. No queue, no analyst, no delay. At the same point, quantum-safe encryption is applied to every connection and machine identities are governed rather than assumed.
Nothing is ripped out. Existing identity infrastructure stays, including existing zero trust network access. Existing cloud, applications and AI models stay. The gateway sits in the middle of what is already deployed. Weeks, not quarters. Invisible to users.
Related reading: zero trust and autonomous AI, what a cybersecurity gateway is and the autonomous SOC.
The bottom line
Zero trust network access solved the problem it was designed to solve, and it solved it well.
It answers who may connect to what. It does not answer what a verified session does next, at machine speed, using credentials that were entirely valid, and it has no view at all of the adversary quietly recording the encrypted result.
Two attackers. One gateway.
