---

Zentinel is a high-performance reverse proxy built on Cloudflare Pingora. It provides explicit limits, predictable behavior, and production-grade defaults for environments where operators need to sleep.

Performance: Lowest p99 latency in benchmarks against Envoy, HAProxy, Nginx, and Caddy. 1M-request soak tests with 99.95% success rate and zero memory leaks. Pure Rust WAF engine processes clean traffic at 912K req/s — 30x faster than the C++ ModSecurity reference.

Status

Production-ready core (proxy, routing, TLS, caching, load balancing). Agents are individually versioned — WAF, Auth, and AI Gateway are stable; others are beta or alpha. See zentinelproxy.io/agents for per-agent status.

Request Flow

   ┌────────┐                                       ┌──────────┐
   │ Client │                                       │ Upstream │
   └────┬───┘                                       └─────▲────┘
        │                                                 │
        ▼                                                 │
   ╔═══════════ Zentinel (core, single binary) ══════════╤════╗
   ║                                                     │    ║
   ║  Listener ─▶ Routing ─▶ Filter chain ─▶ Forward ────┘    ║
   ║  TLS, H2     priority   rate-limit,     LB,              ║
   ║              + LRU      cache, hooks    retries          ║
   ║                              │                           ║
   ╚══════════════════════════════╪═══════════════════════════╝
                                  │ UDS / gRPC (v2 agent protocol)
                                  ▼
          ╔═══════ External agents (separate processes) ═══════╗
          ║   WAF · Auth · Rate-limit · …                      ║
          ║   crash-isolated, any language                     ║
          ╚════════════════════════════════════════════════════╝

Response retraces the filter chain back to the Client. Access logs and metrics emit at completion.

The dataplane runs as a single binary. Security and policy logic that is parsing-heavy or operationally risky lives in external agents behind UDS or gRPC, so a buggy agent cannot take the proxy down with it. See the Manifesto for the reasoning, and crates/proxy/docs/architecture.md for the per-phase details.

Quick Start

# Install (binary only)
curl -fsSL https://get.zentinelproxy.io | sh

# Install and start as a systemd service (Linux, root or sudo)
curl -fsSL https://get.zentinelproxy.io | sh -s -- --enable-service

# Or via Cargo
cargo install zentinel-proxy

# Or via Docker
docker run -v $(pwd)/zentinel.kdl:/etc/zentinel/zentinel.kdl \
  ghcr.io/zentinelproxy/zentinel --config /etc/zentinel/zentinel.kdl

On systemd hosts the install script also drops /etc/systemd/system/zentinel.service, a sysusers snippet, and a starter config at /etc/zentinel/zentinel.kdl. Service enable and start are opt-in via --enable-service. See crates/proxy/docs/deployment.md.

Save this as zentinel.kdl — it proxies localhost:8080 to a backend on port 8081:

system {
    worker-threads 0  // auto-detect CPU cores
}

listeners {
    listener "http" {
        address "0.0.0.0:8080"
        protocol "http"
    }
}

routes {
    route "default" {
        matches {
            path-prefix "/"
        }
        upstream "backend"
    }
}

upstreams {
    upstream "backend" {
        target "127.0.0.1:8081"
    }
}

# Run
zentinel --config zentinel.kdl

# Validate config without starting
zentinel test --config zentinel.kdl

Proxying to an HTTPS backend? Add a tls block to the upstream:

upstreams {
    upstream "backend" {
        target "api.example.com:443"
        tls {
            sni "api.example.com"
        }
    }
}

Without the tls block, Zentinel connects with plaintext HTTP regardless of the port.

More examples: config/examples/ covers API gateways, load balancing, WebSocket, caching, inference routing, and more. Or use the config builder to generate a config interactively.

Features

Feature	Description
Service Types	Web, API, Static, Builtin, and Inference (LLM/AI)
Load Balancing	14 algorithms: round-robin, weighted, least connections, Maglev, Peak EWMA, and more
Security	TLS/mTLS, rate limiting, GeoIP filtering, WAF, zip bomb protection
Agentic Protocols	Native MCP and A2A awareness — per-method and per-tool allow/deny, resolved from the JSON-RPC body rather than trusting mirrored headers
Agent Protocol	External agents for WAF, auth, and custom logic — crash-isolated, any language
HTTP Caching	Pingora-based response caching with stampede prevention and LRU eviction (memory, disk, or hybrid backends)
WebSocket Proxying	RFC 6455 compliant with per-frame agent inspection and session affinity
Observability	Prometheus metrics, structured logging, OpenTelemetry tracing
Hot Reload	Zero-downtime config updates via SIGHUP with validation and atomic swap (routes, upstreams, agents; listener changes require a restart)

See the full feature breakdown at zentinelproxy.io/features.

Use Cases