🧪 Private Beta — Stress-testing detection at scale before public launch.
BETA
Ready to protect your AI? Start scanning for threats in seconds
Try Live Demo GitHub

Detect AI Threats
Before They Execute

Transparent threat detection that runs anywhere – your laptop, your cloud, your edge device.
Under 10ms. 100% local. 100% auditable.

2 lines of code
OWASP Top 10
<10ms latency
Try Live Demo

Test our threat detection in your browser. 100% local, no data transmitted.

Community Edition

Free Forever – Community License, self-hosted AI security

Star on GitHub
<1k stars
Community License
<10ms P95
100% Local
460+ Rules
AI Safety Research

For Developers

Ship secure AI apps fast

  • pip install raxe — one line setup
  • <10ms local detection
  • 460+ rules, 7 threat families
  • Open, auditable, full transparency
Get Started on GitHub

For AI Safety Research

Open access threat intelligence

  • Anonymized telemetry for research
  • Real-world threat trend insights
  • Inform AI governance & policy
  • Built by cyber defense veterans
Request Research Access
What triggers Rule ID, threat type, confidence
Trend data Timestamps for pattern analysis
Hashed metadata Non-reversible, anonymized
Never shared Your prompts, outputs, PII, or data

Sharing threat intelligence with:

AI Safety Orgs Academic Researchers Policy Makers Governance Bodies

Full Telemetry Disclosure

We believe in radical transparency. Here's exactly what we send — nothing hidden.

What We Send vs. What We Never Send

Field What's Sent What's Never Sent
prompt_hash SHA-256 hash (irreversible) Raw prompt text
rule_ids Rule IDs (e.g., pi-001) What text matched
families Threat codes (PI, JB, PII) Detection patterns
prompt_length Character count only Actual content
org_id Anonymous org identifier Company names or emails
scan_duration_ms Performance metrics System details

Exact Telemetry Payloads

These are real examples of what gets transmitted — copy-paste from our codebase.

CLEAN telemetry/clean.json 
{
  "event_id": "evt_a1b2c3d4e5f67890",
  "event_type": "scan",
  "timestamp": "2025-12-06T18:30:00.123456+00:00",
  "priority": "standard",
  "payload": {
    "prompt_hash": "sha256:315f5bdb76d078c43b8ac0064e4a0164612b1fce77c869345bfc94c75894edd3",
    "threat_detected": false,
    "scan_duration_ms": 2.34,
    "detection_count": 0,
    "highest_severity": "none",
    "rule_ids": [],
    "families": [],
    "l1_duration_ms": 1.12,
    "l2_duration_ms": 0.0,
    "l1_hit": false,
    "l2_hit": false,
    "l2_enabled": true,
    "prompt_length": 45,
    "action_taken": "allow",
    "entry_point": "cli"
  },
  "org_id": "org_abc123",
  "team_id": "team_xyz789"
}

The key insight: We can detect threats and improve collective defense without ever seeing your actual data. SHA-256 hashes are cryptographically irreversible — we literally cannot recover your prompts even if we wanted to.

Request Research Access

Enterprise users can disable telemetry. Community Edition shares anonymized detection data to strengthen collective defense.

RAXE emerged from decades of frontline experience at UK Government, Mandiant, FireEye, and CrowdStrike — where we saw firsthand how threat intelligence sharing creates collective defense.

Today, AI security faces a familiar challenge: fragmented visibility across a rapidly evolving threat landscape. We believe the path forward is transparency and collaboration — sharing what we learn so the entire ecosystem gets stronger together.

We built RAXE differently. Our Community Edition isn't just "free" — it's infrastructure for AI safety. Anonymized detection metadata (what triggered, not what you typed) flows back to strengthen defenses for healthcare AI, educational tools, financial systems, and critical infrastructure worldwide.

This is how we bridged the gap in cybersecurity. Now we're accelerating this for AI security.

Immediate ROI

  • $0 license fees - Open source, self-hosted
  • 90% faster incident response with clear explanations
  • Zero data egress costs - All processing local
  • No surprise bills - Predictable infrastructure costs

Compliance Ready

  • SOC 2 Type II - Auditable detection logs
  • GDPR compliant - No data leaves your infra
  • Full audit trails - Every detection is explainable
  • ISO 27001 friendly - Open source = verifiable security

Risk Mitigation

  • Prevent data breaches - Block PII leaks before they happen
  • Protect brand reputation - No toxic AI responses
  • Avoid regulatory fines - Proactive compliance
  • Reduce insurance premiums - Demonstrable security controls

Strategic Freedom

  • Full ownership - Own your security stack
  • Works offline - Air-gapped deployments supported
  • Multi-cloud ready - Deploy anywhere (GCP, AWS, Azure, on-prem)
  • Open roadmap - Community-driven development

Fast rule-based precision + smart ML-powered detection

User Input
→
L1
Rule-Based
<1ms
→
L2
ML Detection
<10ms
→
Safe Output
L1

Rule-Based Detection

Fast, precise pattern matching using 460+ curated rules maintained by security researchers.

