Auto-Grouping Configuration
How grouping rules turn a burst of related alerts into one case, and how to tune them.
Configure auto-grouping to collect related alerts in one case. You can turn a burst of signals about a host or user into a single investigation.
How auto-grouping works
When a detection rule creates an alert:
- Rule evaluation. nano walks the enabled grouping rules in priority order (highest number first).
- Key computation. For each rule, it reads the rule's entity (host, user, IP or detection rule) from the alert's matched events and computes a grouping key.
- Attach to an open case. If a case that is not
resolvedorclosedhas the same key, its last activity is within the rule's time window, and it holds fewer than the rule's maximum alerts, the alert is added to it. The first rule that finds such a case wins. - Create a case. Otherwise, the highest-priority rule that can produce a key creates a new case. If no rule can classify the alert, it gets a standalone case.
Alert created
→ for each enabled rule (priority order): compute key → open case with this key, in window, under max? → add alert
→ no match: highest-priority rule that produced a key → create case keyed by it
→ no rule produced a key: create a standalone caseGrouping keys are case-insensitive: WORKSTATION-1 and workstation-1 group together.
Permissions
To read grouping rules, you need settings:view. To change them, you need settings:system.
Grouping rules
Manage grouping rules in Settings → Case Management → Grouping Rules.
| Field | API key | Description |
|---|---|---|
| Name | name | Rule name |
| Match type | match_type | What to group by: host, user, ip or rule |
| Time window | time_window_minutes | How long after a case's last activity it keeps accepting alerts |
| Priority | priority | Evaluation order. A higher number is evaluated first |
| Title template | case_title_template | Title for cases this rule creates |
| Severity rule | case_severity_rule | How case severity follows its alerts. Use highest (see Severity) |
| Auto-assign | auto_assign_to | Assign new cases to this user |
| Max alerts | max_alerts | Alerts per case before a new case is started (default 100) |
| Auto-create case | auto_create_case | When off, this rule only attaches alerts to existing cases and never opens a new one |
| Enabled | enabled | Turn the rule on or off |
Match types
For host, user and ip, nano reads the first non-empty value from the alert's matched events, trying the source side before the destination side. The fields are OCSF 1.9 paths:
| Type | Fields tried (in order) | Use case |
|---|---|---|
| Host | src_endpoint.hostname, device.hostname, then dst_endpoint.hostname | All activity on one compromised host |
| User | user.name, actor.user.name, user.uid | One compromised account across systems |
| IP | src_endpoint.ip, then dst_endpoint.ip | Scanning or attack activity from one address |
| Rule | The detection rule's ID | All firings of one detection |
Default rules
Each deployment starts with these rules:
| Rule | Priority | Time window | Enabled | Title template |
|---|---|---|---|---|
| Group by Host | 100 | 60 min | Yes | Alerts on host: {{host}} |
| Group by User | 90 | 60 min | Yes | Alerts for user: {{user}} |
| Group by Source IP | 80 | 30 min | No | Alerts from IP: {{ip}} |
| Group by Detection Rule | 70 | 120 min | No | {{rule_name}} |
All four use a maximum of 100 alerts and the highest severity rule.
Title templates
A title template can use:
| Token | Value |
|---|---|
{{rule_name}} | Name of the detection rule that fired |
{{severity}} | Alert severity |
{{entity}} | The value the rule grouped on (host name, user name or IP) |
{{host}}, {{user}}, {{ip}}, {{hash}}, {{domain}} | Aliases of {{entity}} |
Unknown tokens are left as written. Titles are cut at 120 characters. A rule without a template titles the case <rule name> - <context>, where the context is taken from the events (for example admin@WS-001).
For rule grouping there's no entity value, so use {{rule_name}}.
Configuration examples
Group by host (recommended)
{
"name": "Group by Host",
"match_type": "host",
"time_window_minutes": 60,
"priority": 100,
"case_title_template": "Alerts on host: {{host}}",
"case_severity_rule": "highest",
"enabled": true
}Five alerts about SRV-PROD-01 within an hour go into one case.
Group by user
{
"name": "Group by User Account",
"match_type": "user",
"time_window_minutes": 60,
"priority": 90,
"case_title_template": "Suspicious activity by {{user}}",
"case_severity_rule": "highest",
"enabled": true
}Group by source IP
{
"name": "Group by Source IP",
"match_type": "ip",
"time_window_minutes": 30,
"priority": 80,
"case_title_template": "Activity from {{ip}}",
"case_severity_rule": "highest",
"enabled": true
}Group by detection rule
{
"name": "Group by Rule",
"match_type": "rule",
"time_window_minutes": 120,
"priority": 70,
"case_title_template": "{{rule_name}}",
"case_severity_rule": "highest",
"enabled": true
}Severity
With case_severity_rule set to highest (the default), a case's severity rises to match the most severe alert added to it. It never goes down.
Time windows and caps
The time window is measured from the case's last activity, not from its creation.
Time window: 60 minutes
Alert 1 @ 10:00 → creates CASE-1234
Alert 2 @ 10:15 → added to CASE-1234 (within window)
Alert 3 @ 10:45 → added to CASE-1234 (within window)
Alert 4 @ 12:00 → creates CASE-1235 (more than 60 min after Alert 3)The case settings (Settings → Case Management → General, GET/PUT /api/settings/cases) set deployment-wide caps:
| Setting | API key | Default | Effect |
|---|---|---|---|
| Auto-grouping | auto_grouping_enabled | on | When off, every alert opens its own case |
| Max alerts per case | max_alerts_per_case | 100 | Upper bound on every rule's max_alerts |
| Default time window | default_time_window_minutes | 60 | Upper bound on every rule's time_window_minutes |
A rule's window and maximum are each capped by these settings, so the effective value is the smaller one. With the default 60-minute cap, the Group by Detection Rule default (120 minutes) behaves as 60 minutes until you raise the cap.
When a case stops accepting alerts (window expired or full), it stays open for analysts, and the next matching alert starts a new case.
Time window guidelines
| Scenario | Suggested window | Rationale |
|---|---|---|
| Brute force | 15–30 minutes | Attacks are short bursts |
| Lateral movement | 60–120 minutes | Attackers pause between moves |
| Data exfiltration | 60–240 minutes | Can happen in stages |
| General monitoring | 60 minutes | Balances grouping against fragmentation |
Priority order
Rules are evaluated from the highest priority number down:
Priority 100: Group by Host ← evaluated first (default)
Priority 90: Group by User
Priority 80: Group by IP
Priority 70: Group by Rule ← evaluated last (default)| Enabled rules | Alert has | New case keyed by |
|---|---|---|
| Host + User + Rule | host, user | Host |
| Host + User + Rule | user only | User (no host value) |
| User + Rule | host, user | User (host rule disabled) |
| Rule only | anything | Rule |
Why "Group by Rule" may not group
With both "Group by Host" and "Group by Rule" enabled:
Alert 1: Rule X on WS-001 → creates a case keyed by host WS-001
Alert 2: Rule X on WS-002 → host lookup: no open case for WS-002
→ rule lookup: no case keyed by rule X
→ creates a new case keyed by host WS-002To group all alerts of one detection regardless of host or user, either disable the Host, User and IP rules, or give "Group by Rule" the highest priority (for example 200).
API reference
Grouping rules are read with settings:view and changed with settings:system.
# List grouping rules
GET /api/settings/case-grouping
# Create a grouping rule
POST /api/settings/case-grouping
{
"name": "Group by Host",
"match_type": "host",
"time_window_minutes": 60,
"priority": 100,
"case_title_template": "Alerts on host: {{host}}",
"case_severity_rule": "highest",
"max_alerts": 100,
"enabled": true
}
# Update a grouping rule
PUT /api/settings/case-grouping/{id}
{
"time_window_minutes": 120,
"enabled": false
}
# Delete a grouping rule
DELETE /api/settings/case-grouping/{id}Best practices
- Start with the defaults and tune from there.
- Pick windows deliberately. Too short fragments cases; too long merges unrelated alerts.
- Keep
max_alertsworkable. 100 is the default; 50 suits high-volume environments. - Disable rules that never match. Only the highest-priority rule that produces a key creates cases.
Troubleshoot
Need help with these checks? Contact support with the request ID and time with timezone.
Alerts are not grouping
- Check that auto-grouping is on and the rule is enabled.
- Remember that the window runs from the case's last activity.
- Check that the matched events carry the rule's entity fields (see below).
- Check whether a higher-priority rule is keying the cases.
Host grouping creates separate cases
Check which host fields your detection's events populate. Run the rule's query (or a sample like this one) and look at the candidate fields:
class_uid=3002 status_id=2 // replace with your detection's query
| table time, src_endpoint.hostname, device.hostname, dst_endpoint.hostname, user.name, actor.user.name, src_endpoint.ipIf only dst_endpoint.hostname is populated, every destination becomes its own case. Lower the Host rule's priority (for example to 85, below User), disable host grouping, or rely on IP grouping if src_endpoint.ip is consistent.
"Group by Rule" is not working
Host, User and IP rules have higher default priorities, and most alerts have a host or user, so those rules key the cases. Disable them or raise the Rule priority above 100.
Too many cases
- Increase the time window (and the deployment-wide cap if needed).
- Check that the entity fields the rule uses are populated for your sources.
- Try a different match type.
Cases are too large
- Reduce the time window.
- Lower
max_alerts. - Add more specific rules for high-volume detections.