While most businesses know what their critical assets are, far fewer have a clear understanding of their true cyber risk exposure – or what to do about it. This is especially true for cyber pros watching AI proliferate in the wild and within their networks; most organizations are still working to understand external and internal AI threat exposure, let alone forge a path to AI control. We’ll lay out a framework for analyzing attack paths as part of a business impact analysis, enabling security leaders to build a cyber resilience strategy that directly maps to business outcomes.  

Key Answers 

• How does attack path analysis work? An attack path analysis traces the route an attacker could take from an initial point of compromise to a critical asset and measures the controls that stand in the way to uncover the true scope of exposure. This can be completed as a phased process (involving discovery, modeling, and pathfinding), or automated using free resources like Zero Networks’ Breach Map tool.  
• What is the role of an attack path analysis in a business impact analysis (BIA)? A BIA identifies which assets are critical and what downtime would cost; attack path analysis clarifies how exposed those critical assets are and identifies priority interventions for security leaders targeting cyber resilience objectives.   
• How should enterprises prioritize business resilience investments? By identifying the attack paths with the highest business impact relative to containment readiness, then implementing controls that increase path distance or eliminate entire attack scenarios (like microsegmentation), minimize privilege exposure (just-in-time authentication), and constrain potential damage to key resources (identity-based access controls). 

What is Attack Path Analysis?  

An attack path analysis identifies the route an attacker could take from an initial point of compromise to a critical asset, translating unstructured risk exposure insights into a view of real, exploitable paths.  

In the context of a business impact analysis (BIA), attack path analysis shouldn’t only identify exploitable attack paths to critical assets specifically but should also uncover the interventions that will most meaningfully improve cyber and operational resilience. 

How to Use Attack Path Analysis in a BIA 

A business impact analysis starts with identifying which systems and assets are critical to the strategic success and day-to-day operations of the company. Documenting critical assets – and establishing a baseline estimate of what downtime would cost – is the first step in tailoring cyber resilience strategies to business priorities. An attack path analysis answers the logical follow-up question: how exposed are critical assets?  

To uncover the scope of business exposure, attack path analysis maps open pathways and evaluates the level of effort it would take an attacker to move from a common ingress point to a critical asset, giving organizations a documented map of true exposure tied to likely attack tactics rather than a general sense of risk.  

A list of critical assets tells you what’s important, not where to act first. A cyber resilience focused attack path analysis turns that list into a prioritized map of where risk exposure and business impact intersect most sharply. 

Attack Path vs. Attack Vector vs. Attack Surface  

Security teams will deal with three related yet distinct terms when mapping and evaluating attack paths as part of a BIA:  

• Attack surface is the sum of all points in your environment where an attacker could potentially gain entry or exploit a vulnerability – every exposed port, every identity, every endpoint, every cloud workload, and every third-party integration. The larger and more complex your environment, the broader your attack surface.  
• An attack vector is the specific method an attacker uses to exploit a point in the attack surface and gain an initial foothold. For example, compromised credentials or vulnerability exploitation are common attack vectors.  
• An attack path is the route an attacker travels along through the environment after gaining initial access to reach critical assets – the amount of damage they could do along the way makes up an organization’s blast radius.  

In other words, attack surface describes what can be breached, an attack vector is how breaches can occur, and attack paths illustrate where adversaries can go after gaining initial access to eventually reach critical systems.  

4 Attack Vectors to Map for Every Critical Asset  

Starting with the most business-critical assets, security teams should analyze attack paths using scenarios that reflect today's threat landscape: 

• Compromised user: A standard user account compromised through phishing, credential theft, or malware.  
• Compromised cloud identity or AI agent: Stolen credentials or session tokens for a SaaS, IaaS, or agentic identity, often exploited to pivot into on-premises resources through federation, single sign-on trust relationships, or an AI agent’s standing access. 
• Technical perimeter entry: Exploitation of an internet-facing device or service, such as a VPN concentrator, edge firewall, or public-facing web application, to gain code execution and a foothold for further lateral movement. 
• Trusted vendor/third-party access: A compromised or malicious third party using pre-existing privileged access, like a vendor VPN connection or API integration, to reach internal systems. 

For each critical asset, trace the shortest plausible path per vector.  

How to Map Attack Paths: Discovery, Modeling, and Pathfinding  

With critical assets and relevant attack vectors identified, security teams can begin mapping the attack paths they’ll use to analyze exposure – when done manually, this typically happens in three stages:   

1. Discovery: Inventory Systems, Identities, and Connections 

Uncovering attack paths starts with an accurate view of all network assets, identities, connections – including service accounts, AI agents, and other traditionally under-monitored parts of the network – to effectively track how they might contribute to an exploitable pathway between a given entry point and a critical asset.  

2. Modeling: Uncover Communication Pathways  

Convert discovered inventory into a graphical view of what’s reachable across on-prem, cloud, IoT/OT, and Kubernetes: which systems and identities can access which assets, through what trust relationships, and whether or not that access shows up in routine traffic. 

3. Pathfinding: Chain Exploitable Steps Together  

Starting from a pre-defined entry point, trace the routes an attacker could exploit, including paths gated behind authentication or JIT approval, that lead to a critical asset. At enterprise scale, this usually requires graph traversal algorithms to enumerate every path reachable from an entry point to a given asset.  

Automated Attack Path Mapping  

For enterprises that need an accurate view of exposure without months of manual background work, free tools like Zero Networks’ Breach Map automate all three stages. Breach Map scans the internal network to discover reachable assets, then generates an interactive visual map showing how assets connect, where attackers would move, and what they could reach. 

The report surfaces total assets discovered, how many are reachable via lateral movement, average blast radius, attack surface, and direct and indirect crown jewel risk – without weeks of manual discovery and log analysis. It also acts as a personalized benchmark tool for cyber leaders and teams as they work to lock down key attack paths. 

Analyzing Attack Paths: How to Measure Cyber Risk Exposure  

After mapping attack paths from entry point to critical asset, security teams can analyze paths against three threat containment metrics that signal the true scope of exposure.  

Path Distance: How Attackers Move Laterally Through the Network 

Path distance is the most consequential dimension to measure, because interventions here can remove risk rather than just raising its cost. For example, microsegmentation can close lateral movement pathways and effectively eliminate entire compromise scenarios. For the purposes of measuring containment, focus on assessing four things:   

• Authentication boundaries crossed: Distinct credential challenges between entry point and asset, excluding any boundary satisfied by credentials the attacker already holds. 
• Network segments traversed: Segments governed by actively enforced, granular policy – not segmentation that exists on paper but permits broad access in practice due to accumulated exceptions and policy drift. 
• Enforced inspection points in path: Tools actively operating in prevention mode; detection-only controls don't count, since they depend on a human responding in time. 
• Cross-domain traversal: Genuine trust boundary crossings, like on-prem to cloud or IT to OT, that demand a distinct credential set rather than one satisfied by shared federation. 

Privilege Requirements: What Permissions Attackers Need to Access Critical Assets  

Reaching an asset isn't the same as accessing it. Privilege requirements measure how difficult it is for an attacker to obtain the privileges needed to actually impact a critical asset. As a measure of containment, this dimension carries less weight than path distance because privilege controls typically raise the cost of an attack (rather than removing the route entirely via structural controls), but the two are deeply interconnected. Privilege requirements should be captured through details like:  

• Escalation levels required: Each distinct privilege escalation is a separate point of potential failure for attackers, though shortcuts like cached credentials or over-provisioned service accounts can collapse multiple levels into one. 
• Persistent privileged access: Standing access without just-in-time reauthentication means a single compromised credential can be a ticket to critical assets on its own. 
• Service account density: Broadly scoped service accounts are frequent escalation targets and are often excluded from user activity monitoring. 

Additional authentication requirements: Hardware tokens or out-of-band approval that the entry vector can't reasonably satisfy caps the blast radius outright. 

Data-Layer Controls: Limiting Damage After a Breach 

The final containment dimension to assess along identified attack paths answers the only remaining question: if an attacker reaches the critical asset and manages to gain access, how much damage can they do? This can be measured through controls such as:  

• Encryption at rest: With separated key management, a successful compromise can corrupt or delete data but not read or exfiltrate it. 
• Identity-based access controls: Granular access controls limit what any single compromised identity can reach even after accessing a resource, enforcing a final layer of protection for the most sensitive data.  

How to Identify Top Business Resilience Priorities and Investments  

After analyzing attack paths to critical assets for current containment controls, security leaders should have three things:  

1. An inventory of business-critical assets and an understanding of downtime thresholds  
2. A view of all pathways from common ingress points to those critical resources  
3. A breakdown of how exposed the exploitable paths truly are, measured against containment controls  

With these insights, the final analysis can be completed – the goal is to find where business impact and containment readiness converge most sharply. For example, if a billing system has an extremely low downtime threshold due to its high revenue impact but is directly accessible within two lateral movement pivots via compromised user credentials, then it should rank as a high priority.  

With priorities defined, security leaders have a blueprint for tying cyber resilience directly to business impact. Resilience strategies should be implemented using same threat containment dimensions that help uncover risk exposure and define urgency:  

• Increase path distance or completely remove pathways to critical assets: Granular network segmentation, additional authentication boundaries, and inspection points can eliminate entire compromise scenarios. 
• Reduce privilege exposure: Eliminating persistent privileged access, reducing service account scope, and enforcing just-in-time reauthentication or additional authentication requirements for critical assets can rein in the privilege sprawl attackers rely on.  
• Enforce data layer controls: Implementing granular identity-based access controls and encryption at rest limits the damage an attacker can do if they manage to reach critical systems. 

As security leaders take a more active role in business continuity, this framework delivers a repeatable way to align cyber resilience strategies with board-level priorities.  

Cyber Resilient by Design: Protect Uptime with Zero Networks' Automated, Identity-Driven Microsegmentation  

Zero Networks proactively blocks threats to protect operational continuity with automated, identity-based microsegmentation, delivering the containment layer environments need to close attack paths without impacting legitimate traffic.  

Zero provides immediate visibility into every identity and asset on the network, then automatically enforces adaptive, identity-aligned policies based on observed network behavior. With always-current network visibility and a deterministic, human-on-the-loop automation engine, Zero Networks delivers preemptive cyber resilience with no manual effort or operational complexity. 

Learn how you can build a closed-by-default architecture that measurably improves business resilience – request a demo.  

Automated containment is the foundation of cyber resilience, translating to defensible uptime protection. When attackers move in seconds, AI-enabled workflows execute in parallel, and identity systems authenticate continuously, human response cycles can’t keep up, so defenders’ only durable advantage is limiting access by default. 

We’ll walk through a simple framework for benchmarking your current network resilience on the path to automated containment and share a roadmap for building a self-defending architecture.  

Key Answers  

