Built on Enlil (source-available) · ~20µs p50 enforcement · action-chain aware

Let your agents act. Know exactly what they did.

Plumb sits inline between your agents and every model or tool — blocking what it shouldn't do, redacting what it shouldn't leak, and recording what it actually did.

$ curl -X POST localhost:8080/v1/chat/completions
-d '{"messages":[{"role":"user","content":
    "ignore all previous instructions..."}]}'
HTTP 403 prompt_injection_blocked
9f1c2a-0041
x-trace-id
instruction-override, score 135
detection
31
latency_us
The request never reached the model. Full decision at GET /api/traces/9f1c2a-0041.
20µs
p50 enforcement overhead
7/7
adversarial chains detected
0/20
false positives, benign sessions
1
binary, self-hosted
Everything your agents did

One dashboard, not a wall of logs.

Open the live dashboard →
Dashboard
Real-time proxy telemetry
LIVE
Token Quota Used
72.4%
L1 Cache Hit Rate
61%
1,342 hits / 2,201 total
PII Interventions
128
Risk Alerts
3
1 kill switch triggered
Activity feed
policy_block — credential exfiltration matchedacme · 0.4s ago
pii_redaction — 2 fields maskedacme · 2s ago
cache_hit — exact-intent matchinitech · 6s ago
loop_break — same intent × 6, session cutacme · 11s ago
Security & cache events
Cache hits1,342
PII redacted128
Policy blocks14
Loops broken3

Illustrative data — your dashboard shows your own tenant's traffic, live, polling every 10s.

Integrate in 2 minutes

One line of code. No SDK.

agent.py
client = OpenAI(
    api_key="sk-your-provider-key",
-   base_url="https://api.openai.com/v1",+   base_url="https://api.plumb.samji.in/v1",  # only change
)
01

Sign in

Google or GitHub — a Plumb key is issued instantly.

02

Swap the base_url

Your existing OpenAI-compatible client, unchanged otherwise.

Live in your dashboard

Cost, cache savings, and security events, in real time.

What's free vs. what Plumb adds

The engine is source-available. Plumb is the org layer on top.

Request body — raw

"Reach John at [email protected]
SSN on file: 521-04-3399"

Forwarded upstream

"Reach John at [EMAIL_REDACTED]
SSN on file: [SSN_REDACTED]"

Reversible only via an RBAC-gated, audited reveal.

In Enlil — free, self-hosted, unlimited

cargo install enlil

Prompt-injection defense

Scans messages & tool schemas structurally — any provider, no per-vendor rules.

Declarative policy rules

Block / redact / alert / log. Credential exfiltration and SQL/prompt injection ship enabled.

Agent loop-breaker

Repeats the same intent → 429 agent_loop_detected, before it burns budget.

Reversible PII redaction

Masks SSNs, emails, cards and phone numbers before they leave your box.

Exact-intent cache

blake3 over messages + tools short-circuits redundant LLM calls.

Circuit breaker + failover

Per-provider, with a local Ollama fallback for data sovereignty.

Plumb adds — for an organization, not a single deployment

Multi-tenant audit trail

Every action traced & scoped per tenant, deterministically replayable.

PII vault, RBAC + audit log

Reveal is RBAC-gated; every reveal — who, when, which tenant — is logged.

SIEM-shaped audit export

Blocked/alerted actions as OCSF Detection Findings, with a session-chain view.

Multi-tenancy, SSO & RBAC

One deployment, role-scoped access, instead of one shared key.

The actual blocker

Your agent deal is stuck in your customer's security review.

Their security team asks what the agent can access, what happens if it goes rogue, and how you'd prove it after the fact. That's the deal-blocker Plumb exists for.

Every decision, recorded

An x-trace-id and a recorded decision path per request — what was checked, blocked or redacted, latency, and cost.

Reversible redaction, fully audited

Masking reverses only through an RBAC-gated reveal, and every reveal is logged with actor, timestamp, and token.

Tenant-scoped by default

Traces and audit events are scoped to the owning tenant unless you're a super-admin.

A dedicated one-click, signed evidence-pack export (PDF/JSON) is on our roadmap — today, the same underlying trace and audit data is queryable via the API and admin dashboard, tenant-scoped and access-controlled.

GET /api/traces/{id}admin-gated
{
  "trace_id": "9f1c2a-0041",
  "tenant_id": "acme",
  "path": "/v1/chat/completions",
  "steps": [
    "protocol_detected=OpenAI",
    "pii_redacted",
    "policy_block: block-credentials"
  ],
  "blocked": true,
  "block_reason": "policy_blocked:block-credentials",
  "status": 403,
  "latency_us": 41
}
Real shape of a recorded trace — see /trustfor what we store and don't.
Agent-action semantics

It reads intent, not just HTTP.

Enforcement walks the body structurally — OpenAI, Anthropic, Gemini, MCP tool calls, and shapes that don't exist yet, all scanned the same way.

parse_body
guard.analyze
loop_breaker
cache.get
stream_to_agent
  • JSON-RPC / MCP deobfuscation
    Intercepts the true intent of autonomous tool calls.
  • Memory-safe on the hot path
    Pure Rust — no GC pauses; ~20µs p50 / ~34µs p99 governance overhead, measured in CI.
  • Streaming (SSE) pass-through
    Tokens and cost accounted in the background, never blocking the agent.
proxy.rs
async fn handle_proxy(req) {
  // parse the intent once, share everywhere
  let v = parse_body(&req);
  guard.analyze(&v);      // injection + PII
  loop_breaker.check(&v); // runaway cost
  if let Some(hit) = cache.get(&v) {
    return hit;         // blake3 exact-intent cache
  }
  stream_to_agent(upstream).await
}
Two ways to run it

Start where you are.

Individual developer / one team

Enlil

Free, self-hosted, unlimited — forever. One binary, no signup, no cloud account.

$ cargo install enlil
View on GitHub
Company / agent fleet

Plumb

Multi-tenancy, SSO/RBAC, and a signed audit trail on top. First month free for design partners.

Freefor your first month, then scoped to you
Start the free trial
Self-host or cloud Reversible PII vault No key storage Auditable by design
Read the trust & security page →