November 19, 2026

AI incidents of 2026: Rogue agents, stolen keys, and other familiar stories

TL;DR

  • We reviewed 50 AI-related security incidents from 2026 to understand how AI was involved and what actually went wrong.
  • Most came back to familiar security problems: exposed credentials, excessive permissions, weak isolation and compromised vendors.
  • AI helped attackers move faster, while agents introduced additional risks by acting beyond their intended boundaries.
  • A lot of these incidents show how much familiar security practices still matter, especially as AI speeds things up.
  • For exposed secrets and supply chain risk, Aikido Device Protection finds plaintext credentials on developer machines and blocks malicious installs, and Secrets detection catches API keys in code.
  • For over-scoped access and weak isolation, Attack Path Analysis shows what a compromised workload could reach. AI Capabilities pentests check agents for actions they shouldn't take, and Zen blocks injection attacks at runtime.

Reading past the headline

It feels like every security incident we hear about lately has AI somewhere in it. But AI and the role it plays can mean a lot of different things. In some incidents, AI was the weakness an attacker exploited. In others, AI was the tool they attacked with. We wanted to understand which role AI played and what went wrong in each incident, because knowing the root cause tells us what to monitor, detect and fix going forward.

So we went through 50 incidents disclosed this year through November 19 and wrote down every root cause their reports stated. A lot of it came back to familiar problems, like exposed secrets, over-privileged accounts, weak isolation and compromised vendors. AI changed how some of these incidents played out, but the underlying failures weren’t always something new. Here’s what we found.

A few you’ve probably heard about

You’ve probably heard about most of these as “AI incidents.” Here are a few of them, with what each one came down to.

  • Meta (April-May 2026). Attackers used an AI support assistant to initiate password resets for Instagram accounts they didn’t own. The recovery system failed to verify that the supplied email belonged to the account, potentially exposing up to 20,225 accounts.
  • OpenAI and Hugging Face (July 2026). AI agents escaped their intended test boundaries and reached Hugging Face's platform. The sandbox could reach systems it shouldn't have, monitoring raised an alert but the run continued, and a shared long-lived admin credential gave the agents access to infrastructure beyond their intended scope.
  • Online retailers (September 2026). AI agents ran a card skimming campaign across at least 27 retailers and took more than 600,000 cards from two of them. They got in through a SQL injection in a login field and then added skimmers to the checkout code without setting off any alerts.
  • ConnectWise (October 2026). Storm-0940 used ARTEX, an agentic offensive framework, to attempt sign-ins against more than 2,250 tenants. ARTEX automated reconnaissance, authentication attempts, and actions such as modifying credentials and privileges. The attackers took advantage of compromised applications that already had trusted access to customer environments, allowing them to operate without users signing in.
  • Railway (October 2026). An AI-assisted attacker exposed tokens for 1,852 users, and about $740,000 of unauthorized usage followed. The path there was customer builds sharing a VM, plus a build credential that worked on internal systems it was never meant for.

October alone accounted for seventeen of the 50 incidents we reviewed, of which nine involved AI development and hosting platforms. Some organizations published detailed reports explaining what went wrong, while others are still investigating or haven’t shared enough to identify a cause.

ARTEX and other agentic offensive frameworks appeared in several of the incidents we reviewed from October. These tools use AI agents to automate parts of an attack, from reconnaissance and vulnerability discovery to exploitation. The underlying techniques aren't particularly new, but these frameworks can explore different attack paths, adapt when something fails, and carry out attacks with far less human involvement.

AI’s different roles in cybersecurity incidents

Cybersecurity is still cybersecurity, but with some AI added to the mix. Sometimes AI was the target, sometimes it was the tool being used, and other times AI agents were deployed without enough guardrails.

  • AI as the target. In 25 of the 50 incidents, attackers went after AI platforms, developer tools and services holding AI credentials. They targeted API keys, infrastructure and software packages, often with familiar techniques.
  • AI as the attack tool. In 12 incidents, attackers used AI agents or agentic frameworks like ARTEX to carry out parts of the attack themselves. AI used to write malware or phishing lures isn’t counted here.
  • AI without enough guardrails. In the other 13, AI agents running in products or test environments were set up with too few limits. Some followed instructions from untrusted sources, and others had permissions that let them reach systems or take actions no one meant them to.