• How does automated containment strengthen cyber resilience? Automated containment strengthens cyber resilience by constraining blast radius structurally, so a compromised asset is isolated automatically rather than depending on a team to detect and respond fast enough. This shifts resilience from a reactive workflow to a demonstrable outcome – uptime and continuity hold during an incident because containment is built into the architecture itself, not bolted on after the fact. 
• What are the pillars of network resilience? Containment architecture, identity and access governance, network visibility, and policy automation are the four central priorities for building network resilience. Together, they proactively minimize blast radius to contain the impact of any attack.  
• What does a self-defending network architecture look like? Automated, identity-aware microsegmentation keeps access paths closed by default, privileged access requires just-in-time authentication, and a real-time network map informs dynamic policy automation, so coverage adapts as the network changes.  

5 Stages of Network Resilience: Maturity Benchmarks  

Cyber resilience isn’t just about recovering from a breach – it’s about preventing the breach from spreading in the first place, so sensitive systems stay isolated and critical operations keep running. Rather than more automated detection or faster response, true resilience limits the impact of a breach automatically by proactively constraining blast radius.  

Because network resilience refers to an infrastructure’s capacity to provide continuous business operations, it’s the most direct measure of security success against business priorities – and it’s achieved when four interconnected capabilities work together:  

1. Containment architecture: How granularly assets and workloads are isolated from one another – and how much of the environment is accessible from any given foothold – defines the structural ceiling on how far a breach can travel, known as the blast radius.  
2. Identity and access governance: Network architecture defines the shape of the environment; identity determines who can move through it, where they can go, and under what conditions. 
3. Network visibility: Comprehensive, real-time visibility across every asset, workload, identity, and communication pathway ensures that resilience controls reflect the environment as it actually exists.  
4. Policy automation: A security posture held together by manual processes and periodic reviews will drift as the environment changes; automation ensures controls adapt continuously rather than degrade slowly. 

With these pillars in mind, organizations can map their network resilience against a simple five-stage framework:  

• Stage 1 – Flat and Blind: Everything trusts everything and there are no East-West controls.  
• Stage 2 – Alert-Heavy: Tools like EDR and SIEM provide visibility without containment.  
• Stage 3 – Early Containment: Some level of segmentation has been implemented but policies are manual and constantly multiplying. 
• Stage 4 – Automated Containment: Identity-aware segmentation automatically blocks unauthorized lateral movement. 
• Stage 5 – Self Defending: Adaptive controls create an audit-ready posture and breach containment is built into the network architecture. 

According to Chris Boehm, Field CTO at Zero Networks, most organizations sit between stages two and three today – they have tools in place, they complete red teaming exercises, and they meet basic compliance requirements, but they’re grappling with an unmanageable alert volume.   

“A developer says, 'I need access to everything or I won't get this done.' You open holes temporarily. A temporary hole here, a temporary hole there. You're paying someone $200,000 a year and you just need to get them going. That's how most organizations end up between stages two and three.”  

- Chris Boehm  

Benchmarking your current network resilience across core pillars delivers a clear starting point for building automated containment and, in turn, strengthening cyber resilience.

Automated Containment Roadmap: How to Build a Self-Defending Network Architecture 

As security leaders are increasingly tasked with proving a zero-tolerance policy for downtime, building automated containment – that dynamically adapts as the environment changes – into the network architecture is the most reliable path to true network resilience.  

Regardless of where your resilience posture sits today, you can reach a self-defending state in months by following a four-step roadmap:  

1. Map Every Network Asset, Identity, and Connection 

Manual discovery has historically taken months and gone stale almost immediately, since new assets and accounts appear faster than periodic audits can track them. By leveraging an automated solution, security teams can immediately pinpoint all assets and identities then learn logon activities, account behaviors, and asset access patterns to establish a baseline without the months of manual effort.  

This is the step that pulls flat, alert-heavy networks out of established blind spots, where East-West and inter-VLAN traffic often lacks visibility.  

2. Generate Deterministic, Identity-Aware Segmentation Policies  

Using the behavioral baselines learned through real network mapping and observation, a deterministic, human-on-the-loop automation engine generates and enforces granular, identity-based policies that precisely lock down unauthorized lateral movement without impacting legitimate operations.  

This step replaces implicit internal trust with explicit, least-privilege access, moving organizations out of early containment stages – where manually scoped exceptions keep multiplying to create gaps – and into automated enforcement. 

3. Enforce MFA on Privileged Internal Pathways  

Four admin protocols account for an outsized portion of lateral movement – 71% of enterprise threat activity flows through SMB, RDP, WinRM, and RPC. Business operations depend on privileged internal pathways like these, which is why they typically remain open, even in organizations that have made meaningful network segmentation progress. The fix is adding just-in-time network-layer MFA to make privileged access verified and time-bound, ensuring attackers hit a dead-end while legitimate operations keep moving.  

This is the identity governance evolution that closes least privilege security gaps, so attacks are automatically contained regardless of how they gain initial access.  

4. Automate Policy Updates Alongside Network Changes  

Modern enterprise environments never stop shifting; static policies can’t provide consistent coverage. The combination of real-time network visibility and deterministic automation closes this gap without manual overhead – new assets, identities, connections, and behaviors are automatically mapped and addressed with fine-grain policies, unlocking a self-defending architecture for true network resilience.

Fast-Track Cyber Resilience Success with Zero Networks  

Zero Networks delivers the proactive containment layer enterprises need to protect uptime with automated, identity-based microsegmentation, unlocking 91%+ segmentation coverage within 90 days.

Zero granularly segments every asset and identity with adaptive policies based on observed network behavior. This dynamic approach means containment remains an automatic architectural feature, even as environments change – removing the privilege creep and rule sprawl that create gaps in static architectures.   

By strengthening every pillar of network resilience, Zero enables security teams to build a mature, business-aligned posture without adding operational complexity or manual effort – request a demo to learn more.  

CertiGhost allows a basic Active Directory account to become a full domain takeover by tricking a trusted certificate system into treating the attacker like a domain controller. Installing Microsoft’s July 14 patch is important, but security teams should also confirm the protection is actually active across their environment. CISOs and their security teams should restrict certificate servers so they can communicate only with approved systems and block unauthorized attempts to copy sensitive identity data from domain controllers. The larger lesson: patches fix individual flaws, while segmentation and tight access controls can stop entire categories of attack.

Microsoft fixed CertiGhost on July 14, 2026. Researchers H0j3n and Aniq Fakhrul published a working proof-of-concept ten days later. If your CAs and domain controllers took the July updates, you are probably in reasonable shape — but you should be aware of the patch-versus-enabled loophole attackers are betting on and go verify that the fix is actually enforcing on your CAs and DCs, not just sitting around installed but inactive. 
I want to share a note on what “patched” means in AD CS specifically. When Microsoft shipped the SID security extension in May 2022 to counter Certifried (CVE-2022-26923), the fix arrived in a compatibility mode that still permitted weak certificate mapping. Full enforcement did not become the default until February 2025, three years later, which means the fix was installed almost everywhere but enforced almost nowhere unless an administrator knew enough to go investigate it. That’s a wide open door for attackers to sneak through. 
The CertiGhost fix leaves a similar attack vector open to attackers – but it hides in plain sight. The new validation sits behind a Windows velocity feature gate — Feature_3185813818 in the patched certpdef.dll, guarding the branch that calls _ValidateChaseTargetIsDC. Velocity gates are ordinary servicing machinery, not evidence of an incomplete fix: they let Microsoft stage, wave, or roll back a change without shipping a new binary, and MSRC security fixes are one of the things they gate. Most security features ship as always-enabled, in which case the gate is a rollback lever nobody will ever pull. What this means to real security teams is that enforcement is a runtime state rather than a property of the build, and a runtime state is something you have to confirm on your own CAs rather than infer from a patch level.
The rest of this post is about the more uncomfortable question. CertiGhost is a low-privileged domain user turning into krbtgt in a single automated script. The chain is short, the prerequisites are close to default, and nothing in it exploits memory corruption or breaks cryptography. It is a missing validation in a trust decision.
Since Will Schroeder and Lee Christensen published Certified Pre-Owned in 2021, the community has kept a running catalogue of AD CS escalation paths: ESC1 through ESC8 in the original research, extended by later work to ESC17. It's not a Microsoft scheme and not a CVE series — it’s an informal numbering that grows whenever someone finds another way to turn certificate issuance into domain privilege. Most of the seventeen are misconfigured templates or weak ACLs on PKI objects. Two of them, ESC8 and ESC11, are relay attacks that work for no reason more sophisticated than an enrollment endpoint being reachable by something that should never have reached it. CertiGhost belongs to the same family: the CA made a trust decision on data an attacker supplied. There will be an eighteenth.
So: if you had not patched on July 14, what in your network would have stopped this?
For most environments the honest answer is nothing, because the attack looks like ordinary Windows traffic at every step. But two of the four network legs in the chain are gateable with controls that don’t know or care that CertiGhost exists. That is the point worth making. 

Key answers in this article

• What is CertiGhost (CVE-2026-54121) and why does patching alone not close the risk? CertiGhost is an Active Directory Certificate Services (AD CS) exploit chain that turns a low-privileged domain user into a domain controller by tricking a certificate authority into signing a DC-identity certificate, which converts into krbtgt compromise via PKINIT and DCSync. Microsoft patched it July 14, 2026, but the fix ships behind a Windows velocity feature gate, meaning enforcement is a runtime state on each CA rather than a guaranteed property of the patch — the same pattern that left the 2022 Certifried fix in compatibility mode for nearly three years.
• How does the CertiGhost attack chain actually work? The exploit abuses AD CS's "chase" fallback, where a CA follows attacker-supplied cdc and rmd enrollment attributes to a secondary lookup host without validating it's a real domain controller; an attacker stands up rogue SMB/LDAP/LSA services, creates a machine account via the default ms-DS-MachineAccountQuota, relays Netlogon authentication to a real DC, and receives a certificate carrying that DC's identity.
• What single network control neutralizes the most dangerous leg of the attack? Default-deny egress on the certificate authority — permitting outbound SMB and LDAP only to known domain controllers — collapses the attack before identity confusion occurs, because this control requires no knowledge of CertiGhost, no signatures, and no patch-level awareness; it simply enforces that a CA's legitimate outbound peer set is small, stable, and enumerable.
• Why does per-asset microsegmentation matter more than per-subnet or VLAN-based rules? A CA sitting in a broad server VLAN with permissive east-west traffic has effectively no egress policy at all; the defensive value comes specifically from scoping rules to the individual asset (or even the process, like certsrv.exe), since CAs have a narrower legitimate communication footprint than the network segment they sit in.
• What is the single highest-ROI rule for blocking this entire class of AD CS attacks? Denying DCSync (MS-DRSR / DRSGetNCChanges) from all non-domain-controller sources is a narrow, low-breakage rule that neuters CertiGhost, every AD CS ESC escalation path, Zerologon, and any other attack whose final move is replicating secrets out of the directory.
• What's the broader architectural lesson beyond this one CVE? CertiGhost will be patched and forgotten within months, like the ESC series before it — but every one of these bugs shares the same weakness: a trust decision made on attacker-influenced data. The defense that ages well isn't one that recognizes cdc specifically; it's one that constrains what a compromised or confused asset can reach, since a CA that can't open SMB to an arbitrary host is indifferent to which validation was missing this time.

