Cybersecurity has taken a drastic turn in 2026, and we are not talking about a rise in the usual false positives or minor alerts, but about a wave of fully functional exploits that are hitting infrastructures we always considered secure, such as the Linux kernel and the npm and PyPI repositories.
And at the center of all this, artificial intelligence is working as an excellent copilot for finding bugs in code, but also as a precision weapon for attackers. It is precisely this dual facet that is forcing us to rethink how secure continuous integration (CI/CD) environments are and how the software development ecosystem must evolve to avoid the chaos looming on the horizon.
The boom in automated code audits
After all, the use of advanced language models, such as Claudo Mythos, is changing the rules of the game forever when it comes to hunting for programming flaws. Thanks to these tools, researchers now have a partner that allows them to review code autonomously and with a large number of variables, to find bugs and generate exploits that take advantage of them.
One example of this is that a critical vulnerability was recently discovered in the Linux NFS protocol that had been hidden for 23 years. The exploit is complex (it requires the coordination of two NFS clients), but it takes advantage of a 1024-byte limit in the owner identifier to overflow a buffer of just 112 bytes on the server. The result: privilege escalation and the possibility of taking full control of the target server.
What free software is and how it transformed technology and finance
We might think this is positive, and it is; finding problems and fixing them is the best thing that can happen. But the real problem is that the speed at which AI analyzes code and designs attacks has outpaced the capacity of these projects' support teams. Willy Tarreau, a key kernel developer, mentioned on the kernel mailing listthat the Linux security list went from receiving two or three reports a week to peaks of between five and ten a day.
Although most reports are technically correct, the fact that several independent researchers submit the same report at the same time saturates the maintainers. That is why the Linux team had to hit the brakes and introduce rules in the recent versions of the 6.x branch to regulate the use of these tools.
The vulnerability crisis in the Linux kernel
However, this is only part of the problem. The reality is that the Linux kernel has been chaining several local privilege escalation flaws that are deterministic (they do not depend on luck or race conditions). This is a huge headache for cloud servers and container clusters. By compromising the page cache in memory, an unprivileged user can alter common administration binaries without leaving a trace on the physical disk.

Four major vulnerabilities
The case of Copy Fail shows how a performance optimization made in 2017 can backfire years later. By combining the AF_ALG cryptographic socket interface with the splice() call, an attacker can write directly to shared memory data. This breaks container isolation and allows jumping to the host system. With a severity of CVSS=7.8, the exploit achieves root access consistently with a script of just 732 bytes.
On the other hand, Fragnesia, discovered by William Bowling, exploits a similar flaw by reassembling network fragments in the IPsec stack. The kernel forgets to set the SKBFL_SHARED_FRAG flag when moving data between buffers, ignoring that the memory is externally backed. The result? Decompression and AES-GCM decryption occur directly on the page cache of read-only files such as /usr/bin/su. The attacker only needs to apply an XOR operation in memory to bypass the password and become superuser instantly.
Claude Mythos takes down the security of Apple's new M5 chips
Finally, the ptrace Exit-race vector (nicknamed ssh-keysign-pwn) uses an ingenious trick to steal confidential file descriptors. When a process exits (do_exit), there is a millisecond-long window in which its memory descriptor is unlinked before its files are closed. At that instant, the system does not apply the usual debugging protections because the pointer is null. Any local process can call pidfd_getfd(2) to duplicate the files opened by SUID executables in their last breath, stealing SSH private keys or data from /etc/shadow (an important security file in Linux).
Autonomous attacks and malware in the supply chain
But cybercriminals are also using AI to create autonomous campaigns. The most destructive example right now is the Mini Shai-Hulud worm (named after the creatures from Dune) created by the TeamPCP group. Once released, the malware acts on its own. In mid-May 2026, it coordinately infected more than 170 packages on npm and PyPI, hitting massive projects such as TanStack, UiPath and platforms such as Mistral AI.
The entry point is usually careless automation in CI/CD systems. The worm exploits the "Pwn Request" pattern in GitHub Actions through the pull_request_target trigger combined with cache poisoning. This way it extracts OpenID Connect (OIDC) authentication tokens from the runner's memory, bypasses two-factor authentication and generates malicious packages that look completely legitimate, even with SLSA level 3 security certifications.
The worm infected the library
The impact on the real development ecosystem was immediate. The worm infected the @tanstack/react-router library, which exposed workflow credentials at several companies and compromised two internal devices at OpenAI. Mistral AI also confirmed that an engineer on its team ended up with their personal machine infected after mistakenly downloading the compromised version 2.4.6 of its Python library. The situation escalated so much that public agencies, such as the UK's NHS, had to issue emergency alerts to protect their networks.
To all this we must add the rise of "Vibe Coding" (programming by delegating almost everything to AI). When TeamPCP published the Mini Shai-Hulud code on GitHub, it became clear that attackers use language models to deobfuscate malicious code instantly. This accelerates the creation of new malware variants and makes it easier for hacker communities to organize "challenges" to see who can design the worst supply chain attack.
Google pays 32 billion for Wiz to compete in AI security
The challenge of secure development and the new rules
Be that as it may, the daily use of coding assistants such as Lovable, Cursor and Replit Agent has greatly accelerated the delivery of commercial software. However, experts agree that we are accumulating enormous technical debt. Writing code so fast without serious human review leaves logic and memory management errors that attackers easily find using automated scanners.
This scenario is what forced a change in Linux kernel policies. The new rules require that any report made with the help of AI be handled publicly, mainly because these tools tend to suggest the same flaws to different users in a very short time. In addition, reports with theoretical explanations or speculative impacts generated by bots were banned; if you want to submit a patch, you have to include a real, repeatable and empirical proof of concept.
How do we defend ourselves against this?
However, there is a very clear reality: to stop exploits such as ptrace Exit-race or Copy Fail, we have to change the way we configure infrastructure. Thus, in order to secure development workflows against autonomous malware, the industry is exploring the use of cryptographic transparency logs and signed attestation systems (such as Sigstore). Recording every commit and the metadata of the artifacts generated in a public and immutable structure helps ensure that no one alters the code along the way.
Standardization of ephemeral OIDC-based workload identities is also being promoted, which seeks to tie the cryptographic identity of each AI assistant or automation bot to an access policy strictly linked to a human supervisor or a legally responsible company, preventing autonomous tools from publishing packages freely or with fake profiles.
Traditional perimeter security is no longer enough
In any case, the use of cryptographic tokens and decentralized control systems also makes it possible to automate write permissions in repositories. If an infected bot steals a developer's local credentials, the potential damage is drastically reduced because access is limited and decentralized. In addition, this approach generates a transparent and clean audit trail that malware cannot erase or alter.
Cybersecurity trends 2026: post-quantum cryptography underway
Be that as it may, the conclusion is clear: in the era of algorithm-assisted programming, traditional perimeter security is no longer enough. We need strict controls on engineers' computers, mandatory SLSA signatures for every package and mathematical verification of dependencies. Only by combining verifiable infrastructures and cryptographic protocols will we be able to face attacks that run at machine speed.