Artificial intelligence has moved from experiment to infrastructure. It now sits inside customer support, fraud detection, code generation, medical triage, and countless other workflows that organizations depend on every day. But as AI becomes load-bearing, it also becomes a target, and securing it requires more than the controls we already apply to traditional software.
AI introduces new attack surfaces: the data it learns from, the model itself, the pipelines that build it, and the unpredictable ways it behaves in production. Protecting an AI system means thinking across all of these layers at once.
This post breaks AI security into eight practical pillars. Together they form a defense-in-depth approach. No single one is enough, but layered together they give you real resilience.
1. Data Security
Everything an AI system knows comes from data, which makes data the first and most important thing to protect.
The risks here are broad. Training data can be poisoned, where an attacker quietly injects manipulated examples so the model learns the wrong thing, like a backdoor that triggers on a specific input. Sensitive data can leak, either through the training set itself or through model outputs that memorized and regurgitate private records. And data can simply be stolen, since curated, high-quality datasets are valuable assets in their own right.
What helps:
Validate and clean training data, and track its provenance so you know where every dataset came from.
Encrypt data at rest and in transit, and apply strict access controls to training pipelines.
Use techniques like differential privacy or data minimization to reduce what the model can memorize about individuals.
Watch for anomalies in your data sources that could signal tampering.
2. Model Security
The model itself, including its weights, architecture, and behavior, is a high-value asset that needs its own protections.
Threats include model theft, where attackers extract or copy a proprietary model, sometimes just by querying it enough times to clone its behavior. There's model inversion, where attackers reconstruct sensitive training data from the model's responses. And there's tampering, where the model file itself is swapped or modified before deployment.
What helps:
Treat model weights like crown-jewel secrets: encrypt them, control access, and log who touches them.
Sign and verify model artifacts so you can detect tampering before deployment.
Rate-limit and monitor inference APIs to make extraction attacks harder and slower.
Watermark models where appropriate so stolen copies can be identified.
3. Infrastructure Security
AI runs on infrastructure: GPUs, containers, orchestration layers, vector databases, and cloud services. All the traditional security rules still apply here, plus a few AI-specific wrinkles.
The pipelines that train and serve models are complex and often stitched together quickly, which leaves gaps. Misconfigured storage buckets expose datasets. Over-permissioned service accounts give attackers a foothold. And the heavy compute AI requires makes it an attractive target for resource hijacking, such as cryptomining on your GPUs.
What helps:
Apply least-privilege access across the entire MLOps pipeline, not just production.
Harden and patch the containers, orchestration tools, and dependencies that run your models.
Isolate training and inference environments so a compromise in one doesn't spread.
Monitor compute usage for anomalies that could indicate abuse.
4. AI SBOM (Software Bill of Materials)
You can't secure what you can't see. An AI SBOM is an inventory of everything that goes into an AI system: the models, datasets, libraries, frameworks, and pre-trained components, along with their sources and versions.
This matters because modern AI is assembled from many parts, often pulled from open repositories like Hugging Face or public package registries. A single compromised pre-trained model or poisoned dependency can undermine the whole system, and without an inventory you'd have no way to trace the problem or even know you're affected.
What helps:
Maintain a complete, up-to-date inventory of models, datasets, and dependencies.
Record provenance and licensing for every third-party component you pull in.
Scan dependencies for known vulnerabilities and malicious packages.
When a new threat emerges (a poisoned model on a public hub, say), use your SBOM to immediately check your exposure.
5. AI Adversarial Testing
Traditional testing checks whether software does what it should. Adversarial testing, often called red teaming for AI, checks how the system fails when someone is actively trying to break it.
This means probing the model the way a real attacker would: crafting inputs designed to make it misbehave, bypass its safety controls, leak information, or produce harmful output. For generative and language models, this includes prompt injection and jailbreak attempts. For other models, it includes evasion attacks, where carefully tweaked inputs fool the model into wrong predictions.
What helps:
Red-team your models before launch and on an ongoing basis, not just once.
Test against known attack techniques (prompt injection, jailbreaks, evasion, data extraction).
Combine automated adversarial tooling with creative human testers.
Feed findings back into your guardrails and training to close the gaps you discover.
Even a well-built model needs a safety layer around it at runtime. Guardrails are the checks that sit between the user and the model, and between the model and the outside world.
Input guardrails inspect what's coming in, filtering malicious prompts, prompt-injection attempts, off-topic requests, or sensitive data that shouldn't be sent to the model. Output guardrails inspect what's going out, catching harmful, biased, or confidential content before it reaches the user, and validating that the model isn't taking unsafe actions in agentic systems.
One threat deserves special attention here: indirect prompt injection. Unlike a user typing a jailbreak directly, indirect injection hides malicious instructions inside content the model later reads: a web page, a PDF, an email, a calendar invite, or a document in a knowledge base. The model processes that poisoned content and treats the hidden instructions as commands. This is one of the hardest problems in AI security today, precisely because the attack doesn't come from the user at all. It rides in through the data the model was asked to work with.
What helps:
Filter and sanitize inputs to catch injection attempts and policy violations before they reach the model.
Treat all external content the model ingests (documents, web pages, tool results) as untrusted, not just the user's direct prompt.
Validate outputs against safety, privacy, and accuracy rules before they're returned or acted on.
For AI agents that can take actions, gate high-risk operations behind explicit checks.
Keep guardrails updated as new attack patterns appear. This is not a set-and-forget control.
7. Agentic and MCP Security
The newest and fastest-growing attack surface comes from AI that doesn't just answer, it acts. Modern AI agents can call tools, browse the web, query databases, run code, and chain these actions together. Increasingly they connect to external systems through standards like the Model Context Protocol (MCP), which lets a model plug into tools and data sources. Every one of those connections is a new door.
The risks are distinct from anything in the earlier pillars. A malicious or compromised MCP server can exfiltrate data, return poisoned results, or quietly take unauthorized actions on the user's behalf. Tool poisoning hides malicious instructions inside a tool's description or metadata, so the model is subverted just by having the tool available. Excessive agency is the problem of giving an agent broader permissions than it needs, the ability to take consequential actions with too little oversight. And the confused deputy problem arises when an agent with legitimate access is tricked into misusing that access for an attacker.
There's also an identity dimension. As agents act on behalf of users, you have to answer a new question: who is this agent acting as, and what is it allowed to do? Non-human identities, scoped credentials, and clear delegation boundaries become essential, because an over-privileged agent with a stolen or spoofed identity is a powerful tool in the wrong hands.
What helps:
Vet and trust MCP servers and tools before connecting them; treat third-party servers with the same scrutiny as any external dependency.
Inspect tool descriptions and metadata for hidden instructions, and pin versions so a tool can't silently change underneath you.
Apply least-privilege to agents: grant only the tools and permissions each task actually requires, and scope credentials tightly.
Gate high-risk or irreversible actions behind explicit confirmation or human approval.
Give agents their own scoped, auditable identities rather than borrowing broad human or service-account credentials.
Log every tool call and action an agent takes, so you can trace exactly what happened during an incident.
8. Human in the Loop and Monitoring
No matter how good your automated defenses are, AI systems behave probabilistically and can fail in ways you didn't anticipate. Keeping humans involved, and watching the system continuously, is the safety net.
Human-in-the-loop means routing high-stakes or low-confidence decisions to a person for review rather than letting the model act alone. Monitoring means continuously observing the system in production: tracking inputs and outputs, watching for model drift, detecting abuse, and alerting on anomalies.
What helps:
Require human review for consequential decisions (denying a loan, taking an irreversible action, flagging someone).
Log inputs, outputs, and decisions so you have an audit trail to investigate incidents.
Monitor for model drift and performance degradation over time, not just security events.
Build clear escalation paths so flagged issues reach the right people quickly.
Bringing It Together
These eight pillars aren't a checklist you complete once. They're overlapping layers that reinforce each other. Strong data security reduces what adversarial testing has to catch. A good SBOM makes infrastructure incidents traceable. Guardrails and human oversight catch what slips through everything upstream.
The organizations that get AI security right treat it as a continuous discipline: built into the pipeline from day one, tested constantly, and watched closely in production. As AI takes on more responsibility, that discipline is what separates a trustworthy system from a liability.
Start where your risk is highest, build outward, and remember: in AI security, depth beats any single defense.