The chain, briefly

Certificate enrollment in AD CS has a fallback path the researchers call a chase. When the CA can’t resolve the requester’s directory object locally — a real scenario in multi-domain forests with replication lag — the enrollment request may carry two attributes that steer a secondary lookup: cdc, naming the host the CA should contact, and rmd, naming the principal to resolve.
Before the July patch, the CA followed the cdc value without confirming that the host was actually a domain controller. In certpdef.dll, CRequestInstance::_LoadPrincipalObject read the attribute straight out of the request and passed it into _GetDSObject with chase enabled. The July build wraps that call in _ValidateChaseTargetIsDC, which rejects IP literals, LDAP metacharacters, and oversized hostnames, then queries AD for exactly one computer object whose dNSHostName matches and whose userAccountControl carries SERVER_TRUST_ACCOUNT (8192).
The exploit stands up rogue SMB, LDAP, and LSA services on an attacker-controlled host, creates a machine account through the default ms-DS-MachineAccountQuota of 10 so it holds a genuine domain identity, and points cdc at itself. When the CA connects, the rogue services relay the authentication challenge to the real DC over Netlogon — satisfying the CA’s authentication checks — while returning the target DC’s objectSid and dNSHostName as directory data. The CA signs a certificate carrying a domain controller’s identity. PKINIT converts that into Kerberos credentials for the DC, and DCSync converts those into krbtgt.
Four network legs matter:

Leg 2 is the one to sit with. Every other leg is an attacker reaching into your infrastructure, which is the situation security tooling is built for. Leg 2 is your certificate authority — one of the most trusted machines in the domain — opening an SMB and an LDAP session outbound to an attacker’s Linux box, because a string in an untrusted request told it to.

Leg 2: the CA’s outbound peer set is small, and this isn’t in it

A certificate authority is not a general-purpose client. Its legitimate outbound connections are few, stable, and enumerable: domain controllers, its database, possibly an HSM, and wherever it publishes CRLs. That list changes on the order of once a year.
Which means the exploit’s critical leg is not merely suspicious — it is outside the CA’s entire behavioral envelope. Default-deny egress on the CA, permitting SMB and LDAP only to known domain controllers, collapses the attack before the identity confusion ever happens. The rogue LSA service never gets a connection. No directory data comes back. No certificate is issued.
The bar this sets is high rather than infinite. An attacker who has already compromised a host the CA is permitted to reach can stand the rogue services up there instead, and the chase succeeds. But that moves the prerequisite from “create a machine account, which the default quota lets any user do” to “own something on the CA’s short list of permitted peers” — a materially different class of problem, and one you are far more likely to have instrumented.
The thing worth dwelling on is that this control requires knowing nothing about CertiGhost. It doesn’t parse cdc. It doesn’t inspect enrollment attributes. It doesn’t need a signature, a patch level, or a threat intel feed. It enforces a statement that was true before the CVE existed and remains true after: this CA talks to these hosts on these ports, and nothing else.
Two things make this practical rather than aspirational. The first is automated policy generation — you cannot hand-write egress policy for every server in an estate, but you can observe what each asset actually connects to and propose a least-privilege ruleset from that — then run it in monitor mode and see what it would have blocked before it blocks anything. The organizations that get burned by least-privilege network policy are the ones that wrote it from an architecture diagram instead of from observed traffic. The second is that policy has to be per-asset rather than per-subnet. A CA in a broad “server VLAN” with permissive east-west rules has effectively no egress policy at all; the whole value is in the CA’s ruleset being narrow specifically because CAs have narrow needs.
If you want to go further, per-process egress narrows it again: certsrv.exe has a smaller legitimate peer set than the host as a whole, and the chase originates from exactly that process.

Legs 1 and 4: RPC-layer control

The remaining legs are RPC, which makes them addressable at a different layer.
Leg 1 is MS-WCCE enrollment. In the public PoC — impacket-based, no web enrollment endpoint involved — that means ICertPassage over DCERPC on the \pipe\cert named pipe: interface 91ae6020-9e3c-11cf-8d7c-00aa00c091be, opnum 0, CertServerRequest. The cdc and rmd attributes ride in that call’s attribute string. Note the transport: this is ncacn_np over port 445, not ncacn_ip_tcp over 135, so a port-based rule aimed at the RPC endpoint mapper never sees it. An RPC firewall that hooks the RPC runtime rather than filtering ports does.
Be precise about what this buys you. Filtering at the interface and opnum level tells you who may submit enrollment requests over RPC; it does not distinguish a malicious cdc from a benign one, because the discriminator is a string inside the parameters. So Leg 1 is an allow-list exercise: enrollment RPC to the CA should come from managed endpoints and enrollment proxies, not from an unmanaged host that appeared in the domain forty seconds ago. That shrinks the population who can attempt the attack. It does not identify the attempt.
It also only covers the RPC transport. If you run Certificate Enrollment Web Services, MS-WSTEP over HTTPS reaches the same policy module and the same chase logic, and RPC-layer filtering is blind to it. Leg 1 coverage is incomplete wherever web enrollment is deployed — which is another argument for Leg 2 carrying the weight, since egress policy on the CA is indifferent to how the request arrived.
That allow-list does have a second payoff worth naming. ESC11 is NTLM relay against precisely this interface — the RPC-based enrollment endpoint, as distinct from ESC8, which relays to the HTTP one. So restricting who may reach ICertPassage constrains CertiGhost’s submission leg and ESC11 with the same rule. That is the difference between an architectural control and a patch: the patch closes one bug, the rule closes a class of reachability.
Leg 4 is where RPC filtering earns its keep unambiguously. DCSync is MS-DRSR — interface e3514235-4b06-11d1-ab04-00c04fc2dcd2, DRSGetNCChanges at opnum 3. Only domain controllers have any business calling it. Denying it on your DCs from every non-DC source is a narrow, low-breakage rule, and it neuters the payoff of this attack, every AD CS ESC path, Zerologon and its derivatives, and any other chain whose final move is replicating secrets out of the directory. If you implement one rule from this post, implement that one.
Leg 3, the Netlogon relay, is MS-NRPC (12345678-1234-abcd-ef00-01234567cffb). It is RPC, but every domain-joined machine legitimately speaks it to DCs, so protocol-level blocking is disruptive. The tractable angle is source identity rather than protocol: an unmanaged Linux host making NRPC calls is the anomaly. Treat this as a detection opportunity, not a chokepoint.
Both rules want an audit pass before an enforcement pass. Logging calls to ICertPassage and DRSUAPI for a week gives you the real caller population, which is almost always narrower and stranger than the documentation implies, and occasionally includes a backup agent nobody remembers deploying.
One non-network control belongs on the same list, because it is cheaper than everything above it: set ms-DS-MachineAccountQuota to 0. The exploit needs a machine account to hold a valid domain identity, and the default lets any authenticated user create ten of them.

The generalization

CertiGhost will be patched everywhere within a few months and then largely forgotten, which is roughly what happened with the ESC series before it. The structural observation outlasts it.
Every one of these bugs is a trust decision made on data the attacker influenced, and the fix is always the same shape: add the validation that was missing. So the defense that ages well is not the one that knows about cdc. It is the one that constrains what a compromised or confused asset can reach — because a certificate authority that cannot open SMB to an arbitrary host, and a domain controller that will not replicate secrets to a non-DC, are indifferent to which validation was missing this time.
The cryptography was never the weak part. The reachability was.
If you want to see and control what your CAs and DCs can actually talk to right now — not what you assume they can talk to — request a demo.
 

What happened 

Hugging Face first disclosed an intrusion into part of its production infrastructure and attributed it to an external AI agent whose underlying model was unknown. On July 21, OpenAI took responsibility. The breach came from its own models during an internal cybersecurity evaluation. The models escaped their isolated testing environment and reached Hugging Face from there. 

OpenAI was running the models against an internal benchmark called ExploitGym, which measures how well a model can execute attacks against known vulnerabilities. The models involved were GPT-5.6 Sol and an even more capable pre-release model, with safeguards intentionally lowered for the test. According to OpenAI, the models became hyperfocused and went to extreme lengths to get the test solution. In plain terms, they tried to cheat on the eval by hacking Hugging Face to steal the answers. 

The attack chain 

The mechanics were ordinary even if the attacker wasn't. 

The models found a zero-day in a package proxy to get out to the internet. They escalated privileges and moved laterally through Hugging Face's internal infrastructure until they reached the target: the ExploitGym answer key in a production database. 

Hugging Face's account matches. Malicious content exploited code-execution paths in its data-processing pipeline and landed on a processing worker. From there the attacker escalated to node-level access, harvested cloud and cluster credentials, and moved into several internal clusters. OpenAI's account fills in on the other side. Its models exploited a zero-day in the research environment, escalated, and moved laterally to a node with internet access, then chained stolen credentials and more zero-days into a remote-code-execution path against Hugging Face production. 

Compromise one system. Gain privilege. Steal credentials. Move to the next. Repeat until something valuable is reachable. That sequence is why lateral movement is the control point that decides how bad a modern attack gets. 

The incident didn't turn serious because an AI found one vulnerability. It turned serious because that first foothold led somewhere that mattered. 

Preventing infiltration is no longer enough 

Keep patching. Keep securing pipelines. Keep protecting credentials and watching for bad behavior. None of that goes away. But this incident shows why you can't build a security model on stopping every first compromise. 

AI changes the economics of offense. It can hunt for vulnerabilities, test combinations, retry what failed, and run thousands of actions without getting tired. Hugging Face described an autonomous framework running many thousands of actions across short-lived sandboxes. Work that used to need a skilled team can now be automated. 

So, the asymmetry keeps widening. Vulnerabilities and possible paths grow faster than any team can patch, investigate, or contain by hand. Traditional detection leans on human habits: known tools, known protocols, known sequences. AI agents have none of those. They adapt as they go. The reliable move is to remove the paths, not to recognize the attacker walking them. 

Enterprise networks give an attacker room to run 

The Zero Networks 2026 Lateral Movement Exposure Report shows the size of the problem. Across hundreds of enterprise environments, one compromised system could reach a median of about 85% of the network in a single hop. By the second hop, reachability approached the entire environment. About 60% became reachable inside the first hour. A small foothold can become an enterprise-wide incident before most teams finish triage. 

This isn't spread across thousands of exotic techniques. About 71% of threat-relevant activity sat in four familiar protocols: SMB, RDP, WinRM, and RPC. Businesses run on those every day. Attackers spread on those same protocols. 

