Agent or proxy

Block what the fleet already saw

When an address one of your agents banned reaches another, let the fleet's evidence count. Each agent reports what it blocked; the platform corroborates across the deployment, and every agent pulls the set back. Run it advisory first, read the numbers, then enforce where they hold up.

Overview

One agent blocking an address is an observation. Forty agents blocking the same address is a different kind of fact, and it is invisible to any agent looking only at its own traffic.

Fleet bans close that gap in two halves: the ban ledger uploads what this agent decided to block, and the fleet set downloads what the deployment corroborated. They are kept apart on purpose, so a fleet ban is never re-reported as fresh evidence and corroboration never becomes an echo.

When you see this

  1. The same source shows up on several agents, minutes apart.
  2. An attacker works through your sites one after another.
  3. Each agent blocks the source, but only after the source has reached it first.

Steps

  1. 01

    Turn on both halves

    Both inherit platform.base_url. interval_secs is how fast a ban propagates, not how much traffic it costs: a tick whose snapshot has not changed sends nothing. refresh_secs is a cheap version check; the set is downloaded only when its version changes.

    /etc/synapse/config.yaml
    platform:
      ban_ledger:
        enabled: true
        interval_secs: 60
    
      fleet_bans:
        enabled: true
        refresh_secs: 60
        advisory: true
        advisory_dedup_secs: 300
        enforce: false
  2. 02

    Protect your own infrastructure

    Every agent re-applies two checks to whatever the platform serves: anything not unambiguously global-unicast is dropped, and so is your own infrastructure in HOME_NET. A public load balancer VIP is global-unicast, so it must be in HOME_NET; banning it blackholes every client behind it. On Kubernetes the operator puts the VIPs there.

    /etc/synapse/config.yaml
    ids:
      address_vars:
        HOME_NET: "10.0.0.0/8"
  3. 03

    Run it advisory and read the numbers

    Out of the box a fleet ban is consulted, counted and logged, and traffic is unaffected. Judge a ban by agents against agent_count_total, a ratio rather than a count, and by the layers that reported it: three agents agreeing through three layers is stronger than one rule firing three times.

    DecisionDo the corroborated bans hold up against your own traffic?

    Yes Enforce on the agents where they do.

    No Stay advisory. The set is still consulted, counted and logged.

  4. 04

    Enforce in the kernel

    Each fleet ban goes into the same kernel IP filter local bans use, and comes out when its deadline passes or the fleet withdraws it. Fleet bans take at most a quarter of the filter, leaving the rest for this agent's own bans. enforce is read at startup, so changing it takes a restart.

    /etc/synapse/config.yaml
    platform:
      fleet_bans:
        enforce: true
  5. 05

    Behind a load balancer, enforce at the proxy

    The kernel sees only the balancer's address, so a kernel ban on the client never matches. With PROXY protocol the proxy knows the real client and refuses a fleet-banned one with 403 and X-Block-Reason: fleet_ban. It does not use X-Forwarded-For for this.

    /etc/synapse/config.yaml
    proxy:
      protocol:
        enabled: true
  6. 06

    Know what is never enforced

    An address you allow in access_rules.allow, your own infrastructure, an address your configuration already blocks, and a ban without a deadline. Rejections are counted as rejected_unsafe, rejected_protected and rejected_malformed, so a set that arrives but is discarded is visible rather than looking empty.

Common mistakes

  1. Writing a threshold as a count of agents instead of a ratio of agent_count_total.
  2. Leaving a load balancer VIP out of HOME_NET.
  3. Expecting a kernel fleet ban to work behind a load balancer without PROXY protocol at the proxy.

Escalate when

  • A fleet ban on an address your own users come from.
  • rejected_protected climbing: the platform is serving bans on your own infrastructure.

Where this stops working

  • An unloaded set is not an empty one. Before the first set arrives, a miss means we do not know yet, not that the address is clean.
  • A stopped agent lifts nothing. What it installed stays in the filter until the next start.
  • Turning enforcement off takes a restart.
Run it here

Send the request. Watch where it stops.

Edit the request or any rule and the pipeline runs again. The rules are real wirefilter expressions, evaluated the way the agent evaluates them; the traffic and model scores are samples. It all runs in your browser.

Try this Turn on platform.fleet_bans.enforce and the ban goes into the kernel's IP filter. Then change ip.src to 198.51.100.191: the fleet never banned it.

The request

ingress · agent mode

Every value is a rule field. Change one and the pipeline re-runs.

Connection
Source, resolved by the platform
Fingerprints, from Dendrite
Model scores, sample output from Cortex
Flow behaviour, per source
Payload, what Thalamus inspects
Result Delivered to the application
ResultDelivered to the applicationAllowed, with findings · Fleet ban, advisory
  1. 01Capture and fingerprintDendrite · On the wireObserved

    Computed JA4T for this connection. Capture only: Dendrite never blocks.

  2. 02Access rulesHillock · XDP hook, before routingFlagged

    198.51.100.190 is a fleet ban: 40 of 120 agents in the workspace banned it. Advisory: consulted, counted and logged. Traffic is not affected.

    From the threat feed: known-bad sourcesNo match
    Country, resolved to IP ranges on the platform sideNo match
    Fleet bans, from the platform
    Matched
  3. 03Firewall rulesHillock · TC hook, in the kernelNot used

    No firewall rules in this policy.

  4. 04Intrusion detectionThalamus · On the hostNot used

    No signatures loaded for this scenario.

  5. 05Behavioural modelsCortex · On the host CPUObserved

    Sample scores, 0 to 100: C2 2, scan 3, malicious flow 4. Nothing leaves the machine to be scored.

  6. 06Service graphHippocampus · On the hostNot used

    No workload identity on this flow.

  7. 07Smart firewall rulesAmygdala · Decided on the host, enforced in nftablesNot used

    No smart firewall rules in this policy.

  8. 08WAF rulesProxy · In the proxy, after decryptionNot used

    Agent mode does no HTTP proxying, so there is no request for the WAF to read.

  9. 09Content scanningProxy · ClamAV, before forwardingNot used

    No WAF rule selected this request for scanning, so nothing was scanned.

Field names and operators follow the docs: WAF and Smart Firewall. A rule that names an unknown field does not load; a field the request does not carry never matches.

What lands in the event log
{
  "ts": "2026-11-17T09:41:07.212Z",
  "layer": "access_rules",
  "action": "log",
  "source": "fleet_ban",
  "rule_id": "fleet_bans.enforce",
  "src_ip": "198.51.100.190",
  "src_port": 54321,
  "dst_ip": "198.51.100.10",
  "dst_port": 22,
  "src_country": "US",
  "fingerprints": {
    "ja4t": "64240_2-4-8-1-3_1460_10"
  }
}

Shaped like the documented event schema; the timestamp, ports, rule ids and ban duration are illustrative.

Now on your own traffic.

A demo runs the same pipeline against real packets, with the engineers who built it.