Credit
This post builds on Tal Be'ery's essays "Dense in Depth" (November 5, 2026) and "Why the AI Vulnpocalypse Isn't the Breachpocalypse (Yet)" (October 7, 2026). Tal put into clear words something I have been trying to articulate for a long time, and I am grateful to him for it. The core argument, the removal-capture method and the term "dense in depth" are his. The castle metaphor, the recount of Chrome's release notes, the field data and the extension of his argument from one codebase to the whole attack surface are ours, and so are any errors.
For twenty years, security teams measured their work by counting cracks in the wall and repairing them. Find a vulnerability, patch it, report the number to the board. AI has now shown that the count was never going to reach zero.
Tal Be’ery, a security researcher and the co-founder of ZenGo, made the data case for this in his essay Dense in Depth: software vulnerabilities are far more common than our defenses assume.1 Our incident response and threat intelligence work shows the other half of the picture. Attackers now run AI agents that test every crack, without tiring, across hundreds of organizations at once.
Be’ery measured one codebase. An attacker does not limit the search to one. The attacker works with everything reachable from outside: your own code, the appliances at the gate, the libraries inside your builds and the SaaS products wired into your systems. Patching a single codebase can still pay off, but it improves one part of the wall. This post extends his argument from the codebase to the whole attack surface.
The short version
From the watchtower, a castle looks defensible. The walls are high, the defenders are in position, and the attackers come from directions you can see. Most organizations picture their security the same way: a perimeter with a known number of weak spots, and a team that repairs them faster than attackers find them.
That picture rests on one assumption: that the weak spots are few. If a wall has six cracks, repairing one is real progress. If it has six thousand, repairing one changes nothing. Four points follow from the evidence below:
- Every wall is cracked. When Google pointed AI at Chrome, weekly security fixes rose roughly twentyfold, and months later it still has not started to fall.
- The siege got bigger. The AI operators we tracked named more than 250 target organizations, tested thousands of variations of each idea and shared what they learned within hours.
- The wall is not only yours. Edge appliances, third-party libraries and SaaS integrations are part of your wall, and you cannot patch most of them yourself. The attacker needs one crack in any of them, and some stones are sandstone, soft and quick to crumble.
- The goal changes. You will never repair every crack. You can replace the weakest stones, build inner walls and be ready to act when one gives way.
How we know: counting cracks you cannot see
Be’ery starts from a question the field has argued about since Eric Rescorla’s 2004 paper “Is finding security holes a good idea?”: are vulnerabilities sparse or dense? He quotes Dan Geer on why it matters: “Six-take-away-one is a 15% improvement. Six-thousand-take-away-one has no detectable value."1 The question stayed open because nobody could count the cracks.
Be’ery’s method comes from wildlife biology: the removal-capture estimate. In castle terms, inspect the wall for a fixed time and repair every crack you find, then inspect it again with the same effort. If the second inspection finds noticeably fewer cracks, the wall holds only a few more than you saw. If it finds as many as before, the wall holds far more cracks than any inspection can reach, and the estimate of the total goes to infinity.
Chrome as the test wall
Chrome is the natural experiment, because Google publishes every stable release with a list of the security fixes it contains. Be’ery reads the data in two parts.1
Before AI, the inspection was constant and the count stayed flat. For years, Chrome’s internal team, outside researchers and one of the industry’s richest bug bounties found a few dozen vulnerabilities per milestone. Years of repairs never made the count fall.
Then Google upgraded the inspection. Google says it began scanning Chrome with AI in early 2026. In Chrome 149 and 150 alone, it fixed 1,072 security bugs, more than in the 23 milestones before them combined.2 If the wall held a finite number of cracks, the AI-era counts should start to fall after a few months. Be’ery finds the opposite: eight months and several thousand fixes in, the rate reached an all-time high of 175 per week in milestone 156.1
Our recount from Google’s release notes
We rebuilt the core numbers from Google’s own release notes: all 197 “Stable Channel Update for Desktop” posts on the Chrome Releases blog from milestone 113 to 157, collected on November 10, 2026.3 For each post we took the number in “This update includes N security fixes”, or the count of CVEs it lists when there is no number, and grouped updates by milestone. Milestones vary in length, and Chrome moved from four-week to two-week milestones in August 2026, so like Be’ery we compare fixes per week. Our count for milestones 149 and 150 is 1,082, within 1% of Google’s 1,072.
From milestone 120 to 145, Chrome fixed an average of 6 security bugs per week. From milestone 146 to 156, the average was 117 per week, and milestone 156 reached 214. That is higher than Be’ery’s 175 for the same milestone; his method differs from ours, but the direction is the same. The count has not started to fall.
Objections the data answers
“Google is just finding the cracks before anyone else.” If AI inspection were draining the wall, outside researchers would find less. Be’ery treats them as a control group, and they found more.1 In our recount, CVEs credited to reporters outside Google rose from 4 per week (milestones 120 to 145) to 25 per week (146 to 156). Before 2026 the release notes listed mostly external reports, so only the external line is comparable across the whole period.
“AI finds trivial bugs in new code.” Neither holds. In our recount, Critical and High CVEs went from 2.3 per week to 43.9 per week. And Be’ery traced each fix to the code it changed: AI-era fixes repaired code with a median age of three to four years, the same profile as before AI.1 The masons are finding old cracks, not fresh ones.
One limit remains: removal-capture assumes constant effort, and Google does not publish how much AI scanning it runs. Be’ery’s answer is that outside researchers, whose effort Google does not control, keep finding more.1
Chrome is also the best case for the defender. It has one vendor, one patch channel, a large internal security team and one of the industry’s richest bug bounties, and it still fixed 214 bugs in a single week. Most of what sits in your environment has none of that.
Why the cracks never run out
Be’ery’s explanation: vulnerabilities are not a property of lines of code, but of how the code runs, meaning program states and the order in which instructions execute.1 In castle terms, the cracks live in the mortar between the stones. Every new stone creates joints with the stones around it, so the code grows one line at a time while the joints grow exponentially.
Your castle is bigger than your code
Density is not uniform. Be’ery’s own caveat: “Smaller codebases, or ones written in memory-safe languages from the start, may well be sparser."1 In castle terms, some stones are granite and some are sandstone, soft and quick to crumble.
Suppose you could make one codebase sparse. The attacker moves to another, because every component reachable from outside is part of your wall, whether you wrote it, bought it or only connected to it. For each part, the question is who can patch it:
| # | Part of the wall | Who can fix it | Recent example |
|---|---|---|---|
| 1 | Your own code | You | IDOR and secrets in client code, below |
| 2 | Edge appliances | The vendor, on its schedule. You apply the fix | Check Point VPN, Citrix NetScaler, Ivanti EPMM |
| 3 | Third-party libraries and packages | The maintainers. You rebuild | ChainDrop npm worm |
| 4 | SaaS and integrations | The vendor, entirely. You can only revoke access | Klue |
The attacker picks the weakest row, not the one you are best at. Patching your own code faster improves row 1 and leaves the rest as they were.
Your own code
- Authorization done in the wrong place. Where server-side authorization checks were missing, one AI operator claimed thousands of records from a single IDOR (insecure direct object reference).
- Secrets in client code. The same operators mined production JavaScript bundles for API keys, encryption keys and internal hostnames.
Edge appliances
Appliances sit at the gate, run code you cannot read, and wait for the vendor’s patch.
- Ivanti EPMM. The Ivanti EPMM chain we responded to was pre-authentication and trivial to exploit. Some threat actors weaponized it before public proof-of-concept (PoC) code appeared, and exploitation attempts surged once it did. Most EPMM environments lacked native forensic tooling. In multiple cases, attackers had moved from the appliance into connected systems such as LDAP, Exchange and SQL before the appliance was isolated.
- Check Point VPN. Rapid7 described a critical authentication bypass (CVE-2026-50751, CVSS 9.3) in Check Point Remote Access VPN gateways that still accept legacy clients over the deprecated IKEv1 protocol. It let an unauthenticated attacker open a VPN session. Check Point traced exploitation back to May 7, 2026, and counted several dozen affected organizations. By June 8 the flaw was on CISA’s Known Exploited Vulnerabilities list.6
- Citrix NetScaler. Two NetScaler ADC and Gateway flaws were exploited as zero-days. After a public root-cause analysis and PoC appeared, targeted attacks turned into mass “spray and pray” exploitation. Censys counted about 42,000 internet-facing NetScaler hosts.7
Third-party libraries
A dependency runs with your application’s privileges, and you inherit its maintainers’ security habits. In August 2026 Microsoft described ChainDrop, a self-propagating worm in more than 400 npm packages from unrelated publishers. Microsoft’s evidence points to stolen maintainer credentials. The malware harvested npm, GitHub and cloud credentials from developer workstations and CI/CD systems.8 The entry point was a dependency, not the victim’s own code.
SaaS and integrations
You cannot patch a SaaS product. You can only decide how much it can reach. In June 2026, according to Rescana’s account, attackers used a legacy credential on Klue’s integration infrastructure that was no longer in use but still active. They pushed a code update that harvested customers’ OAuth tokens, and nearly 200 organizations were affected. Klue disabled all customer OAuth credentials on June 13, and Salesforce disabled the Klue integration on June 17.9
Our case files show the same shape. In one recorded engagement, an AI operator pivoted through a shared SaaS provider to reach data belonging to several of that provider’s customers.
Sandstone anywhere on the list is where sieges are won, and it is where to spend first.
The siege got bigger
Cracks matter only if someone finds them. For most of history, attackers were few and slow, and they got tired. That has changed.
Our analysis of six AI-agent operators found thousands of agent skills and more than 250 named target organizations in at least nine countries. Each engagement runs a loop: map, hypothesize, test at scale, record, distill. The test step sends hundreds to thousands of variants per hypothesis. One recorded engagement ran for two days over more than 20 rounds.
Three properties make this a different siege:
- Memory. Only about one in eight skills had a counterpart in the other collections we examined, so most of the tradecraft is self-generated. When one operator published a library, dozens of copies existed within hours.
- Patience. An agent that spreads a campaign over days, with one attempt per account and a few dozen requests per proxy, stays under alert thresholds tuned for minutes.
- Infrastructure. The ARTEX operator sent traffic through 31 exit IPs across 16 autonomous system numbers (ASNs) in one session, drawing on a pool of about 273,000 residential exits. It was hitting multiple customers with a high success rate.
Why the swarm has not sacked every castle yet
If attackers now test every crack, why are breaches not surging? In an earlier essay, Why the AI Vulnpocalypse Isn’t the Breachpocalypse (Yet), Be’ery argues that entry was never the bottleneck.4 Most attackers want money, and turning stolen data into cash they can launder is the hard part. His evidence: according to Darkweb IQ figures in a Chainalysis report, the average price of victim access on criminal markets fell from about $1,427 to $439 between early 2023 and early 2026.
Our field data fits. In the AI operators’ own files, “Recon is the main product. For most targets the agent took no data.” Be’ery calls this bottleneck a financial dam, and attackers who are not after money never faced it: “Winter is coming, even if it is currently withheld by the financial dam.”
What held
The operators’ case files recorded what stopped them, and the list is short. Each control removes a whole kind of crack rather than one crack:
| # | Control | Kind of crack it removes | Field evidence |
|---|---|---|---|
| 1 | Network-level bans on hosting and proxy ranges | Enumeration from rented infrastructure | Stopped an enumeration campaign outright, despite proxy rotation |
| 2 | Multi-factor authentication (MFA) and account lockout | Password spraying | Turned spray results into dead ends |
| 3 | Server-side authorization checks | IDOR and bulk export | Where missing, thousands of records from one IDOR |
| 4 | Generic injection rules, in blocking mode | Improvised injection | Recommended over payload signatures for the ARTEX operator |
| 5 | Hardened backends behind a well-tuned web application firewall (WAF) | Variant floods | Absorbed thousands of variants without a usable finding |
Be’ery’s phrase for this is “Attack the mechanism, not the instances."1 Our incident data shows the same thing from the other side of the wall: the controls that worked did not need to know which payload was coming.
What defenders can do
In the fifteenth century, cannons turned tall stone walls into targets. Builders did not answer by hiring more masons. They redesigned the fortress: lower, thicker, angled walls that cannon fire could not easily break. AI is that kind of moment. Patching quickly is still necessary, but it is not a strategy on its own.
The actions below combine Be’ery’s recommendations with what we see in incident response. They are grouped by the job they do.
Map the whole wall
You cannot defend what you have not listed. Keep one inventory with four parts: internet-facing appliances and their versions, the third-party libraries in each build (a software bill of materials, SBOM), the SaaS products connected to your systems with every OAuth grant and API token, and the vendors with standing access. Give each entry an owner.
Then decide who acts on each part, and how fast. Patch your own code. Patch appliances on a deadline counted from the public PoC, or isolate them. Pin library versions, check lockfiles and set a minimum release age for new package versions. You cannot patch a SaaS product, so give each token the narrowest access that works and keep a tested way to revoke every grant for one vendor on short notice. Mark the sandstone as you go: legacy systems, appliances without forensic tooling, client-side authorization, secrets in client code, unpinned dependencies and SaaS integrations with broad tokens. Replace it, isolate it or watch it hardest, in that order.
Guard the gate first
Whatever is reachable from the internet gets the shortest patch deadlines and the strictest controls. Edge appliances, VPNs, exposed admin panels and public APIs are the sandstone at the gate, and they are where the AI operators start. Make the gate expensive to probe: ban or challenge hosting and proxy address ranges on sign-in and API endpoints, and run generic injection rules in blocking mode instead of payload signatures.
Answer the breaches attackers are using
Start with what is already being exploited. In a dense world, Be’ery argues, exploitation in the wild becomes the primary input.1 That means the Cybersecurity and Infrastructure Security Agency’s (CISA) Known Exploited Vulnerabilities (KEV) list, and what incident responders see in live cases. A Critical score on a component nobody can reach matters less than a Medium score on your VPN that is being exploited this week.
The gap between disclosure and exploitation is shrinking. Be’ery cites Volexity’s report of threat actors exploiting Chrome fixes that were visible in the public repository before they shipped.1 Subscribe to vendor security advisories for every internet-facing product you run, and take threat intelligence from teams who see live exploitation, filtered to your technology stack. Then measure the time from a public PoC to a patch on your internet-facing systems, and set a target in days, not weeks. The ARTEX operator shows why: it ran a panel that is most likely VulnHunter, an AI vulnerability workbench that generates proofs of concept, at machine speed across many targets in parallel.
Change the stone, not the crack
Retire whole kinds of weakness instead of patching one instance at a time. Be’ery: “We should spend that dividend on rebuilding our software on top of generic security mechanisms, not on patching the old code faster."1 In practice, that means memory-safe languages for new code, authorization enforced on the server, MFA and lockout on every account including service and legacy accounts, and no secrets in client code.
Read every finding as a map of the wall. Be’ery’s phrase is “find to learn, not find to fix”.1 A penetration test or bug bounty finding matters for what it says about a whole kind of weakness, so ask which assumption failed and which control would have prevented every crack like it.
Build inner walls
Separate edge appliances from the identity and data systems they integrate with, so a breached appliance cannot reach LDAP, Exchange or SQL on its own. Our Ivanti cases show what happens without it: the attacker walked from the gate into the rest of the environment. Systems that move money or hold sensitive data belong in the keep, behind more than one wall, with their own access controls and monitoring.
Be ready to act before the breach
I joined Moran Shalom on the “Post Human IR Era” panel at the Cloud Security Alliance (CSA) Israel 2026 conference, during Cyber Week. She put the last gap plainly: “The gap isn’t knowing what to do. It’s who is allowed to do it."5 An AI swarm does not wait for a change board. She proposes three decisions to settle before the next incident:
- Emergency patching on internet-facing systems skips the change board.
- Cutting access to anything that moves money or data is the on-call’s call.
- A containment action that breaks something is reviewed, not punished.
The rest is mechanics. Widen your detection windows to days: correlate sign-in failures, request variants and source rotation over multi-day windows, not minutes, because playbook automation only catches the campaigns someone already wrote a rule for. Keep logs long enough to see a slow campaign, and confirm that responder access to your cloud, identity and endpoint tools works before you need it. Then rehearse: run a breach exercise on your own environment, with the people who would hold the decisions above.
What to report to the board
A count of fixed vulnerabilities no longer tells a board much. Report these instead:
- Time from public PoC to patch on internet-facing systems.
- Share of internet-facing assets, third-party dependencies and SaaS integrations with a known owner and a patch, pin or revocation status.
- Test results showing whether a breach at the gate can reach the keep.
- Time, in Shalom’s words, that “each fix or block waited for a yes."5
- Date of the last breach rehearsal.
How we are building for the siege
This is why we are building Agentic IR, AI agents that work alongside the Profero incident response team:
- Scouts: Agentic EAS finds the sandstone at your gate before attackers do.
- Patrols: Agentic Readiness checks every day that we can see into your environment and respond.
- Guards ready in the garrison: in an incident, agents investigate from the first minute, our responders decide, and your team makes every change.
- Drills: Simulations rehearse a breach with your team and ours, on your own environment.
None of this repairs every crack. It is built for the day one gives way.
Hold the castle
Be’ery ends his essay with: “We were never going to hit rock bottom. It is time to stop diving deeper and start rebuilding."1 In castle terms: stop counting cracks. Guard the gate first, answer the breaches attackers are using, replace sandstone with granite, build inner walls, and decide in advance who can act. The attackers’ agents already work from a map of your walls. To find out how your castle would hold, talk to us about Pre-Emptive IR, or read our comparison of Pre-Emptive IR and a break-glass retainer.
References
| # | Source | Link |
|---|---|---|
| 1 | Tal Be’ery, “Dense in Depth: Rethinking Security When Vulns Are Everywhere”, November 5, 2026 | medium.com |
| 2 | Chrome Security Team, “Stronger with every update: How we’re making Chrome and the web safer in the AI Era”, Google, July 30, 2026 | blog.google |
| 3 | Google, Chrome Releases blog, “Stable Channel Update for Desktop” posts, milestones 113 to 157 (our recount, collected November 10, 2026) | chromereleases.googleblog.com |
| 4 | Tal Be’ery, “Why the AI Vulnpocalypse Isn’t the Breachpocalypse (Yet)? It’s the Economy, Stupid.”, October 7, 2026 | medium.com |
| 5 | Moran Shalom, LinkedIn post on the “Post Human IR Era” panel, CSA Israel 2026 | linkedin.com |
| 6 | Rapid7, “Critical Check Point VPN Zero-Day Exploited in the Wild (CVE-2026-50751)”, June 8, 2026 (updated July 1, 2026) | rapid7.com |
| 7 | Help Net Security, “NetScaler zero-day exploitation escalates into mass attacks (CVE-2026-88771)”, September 29, 2026 | helpnetsecurity.com |
| 8 | Microsoft Security Blog, “ChainDrop supply chain compromise: Anatomy of a self-propagating worm”, August 4, 2026 | microsoft.com |
| 9 | Rescana, “Klue Supply Chain Breach Exposes OAuth Tokens and Salesforce Data in Multi-Stage Cybersecurity Incident (June 2026)”, June 29, 2026 (secondary source) | rescana.com |



