Can Apollo triage your security alerts? The one real signal was buried in ten thousand

A security console lights up ten thousand times before lunch. A human is supposed to look at each one and decide: is this the attacker, or is this nothing? By the third hour, every alert looks like nothing, because nine thousand nine hundred of them were. So the analyst starts clicking “acknowledge” on instinct, and somewhere in that stream, the one that mattered gets the same reflexive click as the rest.

That is how breaches happen with the alert sitting right there, already fired, already ignored.

The job of tier-one security was never to be brilliant. It was to survive the volume. The agent restores the signal-to-noise that a tired human lost, not by finding more alerts, but by killing the ones that were never the story. This post is about how, and why the hard part isn’t detection at all.

The naive version: a human as the queue

The standard setup looks reasonable on a slide. Your tools watch everything, the endpoints, the network, the cloud accounts, the identity provider, and when any of them sees something it doesn’t like, it raises an alert. The alerts flow into one queue. A person works the queue, top to bottom, deciding what to escalate.

It works for the first hundred. Then the volume arrives and the model breaks in a way no one designed for.

The first failure is duplication. One event, a single misconfigured laptop, say, trips the endpoint tool, the network tool, and the cloud-audit tool at once. Now it’s three alerts. A login from an unusual location fires every fifteen minutes for an hour because the user is on a flaky connection. Now it’s four more. The queue isn’t ten thousand events. It’s maybe a few hundred real things, each wearing twenty costumes, and the human has to recognize the costume before they can dismiss it.

The second failure is worse, and it’s the one that ends careers. The known-noise alert, the backup job that always trips the data-exfiltration rule at 2 a.m., the scanner you run yourself every Tuesday, is indistinguishable from a real one at a glance. You learn to wave it through. And the day a real exfiltration happens to look like the backup job, you wave that through too. Suppression-by-fatigue is not a policy. It’s the absence of one, performed by an exhausted person at speed.

The bottleneck was never detection. The tools detect fine, that’s the problem, they detect everything. The bottleneck is a human being asked to be a deduplication engine, a lookup service, and a judgment call, all at once, all day, getting slower and less accurate with every hour. By the afternoon the most important security decision in the building is being made by the most depleted person in it.

The shape of the fix: do the boring work before the human sees it

Here’s the key idea, and it’s simpler than the tooling industry makes it sound. Most of what a tier-one analyst does is not judgment. It’s bookkeeping. And bookkeeping is exactly what you should never ask a tired human to do at volume.

Three of the four jobs in that queue are mechanical. Deduplication is mechanical: same source, same signature, same window, that’s one event, not twenty. Enrichment is mechanical: this IP, this user, this asset, go look them up and attach what’s known before anyone has to ask. Suppression is mechanical too, as long as the rule is written down instead of carried in someone’s head: the Tuesday scanner is the Tuesday scanner, every Tuesday, forever.

Only the fourth job is judgment: this one is different, and here is why you should care. That’s the job you want a human doing at full attention. Everything upstream of it is work that should already be done by the time a person looks.

So the agent does the three mechanical jobs first, in the dark, before the queue ever reaches a human. The agent restores the signal-to-noise that a tired human lost, not by finding more alerts, but by killing the ones that were never the story. Let me walk the three.

Job one: collapse the duplicates into the event

The naive queue treats every alert as a fact. The agent treats alerts as evidence about an event, which is a different unit entirely.

When three tools fire on one misconfigured laptop, those aren’t three problems. They’re three witnesses to one problem. The agent groups by what they have in common, the same host, the same time window, the same underlying signature, and folds twenty alerts into one incident with twenty pieces of supporting evidence attached. The flaky-connection login that fired every fifteen minutes becomes a single line: seven alerts, same user, same pattern, over one hour.

The human now reads incidents, not alerts. Say a typical morning brings four hundred raw alerts; collapse the duplicates and you might be looking at forty real events. That’s not a small win. That’s the difference between a queue you skim in panic and a queue you actually read. And the reading is where the judgment you’re paid for actually happens.

The point of the collapse isn’t tidiness. It’s that an analyst staring at one well-formed incident with its evidence attached makes a better call than the same analyst staring at the twenty fragments it came from, because the fragments hide the shape and the incident shows it.

Job two: enrich before anyone asks

This is the part that feels like magic and is the most mechanical of all.

