> ## Documentation Index
> Fetch the complete documentation index at: https://docs.guardway.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# AIDR

> The incident queue for risky AI agent actions on your machines, with permanent incident numbers, owners, verdicts, suppression rules and its limits.

## What this is for

**AIDR** (AI detection and response) is where your security team works the risky actions AI agents
take on your developers' machines. Guardway files what each machine reports into numbered
incidents that your whole organization shares: each incident keeps its number, a status, an owner,
a verdict and a record of every change. Open it in the console under
**Endpoint AI Risk › Fleet › AIDR**.

> [!NOTE]
>
> The incident queue is in **Beta** and is turned on per organization. Ask your Guardway contact to
> turn it on. Until then, the **AIDR** tab shows its earlier views (**Overview**, **Detections** and
> **Incidents**), where nothing your team decides is saved.

## Options

### What becomes an incident

Each machine's report carries the risky actions its agent recorded. AIDR keeps each one as a
**finding** and files it into the **incident** it belongs to. Findings about the same thing share
one incident:

| Findings about | Share one incident per |
| - | - |
| A host: a command that reads a credential and calls a host, a download piped into a shell, a publish outside the organization, a credential copy sent out | Rule and destination, across every machine |
| A command with no host, such as a recursive delete | Rule and the shape of the command, across every machine |
| Unattended sessions and declined actions | Rule and person, or rule and machine when no person is recorded |
| A credential typed into a file, a skill your organization blocked, an MCP server that is not on the approved list, a change made outside Guardway to the machine-wide Cursor hook file, or an AI tool set up for a custom model endpoint the agent rates high or critical risk | Rule and machine |

A finding of any other kind stays in **Findings**, where search finds it, and opens no incident:
AIDR has no rule for grouping it yet. Its incident cell is blank, and when you open it, its
**Incident** line reads **Kept in Findings; this rule opens no incident**.

A case has at most one open incident. A new finding joins it and moves its last activity forward;
it never changes the incident's number, status or owner. Two incidents from one session that went
to different destinations stay separate, and each card lists the other under
**Same session also**.

Unattended sessions and declined actions open an incident only when they stand out:

* An unattended session (`BEHAV-AUTONOMY`) opens or joins one when its tool calls per prompt
  reach both 20 and three times the usual level over the last 30 days, for that person (or that
  machine, when no person is recorded).
* Declined actions (`BEHAV-REJECT-SPIKE`) open one when the same person (or machine) has 5 such
  findings in 7 days, and the earlier ones join it.