460+
Detection Rules
<1ms
Scan Time
Prompt Injection Jailbreaks PII Leaks Command Injection
L2

ML-Powered Detection

Lightweight CPU-friendly classifier that catches novel attacks and obfuscated patterns.

CPU
No GPU Required
<10ms
Total Latency
Obfuscated Injection Novel Patterns Context Anomalies
Advanced Detection Layers PRO + ENTERPRISE

Community Edition stops 80%+ of attacks with L1+L2. But sophisticated attackers use multi-turn attacks, obfuscation, and context manipulation that slip through. That's where Pro's L3-L6 layers come in:

L3: Statistical & Embedding Analysis Catches semantic anomalies
L4: LLM Judgement & Reasoning Detects context manipulation
L5: Memory & Session Correlation Stops multi-turn jailbreaks
L6: Output Governance & Policy Enforces compliance rules

CPU-only inference that runs anywhere—from Raspberry Pi to enterprise servers. No GPU. No cloud latency.

96.8%
Accuracy
<10ms
Inference
8KB-106MB
Model Size
CPU-only
No GPU
ONNX Runtime BERT Embeddings INT8 Quantization Transformers.js
🍓

Raspberry Pi

ARM Cortex-A72, <15ms inference

Edge detection on $35 hardware

💻

Developer Laptop

Intel i5/i7, M1/M2, <5ms inference

Local dev without cloud costs

☁️

Cloud / On-Prem

AWS t3, GCP n1, <3ms inference

Production scale on cheap instances

📱

Mobile / IoT

iOS, Android, ESP32, 8KB-106MB models

Embedded security in apps

basic_usage.py 
from raxe import Raxe

raxe = Raxe()
result = raxe.scan("Ignore all previous instructions")

if result.has_threats:
    print(f"🚨 Threat detected: {result.family}")
    print(f"Severity: {result.severity}")
# That's it. No cloud calls. No data leaks.
decorator_pattern.py 
from raxe import Raxe

raxe = Raxe()

@raxe.protect  # Monitor mode: logs threats, doesn't block
def generate_response(user_prompt: str) -> str:
    return llm.generate(user_prompt)

# Detects threats without blocking
response = generate_response("safe prompt")  # ✅ Works
response = generate_response("jailbreak")    # ⚠️  Detected and logged
openai_integration.py 
from raxe import RaxeOpenAI

# Drop-in replacement for OpenAI client
client = RaxeOpenAI(api_key="sk-...")

# Automatic threat blocking before API calls
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": user_input}]
)

# If user_input contains threats, raises RaxeThreatDetected
# Your API quota is protected.
fastapi_integration.py 
from fastapi import FastAPI, HTTPException
from raxe import Raxe

app = FastAPI()
raxe = Raxe()

@app.post("/chat")
async def chat(user_input: str):
    result = raxe.scan(user_input)

    if result.has_threats:
        raise HTTPException(400, f"Threat: {result.severity}")

    return {"response": llm.generate(user_input)}

Open Source Forever

Community licensed. Every detection rule is auditable. Full portability and ownership.

View on GitHub →
Star Fork

Contribute Rules

Help detect more threats. Add rules, improve detection, share knowledge.

Contribution Guide →

Join the Conversation

Follow us for updates, insights, and community discussions.

Join our Slack → Follow on X →
Follow @raxe-ai

Your Detections Inform AI Safety Policy

Real-time threat intelligence that helps AI Safety organizations understand emerging attack patterns
Research datasets that inform AI governance recommendations and policy decisions
Open detection benchmarks that improve industry-wide defenses against adversarial AI
Collective defense — your anonymized detection data protects healthcare, education, and critical infrastructure

We share aggregate insights openly with the AI Safety community. This is collective defense for AI safety.

Deployment Tiers

Community Edition

FREE

Perfect for individual developers and small teams getting started with AI security.

  • L1 + L2 detection layers
  • 460+ community rules
  • 100% local processing
  • CLI + Python SDK
  • Community licensed, source visible

⬆️ Upgrade to Pro when:
You're scanning >100k prompts/day, need compliance dashboards, or want advanced detection layers (L3-L6) that catch obfuscated attacks Community misses.

Get Started

Pro

FREE during beta

Free while we build out advanced features. Get early access now.

  • Everything in Community
  • L3-L6 advanced detection
  • Dashboard + analytics
  • Policy enforcement
  • Priority support

⬆️ Upgrade to Enterprise when:
You need on-prem deployment, custom models trained on your threat data, or SLAs with dedicated support for regulated industries (FinTech, Healthcare, Gov).

Try Free Beta

Enterprise

Custom

White-glove service for organizations requiring maximum control and compliance.

  • Everything in Pro
  • On-prem deployment
  • Custom models
  • MSSP partnerships
  • SLA + dedicated support

✅ You need Enterprise if:
You're in a regulated industry, require air-gapped deployment, need custom detection models, or want white-glove MSSP partnership. Trusted by Fortune 500 security teams.

Contact Us

Get Started in 60 Seconds

1

Install

pip install raxe
2

Authenticate

raxe auth
3

Scan

raxe scan "your text"
Star on GitHub Read Full Docs