What are the actual attacks and risks from AI, how do we focus on those specifically, and how do we know we're not just doing security theater? Most AI security conversations skip that question and go straight to one of two bad reactions: panic-buy an AI security product, or dismiss the whole thing as hype with a new vocabulary. Neither answers it. Answering it for real means separating two genuinely different questions that keep getting talked about as if they're one: what changes when attackers and employees both use AI as a force multiplier, and what changes when AI becomes part of the system we're actually defending.
And by fundamentals, I don't mean a checklist of MFA, patching, and logging to tick off. I mean the underlying properties those controls were always supposed to give us: known identities, constrained authority, explicit trust boundaries, visibility into what's actually happening, controlled dependencies, and a blast radius you can contain when something goes wrong.
AI doesn't change what those properties are. It changes how hard they are to maintain, and how fast the gap gets found when you don't.
When AI becomes a force multiplier
Phishing, reconnaissance, credential stuffing. None of it is new. What's changed isn't the technique, it's the analysis and the execution. Automated internet-wide scanning has existed for over a decade. That was never the bottleneck. What AI compresses is turning raw scan output into an attack plan, and writing a phishing email polished enough that it no longer has the broken grammar and off tone people were trained to spot for the last decade.
The old advice for phishing isn't "patch and log more." Those don't stop a good phish from landing. What actually holds up is phishing-resistant authentication. Even if someone clicks and hands over a password, real FIDO2 or WebAuthn authentication, a hardware key or a properly set up passkey, stops that phish from being able to capture and replay the credential the same way. That's fundamentally different from SMS codes or a manually typed one-time password, both of which can still get relayed straight through a phishing kit. Least privilege is the second piece, it limits what a compromised account can touch if the first layer fails. Logging and behavioral detection matter too, but for catching what happens after a compromise, not for preventing the click.
One objection is worth taking head-on: telling someone to "just patch" doesn't mean much when exploitation can happen in hours, while Verizon's 2026 dataset puts median full remediation of observed KEVs at 43 days, up from 32 the year before. Fair. But that's not an argument for a new discipline, it's an argument that the old one finally needs to run at the speed the threat already operates at. Increasingly that means automated patch orchestration instead of a human working a ticket queue, or agentic triage doing at machine speed what an analyst used to do by hand across a wall of alerts. Neither of those changes the underlying security objective. They're still vulnerability management and log analysis, forced to stop pretending human speed was ever going to be enough. The automation isn't the point. It's how the discipline finally keeps a promise it made twenty years ago.
Real breach data backs this up better than a guessed split would. The 2026 Verizon DBIR found vulnerability exploitation became the leading known initial-access vector for the first time in the report's nineteen-year history, accounting for 31% of breaches in that dataset, while Verizon's vulnerability-management data found only 26% of observed CISA Known Exploited Vulnerabilities were fully remediated. That's not primarily an AI tooling problem, it's a discipline problem that predates AI by years, and AI just compresses the time defenders have left to get away with it.
The same logic holds when the person using AI is on your own payroll, engineers handed Claude licenses and told to go, AI reviewing pull requests, AI generating infrastructure as code. Static and dynamic analysis still catch plenty of what they've always caught, though AI-generated code at volume can introduce logic and authorization flaws that a scanner tuned for the old failure modes won't always flag, which is its own reason review has to stay sharp. What genuinely has to change is dependency control. Traditional software composition analysis still matters, but it isn't sufficient by itself: researchers found AI coding assistants hallucinate package names that sound plausible but don't exist, at rates from roughly 5% to over 20% depending on the model, across more than half a million generated code samples.
That creates an obvious supply-chain opportunity: an attacker can register a predictable hallucinated name and wait for a developer or coding agent to install it. A scanner looking for known-bad packages won't catch a malicious package that was only registered yesterday under a name nobody's flagged yet. That needs provenance and reputation checks, dependency allowlisting, and some way to challenge a package an AI assistant introduced before someone blindly installs it. Peer review still matters too, but only if it survives the volume. A rubber stamp because nobody has time to actually read AI-generated code at AI-generated speed isn't review, it just looks like one.
Visibility follows the same pattern. An enterprise browser, for example, can give you visibility into who's using ChatGPT, Claude, or any other LLM on a personal account, and the ability to actually govern it: block an AI service that doesn't meet your organization's data-handling requirements, DeepSeek being one example, or restrict personal AI accounts entirely on managed devices. None of that requires buying an "AI security" product. It requires extending an old discipline, asset visibility and data loss prevention, to cover a category of tool that didn't exist on anyone's inventory two years ago.
When AI becomes part of the system
This is genuinely different territory, and it's also, honestly, the area I know least. I'm not the one writing mitigations into a chatbot's system prompt or hardening a model against injection at the API layer. What I do own is the architect's-level question: now that we're deploying AI systems, what's our actual exposure surface, and who's accountable for closing it.
Prompt injection isn't a patchable vulnerability in the traditional sense, it exploits the fact that a model processes instructions and untrusted data through the same channel. There's no general-purpose equivalent yet to parameterized queries solving SQL injection. Training data and model artifacts can be poisoned in ways traditional vulnerability scanners weren't designed to detect.
It gets substantially more interesting once a model can read untrusted content and then take action on it. A malicious instruction buried in a webpage, a document, an email, or a retrieved knowledge source can become an authorization problem the moment an agent acts on it using access it was legitimately granted. That's where AI that reads becomes materially different from AI that acts: untrusted data quietly becomes input to a system that has real authority.
But the one that actually keeps me up more than prompt injection is authorization for non-human actors. Security has understood service accounts for decades: give a workload an identity, scope its permissions, assign an owner, review it on a cadence. Agents complicate that model because the identity can stay stable while the behavior behind it doesn't. An agent chooses tools, sequences actions, and in some architectures delegates pieces of a task to other agents or external tools, whether a proprietary integration, a plugin, or something exposed through a protocol like MCP, all while operating through access that was granted somewhere upstream.
Nobody's magically receiving new permissions out of thin air. The real problem is understanding and constraining how that delegated authority actually gets exercised: how authority and provenance follow an action through a chain of agents, and whether that action should have required a human to sign off first.
Ask most security teams today, mine included, who's accountable when an agent delegates an action that causes harm, and you probably won't get a clean answer.
The frameworks do have something to say about this. NIST's AI RMF explicitly calls for defined accountability structures and human oversight. What it doesn't do is tell you where the line sits for this specific case, which actions require approval, where delegation stops, how authority actually follows an action through a chain of agents. The frameworks tell you to have an answer. They don't hand you one. And the same controls have to support containment: if an agent starts doing something it shouldn't, can you revoke its authority, stop the workflow, and reconstruct what happened without taking the whole system offline?
A couple of other things are worth flagging here too. AI-specific logging is its own problem. The interaction and action trace around a model or agent isn't the same shape as a server access log, and it creates observability requirements most conventional application logging was never designed to capture.
Cloud providers are building native controls at the model layer too. Amazon Bedrock Guardrails is the implementation I'm most familiar with, and it's a good example of why there's no single magic control: contextual grounding can help flag responses that aren't actually supported by the source material, while Automated Reasoning validates output against logical rules and policies you define yourself, a different job entirely. AWS is explicit that Automated Reasoning doesn't protect against prompt injection on its own, that requires separate controls. Different failure modes, different safeguards. There's also a growing vendor market around this space more broadly that I don't have enough direct experience with to endorse yet, so I'll say plainly I can't vouch for any of them specifically. And there's supply chain risk in every model, plugin, or integration you didn't build yourself, vendor risk wearing a new hat, except the vendor can be a black box you can't fully audit.
The common thread running through all of this is trust boundaries. A model's output should be treated as untrusted until some other control decides what it's allowed to influence. Retrieved content shouldn't inherit authority just because a model read it. An agent shouldn't get broader permissions just because that makes the demo easier to build. The model can recommend, reason, summarize, or plan. The system around it still has to decide what it's actually allowed to do.
This category is real, and it's the part of the conversation that actually needs new thinking rather than an old control renamed. It's also narrower than the discourse suggests. These risks become materially different when AI is connected to your data, your applications, or your authority, not simply because somebody opened a chatbot.
AI that talks < AI that reads < AI that acts.
Each step to the right generally crosses another trust boundary.
Governance tells you where to look. It doesn't do the work.
This is also the honest answer to "how do we know we're not doing security theater." NIST's AI Risk Management Framework, MITRE ATLAS, and OWASP's GenAI LLM Top 10 all get lumped together like they're interchangeable, but they're doing three different jobs. NIST is organizational scaffolding, how you think about AI risk as a business, not a technical control. ATLAS is a threat-modeling catalog, ATT&CK's sibling, cataloging what adversarial tactics against AI systems actually look like. OWASP's LLM Top 10 is the practical, systems-level checklist, and it's worth noting OWASP now maintains a separate Top 10 specifically for agentic applications, which is a useful distinction on its own: prompt injection and an agent taking an action it shouldn't are related problems, but they're not the same problem.
The frameworks tell you what to worry about. They don't extend your access control model to cover it.
An organization can map itself cleanly to every one of these frameworks and still have an intern-issued API key sitting with standing access to production data. Mapping to a framework isn't security. It's an inventory of what you still have to go build. That's the actual test for theater versus substance: not whether you can point to a framework, but whether you can point to what changed in your environment because of it.
What this actually looks like
Managed security providers are starting to use agentic workflows for tier-one log triage, and the speed gain can be real. Evaluating that kind of system still comes down to familiar questions: what can it touch, what can it decide, and what happens when it's wrong. On the employee side, the same logic applies through AI acceptable-use policy and browser controls, because "don't paste customer data into a chatbot" has to be enforceable, not assumed. Neither example is glamorous. Both are what this article is arguing for: applying security discipline to a new kind of system instead of assuming every new system needs an entirely new discipline.
So when someone tells you AI needs an entirely new security stack, ask what's actually missing from the old one first. Some of it genuinely is new, that's what this whole piece has been trying to be honest about. But in my experience the bigger problem is still the one it's always been: most of us never finished installing what we already had.
Sources and further reading: NIST AI RMF · MITRE ATLAS · OWASP GenAI Security Project · Verizon 2026 DBIR · USENIX Security: package hallucination research