LearnGrok
Prompts
PromptIntermediateAPI errors

Incident timeline from alerts and chat logs

Produce a checked, handover-ready incident timeline from operational evidence for on-call engineers and incident commanders.

5 min read

You need one record that survives a shift change. Start by extracting evidence, then order it, challenge it, and write the handover from the checked version. This is for on-call engineers, incident commanders and engineering leads handling an active or recently closed incident.

The aim is not a polished narrative. It is a record that separates what the systems showed from what people reported, and makes the next owner clear.

Key point

Keep evidence separate from conclusions

A timestamped alert can support an alert state. It does not, on its own, prove customer impact, root cause or recovery.

1. Gather the source material

Collect the material before asking for a timeline. Use the smallest useful extract, but retain timestamps and the context around each key message.

Include:

  • Alert history, including trigger and clear times, alert names, thresholds and affected service.
  • Incident-channel messages, especially declarations, impact reports, mitigation decisions and ownership changes.
  • Dashboard readings recorded during the incident, with the metric name, value and observation time.
  • Operator notes, deployment records, rollback records, feature-flag changes and traffic changes.
  • The current state of alerts and the latest dashboard observation.

Remove secrets, access tokens and credentials. Replace customer names or identifiers if they are not needed to establish impact. Do not paste an entire channel merely because it is available. Include messages that establish a fact, a decision, an action, a claimed recovery, or a disagreement.

Stop

Do not treat chat as the system of record

A message saying a deployment fixed the problem is a report until a timestamped deployment record and service evidence support it.

Use Extract evidence from incident sources when the raw material is mixed. It gives each statement a source ID. Those IDs matter later. They let a reviewer trace a timeline row back to the alert, message or note that supports it.

If your incident spans regions or teams, retain the timezone shown in the source. Convert only when you know the source timezone and the display timezone. A confident but wrong conversion can reverse the apparent order of a rollback and a recovery signal.

2. Build the event order

Paste the evidence register into Build the factual incident timeline. Set the start boundary first. For a customer-impact incident, use the first confirmed customer impact where possible. For an operational event with no confirmed impact, use the first known signal and say that impact is not established.

The timeline distinguishes five useful event types:

Status Use it for Do not use it for
observed Alert, metric or user report A conclusion about cause
action taken An operator action The effect of that action
change made Deploy, rollback or configuration change Proof the change resolved the incident
recovery signal A metric, alert or impact signal improves A final closure claim without sufficient observation
decision A recorded choice and owner An implied decision

Keep the timeline narrow. A handover reader needs to find the first impact, each mitigation attempt, every material change, and the latest state. They do not need greetings, repeated status updates or speculation from the channel.

Check

Check the boundaries before sharing

The record should show a source for the first signal, first impact, mitigation start and recovery. If any is missing, say not established.

3. Resolve uncertainty without hiding it

Run Reconcile conflicting incident evidence whenever the evidence tells more than one story. Common examples include an alert clearing before users report recovery, a dashboard aggregation masking a regional failure, or a chat message claiming that a rollback worked before its completion time is recorded.

Do not force a single answer. Replace unsupported certainty with wording that says what is known. For example, change “the rollback restored service” to “the error-rate alert cleared after the rollback; customer-impact end time is not established”. This is more useful to the next engineer because it tells them what still needs checking.

The reconciliation output also gives the incident commander a short verification list. Assign those questions to the person or role able to inspect the missing evidence. Do not assign ownership by guessing from who spoke most in the channel.

4. State what changed and what is true now

Use Record changes and service state after the timeline has been checked. It prevents a common handover failure: listing actions without saying which changes remain active.

For every deploy, flag change, scale adjustment or manual intervention, record both the expected and observed effect. If the service improved after a change but the evidence does not isolate that change, write effect not established. Several actions may have happened close together.

Use stable only when the supplied observations support it. If the latest data is old, alerts are quiet but the key metric is missing, or a mitigation is still settling, recovering or unknown is safer.

Watch out

Alert clearance is not necessarily recovery

