A night of alerts triaged into incidents with evidence

For: Security operations lead or on-call analyst starting the morning shift

Pattern: Map, verify, reduceNeeds a connectorDesigned for 30 to 1,000 agents

The pain today

Overnight the queue fills with alerts, most of them duplicates or noise. The analyst clicks through them one by one, and the few that belong to the same intrusion are never seen together.

The ask

Go through last night's alerts from the connected monitoring system. Group the ones that belong together into incidents, tell me which are noise and why, and for each incident show the log lines and the hosts and accounts involved. Keep anything you are unsure about visible.

Plain words, as you would say it to a colleague. Edit it to fit your case before you send it.

What you attach or connect

  • Alert queue from the security monitoring platform
  • Raw log lines behind each alert
  • Asset and identity inventory
  • Known-benign patterns and suppression rules
  • Triage runbook

The unit of work

One worker task per one alert with its supporting log lines.

Why a swarm fits

Each alert can be read alone with its log lines and the asset record. Grouping happens afterwards on small structured summaries, not on raw logs.

Not for

An intrusion in progress: a responder needs hands on the systems, not a batch report.

The decision tree

6 typed decisions, each with an action for every answer

At fixed moments in a run, the engine puts one narrow question to a decision model. The decision model never writes text: it answers yes or no with a probability, picks from listed options, or gives a score, about a small slice of the material. The engine then does exactly what this tree says, which is what makes the run auditable. The thresholds are the template's design values, not measured results.

  1. Planner, while planning

    Scope checkYes or no, with a probability

    Before work starts on a unit

    Does this alert come with at least one raw log line and an identifiable host or account?

    Sees only: One alert record with its attached log lines

    Why: An alert without logs cannot be judged, so it goes to a person instead of being closed.

    • Yes: 0.60 or higherthenAccept
    • Unsure: 0.30 up to 0.60thenAccept
    • No: below 0.30thenMark unresolved
  2. Before workers, before a task runs

    Small worker or strong modelYes or no, with a probability

    Before a task runs

    Is this alert from a detection rule and asset class for which the runbook gives explicit triage steps?

    Sees only: The alert's rule name, the asset record and the runbook index

    Why: Routine alerts stay on cheap workers; unfamiliar ones get a strong reader.

    • Yes: 0.60 or higherthenAccept
    • Unsure: 0.30 up to 0.60thenEscalate to a strong model
    • No: below 0.30thenEscalate to a strong model
  3. After workers, the judge checks

    Evidence checkYes or no, with a probability

    After a worker answers

    Do the quoted log lines match the documented benign pattern on every condition it lists: source, account, process and time window?

    Sees only: The quoted log lines and one entry from the known-benign list

    Why: A wrongly closed alert is how an intrusion is missed, so partial matches stay open.

    • Yes: 0.90 or higherthenAccept
    • Unsure: 0.50 up to 0.90thenEscalate to a strong model
    • No: below 0.50thenMark unresolved
  4. Reconciler, while merging

    Conflict checkYes or no, with a probability

    While reconciling

    Do these two alert summaries share a host, account or indicator, close enough in time that one could have led to the other?

    Sees only: Two alert summaries with their entities and timestamps

    Why: Links related alerts into one incident while marking weak links as weak.

    • Yes: 0.80 or higherthenAccept
    • Unsure: 0.45 up to 0.80thenMark unresolved
    • No: below 0.45thenContinue
  5. Run control, between rounds

    Retry or stopYes or no, with a probability

    After a rejection or low confidence

    Does this alert involve a privileged account, a directory server or a system the inventory marks as critical?

    Sees only: The alert summary and the matching inventory rows

    Why: Alerts on the assets that matter most are re-read by the strongest model before grouping.

    • Yes: 0.50 or higherthenEscalate to a strong model
    • Unsure: 0.20 up to 0.50thenEscalate to a strong model
    • No: below 0.20thenContinue
  6. Accountable person, before anything is settled

    Person decidesYes or no, with a probability

    Before anything is reported as settled

    Does this candidate incident contain any alert that was not confirmed benign against a documented pattern?

    Sees only: One candidate incident with the verdict for each alert in it

    Why: An analyst declares incidents; the swarm never closes anything on its own authority.

    Accountable: An analyst declares incidents and approves any suppression rule; the swarm never closes an alert on its own authority.

    • Yes: 0.30 or higherthenAsk a person
    • Unsure: 0.10 up to 0.30thenAsk a person
    • No: below 0.10thenAccept

The fleet: who does what

Model tiers by role, not brands: you choose the models. Strong reasoning models plan and reconcile, small fast models do the wide work, and the judge is a decision model from a different family, so it does not share the workers' blind spots.

  1. Planner

    A strong reasoning model turns the runbook into triage questions and buckets alerts by rule, host and account.

    Decisions here:1. Scope check

  2. Workers

    Small fast workers from an open-weight family each summarise one alert: what happened, to what, on which evidence.

    Designed for 30 to 1,000 agents, one worker task per one alert with its supporting log lines. Each worker receives only its own unit.

    Decisions here:2. Small worker or strong model

  3. Judge, from a different model family

    A decision model from a different family checks each 'benign' verdict against the quoted log lines and the benign list.

    Decisions here:3. Evidence check

  4. Reconciler

    A strong reasoning model links summaries into candidate incidents by shared entities and time, marking weak links.

    Decisions here:4. Conflict check5. Retry or stop

  5. Accountable person

    An analyst declares incidents and approves any suppression rule; the swarm never closes an alert on its own authority.

    Decisions here:6. Person decides

Checked before anything is accepted

  • Every verdict cites the log lines it rests on
  • 'Benign' needs a match to a documented benign pattern, or the alert stays open
  • Incident links name the shared host, account or indicator
  • Alerts with missing logs are escalated, not closed

What comes back

  • Candidate incidents with timeline, entities and cited log lines
  • Noise list with the reason per alert
  • Unsure pile for an analyst
  • Suppression rule proposals, never applied automatically

What to measure

  • Incidents missed and found later
  • Alerts closed as benign and later reopened
  • Analyst time to the first real incident
  • Cost per alert triaged

Names of measures only. No result is claimed for this template.

Templates open in the workspace chat with the ask filled in. Nothing runs until you send it.

Get early accessSign in to use

Root-cause hypotheses tested against log windows

For: Site reliability engineer or incident commander writing the review after an outage

After an outage the first plausible story wins.

Pattern: Cross-examinationNeeds scale6 decisionsDesigned for 20 to 500 agents

Threat model attacked before the design is built

For: Security architect or product security engineer reviewing a new system design

Threat models are written by the people who designed the system, so they list the threats the design already handles.

Pattern: Adversarial reviewNeeds live models5 decisionsDesigned for 6 to 60 agents

Access recertification across every account and role

For: IT security manager or identity owner running the periodic access review

Managers receive a spreadsheet of entitlements and approve all of it, because nobody can judge that many rows.

Pattern: Map, verify, reduceNeeds scale5 decisionsDesigned for 40 to 1,000 agents