The State of AI Security (And Why You Should Care)

AI is everywhere now. But securing AI systems is a problem most DevOps teams haven’t even started solving. Traditional security tools don’t cover AI-specific attack vectors — prompt injection, model poisoning, data leakage through embeddings, and the dozen other ways AI systems get compromised that have nothing to do with traditional infrastructure.

The good news? The open-source AI security toolchain is mature enough to use right now. You don’t need a $50K enterprise license. You don’t need a PhD. You need a laptop, a terminal, and about 30 minutes to set up.

Here are 10 free tools that form a complete AI security toolkit.

1. Garak — AI Red Teaming Framework

What it does: Automated red teaming for large language models. Tests for prompt injection, jailbreaks, data leakage, and 1000+ other vulnerability types.

Why it matters: This is NVIDIA-backed, actively developed, and covers more attack vectors than most commercial tools. It’s the closest thing to “automated penetration testing for AI” that exists right now.

# Install
pip install garak

# Test a local model
python -m garak --model_type ollama --model_name llama3

# Test an API model
python -m garak --model_type openai --model_name gpt-4

Best for: Understanding what vulnerabilities exist in your AI system before someone else does.

2. Semgrep — Static Analysis for Code and Config

What it does: Fast, precise static analysis that finds security vulnerabilities in code. While not AI-specific, it’s essential for catching insecure code patterns in AI applications.

Why it matters: Most AI apps are just web apps with a model attached. Semgrep catches the web app vulnerabilities (SQL injection, XSS, path traversal) that get amplified when connected to AI.

# Install
brew install semgrep  # or pip install semgrep

# Run against your codebase
semgrep scan --config auto .

# AI-specific rules
semgrep scan --config p/owasp-llm .

Best for: Catching traditional vulnerabilities in AI-powered applications.

3. Ollama + Open WebUI — Local AI Testing

What it does: Run AI models locally for testing security without exposing data to external APIs.

Why it matters: You can’t test AI security effectively if every test sends your data to someone else’s API. Local models let you test prompt injection, data leakage, and model behavior safely.

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Pull a model
ollama pull llama3

# Start Open WebUI (Docker)
docker run -d -p 3000:8080 --name open-webui ghcr.io/open-webui/open-webui:main

Best for: Safe, private testing of AI models and security tooling.

4. LangSmith — AI Application Observability

What it does: Monitor, debug, and test AI applications. Track prompts, responses, and model behavior.

Why it matters: You can’t secure what you can’t observe. LangSmith helps you see what your AI is actually doing — which is the first step to securing it.

# Free tier available
# Install the CLI
pip install langsmith

# Set up monitoring in your app
from langsmith import Client
client = Client(api_key="your-key")

Best for: Understanding AI behavior in production before it becomes a security incident.

5. Dependency-Check — SCA for AI Dependencies

What it does: Software Composition Analysis (SCA) that finds known vulnerabilities in your dependencies.

Why it matters: AI applications pull heavily from Python ecosystems (PyTorch, TensorFlow, LangChain, etc.). A compromised dependency in your AI stack is a backdoor to your entire system.

# Install
brew install dependency-check

# Run against your project
mvn org.owasp:dependency-check-maven:check

Best for: Catching vulnerable dependencies in your AI stack.

6. Falco — Runtime Security for Containers

What it does: Runtime threat detection for containerized environments. Monitors system calls and flags anomalies.

Why it matters: Most AI models run in containers. Falco catches when something goes wrong — unexpected file access, network connections, or privilege escalation.

# falco_rules.yaml
- rule: Unexpected network connection from AI model
  desc: Alert when the AI model makes unexpected outbound connections
  condition: >
    spawned_process and
    container.image contains "ollama" and
    not fd.name startswith "/dev/null"
  output: "AI model made unexpected network connection"
  priority: WARNING

Best for: Catching compromised AI models in production.

7. Trivy — Container and IaC Scanner

What it does: Comprehensive scanner for container images, Kubernetes configs, and Infrastructure-as-Code.

Why it matters: If you’re deploying AI models via Docker or Kubernetes (and you probably are), Trivy finds vulnerabilities in your deployment infrastructure.

# Install
brew install trivy

# Scan a container image
trivy image ollama/ollama:latest

# Scan Kubernetes manifests
trivy fs --scanners misconfig .

Best for: Securing the infrastructure that runs your AI models.

8. Promptfoo — AI Prompt Testing Framework

What it does: Automated testing for AI prompts. Evaluate prompts for safety, correctness, and consistency.

Why it matters: Prompt injection is the #1 AI security vulnerability. Promptfoo lets you test your prompts against thousands of attack vectors automatically.

# Install
npm install -g promptfoo

# Create a test config
promptfoo init

# Run tests
promptfoo eval

Best for: Testing prompt injection and output safety before deployment.

9. OWASP Top 10 for LLMs — The Reference

What it depends on: Not a tool, but the definitive reference for AI security vulnerabilities. Updated regularly, free, and maintained by the OWASP foundation.

Why it matters: Before you can secure an AI system, you need to know what can go wrong. The OWASP Top 10 for LLMs covers the 10 most critical AI-specific vulnerabilities.

1. Prompt Injection
2. Sensitive Information Disclosure
3. Training Data Poisoning
4. Model Denial of Service
5. Supply Chain Vulnerabilities
6. Model Theft
7. Excessive Agency
8. Data Leakage
9. Malicious Use
10. Insecure Output Handling

Best for: Understanding what to look for. Read this before anything else.

10. Grafana + Prometheus — Monitoring AI Systems

What it does: Open-source monitoring and alerting. Track model performance, latency, error rates, and security events.

Why it matters: When an AI model starts behaving oddly (hallucinating, leaking data, responding to prompts it shouldn’t), monitoring catches it first.

# prometheus.yml
scrape_configs:
  - job_name: 'ai-monitoring'
    static_configs:
      - targets: ['localhost:9090']

Best for: Detecting AI anomalies in real-time.

Putting It Together: Your AI Security Pipeline

Code → Semgrep → Trivy → Dependency-Check
       ↓
Prompt → Promptfoo → Garak
       ↓
Deploy → Falco → Grafana/Prometheus
       ↓
Test → Ollama (local) → Open WebUI

This is a complete, free AI security pipeline. No enterprise licenses. No paywalls. Just tools that work.

Getting Started (Right Now)

Here’s your first hour:

  1. Install Ollama — curl -fsSL https://ollama.com/install.sh | sh
  2. Pull a model — ollama pull llama3
  3. Install Garak — pip install garak
  4. Test your model — python -m garak --model_type ollama --model_name llama3
  5. Read the OWASP Top 10 for LLMs — https://owasp.org/www-project-top-10-for-large-language-model-applications/

That’s it. You now have a working AI security testing environment. The rest is practice.

What’s Next

This is just the beginning. In future posts, I’ll cover:

  • Deep dive into each tool with real-world examples
  • Setting up a home lab for AI security testing
  • Log analysis with AI — how to use local LLMs to find anomalies
  • Automating security testing in your CI/CD pipeline

Stay tuned. Or better yet — subscribe to the newsletter for updates.

This post is part of the Cyber-AI initiative — free, open-source cybersecurity and AI education for everyone.

Found this useful? Share it with someone who’s building AI applications. They’ll thank you later.