An alert can clear because traffic changed, a threshold was crossed, telemetry failed or the affected scope narrowed.

5. Produce the handover record

Run Write the on-call handover record last. Paste the checked timeline and the change-and-state record, not the original chat log. This reduces repeated interpretation and makes the handover concise enough to use during a live shift change.

Read the Situation now section first. Then check that every action has an owner and due time, and that the Next decision owner is a real role or named person. If ownership is unknown, leave it explicitly unassigned and ask the incident commander to assign it.

The model's available behaviour and limits can vary. Check the current guidance in the xAI documentation overview before relying on a workflow for a critical incident.

When the record does not work

If the output has invented a time, cause or owner, return to the evidence register and ask for the source ID. Remove any claim that cannot be traced. If the ordering is unclear, retain both events with their recorded times and mark the order as unresolved. If the current service state is vague, collect one fresh dashboard observation and the current alert state, then rerun the service-state and handover prompts. Do not close the incident record by making uncertainty sound like recovery.

Copy-ready prompts

5 prompts. Open one to read it, or take the whole pack.

1Extract evidence from incident sourcesUse this first when the evidence is scattered across alerts, chat, dashboards and operator notes.
Create an evidence register for incident [INCIDENT ID OR SHORT NAME]. Use only the source material below. Do not infer missing facts.

Alert history:
[paste alert history]

Incident-channel messages:
[paste chat messages, including timestamps and names or roles where available]

Dashboard observations:
[paste dashboard values, screenshots transcribed as text, or links with observed values]

Operator notes:
[paste notes]

Return a Markdown table with these columns: `source ID`, `source type`, `timestamp as recorded`, `timezone if stated`, `actor or system`, `observed event`, `metric or alert value`, `direct quote or exact value`, `confidence`.

Use source IDs `A-01`, `C-01`, `D-01`, and `N-01` for alerts, chat, dashboards and notes. Keep quoted wording short but exact. For dashboard observations with no timestamp, write `timestamp not supplied`. For conflicting values, create separate rows rather than choosing one. Mark confidence as `high` only for directly recorded facts, `medium` for a clear paraphrase, and `low` where the source is incomplete. End with a section called `Missing evidence` listing the specific source, timestamp, metric, or action record needed to close each gap.
2Build the factual incident timelineUse this after extracting the evidence register, or when the raw material already has reliable timestamps.
Write a factual incident timeline for [INCIDENT ID OR SHORT NAME] from the evidence below.

Incident start boundary: [for example, first customer impact, first alert, or unknown]
Incident timezone for display: [UTC or named timezone]
Evidence register:
[paste the evidence register]

Return these sections in this order:

1. `Timeline`
Create a Markdown table with columns: `time`, `event`, `evidence`, `status`, `certainty`. Sort oldest to newest. Use `observed`, `action taken`, `change made`, `recovery signal`, or `decision` in the status column. Cite one or more source IDs in every row. Use `confirmed`, `conflicting`, or `unknown` in certainty.

2. `Incident boundaries`
State: `first known signal`, `first known customer impact`, `mitigation started`, `service recovery observed`, and `incident end`. Write `not established` where evidence does not support a time.

3. `Unresolved timeline questions`
List only questions that could alter event order, impact, ownership, or the claimed recovery time.

Do not invent timestamps. If sources use different timezones, retain the original timestamp and add `timezone conversion not verified` unless the offset is explicitly supplied. Do not describe a correlation as a cause.
3Reconcile conflicting incident evidenceUse this when chat claims, dashboard data and alert timestamps do not agree, or when a retrospective is likely to challenge the sequence.
Audit the following incident timeline against its source evidence. Find contradictions, unsupported statements and uncertain ordering.

Timeline:
[paste timeline]

Evidence register or raw sources:
[paste evidence]

Return a Markdown table with columns: `issue ID`, `timeline claim`, `conflicting or missing evidence`, `why it matters`, `safe replacement wording`, `owner to verify`.

