Hand someone a page with a hundred lines of routine activity and one odd line in the middle, then ask whether the page looks suspicious. Most people will say no, and they are right: the page doesn't look suspicious. The line does.
Detection systems face this question every time they judge what happened on a host. They can judge everything together, or they can judge the parts. The choice sounds like an implementation detail. It decides whether a single quiet command gets noticed or gets outvoted by everything around it.
Key Takeaways
- Context helps a verdict only when it is related to the activity being judged. Unrelated activity on the same host is noise that looks like evidence.
- When a host is judged as a whole, a crowd of benign activity can outvote one suspicious action, and the busier the host, the bigger the crowd.
- Judging each thread of related activity separately fixes the crowd problem but creates a new one: an attack whose steps aren't visibly linked gets split into harmless-looking pieces.
One line on a busy page
Consider a hypothetical ten minutes on a busy workstation. An office suite saves drafts. A browser updates itself. A management agent takes inventory, a backup agent walks the file system, and a security product checks its own health. Hundreds of actions, all routine, all expected.
In the middle of it, a command prompt that nobody seems to have opened runs a single command:
netstat -ano
List every network connection and the process that owns it. MITRE ATT&CK calls this System Network Connections Discovery (T1049): adversaries "may attempt to get a listing of network connections to or from the compromised system", and the technique names netstat among the utilities used. (MITRE ATT&CK, T1049)
On its own, the command is ambiguous. Administrators run netstat to troubleshoot. An intruder runs it to learn what the host talks to. Which one it is depends on the context: who opened that prompt, what it did next, and whether anything else is tied to it.
Now ask a detector to judge the whole ten minutes at once. The evidence for "benign" is enormous: hundreds of actions by known software doing exactly what it always does. The evidence for "suspicious" is one line. Weighed together, the verdict can follow the crowd.
Why the crowd wins
This isn't specific to one technique; any method that judges in bulk is exposed to it.
A score averaged across a host's activity drifts toward the average. A threshold applied to a host-level total needs many signals before it trips. Human analysts are not immune either: a long, mostly routine timeline invites the reader to skim, and the eye slides past the one line that matters.
AI models add their own version of the problem. Research on how language models use long inputs found that "performance is often highest when relevant information occurs at the beginning or end of the input context" and "significantly degrades when models must access relevant information in the middle of long contexts". (Liu et al., Lost in the Middle, 2023) The study tested question answering and key-value retrieval on 2023-era models, not security verdicts, and it measured position, not outvoting. What it does show is that surrounding a key fact with more material can make it harder for a model to use, even when the model can technically read all of it.
There is an awkward tension here with an argument made earlier in this series: that context is what separates routine work from suspicious behaviour. Both points hold. Context is evidence only when it is connected to the action being judged. The process that opened the prompt is context. The backup agent running in the same ten minutes is not; it just happens to share the host.
The crowd can be chosen
Dilution is usually an accident, but nothing stops an attacker from using it on purpose.
An intruder may not need to hide a command if they can make it one of many. Acting during the busiest hours, choosing hosts that already run heavy agents, or creating a burst of harmless noise would all have the same effect: the suspicious action is still recorded, but it has to compete with everything around it for the verdict.
That matters for how detection is tested. A lone suspicious command on a quiet lab machine is the easy case. The same command on a production desktop with six agents running is the real one, and the two can give different answers.
Judge the threads, not the room
The obvious fix, judging every event on its own, throws away the context that made judgement possible in the first place. netstat alone is just netstat.
The better unit sits between the two: the thread of related activity. Actions belong to the same thread when they are linked by what actually happened. One process started another. A process wrote a file that something later ran. A process opened the connection. Activity with no such link to the command prompt, like the backup agent or the browser update, is a different thread and gets judged on its own.
| How the host is judged | What it catches well | Where it fails |
|---|---|---|
| Each event alone | Known-bad single actions | Ambiguous actions that only make sense in context |
| All activity together | Multi-step activity on quiet hosts | A lone suspicious thread on a busy host |
| Each related thread separately | A lone suspicious thread, whatever surrounds it | Attack steps that aren't visibly linked to each other |
Nothing in the third row ignores the backup agent's activity; it is assessed in its own right, without a say in the verdict on the command prompt.
One way to build it
This is a design choice in Logster, an AI-driven endpoint threat detection platform for Windows and Linux built by the team behind these articles.
By default, Logster's AI model judges an endpoint's activity in a single assessment, which is cheaper and keeps context that can help clear benign work. Teams whose endpoints are busy enough for dilution to matter can switch to judging each separate thread of activity on its own, and should measure which works better on their own fleet.
A suspicious thread doesn't need the crowd's agreement. If any part of a host's activity looks like an attack, the endpoint is reported as an attack. If part of it couldn't be assessed, that is reported too, not quietly counted as clean.
A part is judged as a part. A small, self-contained piece of activity is judged as one part of a busier host, not as the whole story of a quiet one.
The explanation comes from the thread that raised it. When a thread is judged an attack, the analyst sees the reasoning for that thread, not a summary diluted by unrelated activity.
The cost stays bounded. Judging threads separately costs more per endpoint, so Logster limits that cost on the busiest hosts.
Where separating falls short
Separating threads trades one failure for another, and the new one deserves equal attention.
The split is only as good as the links that were observed. An intruder who runs discovery from one session and moves data from another may leave two threads with nothing visibly joining them. Judged apart, each can look like routine administration. Judged together, the pair might have looked deliberate. Call it fragmentation: the reverse of dilution.
Judging a thread alone also removes context that sometimes clears activity. Seeing a deployment tool busy elsewhere on the host can be a reasonable hint that a script it launched is part of a rollout. Take that away and some benign threads may look more suspicious than they are.
On the very busiest hosts, cost limits mean separation reduces dilution rather than removing it.
Neither approach wins everywhere. Which one fits a fleet is something to measure on that fleet's own endpoints, against its own agents and workloads, not something to settle by argument.
Run the crowd test
Try this against whatever detection you run today. Use a test host you're allowed to experiment on.
- On a test machine, at a quiet moment with little else running, open a command prompt by hand and run one harmless discovery command, such as
netstat -ano. Note what your detection reports. - Repeat it the same way on the same machine while it runs its normal agents and workload.
- Compare the two results. If the verdict changes, the most likely difference is the activity around the command.
- Look at the explanation, if your tool gives one. Does it discuss the command, or does it spend most of its words on the software that happened to be running nearby?
- Now try the opposite failure. Run a harmless discovery command in one session and a harmless file copy in another, with nothing linking them. Does your tool connect the two, or judge each as routine?
A detector should be tested on the busy host and on the split attack, because an attacker who has done their homework will try both.
Top comments (0)