This, however, doesn't tell us much about why they happened. For that, we looked at the underlying failures across all 50 incidents. And despite the different ways AI was involved, a lot of the same problems kept showing up.

Exposed secrets showed up more than anything else

Bar chart titled “What went wrong across 50 incidents,” showing how many of 50 AI-related security incidents disclosed through November 19, 2026 involved each failure point. Secrets reachable 13, over-scoped identity or trust 11, weak isolation 11, third party or supply chain 10, agents acting unchecked 9, fixes that didn’t happen 8, legacy system still live 7, no authentication 7, nobody watching 7, application flaw 6, long-lived or plaintext credentials 6, weak authentication 6, unpatched or insecure default 5, missing authorization 4, unverified claim 4, internet exposure 3, previously unknown vulnerability 3, human or endpoint compromise 2, model misuse 1. Most incidents had more than one failure point.

Nothing near the top of that chart is exotic. We see secrets left where they could be found, tokens that could reach too far, trouble that came in through a vendor, and boundaries between systems that didn’t hold. Only 3 of the 50 incidents we reviewed involved a reported previously unknown vulnerability.

Even in those three, the unknown vulnerability only got the attacker in. What happened next depended on familiar controls. At Railway, an over-scoped build credential and a long-lived decryption key turned one escape into access to around 100,000 workspaces’ secrets. At Hugging Face, exposed tokens and a shared admin credential helped the agents spread to code running on 41 production servers. At DIVD, an AI agent chained two previously unknown flaws in its Zammad helpdesk to get root access, but network segmentation kept the damage mostly to volunteer contact details.

Most of these failure points are common, and we’d bet plenty of security teams could find at least one of them in their own environments today. In these 50 cases, someone else found the problem first. The organizations that shared what happened gave the rest of us something to learn from and a chance to fix the same weak spots in our own environments.

What AI did change is the pace and the prize. In one campaign Microsoft tracked, there were multiple cases where attackers using an agent framework went from first targeting to privileged access in under three hours. And with AI platforms, stolen credentials can quickly turn into unauthorized usage and significant costs.

The root causes

These problems often overlap. Take Vercel’s April incident. An employee connected a third-party AI tool to their corporate Google account, and the workspace settings allowed it broad permissions. When the tool’s vendor was compromised, the attacker got in through those existing permissions. The vendor compromise was the starting point, and the breadth of access the tool had been granted made the impact much worse.

We saw this pattern across most of the incidents: 35 of the 44 with a stated cause had more than one failure point. An exposed credential, broad permissions and limited monitoring can each be a problem on their own. Put them together, and an attacker has a much easier path through an environment.

This overlap matters when you think about prevention. Fixing one weakness might not stop an attack entirely, but it can limit how far an attacker gets. The same goes for agents running inside your own environment. Limiting what they can access, keeping credentials out of their reach and watching what they do can all help contain the damage when something goes wrong.

Below are six failure points (the four most common, and two that matter most for teams running agents) with what to check in your own environment for each.

Failure pointWhat went wrongWhat to do about it
Secrets reachableCredentials sat in agent traces, config files and build environments.Redact secrets from agent logs and traces. Keep build secrets out of places that don’t need them.
Over-scoped identity or trustTools and service accounts had more access than they needed, and attackers inherited it.Audit connected apps, OAuth grants and service accounts. Scope access to specific resources.
Third party or supply chainCompromised vendors, integrations and CI tools became a way in.Limit what integrations can reach. Keep untrusted CI steps away from publishing credentials.
Weak isolationAgent sandboxes and build environments could reach systems they shouldn’t.Enforce network limits at runtime. Don’t rely on prompts to keep agents in scope.
Nobody watchingUnusual activity went unnoticed, or was flagged and not acted on.Alert on unusual data volumes and API calls, including from agents. Decide who responds.
Agents acting uncheckedAgents acted without approval or without limits on what they could reach.Scope agent permissions to the task. Require approval for irreversible actions, and keep backups out of reach.

Where AI introduces a new risk

The familiar problems aren't the whole story. AI agents introduce another complexity because they can interpret instructions and take action across systems without someone approving every step.

