Inspect every request.
Block the attack inline.
RedEyes is an inline reverse-proxy WAF. It deeply normalizes each request and fuses four detection engines — curated signatures, OWASP CRS, libinjection semantic analysis, and behavioral anomaly — to block SQLi, XSS, traversal, RCE and more in milliseconds, with a corroboration gate that keeps false positives low.
Observe first, enforce when ready · fail-safe by default · every decision audited
Autonomous enforcement needs brakes: a shadow mode that observes before it blocks, per-site allowlists, a per-request inspection deadline that fails safe, and fail-closed on critical paths. Every decision is logged with its reasoning.
Two eyes. One gateway.
RedEyes watches with two eyes — one on your web layer, one on your AI / LLM layer. When both watch the same request, nothing crosses unseen. That is RedEyes.
The first eye: an inline WAF that normalizes and inspects every request and blocks web attacks in milliseconds.
The second eye: inspection for the AI / LLM layer — the direction RedEyes is built to grow into.
Regex WAFs miss what they can't pattern-match.
A signature-only WAF matches attack strings literally — so attackers encode, comment-split, and case-flip their payloads until the pattern no longer matches. Tune the rules up and false positives bury your team in noise; tune them down and real attacks slip through. And most WAFs never inspect the request body the way your backend actually parses it.
Double-encoding, inline comments, unicode and case tricks — a literal signature match is trivially bypassed.
Loosen the rules and you miss attacks; tighten them and you block real users. There is no good static setting.
Bodies over a size cap, unusual charsets, or compressed payloads often forward uninspected — straight past the WAF.
From interception to an audited decision.
Inline reverse proxy.
RedEyes sits inline in front of your app and intercepts every HTTP request — one point, one normalization, before anything reaches your backend.
Read it the way the backend will.
Each request is decoded through many canonical forms — multi-pass URL/HTML/base64 decode, comment-strip, charset fold — to defeat the encodings attackers hide behind.
Four engines, fused.
Curated signatures, OWASP CRS (Coraza), libinjection semantic analysis, and behavioral anomaly each score the request; a weighted noisy-OR combines them.
Block safely, log everything.
A corroboration gate keeps false positives low; shadow / normal / hardened modes control enforcement; critical paths fail closed; every decision is logged with its reasoning.
A hybrid, not a single ruleset: a battle-tested open-source engine (Coraza / OWASP CRS) plus RedEyess' own normalizer, semantic and anomaly layers, combined under one corroboration gate.
Everything on the request path.
Multi-pass decode, comment-strip and charset fold across many canonical forms — the evasion defense a literal signature match lacks.
Signatures + OWASP CRS + libinjection semantic + anomaly, combined with a corroboration gate so a single noisy rule can't false-positive alone.
The request body is buffered within a cap and inspected the way your backend actually reads it — not just the URL.
Start in shadow to see what would block, then flip to normal (403) or hardened (IP-ban) per site when you're ready.
A privilege-split host agent applies nftables drops; the internet-facing proxy itself holds no elevated capabilities.
Detect and strip PII and leaked secrets from response bodies before they leave your app.
JA3/JA4 match-lists flag or block clients by their TLS handshake — before a byte of HTTP is parsed.
Per-site rate limiting, IP-reputation blocking, and positive-security OpenAPI schema enforcement.
Run it yourself, or let us run it.
Self-hosted (GA)
One command brings up the proxy + dashboard in your own infrastructure. Your traffic never leaves your network — air-gap friendly.
Managed cloud
Multi-tenant SaaS with per-tenant isolation (Postgres row-level security, a dedicated proxy per tenant), usage-based billing, and per-plan quotas.
Observe before you enforce
Every deployment starts in shadow mode and shows exactly what it would block — flip to enforcing once the false-positive rate is right.
One evasive payload. Two outcomes.
The signature is written for the literal string ' OR 1=1. The attacker sends it double-encoded, so the WAF sees only %2527%20OR%25201%3D1 — no pattern match — and forwards it to the app.
RedEyes decodes the request to the form the backend will actually run, libinjection recognizes the SQL tautology, OWASP CRS corroborates, and it is blocked autonomously — with the full decode trail in the audit log. If RedEyes can't fully parse or reach a verdict on a request, it blocks by default rather than letting it through — an ambiguous request is treated as hostile, so a parser failure can never become a bypass.
Straightforward, per-site pricing.
Cloud plans shown; every plan starts with a 14-day free trial. Self-hosted is licensed separately — talk to us.
- 3 protected sites
- 3 operator seats
- Hybrid fusion detection
- Shadow + enforce modes
- Full audit trail
- 10 protected sites
- 10 operator seats
- Everything in Starter
- Alert channels (Slack / webhook)
- Higher detection depth
- 50 protected sites
- 25 operator seats
- Everything in Pro
- API-schema enforcement
- TLS-fingerprint rules
- Unlimited sites & seats
- Self-hosted or sovereign
- Priority support & SLA
- SSO / SAML
- Custom onboarding
One inline gateway in front of every app.
Deploy RedEyes inline in your own infrastructure or our managed cloud. It starts in observation mode and shows you what it would block — then enforces autonomously when you're ready, with fail-safe on from day one.