The gap holds across the industry. In Kiteworks' 2026 Data Security and Compliance Risk Forecast, a survey of 225 security leaders, 63% said they can't enforce purpose limits on AI agents and 60% can't shut down one that misbehaves. Most can watch an agent go wrong. Far fewer can stop it. 

Hugging Face fits the pattern. The execution path created access. Credentials and too much internal connectivity created reach. Lateral movement turned one vulnerable worker into access across multiple clusters. 

Stop the movement, stop the attack 

Defenders have an edge here. You may not know which vulnerability a human or an AI finds next. You do get to decide which systems can talk to each other and which identities can use privileged pathways. 

If the first compromised worker can't freely reach other nodes, the attack stalls. If stolen credentials can't be reused across clusters, it stalls. If admin protocols are limited to the users and systems that need them, it stalls. The attacker might still get initial execution. The company-wide breach never happens. 

That's the design goal: one compromised system stays one compromised system. 

Detection still matters. It just can't be the only thing standing between initial access and real damage. AI-enabled attackers move at machine speed. An architecture that waits for an analyst to see an alert, work out the path, and block it by hand will keep losing the race. 

When Hugging Face's own responders tried commercial frontier models to analyze the attack logs, the providers' safety guardrails blocked the requests. The models couldn't tell an incident responder from an attacker, so the team fell back to open-weight models they ran themselves. Provider-side safety is not a containment strategy. Containment must live in the network. 

How Zero Networks handles this 

Zero Networks decides which network paths are allowed to exist at all. It deploys directly on servers, cloud workers, and endpoints, and it works at the process level rather than only at the perimeter. So, you can enforce a rule like this: this dataset-processing worker may never SSH into an internal database cluster, no matter what credentials it holds. Present stolen credentials and the path still isn't there. The attack stops at the boundary. 

In the Hugging Face case, the first code execution on the worker was a software flaw. The moment that agent tried to move across internal clusters with harvested credentials, it would have hit a wall. The 17,000-plus recorded events in the campaign all depended on one thing: the ability to move. Take that away and the breach stays a single worker instead of a multi-cluster event. 

A practical agenda for CISOs 

Ask four questions: 

• How much of our environment can one compromised system reach? 
• Which pathways lead to critical servers, cloud workloads, and clusters? 
• Can stolen credentials move through those pathways? 
• Can we contain a compromised workload automatically, without waiting for an analyst? 

Then act on the answers. Segment the network so one compromised system can't reach the rest. Restrict privileged protocols to the systems that genuinely need them. Bind identities to paths so stolen credentials can't travel. Automate containment so a suspicious workload is isolated in seconds. 

The goal isn't to predict every AI-enabled attack. It's to remove the pathways that let any attacker, human or autonomous, turn access into impact. 

Hugging Face detected the activity, contained it, rebuilt the compromised nodes, rotated credentials, and tightened cluster controls. All necessary. The larger lesson is preventative. Constrain the blast radius before the incident starts. 

AI will find vulnerabilities faster. Attackers will chain them faster. The answer isn't a permanent race to patch everything first. You don't have to outrun every new attack. You have to out-architect its ability to spread. 

The blast radius is a design choice. Book a walkthrough and watch Zero Networks contain lateral movement in your own environment. 

Zero standing privileges (ZSP) is an advanced response to that condition that removes excessive standing access rights by default and replaces them with narrowly scoped, time-bound entitlements. We’ll break down what ZSP means, why persistent access has become one of the most exploited weaknesses in modern networks, and a practical approach to implementing the ZSP standard.  

What Does Zero Standing Privileges (ZSP) Mean?  

Zero standing privileges is a security principle that requires eliminating persistent, always-on access rights in favor of just-in-time, just-enough access – granted only when it's needed and only for as long as it's needed.  

Rather than a user, service, admin, or AI agent holding a permission indefinitely, access is requested, verified, and provisioned for a defined window, then automatically revoked when that window closes. 

ZSP vs. the Principle of Least Privilege (PoLP) 

At a high level, zero standing privileges and least privilege are different articulations of the same underlying principle:  

• The least privilege principle states that a user, process, or system should receive only the minimum level of access required to perform its intended function – but it does not limit how long privileges are available.  
• ZSP applies the same access scoping discipline that PoLP requires, then adds a time dimension: access isn't just limited to what's necessary, it's limited to when it's necessary. 

The principle of least privilege was first introduced in the 1970s, while zero standing privileges was coined within the last 10 years, meaning ZSP is an evolution of the PoLP – not a distinct philosophy. And in fact, least privilege is a core tenet of ZSP. 

Key Pillars of Zero Standing Privileges  

Like Zero Trust or any other security philosophy, ZSP is an ideal upheld by a few core principles:  

• Just-in-Time (JIT) Access: Critical for operationalizing the time constraint that is core to zero standing privileges, JIT access allows organizations to unlock temporarily elevated permissions before automatically revoking them.  
• Least Privilege Principle: By restricting every identity – including admins and service accounts – to least privilege by default, enterprises implement the foundation for ZSP.  
• Always-Current Network Visibility: A live network map delivers the real-time insights teams need to keep policies granular and prevent privilege creep.  

Where JIT Isn’t Possible: A Risk-Aligned Approach to ZSP in Real Enterprise Environments  

While just-in-time access is central to the zero standing privileges philosophy, it’s important to note that not every application or workload is designed to support just-in-time access. Some legacy systems require persistent connectivity. Others break under real-time gating.  

This is why a risk-aligned approach to just-in-time access – and, in turn, to ZSP – is critical. By enforcing just-in-time access controls on lateral movement paths, privileged activity, and interactive sessions, while applying least privilege policies to everything else, organizations can achieve zero standing privileges where it matters most without the risk of breaking something.  

A risk-aligned approach like this gets enterprises as close as their environments allow to comprehensive ZSP while effectively managing legacy limitations.

Why Standing Privileges Are a Security Risk 

Privileges accumulate over time for the sake of operational ease. But the same internal pathways that enterprises rely on to keep the business operating are the ones that attackers exploit, creating gaps that leave organizations vulnerable to familiar risks.  

Lateral Movement and Privilege Escalation  

Over 80% of attacks leverage stolen credentials at some stage. When an identity carries broad, always-on access, attackers immediately inherit those entitlements via stolen credentials, allowing them to escalate privileges and move laterally across the network without triggering alerts.  

Overprivileged Service Accounts and Machine Identity Sprawl 

Machine and service identities now outnumber human identities 109:1, and only 2.6% of workload identity permissions are actually used – meaning the overwhelming majority of machine access exists as unmonitored and unnecessary risk. To top it off, AI agents are compounding the issue. Roughly 80% of enterprises are already deploying AI agents, but nearly two-thirds don’t have the necessary policies to effectively govern them.  

Because identity-based attacks exploit legitimate permissions and blend in with normal activity, more detection tools and alert dashboards won’t solve the problem.  

How to Implement Zero Standing Privileges 

Implementing the zero standing privileges model requires a multi-step approach for removing excessive “always-on” access and operationalizing granular, dynamic controls.  

1. Discover every network asset, identity, and activity 

Start by comprehensively mapping every identity, asset, and existing privileged pathway – including service accounts, AI agents, and machine identities, not just human users and admins.  

2. Learn network connections and baseline permissions 

Determine what access is genuinely needed by observing real behavior, logon activities, and asset access patterns rather than relying on assumed or historically granted permissions. 

3. Build deterministic, identity-based policies 

Translate learned network insights into policies grounded in real behavior. Automatically restrict all identities to pre-approved assets and logon types, and define privileged access policies for specific resources tied to identity.  

4. Enforce JIT network-layer MFA for privileged access 

Enforce JIT verification for access to admin protocols, critical services, and other privileged activity. Use context-aware, identity-based policies to ensure that only in-scope identities are eligible for access, and network-layer MFA to provision access only for the duration needed – without adding operational friction.  

5. Dynamically adapt policies on an ongoing basis 

Standing privilege has a way of creeping back in as new accounts, services, and access paths are created. Policies should adapt continuously based on real-time visibility that automatically flags out-of-scope privileged access, anomalous paths, and high-risk ports.  

Close Privileged Pathways by Default with Zero Networks  

Zero Networks delivers every core pillar of ZSP in a single, unified platform – automated, identity-based microsegmentation enables least privilege enforcement at scale, just-in-time network-layer MFA keeps privileged access closed by default, and our real-time network map delivers up-to-date insights that power adaptive policies.  

By making least privilege the default and adding an adaptive authentication at the exact moment of privileged access, Zero Networks removes risky always-on permissions and closes the privileged internal pathways attackers rely on to escalate breaches. Request a demo to learn more.  

Microsoft may be the most dramatic example, but it is not the only one. Since Anthropic introduced Mythos Preview on April 7, 2026, Microsoft’s monthly Patch Tuesday count rose from 120 vulnerabilities in May to 200 in June and a record 570 in July—a 375% increase in two months. Google’s major Chrome releases followed a similar pattern: 126 security fixes on May 5 jumped to 429 on June 2, an increase of approximately 240%, followed by another 433 fixes on June 30. Adobe’s monthly vulnerability count more than doubled as well, rising from 52 vulnerabilities in May to 123 in June—a 137% increase. These figures do not establish that Mythos found these vulnerabilities (although I believe these are of direct result of Mythos and similar models), but they illustrate how many vulnerabilities exist (a lot more for sure) and that we will forever be in a chase a step behind them to really solve for the issue they create an organization must think in a containment mindset. 

Five hundred and seventy vulnerabilities in a single month should also force us to ask a harder question: What happens when finding vulnerabilities scales faster than our ability to fix them? 

Anthropic says its Mythos Preview model has already found thousands of high-severity vulnerabilities, including flaws in every major operating system and web browser. As these capabilities improve and proliferate, both defenders and attackers will gain the ability to discover vulnerabilities at a speed and scale that human security teams cannot match. 

Microsoft’s record Patch Tuesday may be an early indication of that future: AI discovers more flaws, vendors disclose more flaws, and security teams receive an ever-growing list of systems that must be tested and patched immediately. 

The traditional security model tells CISOs to run faster. The better answer is to change the race. 

The Vulnerability Is Only the Entry Point 

A vulnerability does not usually create a companywide outage by itself. It gives an attacker an initial foothold. 

The attacker still needs to move from that compromised browser, laptop, server, identity, or application to the systems that matter: domain controllers, databases, production environments, backup infrastructure, cloud control planes, and operational technology. 

That is where lateral movement turns an isolated security incident into a business crisis. 

Zero Networks’ 2026 Lateral Movement Exposure Report analyzed 54 trillion activities across 312 live enterprise environments. The findings reveal how much freedom attackers typically inherit after that first compromise: 

• 80% of enterprise servers are reachable from anywhere inside the network
• 87% accept inbound RDP or SSH connections from broad internal sources 
• 78.7% are reachable over SMB or WinRM
• 43.2% of internal authentication still relies on NTLM
• A single compromised host can reach 85% of internal systems on the first hop

