Incidents
How Möbius finds problems in your logs, metrics and traces, and everything an incident page shows you about one
An incident is the unit Dstl8 uses to group everything it knows about a single problem in your system over a window of time: its status and severity, the components it affects, the evidence, the metrics and traces behind it, what to do about it, and Möbius's analysis of the cause.
Most incidents are created automatically by Möbius, the Dstl8 agent, as it watches your logs, metrics and traces. You can also create one yourself, which asks Möbius to investigate it.
What Möbius looks for
Möbius keeps watching each workspace. What it can find depends on the telemetry the workspace receives.
Logs
Error and warning spikes on a component, a flood of one log message (a retry loop or a log storm), many warnings at once with no errors, sharp drops in log sentiment, and several components failing at the same moment.
Kubernetes events
Warning events such as BackOff, ImagePullBackOff, FailedScheduling, Unhealthy, OOMKilling, Evicted and FailedMount.
A value far outside its usual range; a resource heading for a hard limit, such as memory toward a pod's limit or a disk filling up (a forecast); metrics that stopped arriving from a workload, node or namespace; and a Dstl8 agent that stopped reporting.
An operation whose error rate is rising, and an operation that's much slower than it usually is. Möbius names the operation that failed or slowed, not just the service that called it.
A few things Möbius deliberately leaves alone, so they don't become noise: a handful of errors that don't come back, small moves in a metric, metrics it's still learning (a new metric needs some history before Möbius knows what's usual for it), and operations with too little traffic to judge.
How Möbius handles incidents
Checking before you see it. Before a new incident appears, Möbius checks its evidence against your telemetry. An incident whose evidence doesn't hold up is dropped, and an incident with details that are slightly off is corrected, so what reaches you is something Möbius has verified.
Impact matches what happened. Impact reflects how widespread and how long-lived the problem is, not how alarming an error message sounds. One component failing for a few seconds is usually Minor, however scary the log line.
One problem, one incident. When a new signal matches an incident that's already open, it's added to that incident instead of opening another. A new component showing the same failure is added to the incident's affected resources.
Recurrences. When a problem that was resolved in the last two days comes back, Möbius reopens the earlier incident instead of starting over, so its history and fix stay together.
Keeping it current. While an incident is open, Möbius updates it as the problem grows, spreads or changes.
Winding down. An Active incident with no new activity for a day moves back to Investigating, and it's resolved automatically after two quiet days. If someone on your team changed the incident recently, Möbius leaves it for you.
Forecasts. When a metric is heading for a limit, Möbius can open an incident before anything fails. Forecasts follow their own rules; see Forecasts.
Incident lifecycle
An incident usually moves forward through these workflow states:
Investigating → Active → Resolved → Closed
It can also move back: an Active incident that goes quiet returns to Investigating, and a Resolved incident reopens if the problem comes back.
Investigating
A problem Möbius is still looking into, a forecast, or one that has gone quiet.
Active
A confirmed, ongoing problem.
Resolved
The problem is over. Resolved incidents can reopen if the problem comes back.
Closed
Done, and kept for the record.
Change the state with the status button on the incident page. Moving an incident to Resolved or Closed asks why; see Closing an incident.
When a deploy stops the problem
When Dstl8 sees a deploy land on the components of an open incident while the problem is still happening, Möbius checks the result once the deploy has had time to settle:
Back to normal. The incident is resolved as Fixed, with a note on its timeline such as it stopped after the deploy of checkout at Nov 3 14:05 UTC. The note says the problem stopped after the deploy, because that's what Möbius can show; it doesn't claim the deploy caused the fix.
Not back to normal. The timeline says Still happening after the deploy of … and the incident stays open.
Some components recovered, some didn't. The ones still failing are split off and tracked on their own, with a note naming them.
Too little traffic to tell. Nothing changes.
A deploy right at the start of an incident is more likely its cause than its fix, so it isn't checked. An incident someone on your team has just changed is left for you.
For two days after an incident is resolved this way, Möbius keeps watching for its errors. If they return, the incident reopens to Active with a Recurred entry saying it came back after the deploy.
Finding incidents
The Incidents page lists your incidents. Each row shows when it started, how long it lasted, its title, Impact, Status, Activity (how recently it was seen and how many bursts and objects it has), the Sources its data came from, and its workspace.
Narrow the list with:
Search incidents… to find incidents by text.
All Impacts to pick one impact level.
Forecasts and failures to show only forecasts (Forecasts only) or only problems that are actually happening (Failures only).
Filter by Resource Type and Filter by Resource for a kind of component or one by name.
The filters are part of the page's address, so you can bookmark or share a filtered list.
A Forecast badge marks an incident Möbius opened before anything failed. Hover the Sources chips to see every source involved, with its type.
The incident page
The incident page brings everything about the problem into one place:
The header — the incident's workspace, its status button, a Forecast badge when it's a forecast, its impact and environment, and a line naming the Sources involved, each linked to its source page.
Incident details — status, impact, start and end time, and where it's happening.
Description — what's wrong, in words.
Related Code — the lines in your code that emit this incident's log patterns, when your organization has the Code Graph.
Impacted Resources — the services, deployments, pods and hosts involved, grouped by the source they come from.
Notifications — the notifications sent about the incident: to which channel, for which event, and whether each one arrived. See Delivery history.
Evidence — the log lines, metrics and traces behind the incident; see Evidence.
Actions — what to do next. When the incident has an analysis, these are the analysis's actions (marked From the analysis below); otherwise they're the ones written when the incident was opened.
Analysis — Möbius's structured look at the cause; see Analysis.
Signals — charts of the metrics and traces the incident cites; see Signals.
Seen before — earlier incidents with the same problem, what fixed them, and how often it has come back, from Memory.
Tabs underneath for the incident's Patterns, Logs, the Events around it (deploys, configuration changes and similar), its affected Objects, and its Timeline.
The page header has:
Build canvas — builds a canvas for the incident, or opens the one it already has.
Copy for AI — copies the whole incident as Markdown for pasting into Claude or another AI tool: the details, related code, evidence, actions, the full analysis and the affected resources, with the IDs a tool connected to the Dstl8 MCP server needs to look deeper.
Edit incident (in the menu) — change its details, such as the title, summary, description or impact.
The chat sidebar knows which incident you're looking at, including its analysis, so you can ask Möbius about it directly: "what should I check first?", "is the deploy the cause?".
The side panel
On a workspace's page, clicking an incident opens it in a side panel instead of leaving the page. The panel shows the same evidence, actions, analysis and Signals as the incident page, so you can look into it without losing your place. Full details → opens the full incident page, which also has the impacted resources and the timeline.
Evidence
Evidence is what Möbius found that shows the problem, and each line is shown as the kind of signal it came from:
A log line shows when it was logged, its level, the message, and where it came from: the source, the stream, and the pod, service or host that wrote it. Source and stream names link to their pages. Expand the line to see every detail of where it was logged (source, stream, namespace, deployment, pod, service, host), and use Open in Logs to see the logs around it.
A trace shows the operation, its service, how long it took and whether it failed. Open the trace opens the whole trace without leaving the page.
A line marked Not found in the data for this incident's window is one Möbius quoted but Dstl8 couldn't match to your telemetry for that time. Treat it with some caution.
Older incidents, written before evidence was shown this way, show their evidence as text.
Signals
When an incident involves metrics or traces, the Signals section charts each one over the incident's window, so you can see the problem's shape without leaving the page. Log-only incidents don't have this section.
Each metric card shows:
A one-line summary: the value now (or at the end, for an incident that's over), what it usually is, what it peaked at and when, and its limit when it's heading for one. A value at least twice the usual also says how many times the usual it is.
A chart with the usual level as a dashed line, the limit when there is one, a marker where the incident opened, and markers for deploys in the window.
A badge for what's wrong with it: Anomaly (outside its usual range), Forecast (heading for a limit) or Silent (stopped reporting).
Open in Metrics to explore it further.
Each trace card is one operation and what's wrong with it, Errors (its error rate) or Slow (its p99 latency; the Traces page charts p95), with the same summary and chart. Open a failing trace or Open the slowest trace finds an example trace for you, and Open in Traces opens the service on the Traces page.
The section shows the first few metrics and traces. Use Show all … metrics or Show every trace signal for the rest.
Analysis
Once an incident is confirmed, Möbius writes an Analysis: a structured investigation of the cause, drawing on recent changes, your code, your infrastructure's topology, earlier incidents and the shape of the errors over time. The badge at the top shows what it focused on (Infrastructure, Application or Metrics & traces), and looked at lists what it drew on.
An analysis has:
A summary of what Möbius thinks is happening.
Hypotheses — two to four possible causes, ranked, each with a confidence, a status (supported, unsupported or untested) and the evidence it rests on. Changes Möbius tested as a possible cause are listed too. Use the thumbs on each hypothesis to tell Möbius whether it's right.
Timeline — the moments that matter, in order: when the errors started, deploys, earlier incidents, recoveries. Anything named in a line links to it.
Blast radius — what's affected and how, as a list: each component's kind, its name, and how it relates to the incident, for example likely cause, affected, hosts the affected workload or affected downstream. Likely causes are listed first. Names that exist in your topology link straight to them there.
Suggested for Memory — anything durable the analysis learned, like a dependency or a known issue, suggested to Memory for your review. A thumbs-up on a hypothesis confirms the suggestions it relied on.
Metrics and traces the analysis mentions link to their charts in Signals.
Möbius analyzes an incident when it's first confirmed and again when the problem changes significantly, such as a new burst or a reopen. The latest analysis is the one shown.
When Möbius suggests closing
Sometimes an analysis concludes the incident doesn't need to stay open. Möbius doesn't close it on its own; instead a banner at the top of the incident page says what it thinks and why:
Möbius thinks this is expected noise, not a problem — with Close as not an issue. Closing it this way also teaches Möbius to leave these lines alone.
Möbius thinks this has been fixed — with Close as fixed.
Möbius thinks this is the same problem as another incident, linked — with Close as duplicate.
The close button opens the usual close dialog with the reason and Möbius's reasoning filled in, so you can check and edit the note before saving. Keep open dismisses the suggestion; Möbius remembers and won't suggest closing it that way again.
Affected objects
An incident's affected objects are the individual components it involves: a service, deployment, pod or host. Each is tracked on its own, so one pod can recover while the incident as a whole is still active.
Object type / name
What it is, for example type deployment, name checkout
Impact
How badly this object is affected
State
open or resolved, independent of the incident's status
First / last seen
When the problem was first and most recently seen on this object
Occurrences
How many times the problem has occurred on it
The Objects tab lists them, and Impacted Resources groups them by source.
Timeline
The Timeline tab is the incident's story, written as it happens. Entries are marked by kind: Detected, New component, Escalated, Cause identified, Recovery, Resolved, Recurred, Comment and Analysis. Möbius adds most of them, and state changes your team makes are recorded there too. Automatic changes, such as an incident winding down after going quiet or resolving after a deploy, say why in their entry.
Closing an incident
When you resolve or close an incident, Dstl8 asks why. The answer is how Möbius learns, so it's worth the click:
Fixed
The underlying problem was fixed.
The problem and its fix, together. Add a note under How was it fixed?, such as "rolled back the config map", and it's kept with the fix. When the problem comes back, the new incident shows it under Seen before.
One-off
It was real, but it cleared up on its own: a blip during a deploy, a short network drop, a dependency that recovered.
Nothing. If the same problem comes back, Möbius raises it again. Use this rather than Not an issue when the problem was real, so a repeat isn't ignored.
Not an issue
It's expected noise, not a real problem.
That pattern is expected noise. Tick Remember this as expected noise to also save it as guidance Möbius always follows.
Duplicate of…
Another incident already covers it.
Nothing new. The incident is linked to the one it duplicates.
Inaccurate
The incident's text is wrong or misleading.
That the signal behind it shouldn't have become an incident on its own.
Every reason except Duplicate of… takes an optional note: How was it fixed? for Fixed, What happened? for One-off, What is it really? for Not an issue, What's wrong with it? for Inaccurate. The note is kept on the incident's timeline and, except for One-off, becomes part of what Möbius remembers, so "scanners probing for SFTP usernames that don't exist" is worth the sentence.
You can skip the question, but an incident closed without a reason teaches Möbius nothing.
Closing from your own assistant through the MCP server works the same way. A close made with your personal API token is your verdict: pass close_reason and close_note with the status change, and Möbius learns from it exactly as it does from the dialog. One-off is transient there. Tokens created for automation (service tokens) don't teach Möbius anything.
Near the bottom of the page, Was this analysis helpful? takes a quick Helpful or Not helpful. Choosing Not helpful asks why: the incident was expected noise (Not an issue), a Duplicate of another incident, Inaccurate, or the problem was already Fixed. The reason is kept with the incident.
Creating an incident manually
While Möbius creates most incidents on its own, you can open one manually from the Incidents page. Creating an incident this way triggers Möbius to investigate it.
The form takes:
Workspace: the workspace the incident belongs to.
Title: a short description of the problem.
Summary: a one-line summary.
Description (optional): more detail.
Impact: severity, defaulting to None.
Status: starting lifecycle state, defaulting to Investigating.
Start Time: when the incident began, defaulting to now.
End Time (optional): leave empty for an ongoing incident.
Tips and troubleshooting
"Why did Möbius open this?" Read the Evidence, then the Detected entry on the Timeline. For metrics and traces, the Signals charts show the moment it opened against the usual level.
"Why didn't Möbius open an incident for something I saw?" Check that the workspace has a Möbius agent assigned and receives the signal (metrics and traces each need a source that sends them), that no maintenance window was running, and that nobody closed the same problem as Not an issue. A short or small blip that settles on its own is skipped on purpose.
"Why did it resolve on its own?" It went quiet for two days, it stopped after a deploy (the timeline names the deploy), or, for a forecast, the metric stopped heading for its limit.
"Why did it reopen?" The problem came back within two days of being resolved, or its errors returned after a deploy had seemed to stop them.
"Why is this Minor when the error looks serious?" Impact follows how many components are affected and for how long. If it spreads or keeps going, Möbius raises it.
Want alerts? Incidents become emails, Slack or Teams messages and webhook requests through alert rules; see Alerts and notifications.
Last updated