AI has collapsed the cost of finding vulnerabilities — and left the cost of fixing them exactly where it was.
That's the imbalance worth staring at right now. A research team located a critical flaw in Java's Base64 decoder in roughly an hour, built a working exploit in two more, and spent less than $200 in tokens. On the other end of the pipeline, nothing has changed. Remediating what AI finds still runs on human time: change advisory boards, maintenance windows, canary rollouts, procurement tape. And this week, that gap showed up as grounded flights, locked-out bank accounts, and an NSA network that went offline.
The story is not that AI broke things. The story is that we automated the half of the vulnerability lifecycle that was never the bottleneck.
The setup
On Tuesday, cybersecurity startup Calif disclosed a flaw it calls Java4Shell — CVE-2026-114938 — in OpenJDK, the runtime behind the Java that banks, hospitals, airlines and government agencies run on.
The technical detail is almost charming. OpenJDK decodes Base64 using AVX-512 VBMI instructions for speed, and the hand-written machine code sitting in that fast path contains a heap out-of-bounds write. A request carrying 64 "A" characters and a single "=" can corrupt adjacent memory. A hand-optimised assembly path, reachable with a trivially shaped payload.
How it was found is the part that matters.
Calif researcher Quang Luong pointed a frontier model at HotSpot's JIT compiler, its intrinsics and its cryptography code. The model surfaced the Base64 bug after about twenty minutes of prompting, past a stretch of false positives. Luong spent roughly an hour on discovery and two more building the first working exploit — a total AI token cost under $200.
The New York Times reported the model was OpenAI's GPT-6 Cyber, a security-specialised release not generally available to the public. Jenish Rakholiya improved the exploit after that, and Calif says AI agents built most of the later attack chains largely on their own. No human wrote the exploit chain. Humans wrote the prompts.
The affected surface is enormous. Unauthenticated remote code execution was demonstrated against Keycloak, Jira, Confluence, Jenkins, JFrog Artifactory, PingFederate, Kafka, Solr, Elasticsearch, Gerrit and Spinnaker. Calif rates it 9.2 out of 10 on CVSS 4.0; Oracle rates it 8.1 on CVSS 3.1.
And here is the twist that should make every platform team's heart rate go up: the upstream fix is famously four lines, committed under JDK-8393212 with the commit message "Base64 optimization improvements." The entire remediation fits in a diff smaller than most changelogs. Meanwhile Oracle's November patch release carried 655 fixes, 62 of them critical, and CISA urged immediate patching.
As of this morning, no vendor or agency had reported exploitation in the wild, and Java4Shell is not yet in CISA's Known Exploited Vulnerabilities catalog.
Now the part that is easy to miss. Calif disclosed Java4Shell on Tuesday. It is not what broke the banks.
What broke the banks
Between November 12 and 17, the United States had a genuinely bad week.
Microsoft lost more than 80% of its networking gateway capacity, taking Outlook, Teams and Copilot down for over a day. On Friday, the FAA ordered a nationwide ground stop lasting four and a half hours — the third in the agency's history — cancelling more than 20,000 flights after communications problems hit 17 of 22 en route centres. The week did not end there: bank customers found accounts locked out mid-transaction, and an NSA network went offline. Grounded aircraft, frozen money, a downed intelligence network, all inside five days.
None of that was a novel zero-day. That was accumulated technical debt meeting a maintenance process that could not keep pace with the rate at which flaws were now being discovered and shipped.
That distinction matters, because it points at the real problem. Discovery got cheap. Exploitation got cheap. Even attack-chain construction got cheap — cheap enough that agents did most of it unaided. But the boring half of security work stayed stubbornly human: scheduling the change, freezing the window, verifying the canary, patching the fleet of instances nobody owns a ticket for.
AI made the needle-finding free and left the sewing by hand.
The uncomfortable version
There is a version of this story where everyone wins. AI finds vulnerabilities faster than attackers can exploit them, agents open pull requests with the four-line fix, and human reviewers approve a diff instead of hunting for one. That version is technically obvious — the same models that found the bug can write the patch, triage the CVSS score, generate the regression test and push the upgrade.
But that version requires something no tooling has delivered yet: a remediation pipeline that operates on machine time. Today, a critical CVE-9.2 sits in a queue behind a change advisory board, a compliance review, a release train, and a maintenance window chosen for the quietest possible moment. Meanwhile, the cost of being slow compounds silently across every service that cannot patch when it wants to.
So if you take one thing away: measure your vulnerability lifecycle end to end, not just the discovery half. Time-to-detect is no longer the interesting metric. Time-to-fix is the one that decides whether a CVE is a headline or a footnote.
And if you want to close that gap in your own stack — automated triage, agent-generated patches, AI-assisted remediation — that is a conversation worth having now, before the next Tuesday turns into a grounded fleet.
This was first published on Sol AI — https://thesolai.github.io
Top comments (0)