That last number should concern every CISO. It means an attacker may not need a sophisticated multistage campaign to cross the environment. In many enterprises, the first compromised machine already has a pathway to nearly everything else. 

This is the real danger behind the growing number of vulnerabilities. AI is creating more ways in, while enterprise networks still provide too many ways across. 

Detection and Response Cannot Carry the Security Model 

For years, organizations have built security architectures around a familiar sequence: 

• An attacker exploits a vulnerability. 
• Security tools identify suspicious activity. 
• The SOC investigates the alerts. 
• Responders determine what happened. 
• The organization contains the attacker before material damage occurs. 

Detection and response remain necessary. CISOs still need EDR, SIEM, threat intelligence, incident response, and strong vulnerability management. 

But these capabilities are becoming less useful as the primary control because the model depends on defenders having enough time. AI is compressing that time. 

Attackers can use automation to identify exposed systems, test credentials, enumerate network pathways, and move through trusted administrative protocols. RDP, SMB, SSH, WinRM, and RPC are not inherently malicious. They are the same tools administrators and applications use every day, which makes malicious use harder to distinguish quickly from legitimate activity. 

Our research found that more than 70% of enterprise threat activity travels over SMB, RDP, WinRM, and RPC.  

That creates a fundamental disadvantage for a detection-first strategy: the SOC must identify malicious intent inside traffic the business already trusts, investigate it, and respond before the attacker reaches a critical system. 

At machine speed, that is a dangerous bet. 

The new model should not assume the organization will detect every important action in time. It should assume: 

• Some vulnerabilities will remain unpatched. 
• Some zero-days will be exploited before disclosure. 
• Some identities and credentials will be compromised. 
• Some malicious activity will look legitimate. 
• Some alerts will arrive after the attacker has begun moving. 
• Human responders will not always act before automated attackers. 

The architecture must contain the attack even when those assumptions prove true. 

Build an Architecture That Does Not Care About the Next 100 Vulnerabilities 

No organization can become literally immune to software vulnerabilities. But it can become resistant to their blast radius. Imagine that an attacker exploits an unknown Chrome or Windows vulnerability on an employee laptop tomorrow. 

The first question should not be: Will our SOC detect it? 

The first question should be: What can that laptop reach? 

Can it initiate RDP or SSH connections to servers? Can it access file shares over SMB? Can an attacker use stolen credentials over WinRM or RPC? Can it reach a domain controller, backup system, production database, or critical cloud workload? 

In too many environments, the answer is yes. 

A containment-first architecture changes that answer. It continuously identifies legitimate communication, removes unnecessary pathways, closes privileged ports by default, and requires identity verification when users or agents request high-risk access. 

The 5-Step Practical CISO Checklist 

1. Measure the actual blast radius 

Start with evidence, not architecture diagrams. 

Select a representative employee device, server, privileged identity, cloud workload, and operational asset. Determine which systems each one can actually reach and over which ports and protocols. 

Ask: 

• Can a typical endpoint reach critical servers? 
• Which administrative protocols remain broadly open? 
• Can one compromised credential unlock multiple environments? 
• Is there a direct pathway from user devices to critical assets? 
• How many systems are reachable on the first hop? 

A vulnerability score tells you how serious a flaw might be. A blast-radius assessment tells you how serious it is in your business. 

2. Close unnecessary east-west pathways 

Most internal access exists because nobody has removed it—not because the business requires it. Microsegmentation drastically reduces pathways there by the blast radius and almost eliminates the chance of something unpatched to be exploited. 

Identify and eliminate connections created by flat network designs, legacy configurations, permissive firewall rules, and operational convenience. 

Allow the communications the business needs. Deny everything else. 

Do not wait for the next vulnerability announcement to decide that employee laptops should never have been able to reach production servers. 

3. Protect privileged protocols at the moment of access 

RDP, SMB, SSH, WinRM, and RPC create powerful administrative pathways. They also give attackers the ability to expand a small foothold rapidly. 

Keep privileged ports closed until legitimate access is requested. Require just-in-time identity verification for unexpected human or AI-agent access while allowing known machine-to-machine communications to continue. 

Identity based Microsegmentation help to only open certain ports as needed after strong validation such as MFA.

4. Make containment independent of detection 

Test whether controls stop lateral movement even when the organization has not yet identified the initial compromise. 

Assume: 

• The endpoint tool missed the exploit. 
• The credentials appear valid. 
• The attacker uses legitimate administrative tools. 
• The SOC has not opened an incident. 
• The vulnerability has no available signature. 

Then determine how far the attacker can travel. 

Detection should provide visibility and context. It should not be the only thing standing between one infected laptop and a companywide outage. 

5. Replace SOC-speed metrics with resilience metrics 

Mean time to detect and mean time to respond still matter, but they do not tell the board whether the business can withstand an AI-speed attack. 

Add metrics such as: 

• Percentage of critical assets protected from unnecessary access. 
• Percentage of privileged pathways closed by default. 
• Percentage of servers reachable from standard user devices. 
• Number of verified pathways to critical systems. 
• First-hop reachability from a compromised endpoint. 
• Time required to isolate a workload or environment. 
• Reduction in attack paths over time. 

The central board-level metric should be simple: 

How much of the business can one compromised asset disrupt? 

6. Prepare a credible answer for the board

Boards will increasingly ask: 

What happens when AI finds an exploitable vulnerability before we can patch it? 

“We expect to detect the attack” is no longer a sufficient answer. 

A stronger answer is: 

We know which systems a compromised asset could reach. We have removed unnecessary pathways, restricted privileged protocols, verified high-risk access, and limited the blast radius before the attack begins. 

That is a measurable statement of resilience. 

7. Prioritize vulnerabilities by reachable impact

CISOs should continue patching aggressively, but CVSS scores alone cannot determine business risk. 

Prioritize remediation using: 

• Active exploitation. 
• Internet exposure. 
• Asset criticality. 
• Privilege available on the affected system. 
• Systems reachable from that asset. 
• Existing containment controls. 
• Potential impact on uptime, revenue, safety, and operations. 

A critical vulnerability on a contained asset may create less business exposure than a lower-rated flaw on a workstation that can reach 85% of the environment. 

Start With the Mythos Readiness Pack 

We created the Mythos Readiness Pack to help CISOs translate this new model into practical action. 

The pack helps organizations determine whether their current architecture can contain attacks accelerated by systems such as Mythos. It includes: 

• A Breach Map Tool that exposes the pathways an attacker could use to move from an initial compromise to critical systems. 
• A board briefing deck that enables CISOs to benchmark and walk through their own resilience posture and AI exposure - ready to present as their own. 
• An AI threat brief that explains to a board the best AI strategy is one that doesn't chase AI threats - it contains them. 

This is not another vulnerability scan. 

It does not produce a longer list of defects for an already overloaded team to remediate. It answers the question traditional vulnerability management leaves unresolved: 

What can an attacker do after exploiting one of them? 

Stop Racing. Start Containing. 

Microsoft and Google deserve credit for finding and fixing vulnerabilities before more attackers can exploit them. Organizations should deploy those fixes as quickly and safely as possible. 

But patching 570 vulnerabilities every Patch Tuesday cannot become the blueprint for the future. 

Mythos and frontier models that follow it will find more flaws. Attackers will automate more of the attack chain. Security teams will receive more signals, more patches, more exposure data, and less time to make decisions. 

CISOs cannot hire enough people or buy enough detection tools to win that race indefinitely. 

The answer is an architecture that expects vulnerabilities, assumes compromise, and prevents the attacker from turning initial access into business disruption. The answer is called Microsegmentation. No matter what happens, the business is always up and running. 

Build one where the next 1,000 vulnerabilities cannot become the next crisis. 

This roundup features six Zero Networks customers, spanning private credit, investment banking, wealth management, and beyond, who closed network security gaps without the operational complexity and outage risks that had stalled prior attempts.  

We’ll walk through how these firms leveraged automated, identity-driven microsegmentation to secure legacy systems, enforce granular controls without breaking critical connections, mitigate recurring pen test and audit findings, and build architectures designed to contain vulnerabilities that can't yet be patched.  

Legacy Complexity in Enterprise Networks: Closing Security Gaps  

Inherited infrastructure is the norm in financial services and enterprise orgs. Assets accumulate across years of mergers and vendor decisions, often maintained by separate teams with no unified network visibility. This leaves security teams to face a forced trade-off: accept protection gaps, or risk operational disruptions by enforcing granular controls.  

Real-World Examples  

Antares Capital is one of the largest direct lenders in the US and is responsible for $60B+ in middle-market lending. Their team recognized lateral movement as a portfolio risk as much as a security risk. But disparate legacy assets made it difficult to get a complete view of the network, so the team struggled to determine which ports were actually necessary for business operations.  

Similarly, La Trobe Financial’s environment had been evolving since the 1980s, leaving the security team to untangle decades of legacy complexity. As one of Australia’s leading and most trusted alternative asset managers – and responsible for securing over $20B in assets – La Trobe understood the urgent need to close legacy enterprise security gaps, but many systems were so deeply embedded in critical operations that replacing them would require years of effort and millions of dollars.  

Other microsegmentation products work if you’re in a cloud native environment – if everything is modern, shiny, and new – down here in the real world, we have to deal with some pretty horrible old school protocols that don’t play nice.

- Aaron Steinke, Head of Infrastructure, La Trobe Financial  

The Solution: Full Network Visibility and Agentless Integration  

Antares Capital and La Trobe Financial solved their enterprise legacy complexity challenges with Zero’s deterministic automation engine and agentless approach:  

• Automated discovery of all network assets and identities – including legacy systems – uncovered traffic patterns and dependencies across previously siloed environments.  
• Deterministic, human-on-the-loop automation fuels policy creation and enforcement, enabling precise rules that scale protection to legacy systems without risking disruption. 
• Agentless architecture deploys in minutes by leveraging native, host-based firewalls, enabling a seamless fit with legacy systems – without introducing latency.  

By integrating with existing infrastructure and unlocking end-to-end network visibility, Zero Networks removed the legacy barriers that stand in the way of comprehensive microsegmentation for many financial and enterprise institutions.  

As a result, Antares reached full segmentation in under three months, freeing 10+ hours a week across cloud and networking teams; La Trobe reached a security posture its team described as historically "out of reach," without a multi-year, multi-million-dollar modernization project.  

Implementing Microsegmentation without Disrupting Critical Operations 

Even when legacy complexity is not the primary barrier to a more robust network security posture, financial services organizations often hesitate to implement granular network segmentation for fear that it will break something – will enforcement disrupt the trading systems, client workflows, or applications the business depends on? Overly complex tools and unsustainable manual burdens can break critical connections outright or leave gaps and inconsistencies that risk continuity over time.  

Real-World Examples  

Baron Funds oversees ~$49B in client assets, making continuity and access integrity extremely critical. After other microsegmentation solutions broke the network, the organization was hesitant to move forward, but pen testing reinforced the need for more granular segmentation.  