Three of the incidents we reviewed show how this can go wrong. In May, Bankr's wallet bot transferred funds after following instructions relayed through another AI's public reply. In February, Cline's issue-triage bot was manipulated through GitHub issue titles that anyone could write, contributing to an unauthorized npm release. And in Anthropic's cybersecurity evaluations, agents reached real systems because their test environments had internet access and the prompts didn't establish clear boundaries.

Across these three incidents, agents were able to act beyond their intended boundaries, whether through untrusted instructions, excessive permissions, or weak isolation. If you're running agents, define what each one is allowed to touch, enforce those boundaries, and require approval for actions that can't be undone.

Screenshot of a July 21, 2026 post from Bill Gurley (@bgurley) captioned “Today in AI.” A hand-drawn comic shows a person telling a computer with the OpenAI logo to “hack this system.” The computer replies “i hacked the system,” and the person says “oh my God.”

What we still don't know

Everything above comes from what's been disclosed, and a decent chunk hasn't been.

Six of the 50 incidents had no specific cause reported. Another 17 were missing at least one detail in an otherwise useful report. Often it’s the first step that’s missing. We know what the attacker reached and what they took, but not how they got in or which flaw they used.

The categories are ours, and some failures could reasonably fit more than one. As more details come out, the numbers could change, especially with the most common causes being so close together.

What to take away from this

If there’s one thing these 50 incidents showed us, it’s that AI doesn’t need to introduce a new vulnerability to make an existing one more dangerous.

An over-privileged account, an exposed credential, or an internal service with weak monitoring can become a much bigger problem when an agent can find it and act on it much faster than a person could. And as more organizations give agents access to their own systems, those same weaknesses start to matter in new ways.

The good news is that we aren’t starting from scratch. A lot of the work comes back to knowing what has access to what, limiting what can be done with that access, and catching unusual activity before it becomes an incident.

AI may be changing how quickly things go wrong, but the basics still give us plenty to work with.

One last thing. The incidents we learned the most from are the ones where the organization published a specific, root-cause report. That's a good thing, and we'd like to see more of it.

How Aikido can help

Several of the failure points on our list map to something you can check or block with Aikido.

  • Secrets reachable. Device Protection finds credentials stored in plaintext on developer machines, including in shell history and AI agent sessions. Secrets detection catches API keys and tokens in your code before they ship.
  • Over-scoped access and weak isolation. Attack Path Analysis connects your cloud exposure and IAM permissions in one graph, so you can see what a compromised workload could reach.
  • Third party and supply chain. Device Protection blocks malicious packages, IDE extensions, browser extensions and MCP servers before they install, and holds newly published packages for 48 hours by default.
  • Agents acting unchecked. AI Capabilities pentests check whether your AI features can be talked into calling tools or reaching data they shouldn't.
  • Application flaws and missed activity. Zen blocks SQL injection and other injection attacks inside your running app and logs every blocked attempt.

Start for free.

Sources

We went through 50 AI-related security incidents reported in 2026 through November 19, using incident reports, company disclosures and security research. We looked at how AI was actually involved and what caused each incident, sticking to what the available evidence could support.

Some incidents had multiple failure points, so the root-cause counts overlap. The 50 incidents are a sample of publicly reported cases, not a complete picture of every AI-related incident this year.

Incident reports and research

4.7/5
Tired of false positives?

Try Aikido like 100k others.
Start Now
Get a personalized walkthrough

Trusted by 100k+ teams

Book Now
Scan your app for IDORs and real attack paths

Trusted by 100k+ teams

Start Scanning
See how AI pentests your app

Trusted by 100k+ teams

Start Testing
Authors
Oscar Sanchez Jr.
Security researcher
Subscribe for news
Share:

Recently Added

November 18, 2026

Aikido's Deep Review finds Java4Shell in the PR that introduced it

We recreated the 2021 OpenJDK pull request behind Java4Shell (CVE-2026-114938) and ran Deep Review on it. It flagged the bug and suggested the upstream fix.
Read more
November 5, 2026

Deleting a leaked key from your repo doesn't protect you

A leaked admin key on GitHub, deleted within hours, still led to a breach months later at LiteLLM. Learn why Git history keeps secrets and why you have to rotate.
Read more
November 4, 2026

Surviving cybersecurity until the end of 2026

After Binance, LiteLLM, PHP2Shell and eMudhra, here are six practices and a checklist to limit what the next compromise can reach before 2027.
Read more