Skip to main content

The security firewall for agents

Give agents power. Don't give up control.

Claw Patrol holds agent credentials, parses their traffic at the wire, and gates actions with rules you write, all while keeping an audit log of everything that happens.

curl -fsSL https://clawpatrol.dev/install.sh | sh

Just call any agent

Prefix any agent command with clawpatrol run. Same workflow, every action gated.

$ clawpatrol run codex

The problem

Access shouldn’t be permission

An agent that can talk to Postgres can DROP TABLE as easily as SELECT.

Using keys shouldn’t mean risking them

If the agent is compromised by prompt injection, the credentials it holds leak with it.

You can’t see what happened

An agent’s work fans out across multiple services. Reconstructing what actually happened means stitching together logs from each one.

Take a tour

Click around the admin dashboard.

A walkthrough of the operator UI at demo.clawpatrol.dev. Drill into any request to see what the gateway captured.

Rules

You write access rules. Claw Patrol enforces them.

Every outbound request runs through a rule engine before it reaches its destination. Match on HTTP method, SQL verb, k8s resource, plugin-defined facets; not just URLs. Edits are hot: save a rule in the dashboard, the next request sees it.

Match anything on the wire

HTTP

Method, path, headers, body. Any host, any service. Match an HTTP request shape, route it through an LLM judge before it goes out.

# Customer-support replies sent from the agent are scanned by an LLM
# judge before they go out: catches offensive content, missing
# salutations, and markdown that shouldn't ship.

rule "support-reply-on-behalf" {
  endpoint = https.deno-deploy
  condition = <<-CEL
    http.method == 'POST'
    && http.path == '/api/admin.supportTickets.replyOnBehalf'
  CEL
  approve = [llm_approver.reply-content-judge]
}

SQL

Postgres and ClickHouse traffic parsed verb-by-verb. Match by SQL verb, table, function name, and substrings of the statement itself.

# Block Postgres functions that could read the filesystem or open
# outbound connections from inside the database — pg_read_file,
# lo_get, and the whole dblink family.

rule "pg-banned-functions" {
  endpoint = postgres.pg-staging
  priority = 100
  condition = <<-CEL
    sets.intersects(sql.functions, [
      'pg_read_file', 'pg_read_binary_file', 'lo_get',
    ])
    || sql.functions.exists(f, f.startsWith('dblink_'))
  CEL
  verdict = "deny"
  reason  = "filesystem-reaching function"
}

Kubernetes

API calls to kube-apiserver. Match by namespace, resource, verb, and name. Catch destructive verbs on the wrong cluster, or hand exec commands to an LLM.

# kubectl exec is gated by an LLM judge that reads the command argv:
# allows ls / ps / df, denies env dumps, sensitive file reads, and
# anything touching pod tokens or container sockets.

rule "k8s-exec-content-check" {
  endpoints = [kubernetes.k8s-dev, kubernetes.k8s-prod]
  priority  = 500
  condition = "k8s.resource == 'pods/exec'"
  approve   = [llm_approver.k8s-exec-content-judge]
}

Extend Claw Patrol with plugins Read more →

Approval flows

Put a human in the loop, or double-check with another agent

Defer ambiguous requests to a model with your prompt, or a real human via Slack. You decide which one runs when.

LLM judge

require_llm

A model with a custom prompt votes on each request. Verdicts are cached so it doesn’t re-bill.

approver "llm_approver" "secret-judge" {
  model      = "claude-haiku-4-5-20251001"
  credential = anthropic_manual_key.anthropic-key
  policy     = "Reject any SELECT that projects secret-bearing columns."
}
incoming
SELECT id, name, api_key FROM users LIMIT 10
AI
✗ Denied — projects api_key, a secret-bearing column.
-or-

Human In The Loop

require_human

A person votes in Slack, the dashboard, or your own webhook. Times out closed if no one’s home.

approver "human_approver" "ops" {
  channel    = "#agent-ops"
  credential = slack_tokens.slack-bot
  timeout    = 600
}
#agent-ops
CP
Claw PatrolAPP1:42 PM
prod-codex wants to DELETE /repos/acme/checkout
JC
Josh1:42 PM
approved
CP
Claw PatrolAPP1:42 PM
✓ Allowed — forwarded to upstream (14s).

Regression tests

Test your rules before you ship them.

Record real actions from the dashboard. Drop the JSON files into a fixtures directory. Run clawpatrol test in CI: when a policy change flips a verdict, the runner prints the diff and fails the build.

No gateway, no database, no auth. A single binary that loads your HCL, replays each fixture against the rule engine, and asserts the verdicts still match.

$ clawpatrol test deno.hcl tests/
ok tests/anthropic-implicit-allow.json
ok tests/clickhouse-default-deny.json
ok tests/clickhouse-read.json
ok tests/deno-com-require-approval.json
ok tests/deno-deploy-read.json
ok tests/github-api-implicit-allow.json
ok tests/k8s-allow-meta.json
ok tests/k8s-debug-pods.json
ok tests/k8s-default-deny.json
FAIL tests/k8s-no-secrets.json
  want verdict="deny"       rule="k8s-no-secrets"
  got  verdict="allow"      rule="k8s-no-secrets"
ok tests/k8s-reads.json
ok tests/orb-dev2-immutable-operations-allow.json
ok tests/pg-staging-banned-functions.json
ok tests/pg-staging-default-deny.json
ok tests/pg-staging-reads.json
36 action(s) checked, 1 mismatch(es)

Comparison

Built for everything agents do

Adjacent tools overlap. Here's where the lines are.

  • LLM Gateways

    Route LLM calls between providers and log usage. Claw Patrol watches LLM traffic too, but focuses on what agents do downstream.

  • Content Guardrails

    Scan model output for unsafe content. Claw Patrol scans actions, not words.

  • HTTP and MCP Gateways

    HTTP proxies that hold credentials and apply policies. Claw Patrol does the same, plus non-HTTP protocols like Postgres.

  • Sandboxes

    Confine what an agent does on its machine. Claw Patrol limits what it can reach instead — stack the two.

  • Credential Stores

    Hold secrets so the agent never sees them. Claw Patrol does that, paired with wire-level rules on every call those credentials authorize.

Self-hosted

Runs on WireGuard or Tailscale

$ clawpatrol join https://gw.example.com
$ clawpatrol run codex

MIT License

Open Source

The proxy holds your secrets and watches every byte your agents send. It has to be auditable, so it’s MIT licensed.

curl -fsSL https://clawpatrol.dev/install.sh | sh
Get Started