In the naive version, a single ambiguous alert kicks off a scavenger hunt. The analyst sees an unfamiliar IP and starts opening tabs, reputation lookup, geolocation, is-this-one-of-ours, has-this-fired-before. They see an unfamiliar username and start another hunt, what’s this person’s role, what do they normally touch, are they even still here. Each lookup is thirty seconds. Multiply by every ambiguous alert in the queue and the scavenger hunt is the job.

The context already exists. It’s scattered, across the asset inventory, the identity directory, the history of past incidents, the threat feeds, but scattered isn’t the same as available. Functionally, if nobody assembled it, it isn’t there.

The agent assembles it in advance. By the time a human sees the incident, the IP is already labeled with its reputation and whether it belongs to the company. The user is already labeled with their role and whether this behavior is normal for them. The asset is already labeled with how sensitive it is. The analyst doesn’t open a single tab. They read one enriched incident and spend their attention on the only question that’s actually hard: given all of this, is it real?

That’s the quiet engine under fast triage, not a smarter analyst, but a brain that did the lookups while the building was dark and handed them over as context instead of homework.

Job three: suppress the known noise, out loud, not in someone’s head

This is the job that quietly decides whether the whole thing is safe.

Suppression is necessary; the backup job really does trip the rule every night and it really is nothing. The danger isn’t suppressing it. The danger is how a human suppresses it, by learning to ignore a shape, which means they also ignore the real thing that happens to share that shape. The knowledge “this is fine” lives nowhere but in the analyst’s reflexes, and reflexes can’t tell a backup from an exfiltration when they finally differ.

The agent suppresses the same noise, but it suppresses a written rule, not a feeling. The Tuesday scanner is suppressed because there’s an explicit rule that says: this source, this signature, this window, expected. When something matches the rule, it’s filed, not surfaced, but it’s filed, not deleted, so it’s there if the picture changes. And here’s the part the human reflex can’t do: when an alert almost matches the suppression rule but differs in one telling way, the backup job, but from an IP the backup never used, the agent doesn’t wave it through. The near-miss is exactly what should escalate. A reflex suppresses the near-miss. A rule catches it.

That’s the inversion. The tired human suppresses by similarity and misses the dangerous exception. The agent suppresses by an explicit rule and the exception is the one thing that survives suppression. Same noise removed. Opposite safety.

The one that’s left is the one you escalate

After the three mechanical jobs, what reaches a human is small, deduplicated, enriched, and noise-free. The escalation isn’t “here’s an alert.” It’s “here’s the one incident this morning that doesn’t fit a known pattern, here’s everything we already know about the asset and the actor, and here’s why it cleared every suppression rule.”

That’s an escalation a human can act on in a minute instead of reconstructing over an hour. And critically, the human is now reading it at full attention, because they’re reading one thing, not the ten-thousandth thing. The signal didn’t get louder. The noise got removed from in front of it.

There’s a guardrail worth naming, because the failure mode of any aggressive filter is that it filters too well. Suppression that’s too eager becomes the same fatigue, just automated, the agent waving things through the way the tired human did. So the safe version keeps the suppressed events filed and reviewable, escalates every near-miss rather than every match, and treats “I’m not sure” as a reason to surface, not to hide. The agent’s job is to remove the alerts that were provably never the story, not to guess about the ones that might be.

The turn: the volume was never the enemy

Strip away the consoles and the feeds and here’s what’s actually true. Nobody on a security team is bad at judgment. They’re bad at judgment at hour six of fighting the queue, which is a completely different thing, and not a personal failing. You can hire the sharpest analyst in the world and the queue will still grind them down to a reflex by the afternoon, because that’s what ten thousand alerts do to a human nervous system.

The work of triage felt like vigilance. It was mostly tax. Every duplicate collapsed by hand, every IP looked up in a tab, every backup job waved through on instinct, that was time and attention spent not on the thing only a human can do: look at the one genuinely strange event with a fresh mind and decide whether the company is under attack. The most valuable person in the room was spending their best hours being a deduplication engine.

So the question isn’t whether an agent can replace your security team. It can’t, and you don’t want it to, the escalation still ends at a human who decides. The question is whether your sharpest people should spend their mornings as the queue or as the judgment. Triage was always two jobs wearing one tired head: the bookkeeping that wears you down, and the one call that’s worth being sharp for. The machine is very good at the first. It exists so the human can finally be good at the second.

---

That’s what we’re building at Apollo, not a louder alarm, but the coworker who reads the whole flood while you sleep and wakes you for the one thing that’s actually different. If you’ve ever clicked “acknowledge” on the alert that turned out to matter, you already know it wasn’t carelessness. It was the volume. Someone should be paying that tax for you.