Apply these rules:
- A claim is supported only if a cited source directly records it.
- Chat statements about cause, recovery, deployment success, or customer impact are reports, not facts, unless corroborated by a timestamped system record.
- If two events have only minute-level timestamps, do not claim their order within that minute.
- Separate `service recovered` from `alert cleared` and from `customer impact ended`.
- Preserve disagreement. Do not resolve it by majority vote.

Then return `Revised timeline entries` as a Markdown table containing only rows that need replacement. Each row must include the original time, corrected wording, source IDs, and certainty. End with `Questions for the incident commander`, limited to five questions that would materially improve the record.
4Record changes and service stateUse this once the timeline exists and you need a clear statement of what changed and whether the service is actually stable.
Create a change and service-state record for [INCIDENT ID OR SHORT NAME]. Distinguish observed state from assumptions.

Incident timeline:
[paste checked timeline]

Deployment, configuration, feature-flag, rollback, scaling and operator evidence:
[paste change records and notes]

Current dashboard and alert observations:
[paste current observations]

Return these sections in this order:

1. `Changes during the incident`
Use a Markdown table with columns: `time`, `change`, `change type`, `executor`, `expected effect`, `observed effect`, `evidence`, `confidence`. Allowed change types are `deploy`, `rollback`, `configuration`, `feature flag`, `capacity`, `traffic management`, `manual operation`, and `unknown`.

2. `Current service state`
Use these exact fields:
- `Customer impact:`
- `Alerts:`
- `Key metrics:`
- `Recent changes still in effect:`
- `Known risks:`
- `Monitoring gap:`
- `State classification:` stable / recovering / degraded / unknown

3. `What cannot yet be claimed`
List statements that would overstate recovery, causation, or the effect of a change.

If no direct before-and-after evidence connects a change to an outcome, write `effect not established`. If the latest observation is older than [STALE AFTER, for example 15 minutes], flag it as stale rather than calling the service stable.
5Write the on-call handover recordUse this at shift change, when ownership moves to another team, or when the incident commander needs one factual record.
Write a handover-ready incident record for [INCIDENT ID OR SHORT NAME]. The next on-call engineer must be able to continue from this document without reading the full chat history.

Checked timeline:
[paste checked timeline]

Change and service-state record:
[paste change and service-state record]

Open tasks, owners and due times:
[paste tasks]

Next decision owner, if known:
[paste person or role]

Return exactly these sections:

## Situation now
Write 3 to 5 bullets. State only the current impact, current service classification, latest confirmed recovery or degradation signal, and immediate risk.

## What happened
Write a Markdown table with columns: `time`, `event`, `evidence`. Include only the events needed to understand impact, mitigation, changes and recovery.

## What changed
Write bullets in the form `time | change | observed result | evidence`. Write `observed result not established` where needed.

## Current service state
Use these fields: `customer impact`, `alerts`, `key metrics`, `changes still active`, `known risks`, `monitoring gaps`.

## Open decisions and actions
Write a Markdown table with columns: `decision or action`, `why it is needed`, `owner`, `due time`, `blocking evidence`. If no owner is supplied, write `unassigned`, not a guessed name.

## Next decision owner
State one role or named person. If no owner is evidenced, write `unassigned, incident commander to assign`.

## Evidence gaps
List unresolved contradictions, missing timestamps and unverified recovery claims.

Use factual language. Label statements as `confirmed`, `reported`, or `unknown` where that distinction matters. Do not add root cause, blame, or follow-up work that is not present in the inputs.

Quick question about the API?

Short answers from the API pages here, with the page itself one tap below. Limits, models and prices go to xAI’s documentation, because those change and this does not chase them.

Last checked against xAI’s own pages on 2026-08-26. Grok changes quickly; anything version-specific should be confirmed upstream before you rely on it.

More in API errors

Found something out of date?

Grok changes quickly and this page is a snapshot. If something here is wrong, or you know a better resource, send it over.

Suggest a link →

Advertise on LearnGrok

$420.69one-time, for a 30-day run

Stripe on the next step. Live once approved.