Agent or proxy, on Linux

Act on a model verdict

When you want to catch what no signature or feed knows, turn on Cortex's models, watch what they flag, and act only when a model and a second signal agree. The probabilities are uncalibrated, so set your own threshold, and read the model card before a verdict decides a block.

Overview

Signatures catch what someone has already seen. Reputation catches what someone has already listed. A new tool, a fresh botnet or a scraper written last week has neither, and that is the traffic Cortex's models are for.

Each model answers one narrow question on the host, with nothing leaving the machine: is this fingerprint malicious, does this flow behave maliciously, what kind of traffic is this. Their answers become ordinary rule fields, so a rule decides what a verdict is worth.

When you see this

  1. Traffic gets through that no signature fires on and no feed lists.
  2. Clients rotate addresses faster than any list can follow.
  3. You want to rank what to investigate by model confidence rather than by alert volume.

Steps

  1. 01

    Install an -ml build

    The models ship in the -ml packages, and inference runs on Linux. On other platforms the agent still builds, but the models return errors instead of scores.

  2. 02

    Turn the models on

    Platform-managed models only need enabled: true; the model is downloaded and its paths default. Models arrive with a signed integrity manifest and are swapped at runtime without a restart. The traffic classifier is early access.

    /etc/synapse/config.yaml
    ml:
      fingerprint_classifier:
        enabled: true
      flow_classifier:
        enabled: true
      traffic_classifier:
        enabled: true
  3. 03

    Watch the verdicts before acting

    The models are alert-first: they emit a verdict, and a rule opts in to acting on it. Start with a log rule, which records what it would have done and enforces nothing. Model probabilities in rules are integers from 0 to 100.

    Smart firewall rule, action log
    ml.flow.label eq "malicious" and ml.flow.malicious ge 80
  4. 04

    Set your own threshold

    Probabilities are uncalibrated. The right cut-off depends on how common malicious traffic is in your environment, not on 50.

    DecisionDid the log rule flag traffic you know is legitimate?

    Yes Raise the threshold or narrow the rule, and watch again.

    No Move on to enforcement.

  5. 05

    Require a second signal

    A model verdict is not a standalone block. Pair it with reputation, IDS context or a second model, so a rule drops only when two agree. Per-class traffic probabilities let a rule fire on a class that was not the top one.

    Smart firewall rule, action drop
    ml.flow.malicious ge 80 and threat.score ge 50
    Smart firewall rule, action drop
    ml.traffic.c2 ge 90 and ids.alert_count > 0
  6. 06

    Read the model card

    Every model has a card covering training data, evaluation and limits. The fingerprint classifier's 0.996 accuracy is a ceiling measured under favourable conditions, not a prediction for your traffic: validate against your own before setting policy on it.

Common mistakes

  1. Blocking on a model verdict alone.
  2. Using 50 as the threshold because it looks neutral: the probabilities are uncalibrated.
  3. Treating the traffic classifier's seven classes as a block decision. It is a parallel signal by design.

Escalate when

  • A source the flow classifier and the IDS both flag.
  • A verdict on traffic from a host that holds credentials other systems trust.

Where this stops working

  • Expect distribution shift: on out-of-distribution malware samples the classifier misclassifies some as benign.
  • A fingerprint is not a person. Many legitimate clients share one.
  • The severity model currently ships trained on synthetic data.
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 Set threat.score to 70: two signals agree and the drop fires. Then set ml.flow.malicious to 40, and nothing does.

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 · Logged by Amygdala
  1. 01Capture and fingerprintDendrite · On the wireObserved

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

  2. 02Access rulesHillock · XDP hook, before routingPassed

    198.51.100.140 (NL, AS64502) is on no access list.

    From the threat feed: known-bad sourcesNo match
    Country, resolved to IP ranges on the platform sideNo match
  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 34, scan 3, malicious flow 91. 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 nftablesFlagged

    Matched a log rule: recorded what it would have done, enforced nothing.

    No match
    Matched
  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": "smart_firewall",
  "action": "log",
  "source": "classifier",
  "signals": [
    "classifier",
    "behavioral"
  ],
  "rule_id": "s20",
  "src_ip": "198.51.100.140",
  "src_port": 54321,
  "dst_ip": "198.51.100.10",
  "dst_port": 443,
  "src_country": "NL",
  "fingerprints": {
    "ja4t": "64240_2-4-8-1-3_1460_10",
    "ja4": "t13d201100_2b729b4bf6f3_9e7b989ebec8"
  }
}

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.