The rest are counted, not queued: they stay in **Findings** and open no incident. A line under the
queue counts them:
**Counted, not queued: \{n} routine unattended or declined sessions from \{p} people or machines, each at their usual level.**
A finding that a [suppression rule](#suppression-rules) covers opens no incident either.

### Time window

The window at the top right applies to all three views: **Last 24 hours**, **Last 3 days**,
**Last 7 days** (the default), **Last 14 days** or **Last 30 days**. **Incidents** lists the
incidents whose latest finding falls in the window, plus every open incident (**New** or
**In progress**) whatever the window: open work stays listed until it is resolved. **Overview**
and **Findings** cover the findings from the window. Charts count by hour in **Last 24 hours** and by day otherwise, in your browser's
time zone. A link to an incident opens it whatever the window.

### Search

The search box at the top filters all three views. Type a word, such as a person, a machine, a
destination or part of a command, or use a token. In **Incidents** a word matches an incident's
number, title, intent, people, machines, AI tool, rules and destination (for an incident grouped by
command, the start of that command), but not the recorded command text; **Overview** and
**Findings** also match the recorded command. Clicking a value in **Overview** or in the
**Filters panel** adds its token for you.

| Token | Finds |
| - | - |
| `rule:GUARD-FETCH-EXEC` | One rule, by its code |
| `host:LEO-DESKTOP` | One machine |
| `user:leo` | One person |
| `tool:"Claude Code"` | One AI tool |
| `outcome:ran`, `outcome:blocked`, `outcome:flagged` | One [outcome](#outcomes) |
| `type:"Credential theft"` | One [type](#finding-types) |
| `intent:"Run untrusted code"` | One intent, as **Overview** names it |
| `session:` and a session ID | One session |
| `last:3d` | Only the last 3 days, up to 30 |

`machine:` and `person:` work like `host:` and `user:`. Put a value that holds a space in quotes.

If AIDR refuses a search, for example one that is too long, the view says
**AIDR refused this search, so nothing was searched** with the reason AIDR gave, keeps your search
as you typed it and offers **Clear the search**. That is a refusal, not the record being out of
reach. A search that takes too long says
**The search took too long; narrow the window or the search** and offers **Try again**.

### Overview

**Overview** draws the window's findings as a flow across three columns, by default **Machine**,
then **AI tool**, then **Intent**: what the agent was trying to do, such as
**Take credentials out**, **Run untrusted code**, **Destroy data** or
**Act with no human watching**. Each column is a picker: **Machine**, **Person**, **AI tool**,
**Rule**, **Intent**, **Destination** or **Outcome**. Weigh the ribbons by **Calls** or by
**Incidents**. Each column shows its busiest values and folds the rest into one node. When the
window holds more combinations than the chart reads, a note under it begins
**The flow leaves out some calls**. Hover a node or a ribbon for its numbers; click a node to
search for it, which narrows **Incidents** and **Findings** too.

Beside the chart, **Activity** counts the calls, how many were blocked and the incidents they
belong to, with the **Busiest** values of each column, and **Rules fired** and **AI tools** break
them down. When your organization has ATT\&CK tags turned on, **Techniques seen** lists the MITRE
ATT\&CK techniques behind the window's findings, with their calls and incidents, most calls first.

When the window holds more combinations than the overview reads, **Calls** and **Blocked** still
count every call. Every other count beside the chart is then marked ≥, with
**A count marked ≥ is read from part of the calls, so it can be low.** under the figures and
**Read from part of the calls, so a count can be low and a \{row} can be missing.** under each
table.

### Incidents

**Incidents** is the queue, in three boxes around the incident card.

**Kill chain** counts the incidents the queue lists by how bad they got. Click a tile, or a stage on the
strip below the tiles, to filter the queue.

| Tile | Means |
| - | - |
| **Breach** | data left the machine or went public |
| **Ran** | a risky action ran, effect unconfirmed |
| **Exposed** | reached something, nothing confirmed left |
| **Contained** | stopped by Live guard |

The strip shows how far along the chain the incidents got: **Asked**, **Agent acted**,
**Target touched**, **Left machine**, **Picked up** and **Used in cloud**. The last two need
identity and cloud logs, which AIDR does not read, so they show no source connected. When
there are more incidents than the queue reads (see [Limits](#limits)), each count is marked ≥
and the box says **A count marked ≥ is read from the incidents the queue holds, so it can be low.**

**Open incidents** is the queue itself. Switch between **Open** (**New** and **In progress**) and
**Resolved**, each with its count; under **Resolved**, pick a classification to see only those.
**Worst first**, the default order, sorts by tile (**Breach**, then **Ran**, **Exposed** and
**Contained**), then by how far along the chain an incident got, then by priority, then by the
most recent activity. **Most recent** and **Most machines** sort the other ways. Each row shows
the incident's number and its owner's initials. Press `j` and `k` to move to the next and the
previous incident. When **Open** lists incidents last seen before the window starts, a line
above the list says
**\{n} open incidents were last seen before \{day}. Open work stays listed until it is resolved.**
(**1 open incident was** for one), where \{day} is the window's first day, with the hour in
**Last 24 hours**. Under the list, **Counted, not queued** says how many unattended sessions and
declined actions in the window did not stand out (see
[What becomes an incident](#what-becomes-an-incident)), and **Suppression rules** lists the rules
that keep calls out of the queue.

**When** places one dot per incident across the window, higher for the ones that got further.
An open incident last seen before the window has no dot. Click a day to see its hours.

**Show**, at the top right, hides or shows **Kill chain**, **Open incidents** and **When**. The
incident card always stays, and the button says how many boxes are hidden.

### The incident card

Click an incident to open its card. The top line shows its number, its status (with the
classification once it is resolved) and who owns it:

| Owner line | Means |
| - | - |
| **\{name} is working on it** | Someone took it and it is **In progress**; their initials pulse softly. On your own incidents it reads **You are working on it**. |
| **Assigned to \{name}, no longer in this organization** | The person who took it is no longer a member of your organization. It shows without the pulse and counts as unowned until someone takes it. |
| **Resolved by \{name}** | Who resolved it (**Resolved by you** on yours). |
| **Unassigned** | Nobody owns it. |

**N of M** and the arrows beside it (**Previous in the queue**, **Next in the queue**) step
through the queue in its order, like `j` and `k`. Under the title:

* A recurrence or suppression note, when one applies (see
  [After an incident is resolved](#after-an-incident-is-resolved) and
  [Suppression rules](#suppression-rules)).
* **Why it ranks here**: what raised or lowered the incident's priority.
* The person, machine, AI tool, destination (or command) and session it is about. When your
  organization has ATT\&CK tags turned on, the card also shows the MITRE ATT\&CK technique IDs of
  its rules: hover an ID for **\{id} · \{name}** and one line on what it means, and click it to
  open the technique on MITRE's site.
* **Find similar** searches **Findings** for the **Same destination** (or **Same command**), the
  **Same session** or the **Same machine**.
* Three clocks: **First event**, **Live guard now** (what Live guard does on the machine now) and
  **Dwell time**. In place of **Dwell time**, a contained incident shows **Contained**, and a
  custom model endpoint shows **Seen**, because the scan does not report when the setting was
  made.

**Big picture** draws the incident as one path, read left to right under four headings: **Who**,
**The agent**, **What it did** and **Where it went**. Badges on the steps show what happened
there, such as **blocked** or **landed** on the destination; when other machines' commands named
the same destination, a chip under it says how many. A blocked call is never shown as ran, sent
or landed. A destination the machine redacted reads **Redacted address**, with
**could be this machine** under it, and is never shown as landed. What the agent cannot see, such
as whether a credential was later used in the cloud, is a dashed gap that names the source it
would need, never a fact. Click a step to see the question it answers, with only the facts the
record holds. **In order**, under the path, lists the same incident as a timeline.

| Step | The question it answers |
| - | - |
| The person | Is this normal for them? |
| The machine | Can it happen again here? |
| The AI agent | Can the agent still act? |
| The session | What was it doing, and is it still going? |
| The credential | What was exposed, and what do I rotate? |
| What it tried, when no credential is involved | What was it trying to do? |
| The calls | Did it run? |
| The destination | Where did it go, and is it known? |
| The command, when there is no destination | What did the command do? |
| A dashed gap | Why can’t we see this? |

**Details** has the ledger **What happened, in order**, the incident's **Status** and
**Across the fleet**. The card keeps the view you last chose, in this browser. The ledger shows at
most the newest 200 calls an incident cites, fewer when the calls are long, and then says
**Showing the newest \{n} of \{total} calls this incident cites.**

Below the views, **Next steps** lists what to check and do for this kind of incident,
**Copy for ticket** copies the incident as Markdown, and the workflow buttons follow (see
[How to configure](#how-to-configure)). Unless the machine is known to enforce (its posture is
**Observe**, or Fleet does not know it), the card also offers to change its policy:
**Open \{policy}** when Fleet knows the Endpoint AI Policy that governs the machine, otherwise
**Enforce on \{machine}**. **Activity** lists every change, newest first, with who made it and
when; changes the detection made itself read **Detection**. A long activity shows the newest 500
changes, fewer when they are long, and says **Showing the newest \{n} changes.**

### Findings

**Findings** lists every finding the machines reported in the window, newest first, whether or
not it is in an incident. Use it to see where else something happened and what else an agent
did.

Each row is one plain sentence with the key words in bold, for example: **leo** ran a command
that pipes a download from **get.example.com** into a shell, through **Claude Code** on
**LEO-DESKTOP**. When a finding names no person, the sentence names its machine instead, starting
"An agent on **LEO-DESKTOP**" ("A person on **LEO-DESKTOP**" for declined actions). A setting the
machine's scan found, such as an AI tool set up for a custom model endpoint, reads "The scan of
**LEO-DESKTOP** found" and the rule's title. Beside the sentence are its [type](#finding-types), its
[outcome](#outcomes) and its incident (**INC-n**, marked **(Resolved)** once resolved). The
incident cell is blank when the finding is in no incident. When a suppression rule kept it out of
the queue, the rule shows under the sentence as **Suppressed by \{name}: \{reason}**.

A sentence never claims more than its rule proves. The credential-to-network rule
(`GUARD-CRED-EXFIL`) says the command reads a credential and calls a host, never that the
credential was sent: **leo** ran a command that reads a credential and calls
**api.example.com**, through **Codex** on **LEO-DESKTOP**. A blocked action reads **tried to**.

Click a row to open it in place:

* **Why it fired** tags the **Credential**, the **Network call** and the **Destination** found in
  the command, and **Command, as recorded** shows the command with them highlighted. Every finding
  that carries a command shows it there. When a rule about a credential reaching the network has
  no network call in the record, a dashed **Network call** tag says
  **not in the part of the command that was kept** or **not one this console recognises**.
* **Rule**, **What it means**, and **Live guard then**: **Blocked before it ran**,
  **Recorded, not blocked**, or **Recorded; Live guard does not block this kind of finding**.
* **Measured**, only for an unattended session or declined actions that carry no command: the
  numbers the agent recorded, for example **42 calls / prompt** or **80% declined**.
* **Configured**, for an AI tool set up for a custom model endpoint: the setting and the address it
  points at. **Edit**, for a credential typed into a file: what kind of credential and the file
  type.
* **ATT\&CK** (when ATT\&CK tags are on), **Session**, **Destination** and **Incident**. **Incident**
  names the incident and its status, or why the finding is in none: **Counted, not queued**,
  **Kept in Findings; this rule opens no incident**, **Suppressed by \{name}: \{reason}**,
  **Not filed yet** or **Not in an incident**.
* **Open INC-n** opens the finding's incident. **Open the session timeline** opens the session on
  the person's page in [People](https://docs.guardway.ai/endpoint-ai-risk/people.md) when the finding names a person and a
  session and its machine is still in Fleet; otherwise a line says why there is none.
  **Find similar** searches for the same rule.

The bar above the list shows the count, **Group by** (**None**, **Type**, **Rule**, **Machine**,
**Person**, **AI tool**, **Session** or **Destination**) and **Views**, which are ready-made
searches:

| View | Searches for |
| - | - |
| **Credential to network** | `rule:GUARD-CRED-EXFIL` |
| **Downloaded and ran** | `rule:GUARD-FETCH-EXEC` |
| **Ran, not blocked** | `outcome:ran` |
| **Credential theft** | `type:"Credential theft"` |
| **No human watching** | `rule:BEHAV-AUTONOMY` |

The **Filters panel** counts the matching findings by **Outcome**, **Type**, **Rule**,
**Machine**, **Person** and **AI tool**; click a value to add it to the search, and again to take
it out. The **Activity chart** shows the findings per hour or per day, split by outcome; drag
across the bars to narrow to those days. Counts and groups cover every matching finding, not only
the rows on screen.

**Show** hides or shows the **Activity chart** and the **Filters panel**; the list always stays.

### Outcomes

Each finding shows one outcome, the same word in rows, filters, charts and **Overview**:

| Outcome | Means |
| - | - |
| **Blocked** | Live guard blocked the action before it ran. |
| **Ran** | A rule that can block matched, but Live guard let the action through: the machine was set to **Record**, or its install records only. See [Live guard](https://docs.guardway.ai/endpoint-ai-risk/policy.md#live-guard). |
| **Flagged** | A finding of a kind Live guard never blocks: an unattended session, declined actions, a credential typed into a file, a credential copied aside and then sent out, a change made outside Guardway to the Cursor hook file, or an AI tool set up for a custom model endpoint. |

### Finding types

Each finding carries a type tag for the kind of risk its rule looks for. The
[Policy](https://docs.guardway.ai/endpoint-ai-risk/policy.md#detections) page uses the same words for its rule tags.

| Type | What it means |
| - | - |
| **Credential theft** | A credential handled in a way that could expose it: read in a command that also calls a host, written to a credential file, or typed into a file. The tag names the risk, not proof that a credential was taken. |
| **Data exfiltration** | Data that may have left the organization: a credential copied aside and then sent out, or a push or publish to a public place outside the organization. The tag names the risk, not proof that data left. |
| **Runs code** | Running code from outside, such as a download piped into a shell. |
| **Data loss** | A delete that could destroy data, such as a recursive delete of a home folder or a filesystem root. |
| **Autonomous behavior** | How the agent was run: a long run of tool calls with nobody watching, or a person declining most of what it proposed. On its own it does not mean the agent was attacked. |
| **Governance** | Something your organization's lists or settings do not allow, or a change to how an AI tool is set up: a blocked skill, an MCP server that is not on the approved list, a Cursor action with Run Everything or its own keys on, a change made outside Guardway to the Cursor hook file, or an AI tool set up for a custom model endpoint. |

A finding whose rule has no type yet shows no tag.

### Statuses and classifications

| Status | Means |
| - | - |
| **New** | Opened by the detection; nobody has started on it. |
| **In progress** | Someone took it, started it or reopened it. |
| **Resolved** | Closed with a classification and a reason. |

Resolving takes one classification, a reason from that classification's list, and an optional
note.

| Classification | What it means | Reasons |
| - | - | - |
| **True positive** | A real risky action | **Contained: stopped before it did harm**, **Remediated: credential rotated or change reverted**, **Policy breach, handled with the person**, **Escalated to incident response** |
| **Benign positive** | Real, but expected | **Our own infrastructure**, **Expected for this repo or task**, **Security testing or red team** |
| **False positive** | The rule matched the wrong thing | **Text in a doc, script or test, not a call**, **Older agent matched by mistake**, **The rule matched the wrong thing** |

## How to configure

**Owner** and **Admin** work incidents from the card. **Read Only** sees the same card without
the workflow buttons (see [Permissions](#permissions)).

**1. Open an incident**

In **Incidents**, pick the time window and click an incident in the queue, or open one from a finding's incident link. Move through the queue with `j` and `k`.

**2. Take it**

Choose **Assign to me**. A **New** incident moves to **In progress**, and the card shows that you are working on it. **Start** moves it to **In progress** without taking it, and **Unassign** gives it back.

**3. Investigate**

Work through **Big picture** step by step, read the ledger in **Details**, and use **Find similar** and **Open the session timeline** to see what else happened. **Next steps** lists what to check.

**4. Resolve it**

Choose **Resolve**. Pick a classification and a **Reason** from its list, and add a note on what you checked, for whoever reads it next. For a **Benign positive** about a destination you trust, or about a custom model endpoint at one host you trust, you can also add a [suppression rule](#suppression-rules). Confirm with **Resolve INC-n**.

**Add a note** adds a note to the incident's activity at any time, also once it is resolved.

### Incident numbers

An incident gets the next number in your organization when it opens, starting at **INC-1**. An
incident keeps its number; numbers are never reused. The same incident shows the same number in
every time window, so a ticket or a chat message can quote it. The page address names the
incident you have open (`case=INC-42`), so a copied address opens that incident for anyone in
your organization, whatever their window, once they open the **AIDR** tab. **Copy for ticket**
includes a link that opens the incident directly.

### After an incident is resolved

A resolved incident never reopens by itself, and new findings never change its status or its
classification.

* **A call made after the resolution** opens a new incident for the same case, linked to the
  resolved one. Its card says
  **Recurrence of INC-n, resolved \{date} as \{classification}: \{reason} by \{name}. This incident holds only the calls since then.**
  Its activity starts with **Opened again after INC-n was resolved**.
* **A call made before the resolution that reaches Guardway after it**, for example from a
  machine that was offline, joins the resolved incident. Its status and classification stay as
  they were. The card says
  **New evidence arrived on \{date}, after this incident was resolved. Its status and classification did not change.**
  and its activity shows **New evidence after it was resolved**, so whoever resolved it can check
  that the verdict still holds.
* **A setting that stays in place**, such as an AI tool set up for a custom model endpoint or a
  changed Cursor hook file, is reported again in every report. While it stays unchanged, those
  reports open no new incident. A change to it counts as new, like a call made after the
  resolution, and so does its return after the machine kept reporting without it, more than 24
  hours after the last report that had it. A machine that was switched off or offline in between
  does not make it new.

### Suppression rules

A suppression rule stops new calls to a destination you trust from opening incidents. Add one
when you resolve an incident as **Benign positive**, if the incident is about a destination or
about an AI tool set up for a custom model endpoint whose findings name one host (the rule then
covers that host): tick **Suppress new calls to \{host} for** and pick **30 days** (the default),
**90 days** or **No expiry**. The rule covers that destination, in any letter case, and the
incident's rule, and keeps the reason you picked. While it holds, the card of an incident about
that destination or that host says
**New calls to \{host} are suppressed until \{date}: \{reason}, added by \{name} on \{date}. They open no incident and stay in Findings.**
With no expiry it says
**New calls to \{host} are suppressed with no expiry: \{reason}, added by \{name} on \{date}. They open no incident and stay in Findings.**

* A suppressed call opens no incident, then or later. It stays in **Findings**, with
  **Suppressed by \{name}: \{reason}** under its sentence.
* A call made while a rule held stays suppressed, even after the rule expires or is removed.
  Calls made after it ends open incidents again. A custom model endpoint that a rule kept out is
  filed again the first time its machine reports it after the rule ends; until then, **Findings**
  shows it suppressed by the rule that ended.
* Once your organization has a rule, **Suppression rules: \{n} active**, under the queue, opens
  the list. Each active rule shows its destination and rule, then its reason, who added it and
  when, and the incident it came from, then **Until \{date}.** or **No expiry.**, then
  **\{n} calls kept out of the queue, still in Findings.** or **No call matched it yet.** When no
  rule is active it says **No rule holds now; new calls open incidents as usual.** Rules that ended,
  because they expired or were removed, stay in the list, folded below the active ones under
  **Ended rules: \{n}**, each with **Expired \{date}.** or **Removed \{date} by \{name}.** and
  what it kept out of the queue while it held.
* **Remove the rule** on the card, or **Remove** in the list, ends a rule from then on. A removed
  rule is kept on record, never deleted. [Reopening](#reopening-an-incident) the incident a rule
  came from ends that rule too.
* If an active rule already covers that destination and rule, the resolve is not saved: the form
  says **New calls to \{host} are already suppressed**, unticks the option and keeps the rest of
  what you entered. Resolve again without it.
* A rule only changes what AIDR queues. It never reaches the machines: Live guard keeps
  recording or blocking those calls as your policy says.

### Reopening an incident

**Reopen** puts a resolved incident back **In progress** and clears its classification and
reason. If resolving it added a suppression rule that still holds, the card says so before you
reopen:
**Reopening ends the suppression this incident’s resolve created, so new calls to \{destination} are no longer kept out of the queue.**
Reopening then ends that rule, and the activity shows
**Ended the suppression of \{destination} when reopening**. Calls made while the rule held stay
suppressed; calls made from then on are filed again. A custom model endpoint on this incident's
machine that the rule kept out joins the reopened incident the next time the machine reports it;
one on another machine is filed into that machine's own incident. When calls after the resolution
have already opened a newer incident of the same case, the card offers no **Reopen** and says
**INC-n already covers what happened after this one was resolved; work that one.**, with a link to
open that incident.

### When two people change one incident

Every change is checked against the incident as you last saw it. If someone else changed it in
the meantime, your change is not saved and the console says
**INC-n changed since you opened it. Your change was not saved; check the activity and try again.**
A note is not checked against what you saw: it is added even if someone else changed the incident.
A note holds at most 2,000 characters.

A change that adds or ends a suppression rule (resolving with one, reopening, removing one) first
waits a few seconds for any report AIDR is filing for your organization. If AIDR is still busy,
nothing is saved and a warning says, in AIDR's words,
**INC-n is being updated; try again in a moment** or
**This suppression is being updated; try again in a moment**. In the resolve form the same words
show under the buttons and the form keeps what you entered. Try again in a moment.

If the answer is lost, or AIDR fails with an error, the change may or may not have been saved,
and the console says
**The change may or may not have been saved. The incident was reloaded; check its activity before trying again.**
When the reload failed too, it says
**The change may or may not have been saved. The incident could not be reloaded; check its activity once it loads, before trying again.**
Removing a rule says the same about the rule:
**The change may or may not have been saved. The rule was reloaded; check it before trying again.**
or
**The change may or may not have been saved. The rule could not be reloaded; check it once it loads, before trying again.**

## Permissions

**Owner** and **Admin** can take incidents with **Assign to me**, unassign, start, resolve and
reopen them, add notes, and add or remove suppression rules. Only an **Owner** or an **Admin** can
be assigned an incident. **Read Only** sees every view, incident, finding and suppression rule,
including the recorded command text, but nothing that changes an incident or a suppression rule is
offered; the card says
**Read only: owners and admins change incidents.**

## Limits

* **Filing starts when AIDR is turned on.** When Guardway turns the incident queue on for your
  organization, it first files the reports of the last 30 days, oldest first, so the first
  numbers follow the order things happened. From then on it files each report as it arrives,
  including a late one from a machine that was offline. Reports from before those 30 days are
  not filed. Until filing starts, the tab says
  **AIDR's incident record is not on yet for this organization**.
* **Filing can be paused.** Guardway can pause filing for your organization. While it is paused,
  the tab says **Filing paused since \{date}** above the record, with
  **Reports that arrive while filing is paused are filed when it resumes. The incidents below can still be read and worked.**
  New reports are not filed meanwhile. Fleet says so too, rather than show an all-clear: its
  incidents card adds the line **filing paused since \{date}**, the **AIDR** tab shows
  **paused**, and a machine's row, opened, says **Incidents: filing paused since \{date}.** when
  nothing else stands out on it. The machine panel, which opens from **Inventory** or **FinOps**,
  says **Filing paused since \{date}**. When filing resumes,
  Guardway files every report it held back while paused, including one that was received before
  the pause but reached AIDR during it.
* **A machine reports about every 15 minutes.** A new finding can take that long to reach AIDR,
  and a few minutes more to be filed. If AIDR reads a report before Guardway has finished storing
  it, AIDR checks again after 30 seconds, then up to three more times, 15 minutes apart (about 45
  minutes in all). A report still missing then is not filed by itself: Guardway's operators are
  alerted to file it.
* **Each report keeps only a machine's most recent findings.** A report carries at most 25
  findings: those the agent rates at severity 25 or more, the most severe first. Custom model
  endpoints are not among them: they come from the machine's scan, and AIDR files at most 25 of
  them per report. A report also carries
  only the newest 20 Live guard decisions, whatever their verdict, so when more than 20 happen
  between two reports, credential reads included, the older ones never reach Guardway. An empty
  list means nothing in what the machines reported, not that nothing happened.
* **Rules that only record are not filed.** A Live guard rule that never blocks is counted on the
  machine but not sent as a finding, so it opens no incident and is not in **Findings**. That
  includes reading a credential on its own (**Command touched a credential store**,
  `GUARD-CRED-READ`, and **Read a credential store**, `GUARD-SECRET-READ`, as the
  [Policy](https://docs.guardway.ai/endpoint-ai-risk/policy.md#live-guard) page names them) and
  **Credential path built inside a one-liner** (`BEHAV-CRED-INDIRECT`). The exception is
  **Credential copied aside, then sent out** (`BEHAV-CRED-RELAY`), which is sent and filed. A
  credential read in a command that also calls a host is a finding of its own
  (`GUARD-CRED-EXFIL`).
* **Machines that send no runtime data are not counted.** A machine whose rules are off sends no
  findings, which does not mean nothing happened on it.
* **Open incidents stay until they are resolved.** The window reaches back 30 days at most, but
  an open incident (**New** or **In progress**) is never left out for its age: it stays in the
  queue, the queue's counts, the Fleet count and the machine's panel until someone resolves it,
  however long ago it was last seen. A resolved incident is listed only in a window that holds its
  latest finding, and still opens from a link to it. **Findings**, **Overview** and
  **Counted, not queued** cover the window only.
* **At most 1,000 incidents in the queue.** Fewer fit when their details are long. When there are
  more, the queue keeps open incidents first, then the most recently seen, and says
  **The queue holds \{n} of \{total} incidents.** A narrower window leaves out resolved
  incidents only, since open ones are listed whatever the window. When the queue cannot hold every
  open incident, the ones seen longest ago are not listed until a search token, such as `host:` or
  `user:`, narrows the list. A typed word matches only the incidents the queue holds. The queue's
  counts still include the incidents it leaves out. The kill chain then marks its counts ≥.
* **The person is the account Live guard recorded.** A finding names the operating-system account
  Live guard recorded the action for. Unattended sessions, declined actions, credentials typed
  into a file, changes to the Cursor hook file and custom model endpoints name no account, so
  they show no person and their incidents are grouped by machine. On a shared machine, runtime
  evidence counts for the whole machine; see
  [Shared Machines](https://docs.guardway.ai/endpoint-ai-risk/shared-machines.md#limits).
* **Times come from the machine's clock.** A finding is placed at the time the machine recorded
  it, and that time decides whether a call came before or after a resolution and whether a
  suppression rule held. A time more than 5 minutes after its report reached Guardway is moved
  back to 5 minutes after. When a machine's clock was more than 5 minutes ahead of Guardway's
  when it reported, the incident card says
  **This machine's clock was \{N} ahead when it reported; times may be off by that much**. A report
  that reaches Guardway late, for example from a machine that was offline, does not show this
  line: arriving late does not mean the clock was wrong. A finding the machine sent without a time
  takes the time of the report that carried it.
* **Command text is what the machine kept.** A finding holds at most the first 240 bytes of what
  the agent tried to run, such as the command or the file path, redacted on the machine before it
  is sent and again when Guardway stores it. Highlights mark only text that is in the record.
* **Destinations come from the command.** AIDR reads where a call went from the recorded command.
  The machine redacts every IPv4 address written in full before it sends the command,
  `127.0.0.1` and `0.0.0.0` included, so they reach AIDR as `[IP]`. The name `localhost` and `::1`
  reach AIDR as written. They are not counted as data leaving the machine when the command names
  them in an `http` or `https` URL, such as `http://localhost:8080` or `http://[::1]:8080`. The same holds for
  `localhost` as the target of `ssh`, `scp`, `sftp` or `rsync`. In a command that sends a
  credential, `localhost` written any other way, as in `nc localhost 4444` or
  `curl localhost:8080`, gives AIDR no destination to read, so a credential sent that way can rank
  as a breach. Any other address,
  including a short form such as `127.1`, is treated like any other host: a credential sent to one
  can rank as a breach. So is a name under `.localhost`, such as `api.localhost`, since it can be
  another machine's host name. An address the machine redacted, such as `[IP]`, could be this machine or a
  remote host, so a credential sent to one is treated as exposed, not as a confirmed breach. That holds when every call of the
  incident that ran named only such addresses, both for a command that reads a credential and
  calls a host and for a credential copied aside, then sent out. **Big picture** shows it as
  **Redacted address**, never as a host name, and **Why it ranks here** says
  **Sent to an address the machine redacted (could be this machine)**.
* **An open incident keeps its evidence.** An incident does not depend on the machine's reports
  or session events. When AIDR files a finding, it copies what the incident shows into its own
  record: the rule, the time, the machine, the account, the AI tool, the destination, the outcome
  and the redacted command text. An open incident, its activity and its findings are never removed
  for their age. No schedule removes any of the record yet. Once Guardway turns retention on,
  resolved incidents can be removed after a set period, and a finding's command text is cleared
  after your organization's retention for machine reports, even in an open incident. This page
  will give the periods when that happens. Once the text is cleared, the card and the finding say
  **Command text no longer kept (the organization’s retention)** instead of a blank. Suppression
  rules are never deleted. Removing a machine from
  [Fleet](https://docs.guardway.ai/endpoint-ai-risk/fleet.md#machine-actions) keeps its findings in AIDR, under the machine's
  name. See [Privacy and Security](https://docs.guardway.ai/resources/privacy-and-security.md#data-retention).
* **The session timeline reads session events, not the incident.** **Open the session timeline**
  shows the session from the machine's session events in [People](https://docs.guardway.ai/endpoint-ai-risk/people.md).
  Session events Guardway received before mid-October 2026 are no longer kept. Newer ones are not
  removed for their age. After a machine is removed from
  [Fleet](https://docs.guardway.ai/endpoint-ai-risk/fleet.md#machine-actions), its sessions no longer show there, and the
  incident says **No session timeline: this machine is no longer in the fleet.** When a session is gone
  from a machine that is still in the fleet, the page says
  **No session \{id} was found on this machine. Session events Guardway received before mid-October 2026 are no longer kept, so an older session may be gone.**
* **No live refresh.** AIDR does not update while you watch. It loads again when you come back to
  its browser tab, once what it shows is more than 30 seconds old, and after each change you make.
  If it cannot reach the incident record, it says
  **AIDR's incident record is not reachable** instead of showing an empty queue. A search AIDR
  refuses says so instead (see [Search](#search)).
* **Not in AIDR.** Assigning an incident sends no notification. Incidents are not sent to a SIEM
  or a ticketing tool; **Copy for ticket** copies one as Markdown, and Live guard's blocks can be
  forwarded as **Policy blocks** under
  [Endpoint events](https://docs.guardway.ai/platform/settings/integrations.md#endpoint-events). There are no bulk actions,
  incidents cannot be merged by hand, and **Views** are fixed: you cannot save your own.
* **Layout is kept per browser.** What you hide with **Show**, your choice of **Big picture** or
  **Details**, and a folded queue are remembered in this browser only.

## Related

* [Fleet](https://docs.guardway.ai/endpoint-ai-risk/fleet.md#aidr): the machine list, its open-incident count, and what
  removing a machine keeps.
* [People](https://docs.guardway.ai/endpoint-ai-risk/people.md): each person's page, where **Open the session timeline**
  leads.
* [Policy](https://docs.guardway.ai/endpoint-ai-risk/policy.md#detections): the rules behind every finding, Live guard's
  **Record** and **Block**, and the type tags.
* [Shared Machines](https://docs.guardway.ai/endpoint-ai-risk/shared-machines.md): whose activity is whose on a machine
  several people use.
* [MITRE ATT\&CK Mapping](https://docs.guardway.ai/resources/compliance/mitre-attack.md): the techniques the ATT\&CK tags name.
* [Privacy and Security](https://docs.guardway.ai/resources/privacy-and-security.md#data-retention): what Guardway keeps.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.