Evercore faced the same underlying concern. A leading global independent investment bank, Evercore needed to shut down lateral movement across a complex, high-value enterprise environment without adding operational friction or deploying intrusive agents. But traditional approaches – manual access controls, privileged group clean-up, and firewall-based segmentation – required an extraordinary amount of effort that made inconsistencies inevitable and still left exploitable pathways open.  

The Solution: Deterministic Automation and Living-off-the-Land Defense  

Baron Funds and Evercore confidently embraced microsegmentation by removing the manual effort, guesswork, and operational complexity of legacy solutions with Zero Networks:  

• Policies are built from observed traffic and network behavior over a defined learning period, rather than manually assembled rule sets that require guesswork and introduce human error at scale.  
• Deterministic, human-on-the-loop automation eliminates unsustainable manual effort without removing human judgement entirely from the equation.  
• Orchestration of the native controls that already exist in today’s environments enable a non-disruptive, “living-off-the-land” defense. 

[Zero Networks] actually uses technology that we already have – it’s technology that we’ve already had on the network for 20 years. For as long as we’ve had firewalls, we could have done this. We just couldn’t manage the firewall at scale. You couldn’t manage the firewall intelligently. We had every piece of the solution there – what we did not have was the brains.    

- Henry Mayorga, CISO, Baron Funds 

By accurately automating rules based on learned network realities and enforcing them via native controls, Zero Networks gave both organizations the confidence to enforce granular segmentation without betting business continuity on an untested rule set or an unsustainable manual process. As a result, Baron Funds reached full segmentation in 30 days with zero disruptions to network traffic; Evercore locked down lateral movement across the entire enterprise from a single platform, managed by a single part-time administrator. 

As a Banking IT Manager pointed out in a Gartner Peer Insights review, the value of these results compounds at scale:  

Pen Tests, Audits, and Cyber Compliance Requirements: Prioritizing and Validating Controls 

Penetration tests and compliance requirements are some of the most common forcing functions for microsegmentation initiatives – especially in highly regulated industries like financial services. But pen tests and audits don’t only expose gaps to help security leaders prioritize strategies, they also validate the impact of controls.  

Real-World Examples  

Auditors had repeatedly flagged a specific gap with La Trobe Financial: the absence of MFA on high-risk protocols like RDP and SSH. But prior attempts to implement MFA on admin protocols and legacy systems had introduced latency, bugs, or errors severe enough to make the fix impractical. 

ACT Commodities – a leading global provider of market-based sustainability solutions – uncovered the scale of exposure across its Azure Cloud environment the same way. Pen testers could access the environment and exfiltrate data within just five minutes, but reimplementing firewalls, adjusting configurations, and completing the other tasks necessary to protect servers proved too difficult. 

Like many financial services organizations, diversified holding company B. Riley Financial saw the same security gaps surface in pen test results year after year but faced an impossible tradeoff: address persistent findings and disrupt key operations or live with known risks to maintain business as usual. 

There were a lot of years of doing penetration testing and coming up with similar results. There was always a critical. There was always a high. There were always multiples. And we just couldn’t stop those from reoccurring; no matter what we did, those same things would just show up again – we thought we had it fixed and then we’d find out a year later that we still had that issue.”

- Aaron Goodwin, CISO, B. Riley Financial  

The Solution: Closing Gaps by Default with Containment Architecture 

La Trobe, ACT Commodities, and B. Riley all closed exploitable pathways before a pen test or audit could find them, rather than remediating findings one at a time after the fact – if at all. With Zero Networks, these financial services orgs implemented comprehensive microsegmentation and built containment into the network architecture via capabilities like:  

• Network-layer MFA that extends authentication to high-risk protocols like RDP and SSH without touching the underlying legacy systems or introducing new points of failure. 
• Least-privilege access enforced by default, closing the specific pathways that attackers – and therefore, pen testers – rely on, rather than depending on manual review to catch every gap. 
• Continuous, automated policy enforcement generates audit-ready evidence as a byproduct of normal operation. 

By closing gaps structurally rather than chasing them one finding at a time, security teams turn audits and pen tests from a source of stress to a validation exercise. For example, after implementing Zero Networks, La Trobe closed the exact MFA gap auditors had consistently flagged without breaking legacy systems; ACT Commodities' five-minute breach window closed entirely, with later pen tests revealing unwanted lateral movement was completely blocked and contained; and B. Riley finally received a penetration test report with no high alerts, closing out a cycle of findings that had persisted for years. 

We had six findings in our penetration test, and every one of them would have been prevented or mitigated with Zero Networks. There’s not one other product we have that could have come close... Zero Networks is a cornerstone piece of security technology.

Chris Turek, Former CIO, Evercore 

Containing Vulnerabilities Before Patching: Preemptive Security in the Frontier AI Era 

Security teams have long faced an uphill battle keeping up with day-to-day vulnerability management. The issue has compounded in this age of frontier AI, where models like Mythos and Daybreak can find, analyze, and generate exploits for vulnerabilities at a speed and scale no human team can match.  

For example, Mythos found over 10,000 previously unknown vulnerabilities in seven weeks, including bugs that had evaded automated detection for decades. The window between disclosure and exploitation has collapsed. Even if vendors release mountains of patches to mitigate this influx of discovered vulnerabilities, organizations face an impossible tradeoff: patch immediately and manage updates that contain thousands of fixes at a time, or wait and prioritize while accepting risk exposure.  

Instead, financial institutions need a way to protect uptime before patches exist, or while validating that patches won’t cause unintended operational disruptions.  

Real-World Examples 

B. Riley Financial faced versions of the vulnerability exposure problem multiple times. In one case, a Microsoft Outlook vulnerability involving outbound SMB traffic left the firm exposed with no patch available from the vendor. Waiting for a fix meant leaving the exposure open. 

The Solution: Structural Containment as a Buffer Against Unpatched Risk 

With Zero Networks, B. Riley deployed a targeted rule blocking outbound SMB traffic from Outlook to the internet, closing the specific path the vulnerability relied on.  

And critically, this is just one example of how a cyber resilient network architecture designed for containment protects financial institutions against vulnerabilities without patching. More broadly, automated, identity-driven microsegmentation buys security teams time to patch safely by:  

• Closing unnecessary access paths by default, limiting what any unpatched vulnerability can reach, regardless of how it was discovered – or how quickly. 
• Constraining privileged access to explicitly authorized identities, so admin protocols aren’t lateral movement highways.  
• Scaling protection across the entire network, including OT and legacy systems that can’t always be patched on short notice – or at all.  

Having microsegmentation in place has really given us a precautionary protection layer so we can delay applying some of these patches. This gives us plenty of time to test, make sure everything’s working, and then apply it, but still have that protection layer in place. 

- Aaron Goodwin, CISO, B. Riley Financial    

Cyber Resilience for Financial Services: Build a Self-Defending Architecture with Zero Networks  

Legacy complexity, operational disruption risk, compliance pressure, and accelerating vulnerabilities are distinct challenges almost every financial institution faces, but they can all be solved with a single platform.  

By delivering automated discovery across legacy and modern assets alike, a deterministic policy engine that builds and enforces rules from real traffic and identity behavior, agentless integration with existing infrastructure, and network-layer MFA for privileged access, Zero Networks enables financial services orgs to build a self-defending network architecture that proactively blocks attacks without disrupting the business.  

See how Zero Networks makes cyber resilience practical for financial institutions – request a demo. 

But scaling least privilege enforcement across sprawling, multi-business-unit enterprise networks with tens of thousands of assets takes more effort and resources than most teams can spare. As a result, 99% of identities still hold excessive permissions.  

Rather than relying on manual processes to generate and enforce least privilege access policies, security teams can leverage deterministic automation for adaptive, accurate policies – without the manual overhead. We’ll walk through how least privilege policy automation works and share tips for unlocking Zero Trust outcomes faster.  

Key Answers  

• Which tools or solutions help enforce the principle of least privilege? Identity-aware microsegmentation and just-in-time MFA – powered by an automated policy engine that continuously learns network behavior – are the core mechanisms. Together, they restrict every connection to the access that’s operationally necessary for only as long as it’s necessary.  
• What tools help automatically generate least-privilege policies based on observed network traffic? Solutions powered by deterministic automation engines that continuously monitor network activity, build a behavioral baseline from observed connections, and generate policy directly from that baseline. For example, Zero Networks learns all network connections over a 30-day period before leveraging those insights to build deterministic, highly accurate firewall rules and policies that adapt dynamically across networks spanning multiple data centers, cloud regions, and business units. This keeps least privilege enforcement accurate and simple even for the largest, most complex orgs. 
• How can security teams automatically learn and map network connections to create access policies? Real-time monitoring that captures which identities and assets communicate, over what protocols, and how frequently can be used as the direct input for policy generation rather than relying on assumed or documented access requirements. 
• Do AI-generated least privilege policies rely on determinism? No. AI-generated policies are typically probabilistic, based on statistical inference. Deterministic automation generates and enforces policies directly from observed behavior using fixed logic and producing a traceable, precise rule rather than a likely guess. 

Automating Least Privilege Access to Accelerate Zero Trust  

Zero Trust security is based on the philosophy “never trust, always verify.” Enforcing least privilege by default is a non-negotiable tenet of Zero Trust – while Zero Trust defines the philosophy, least privilege enforces the mechanics.  

Modern Zero Trust architectures apply least privilege across human identities, machine-to-machine communications, APIs, AI agents, and service accounts. Network segmentation, identity segmentation, and just-in-time multi-factor authentication (MFA) are the solutions that make this comprehensive coverage possible – but it’s only achievable at scale when automated.  

AI agents introduce a new challenge – unlike a static service account, an agent’s access needs can shift from task to task. OWASP’s Agentic Applications Top 10 Project addresses this directly through its Least Agency principle, which calls for constraining an agent’s autonomy, tool access, and decision-making authority to limit the blast radius of prompt injection or compromised agents. 

Manual Policy Creation Challenges: Static Rules, Security Gaps, and Scale  

Manual policy management has a structural ceiling. Rules are typically written from assumptions about what a role or service account should need, and those assumptions rarely stand up to network realities. So, when least privilege policies are a primarily manual effort, a few common challenges emerge:  

• Static rules go stale almost immediately   
• Security gaps or operational breakage as assumed access requirements produce either overly permissive rules that leave too much room for lateral movement, or overly restrictive ones that break legitimate traffic 
• A scale problem headcount can't fix  

As Gartner points out in its report, Reimagining Network Microsegmentation: Beyond the IP – Identity, Context, and Agentless Innovation, continued reliance on static rules leaves organizations especially vulnerable to AI-driven attacks.  

Vendors clinging to manual policies face rapid obsolescence, as these methods are completely incapable of securing dynamic hybrid networks against lateral movement.

- Gartner  

Deterministic Automation vs. Probabilistic Models  

As manual policy management becomes untenable, many cybersecurity tools have rushed to fill the gap with AI capabilities. But AI-generated least-privilege policies aren't the same as ones built through deterministic automation.  

