Written by

Threatmatic

At

Thu Sep 24 2026

Findings: Two Stages of Reasoning, One Conclusion

Most security tools hand you a wall of events and wish you luck. Findings scores everything first, then investigates only what clears the line, and writes you a conclusion with the evidence beside it.

Back

Every security team knows the feeling. The console is full. Tens of thousands of events a day, each one marked alert or warning or info, and somewhere inside is the one that matters. The tool did its job by recording all of it. Finding the one is still your job.

We built Findings to take that job on. It is a two-stage design: a fast first stage that scores everything before anyone reads anything, and a slower second stage that investigates only what cleared the line and writes up a conclusion a person can read in a minute. This piece is how it works, what it will and won't do, and what leaves your environment when you turn it on.

Three-panel comic. A person buried under a wall of alerts. Stage one funnels events into counts and scores them, and only a scored case passes the handoff line. Stage two, a read-only investigator pulls its own evidence and writes a finding that a person marks helpful or not helpful.

Why two stages

Reading every event closely would be thorough and ruinously expensive. Skimming every event cheaply is affordable and shallow. Neither works alone, so we split the job the way a good security operations center does: a fast pass to decide what deserves attention, and a careful pass on only the things that do.

The split also keeps the expensive step honest. The deep investigation never runs on ordinary traffic. It runs only on cases that already carry a score, and each organization has a ceiling on how many it will start per hour, so a noisy day cannot turn into a runaway bill.


Stage 1: score first

Every 30 seconds, Findings looks at your organization's most recent window of activity and boils it down to counts, not raw events: how many beaconing or command-and-control signals per device, how many blocked attempts against one application, how many failed logins, how many high-entropy uploads. That is a handful of numbers per device, however busy the window was.

Each candidate gets a confidence score, and there is a handoff line. Below it, nothing happens and nothing is stored. At or above it, a case is opened for the second stage, carrying the score and the numbers that produced it. We call this pre-scoring: by the time anything is investigated, it has already been measured, ranked and explained in one line.

A second, slower pass runs every 15 minutes over the last hour. It exists for the patterns a 30-second window can never see: a password spray of one attempt every few minutes, a trickle of uploads, a drip of blocks. It only speaks up when the activity is sustained, so a sudden burst stays with the fast pass and you never get two cases for one thing.

Stage 1 is deliberately made of simple, transparent rules today. You can read why a case was opened, and we can tune the thresholds from your feedback. We are not publishing the thresholds themselves, for the obvious reason that they are also a map of where to stay under. The stage sits behind one narrow interface, so a learned decision model can run beside the rules, and be compared against them, before it is ever trusted to decide alone.


Stage 2: an investigator that pulls its own evidence

A case that clears the line goes to an AI investigator. It does not receive a summary and take the summary's word for it. It starts from the case and pulls its own evidence, using read-only tools: what the device tried to reach, what was blocked and what was permitted, and what inspection saw on the wire. It looks a few hours either side of the flagged window, because slow patterns hide outside short ones.

The most useful conclusions come from connecting two views of the same device. A remote-access program blocked once a second and high-entropy beaconing that was permitted, in the same seconds, is a different story from either one alone. So the investigator is told to check both sides, and to say so plainly when it could not check one.

What it writes is a finding, and every one has the same shape:

  • a plain-language title stating the conclusion;
  • two to four sentences on what happened and why it matters;
  • a confidence, meaning how sure it is that a person should act;
  • one suggested next step;
  • an evidence timeline, where each row is a real event with its real timestamp and where it came from.

A finding that says "this looks benign, and here is why" is a good finding, and the investigator is instructed to write it when the evidence points that way. It is also told to quote counts from the numbers its tools return, and to say "at least" when it only saw part of the picture, because a confident wrong number is worse than an honest approximate one.


What it will not do

It is read-only. The investigator has no ability to change a policy, a zone, a device or a setting, and it never says that it did. The worst a wrong conclusion can do is be wrong.

Nothing acts on its own. There is a version of this feature that blocks the device, edits the policy and closes the case. We chose not to ship that one first. An investigation should earn trust by being right, in front of a person, many times, before it is allowed to do anything else.

A person always closes the loop. Each finding has a one-click Helpful or Not helpful, with room for a line on why, and you can change your mind later. That feedback is how the scoring gets better.

It is opt-in. Findings is off by default for every organization. An administrator turns it on, and until they do, none of your events are read for it. They can turn it off again at any time.


What leaves your environment

The investigator is a hosted AI model, so some detail has to reach it to do its work. We would rather tell you exactly which, than leave you to assume.

Before anything is sent, identifying values are replaced with placeholders: device names, user names, policy names, internal addresses and URL paths become things like device_1 and host_3. The same value always gets the same placeholder within an investigation, so the investigator can still see "this one destination, contacted twelve times, once a second" without knowing what it is. The real values are put back on our side only when the finding is saved. The lookup table exists in memory for the length of one investigation and is not stored.

Some things are deliberately still shared: public domain names, public IP addresses and program names. They are what the investigator needs to judge whether traffic looks suspicious, and a model that cannot see a destination cannot tell you whether it is a known cloud service or a stranger. When we tried hiding them too, the conclusions got weaker, so we did not.

Counts, timestamps, protocols, ports and classifications also go through, because they are the substance of what is being judged.


What is next

Two pieces are on the way, and the design has a place for both. A longer memory, so the first stage can notice a destination that is merely unusual for this device and not just loud this minute. And a faster learned decision model in the first stage, running beside the rules first so the two can be compared.

For now, the important part is the shape: score everything cheaply, investigate only what earns it, show the evidence beside every conclusion, and leave the decision with a person. If your team is tired of the wall, turn Findings on for a week and tell us which ones were worth your time.

P.S. This started as an idea from the XML King. He knows who he is.