Probabilistic AI models produce outputs based on statistical likelihood; deterministic automation engines rely entirely on learned realities. 

A rule that's 99% accurate is still wrong enough to break applications or leave security gaps open, which is why AI adoption for security policies is often hindered by what Gartner calls “enforcement anxiety” – the fear that probabilistic algorithms will disrupt business operations. For enterprises that want to automate least privilege policy creation and enforcement at scale but can’t risk operational continuity, deterministic engines offer the best of both worlds.

How Deterministic Least Privilege Policy Generation Works  

Automating least privilege access means translating raw network activity insights to enforceable rules – in practice, that process occurs in four stages.  

1. Observing Real Traffic to Build a Behavioral Baseline 

Before any policy can be written, a comprehensive picture of what's actually happening on the network must be established: which assets and identities communicate, over which ports and protocols, how frequently, and in what direction. This learning period requires continuous observation to build a knowledge base of existing network communication patterns, including logon activity, account behavior, and asset access patterns tied to specific identities – even across networks with hundreds of thousands of connections and complex identity hierarchies.

2. Translating Observed Behavior into Enforceable Rules 

Once a behavioral baseline exists, an automation engine can use it to generate precise policies scoped to what's been observed as necessary for each asset and identity. This is the step that makes the approach deterministic rather than probabilistic – the policy isn't inferred from a model's best guess about likely access needs; it's derived directly from what was actually observed. That distinction is what allows the resulting rules to walk a fine line: tight enough to constitute genuine least privilege and precise enough to ensure legitimate traffic remains unaffected. 

3. Optional Simulation and Review Before Enforcement 

Even when policies are built from real behavior, most enterprises want an added layer of certainty that enforcement won’t break anything. Before any rule goes live, a human on the loop should have the option to simulate its impact – testing the policy against real traffic in a sandbox environment for visibility into what it would allow and block before it affects production.  

4. Keeping Policy Aligned as Behavior Changes 

Generating an accurate least privilege policy once is only half the problem. Modern enterprise networks evolve constantly – new assets appear, old ones get decommissioned, and applications shift how they communicate. Or, new business units get acquired, old ones get divested, and applications shift how they communicate – enterprises need dynamic policy coverage. Automated lifecycle management keeps policies current in dynamic environments: access paths that go unused get closed, new patterns are incorporated, and rule sprawl is structurally prevented rather than periodically cleaned up after the fact. Always-current network visibility fuels the deterministic automation engine, enabling an adaptive least privilege posture.  

Automating Least Privilege Enforcement to Strengthen Business Resilience  

By scaling least privilege across the full enterprise with automation, security teams drastically change the math on what happens when something goes wrong. Because access is continuously scoped to observed network behavior and aligned to business need rather than defaulting to what was granted once and forgotten, breaches are automatically constrained – regardless of how they start. That translates directly into the resilience outcomes security leaders need to show the business: 

• Smaller blast radius by default: access never exceeds what's necessary, significantly reducing the threat of stolen credentials  
• Fewer standing, unused permissions: the exact accumulation attackers rely on to escalate privileges while evading detection gets closed continuously  
• Faster containment: lateral movements pathways that were never open in the first place don't need to be shut down mid-incident 
• Enforcement that doesn’t drift: policies adapt as the network changes, enabling demonstrable compliance and uptime protection  

Deterministic Policy Automation: Real-World Example 

Mediterranean Shipping Company (MSC) operates one of the largest-scale and complex logistics networks in the world, moving 21% of global shipping across a massive footprint of ports, vessels, and facilities spanning dozens of countries. Uptime is nonnegotiable and instability is unacceptable; still, the organization needed a way to strengthen internal defenses.  

Manual segmentation was slow to scale, requiring countless hours of log analysis and manual rule maintenance for only partial coverage. Limited visibility into internal traffic patterns further complicated policy creation.   

MSC offloaded the manual effort of discovery, learning, and policy management to Zero’s deterministic automation engine, successfully segmenting roughly 95% of its servers.  

What once took more than a year of manual work and endless log analysis is now fully automated. We’ve segmented about 95% of our environment, gained complete visibility into network activity, and dramatically strengthened our defenses.

- Sergio Fedelini, SVP, IT Infrastructure, MSC

Build a Self-Defending Network Architecture with Zero Networks  

Zero provides immediate visibility into every identity and asset on the network, monitors and learns all network connections, then automatically generates and enforces identity-aligned least privilege policies to prevent lateral movement by default. Our comprehensive solution operationalizes the principle of least privilege across every axis of network traffic: 

• Automated microsegmentation isolates every asset within its own secure perimeter, closing unnecessary communication paths without disrupting operations.  
• Identity segmentation enforces granular access rules for users, devices, and applications, ensuring every connection is explicitly authorized.   
• Just-in-time network-layer MFA adds adaptive authentication at the moment of privileged access, turning static permissions into temporary access.   
• Deterministic, highly accurate automation learns all network behavior to create and enforce least privilege policies at scale.  

Learn how you can automatically generate least privilege policies that dynamically adapt as your network evolves – request a demo.   

As models like Mythos, Daybreak, and other tools attackers weaponize for AI-driven exploits compress the window between initial compromise and business disruption even further, time is no longer on the defender’s side. Security teams can no longer afford to plan for prevention; they must engineer for the impact of a breach.  

A business impact analysis (BIA) is a vital step in gaining consequence clarity and tailoring cyber resilience strategies to business and board-level priorities. But all too often, a BIA documents critical systems, the disruptions that would materially impact the organization, and how long the business can tolerate downtime without detailing current exposure or producing cyber resilience priorities.  

We’ll walk through a business impact analysis template that translates documented business priorities into actionable cyber resilience enforcement steps, giving CISOs the necessary insights to protect uptime where it matters most.  

How to Conduct a Business Impact Analysis for Cyber Resilience: 3-Step Framework 

A BIA built to produce resilient architecture, not just documentation, moves through three steps: critical asset identification and business exposure quantification, attack path analysis and containment metrics, and investment prioritization. Each step is designed to hand off concrete inputs to the next, ultimately delivering a set of specific intervention priorities tied to specific exposure reductions.  

Step 1: Identify Critical Assets and Quantify Business Exposure 

The first step in resilience-focused business impact analysis is to identify which systems and assets are critical to the strategic success and day-to-day operations of the company. This means evaluating assets across five dimensions of business exposure:  

1. Regulatory Classification: If an asset contains data that is restricted by regulations, then a compromise could incur fines, time-consuming reporting, and disclosure requirements. 
2. Revenue Exposure: If an asset is critical to delivering goods and services or measuring consumption of goods and services, any downtime or breach would disrupt revenue streams and could even force the organization to pay penalties or credits to impacted customers. 
3. Financial Sensitivity: If an asset has the ability to issue or redirect payments, compromise could impact the organization’s operational cash flow. 
4. Customer Notification Requirements: If customer notification processes – often tied to revenue exposure and regulatory classification – are required due to a cyber incident, they can impact ongoing customer conversations and sales cycles.  
5. Reputational Sensitivity: If assets containing data or conducting functions that are core to the organization’s communications or value proposal are impacted by a breach, it could cause reputational harm. 

Identifying business-critical systems requires collaboration across multiple stakeholders – CISOs need to gather information from CROs, CIOs, COOs, and business unit leaders to fully grasp the organization’s overall risk exposure and the disruptions that would materially impact uptime, revenue, or customer commitments, ensuring the assessment reflects real-world operational priorities.  

Following this step, CISOs should have a preliminary list of critical assets, enough information to justify why it’s critical, and a baseline estimation of the business impact if a compromise occurred.  

Step 2: Analyze Attack Paths Against Containment Metrics  

With an inventory of critical assets and an understanding of how downtime would impact the business, CISOs can tackle the question that most urgently affects business continuity: how exposed are critical systems today?  

This is where many BIAs miss out on delivering practical value – they document priorities on paper without establishing whether critical systems are actually protected or where they’re vulnerable.  

An attack path analysis evaluates the level of effort it would take an attacker to move from a common ingress point to a business-critical asset. No analysis can comprehensively map every breach scenario, so CISOs should focus on categories that reflect the current threat landscape, like:  

• Compromised user 
• Compromised cloud identity 
• Technical perimeter entry 
• Trusted vendor/third-party access 

For each threat category and critical system, security teams should identify the nearest ingress point and map a plausible attack path relative to three containment dimensions: path distance, privilege requirements, and data-layer controls.  

The result, run across every combination of scenario and critical asset, is a documented map of exposure tied to likely attack tactics rather than a general sense of risk. This breakdown of exposure across all critical assets bubbles up to two enterprise-level risk insights:  

• Asset-level worst case path: The compromise scenario that presents the shortest, least obstructed route for an attacker to reach a business-critical system.  
• Enterprise-level highest cost path: The single scenario-to-asset combination with the weakest containment and the highest business exposure – the easiest attack with the greatest business impact.  

These insights deliver a baseline for measuring cyber resilience improvements over time, and a natural starting point for prioritizing enforcement and investment.  

Step 3: Prioritize Security Strategies and Investments for Reducing Business Risk Exposure  

With critical assets identified and their exposure mapped against likely attack scenarios, CISOs have what they need to answer the question that turns documentation into a cyber resilience roadmap: what actions will reduce the most risk – and fastest? 

As a general principle, interventions that reduce blast radius structurally, by eliminating an attacker's ability to reach a critical asset in the first place, are more durable than interventions that depend on detecting and responding to an attack already in progress. With that in mind, security teams should focus on strengthening the same dimensions of threat containment used to analyze exposure:  

• Increase path distance or completely remove pathways to critical assets: Granular network segmentation, additional authentication boundaries, and inspection points placed along the worst-case attack path can eliminate entire compromise scenarios rather than simply slowing them down.  
• Reduce privilege exposure: Eliminating persistent privileged access, reducing service account scope, enforcing just-in-time reauthentication, and introducing additional authentication requirements for critical assets can reduce privilege exposure, making it harder for attackers to successfully reach critical assets.  
• Enforce data layer controls: Implementing identity-based access controls and encryption at rest limits the potential damage if attackers do manage to reach critical systems, helping to ensure that a compromise won’t escalate to downtime.  

For each recommended intervention, CISOs should document the expected impact in terms the business understands: which worst-case path do these strategies break or lengthen, which critical assets do they better protect, and how do they reduce business exposure? This creates a direct line from investment to risk reduction, making budgetary conversations concrete and clearly tying security outcomes to business continuity.  

Build a Cyber Resilient Architecture with Zero Networks   

Zero Networks closes the gap between business priorities and real-world enforcement with automated, identity-based microsegmentation. Zero provides immediate visibility into every identity and asset on the network, then automatically enforces adaptive, identity-aligned policies that prevent lateral movement to critical assets to safeguard business resilience.  

The average Zero customer achieves 90%+ segmentation within 90 days, achieving comprehensive protection that measurably reduces risk exposure without disrupting regular operations.  

Find out how Zero Networks can help you build a cyber resilient architecture with measurable business value – request a demo.    

In other words, organizations understand the value of microsegmentation, but there’s a gap between intent and execution. The question is: how can enterprises deploy microsegmentation at scale, in real-world environments, without multi-year projects or partial coverage that leaves gaps for attackers to exploit?  

Gartner answered just that in its report, Reimagining Network Microsegmentation: Beyond the IP – Identity, Context, and Agentless Innovation. The research identifies three critical insights that should shape how security teams evaluate modern microsegmentation solutions – we’ll break down what they are and what they mean for the evolving landscape of zero trust microsegmentation.  

Key Answers  

• What does Gartner's research say about innovative microsegmentation in 2026? In Reimagining Network Microsegmentation: Beyond the IP – Identity, Context, and Agentless Innovation, Gartner identifies three critical insights shaping the future of network microsegmentation: the shift from IP-based rules to identity-first enforcement, the need for autonomous policy governance that moves beyond manual management, and the requirement for agentless, multimodal enforcement architectures that can deliver comprehensive coverage across heterogeneous enterprise environments. 
• Who are the leading enterprise microsegmentation vendors in 2026? Gartner's Reimagining Network Microsegmentation report names a range of sample vendors actively shaping the market, including Zero Networks, Palo Alto Networks, Akamai, Aqua Security, Broadcom, Cisco, ColorTokens, Elisity, Fortinet, Illumio, and Zscaler. Zero Networks is also recognized in the 2026 Gartner Peer Insights Voice of the Customer report with a perfect 5-star rating and a 100% willingness-to-recommend score. Likewise, Zero Networks earned a Platinum rating in EMA’s PRISM Report; we at Zero are proud to receive the analyst validation and customer trust that defines leading microsementation solutions. 
• What does identity-first microsegmentation mean in practice? Policies are bound to verified user, machine, or AI identities rather than network addresses, and enforced dynamically as those identities move across environments. This includes non-human identities like service accounts and AI agents, which already significantly outnumber human identities and are frequently over-privileged and under-monitored. 
• What is the most effective zero trust microsegmentation approach for stopping lateral movement? Gartner's research points to a combination of identity-first controls, automated policy governance, and agentless enforcement across the full environment. Together, these eliminate the coverage gaps and static policies that attackers rely on to move laterally, regardless of how initial access was gained. 
• What should security leaders look for when evaluating microsegmentation vendors? Three capabilities aligned to Gartner's critical insights: whether identity governs reachability at the network layer, whether policy automation is accurate, scalable, and auditable with human-on-the-loop controls, and whether the platform can reach the full environment – including legacy, IoT/OT, and cloud – without requiring agents on every asset. 

Identity-First Microsegmentation: Replacing IP-Based Rules  

For decades, network segmentation meant drawing boundaries around IP addresses, VLANs, and ACLs. The logic was sound for static, on-premises environments: define what can talk to what, and enforce it at the network layer. But the environments these tools were built for no longer exist – according to Gartner, that’s why it’s time to pivot from IP-centric rules to unified identity fabric.  

“The shift from network-centric to identity-first segmentation is a response to the evolution of traditional perimeters to hybrid architectures, the rise of dynamic, cloud-native environments, and the adoption of NHI. Static controls like IP addresses, VLANs, and ACLs are now ineffective, for ephemeral workloads and serverless architectures make manual rule management unmanageable and leave organizations vulnerable to lateral movement attacks.”  

Gartner, Reimagining Network Microsegmentation: Beyond the IP – Identity, Context, and Agentless Innovation  

IP-centric policy governs a location, not an identity – when a workload moves, a cloud instance spins up, or an AI agent is provisioned into your environment, a static rule doesn't follow it. The policy appears intact, but the coverage is full of gaps; for security leaders, that creates a false sense of protection. 

Dynamic Security Enforcement for Human Users, Machine Identities, and AI Agents

The proliferation of non-human identities (NHI) like service accounts and AI agents adds urgency to the identity-first segmentation shift.  

Machine and service identities already outnumber human identities 109:1 – a trend expected to accelerate as organizations anticipate 85% growth in AI agents over the next year. But NHI are notoriously over-privileged and under-monitored: just 2.6% of workload identity permissions are actually used, and 51% of workload identities are completely inactive; meanwhile, nearly two-thirds of organizations do not have AI governance policies.  

The takeaway? Enterprises need microsegmentation solutions that anchor controls to the actual human user, non-human identity, or workload rather than their network location.  

“Relying on static, IP-based microsegmentation guarantees catastrophic vulnerability to AI-driven attacks. Vendors clinging to manual policies face rapid obsolescence, as these methods are completely incapable of securing dynamic hybrid networks against lateral movement.” 

Gartner, Reimagining Network Microsegmentation: Beyond the IP – Identity, Context, and Agentless Innovation  

Context-Aware Identity Governance and Complete Visibility  

Identity-first microsegmentation ensures policies can be dynamically enforced based on the real-time identity of users and NHI as they move across environments. At the core of this shift is what Gartner calls the Unified Identity Graph – a single, comprehensive view of network identities and context that enables real-time, granular policy enforcement.  

When it comes to evaluating microsegmentation vendors, this means security leaders should look for:  

• Real-time network mapping that delivers comprehensive visibility into all identities, assets, and network behavior  
• Policy-based access control (PBAC) that autonomously enforces identity-based, context aware policies across hybrid and multi-cloud infrastructures 
• Product architecture that natively supports identity-based segmentation, so identity governs reachability at the network layer  

Autonomous Governance, Agentic AI, and the End of Manual Segmentation Policy Management 

Just as modern, dynamic environments have rendered IP-centric rules insufficient, they’ve made manual microsegmentation strategies impossible to scale in today’s rapidly changing, distributed infrastructures, leaving a gap between what's configured and what's actually happening on the network.  

To avoid policy drift and hidden risk exposure, Gartner suggests modern microsegmentation should autonomously map application dependencies, generate policies, and enforce rules in real time. The goal is continuous, adaptive governance that keeps protection aligned to network realities.  

Agentic AI: Opportunities and Risks  

Automated policy creation and enforcement is what Gartner recommends, but how can enterprises get there? The report identifies agentic AI as an enabler of autonomous governance – but with a trust gap standing in the way.  

Agentic AI adoption for security policies is often hindered by “enforcement anxiety,” as teams fear that algorithms may disrupt legitimate business operations. What’s more, the deployment of agentic AI brings its own security risks as agents become targets for adversarial attacks.  

Gartner's prescription for closing this trust gap is explainability and human oversight: policy simulation, transparent reasoning, and human-in-the-loop safeguards that allow teams to review and validate automated rules before they go live.  

Deterministic, Human-on-the-Loop Automation  

Security teams that can’t afford to risk operational disruption by replacing human judgement with AI can still operationalize Gartner’s insights by leveraging deterministic, human-on-the-loop automation, which operates on defined logic rather than probabilistic guesswork while keeping security teams in control of outcomes. 

Microsegmentation powered by deterministic automation delivers the adaptive, dynamic protection modern enterprises need by generating precise enforcement based on learned network behavior. For example, Zero Networks’ automation engine learns allowed network behaviors in order to create dynamic rules for identities and assets. As Chris Boehm, Zero Networks Field CTO, points out, this type of deterministic automation hinges on learning: 

In other words, deterministic automation relies on learned realities rather than educated guesses, which are central to probabilistic approaches. Keeping a human on the loop to optionally review, approve, or fine-tune policies in a sandbox environment is a key safeguard for peace of mind while still shrinking manual effort and enabling protection to scale alongside modern environments.  

Whatever mechanism security teams choose to get there, the ultimate goal remains the same: microsegmentation that shifts away from manual policies and embraces automation, enabling defenses that effectively counter AI-driven attacks. When evaluating microsegmentation tools on this capability, CISOs and cyber leaders should ask questions like:  

• Does the platform generate policies based on observed network behavior? Can your team see how a policy was derived? 
• Can teams simulate and validate policies before enforcement goes live, and test against real traffic to catch potential disruptions before they impact operations? 
• Does the platform continuously adapt as environments change, or does staying accurate require manual intervention? 
• How does the platform handle policy drift? Does it detect and remediate unauthorized changes automatically? 

Agentless Enforcement: How Microsegmentation Scales Across Enterprise Environments 

Autonomous, real-time policy governance only works if the underlying enforcement architecture can actually reach the full environment – without introducing performance overhead that makes it impractical. 

That's the core of Gartner's third critical insight: agent-based platforms struggle with performance and scalability across hybrid, cloud, and containerized environments, making granular policy management too complex. The recommended path forward? Multimodal, agentless enforcement that extends comprehensive coverage without the operational burden agents introduce. 

Agent-Based vs. Agentless Microsegmentation  

Agent-based platforms require software on every managed endpoint. In heterogeneous enterprise environments, that creates a structural problem: performance overhead on every host, version management across a diverse fleet, and coverage gaps on the assets that can't run agents at all – legacy systems, IoT and OT devices, unmanaged endpoints, and cloud workloads. These are precisely the assets attackers move through. 

Agentless microsegmentation solves this by extending enforcement through existing OS and network infrastructure rather than requiring software on every endpoint. Coverage reaches the full environment, including assets that could never host an agent, without the performance tax or the operational burden of managing agents at enterprise scale. 

From a solution evaluation perspective, this insight signals that security teams should ask vendors questions like:  

• Does the platform require agents on every endpoint, or does it enforce policy through existing infrastructure? 
• What happens to coverage on legacy systems, IoT/OT, or cloud workloads where agents can't be deployed? 
• Does the deployment model scale as the environment grows, or does agent management become a ceiling on coverage over time? 

Automated, Identity-Driven Microsegmentation for Modern Enterprises: Strengthen Cyber Resilience with Zero Networks   

Modern enterprises are moving away from reactive security to proactive containment – an evolution Gartner describes as the “shift from preventative-only security to cyber resilience.” For security leaders embracing microsegmentation as part of this shift, Gartner’s report paints a clear picture of what innovative solutions must look like: identity-first, automated with human oversight, and agentless.  

Zero Networks is named in the report as a sample vendor, recognized for automated, identity-driven microsegmentation that delivers on all three critical insights:  

• Identity-based policies govern access at the network layer, tied to user, machine, or AI identity, and automatically updated as environments change. 
• A deterministic automation engine maps observed network behavior, generates least-privilege policies, and keeps teams in control through human-on-the-loop simulation and staged rollout before enforcement. 
• Zero deploys agentlessly, orchestrating native OS enforcement mechanisms across IT, OT, IoT, and cloud – no proprietary agents, no rearchitecting, and no coverage gaps on the assets that matter most. 

The average Zero customer segments 90%+ of their environment within 90 days – 91% faster than legacy approaches, at 87% lower cost. Request a demo to see how.