Skip to content

What changed before the alert fired

Incident Management · SLOs, incidents and on-call

The alert is linked to the service and its recent changes, the on-call person is paged on the channel they confirmed, the right runbook is suggested and the timeline becomes the postmortem draft. The probable cause is treated as a hypothesis with evidence, not as a verdict.

The problem

What this product solves

In the middle of an incident, the first question is always "what changed?", and the answer is scattered across several tools.

Without an error budget, every failure looks the same, and the team does not know when to stop shipping and stabilize.

After the incident, the postmortem depends on someone rebuilding the story from memory, and the customer learns about it from the error itself.

updated

Who uses it, and for what

Typical profiles, no customer names. Each use carries the status of the feature behind it.

  • SRE teamTrack the error budget and burn rate of each service across more than one window.SLOs & error budgets
  • Engineering on-callGet paged on the confirmed channel and run the incident from the team's Slack, with roles and a scribe.Incident response
  • Customer support teamPublish incidents and maintenance on a public page without exposing anything internal.Status page

Features

What the product does

Self-service: add it from your account.

  • SLOs & error budgets

    SLIs, error budgets, multi-window burn rates and recent service changes.

  • Incidents

    Alertmanager and Sentry alerts, deduplication, timeline and an AI-suggested postmortem draft built from it, published only after a person approves it.

  • On-call & runbooks

    On-call schedules and escalation, paging by email and WhatsApp (Voxentra Flow) on channels each person confirms, quiet hours and acknowledgement that stops escalation; no SMS or voice paging. Runbooks versioned per service and alert type, suggested when an incident opens, with audited step-by-step execution; actions with side effects (n8n automation or MCP tool) only run after a person approves them at that moment.

  • Incident response

    Manual and drill incidents (including from the chaos GameDay, without paging on-call and outside DORA), commander, scribe, communications and operations roles, the /incidente command in the team's own Slack with verified signatures, a scribe that records the incident channel messages and separates decisions and actions, and escalation to Jira, ServiceNow and PagerDuty with the customer credential encrypted, and the customer Prometheus as a health source for SLOs.

  • Status page

    Public page per organization that only the owner publishes: catalog components, state derived from open incidents and SLOs, 90-day history, incidents and maintenance written by people (nothing internal leaks automatically) and email subscription with confirmation.

How it works

From start to audit record

  1. SLO

    The service has an indicator, an objective and an error budget, with burn rate over long and short windows.

  2. Alert

    Alerts arrive through signed webhooks, are deduplicated and linked to the service and its recent changes.

  3. On-call

    The person on the schedule is paged by email or WhatsApp. Without acknowledgment, the second level is paged.

  4. Runbook

    The service runbook is suggested. Any action that changes something only runs with another person's approval.

  5. Response

    Roles, commands in the team's Slack, a scribe in the channel and a ticket in Jira, ServiceNow or PagerDuty.

  6. Communication

    A person publishes the incident and its updates on the status page, and subscribers are notified.

  7. Postmortem

    The timeline becomes a draft, AI suggests the text, and a workspace admin approves the final version.

Features

Feature by feature

What each one does, how it works, an example from the documentation and what it does not do. Each badge comes from the catalog.

SLOs & error budgets

Know how much error you can afford before users complain

Each catalog service gets an indicator (SLI), an objective and an error budget. The SLI is the ratio of good events to the total in the window, excluding maintenance intervals; budget spent and burn rate come from formulas shown on screen.

Next to the SLO, the screen shows recent changes to the same service, deployments and flag changes, to connect budget consumption to what changed.

How it works

  • Error budget = 1 − objective; budget spent = (1 − SLI) ÷ (1 − objective).
  • Multi-window alerting: it only fires when both the long and the short window cross the threshold, which avoids alarms from isolated spikes.
  • Fast burn: 1 hour and 5 minutes above 14.4. Slow burn: 6 hours and 30 minutes above 6.
  • Composite SLOs with weights, per-SLO annotations and an audited error budget reset with a required reason. An exhausted budget can block the promotion of a release through the delivery policy.
  • A burn rate alert marks the service component as degraded on the status page.
  • Read access through API v1 and the MCP server, with SLI, budget and burn rates.
Through the API (read-only) A key with the engineering:read scope, bound to a workspace.
Base: https://aiuby.com/api/v1
GET /engineering/slos        # workspace SLOs (objective as a percentage)
GET /engineering/slos/{id}   # SLO state; read-only: does not record alerts

What it does not do

  • The API and MCP are read-only: workspace admins create and change SLOs in the UI.
  • Native collection only from Prometheus, through a scheduled query to a public HTTPS URL; other tools send samples through the API.
  • Up to 100 SLOs per workspace.

Incidents

From alert to postmortem on a single timeline

Alerts from Alertmanager, Sentry or any tool that sends JSON arrive through a signed webhook. Repeated alerts are aggregated, a new alert from the same service within 60 minutes joins the open incident, and the incident is created linked to the catalog service, with changes from the previous 6 hours marked as "change close in time".

The timeline records every alert, state change, note, on-call page and runbook step. The postmortem draft comes from it: the structure is assembled without a model, and AI, when turned on, suggests the text, always with the cause written as "Hypothesis (unconfirmed)".

How it works

  • Four states (triggered, acknowledged, mitigated, resolved) and four severities, sev1 to sev4.
  • Caps against alert storms: open incidents per workspace and per source, and new ones per hour. Beyond the cap, the alert joins the most recent open incident.
  • The draft goes to the model through the Gateway, with recorded cost, budget, policy and workspace masking; people appear only as [P#].
  • What the model returns is checked: nonexistent citations are discarded, and a cause without valid evidence is left out.
  • Every generation or edit saves a new version; nothing is overwritten.
  • Only workspace admins approve, with the incident resolved and every action assigned an owner and a due date. The approved version becomes the published postmortem, which no longer changes.
Postmortem draft and approval Incident responders generate drafts; only workspace admins approve.
POST /api/platform/incidents/{id}/postmortem/drafts
{ generate: true }

POST /api/platform/incidents/{id}/postmortem/drafts/{version}/approve

What it does not do

  • AI does not confirm a cause: the hypothesis stays marked as unconfirmed until a person decides.
  • Alertmanager and Sentry do not sign in AIUBY's format: a forwarder that signs the delivery sits between them and the platform.
  • Alert title and text are kept as received, without masking; only labels from a fixed list are stored.
  • There are up to 10 AI generations per incident, and API v1 does not return the timeline or the postmortem.

On-call & runbooks

The right person gets paged, and every step is recorded

On-call schedules with weekly rotation, overrides by period and a second level, paged after 15 minutes without acknowledgement. Pages go out by email and WhatsApp (through the workspace's Voxentra Flow), on the channels each person confirms with a code, respecting each person's quiet hours; sev1 always gets through.

Runbooks versioned per service and alert type are suggested when an incident opens, with the reason. Execution is step by step: an instruction is marked done or skipped, and an action that changes something (a registered n8n automation or a write MCP tool) only runs after another person approves it, at that moment.

How it works

  • A channel starts as pending and receives a 6-digit code valid for 15 minutes. Only the person themselves can confirm it, and a pending channel never receives pages.
  • Each page tries the confirmed channels in priority order, with up to 3 attempts per channel, and never sends duplicates.
  • Acknowledging, mitigating or resolving the incident cancels pending sends and stops escalation.
  • Editing a runbook creates the next version; a run in an incident stays pinned to the version it used.
  • The action request is assembled, frozen and validated beforehand. It waits for approval for 30 minutes and runs exactly once, on behalf of the approver.
  • Every send, failure and runbook step goes into the incident timeline and the audit log.
Register and confirm an on-call channel The code is only accepted from the person themselves; anyone else gets a 403.
POST /api/platform/oncall/contacts
{ channel, address, priority?, userId? }

POST /api/platform/oncall/contacts/{id}
{ code }

PUT /api/platform/oncall/preferences
{ timezone, quietStart, quietEnd }

What it does not do

  • It does not page by SMS or phone call; that channel responds that it is not configured.
  • Runbook suggestions are rule-based (same service, alert type), with no AI model; a runbook without criteria is never suggested.
  • API v1 and MCP read runbooks but do not run steps.
  • With the organization's agent kill switch on, no runbook action runs.

Incident response

Run the incident from chat, with a record and clear roles

An incident can be opened by a person, from the UI or with the /incidente command in your team's Slack. The channel where it was opened becomes the incident channel: the scribe records every message on the timeline and separates those that start with "decisão:" (decision) and "ação:" (action).

Drills use the same path, marked as drills: they do not page on-call, do not count toward DORA or rollout signals, and show how many minutes the team took to acknowledge, mitigate and resolve. Starting a chaos GameDay opens the drill automatically.

How it works

  • Commander, scribe, communications and operations roles, one holder per role, each handoff on the timeline.
  • Commands, in Portuguese: abrir (open), ack, mitigar (mitigate), resolver (resolve), nota (note), decisão (decision), ação (action), papel (role), status and resumo (summary).
  • Each Slack user is linked to a workspace person; the command runs with that person's permissions.
  • Slack signature checked on every request, with a 5-minute window; the secret is stored encrypted.
  • Escalation to Jira, ServiceNow and PagerDuty with the customer credential encrypted: one ticket per incident and integration, with number, severity and link.
  • The postmortem draft reads the decisions and actions recorded by the scribe.

Example use case

Payments go down at 2 a.m. The on-call engineer types /incidente abrir sev1 Pagamentos fora in the team channel, hands command to someone else with /incidente papel commander, writes "decisão: voltar a versão anterior" (roll back to the previous version) and escalates to the operations PagerDuty. In the morning, the postmortem starts from the timeline with that decision.

What it does not do

  • The Slack app belongs to your team: AIUBY receives commands and messages and does not post to the channel.
  • Integrations only with a public HTTPS address; nothing goes to an internal network.
  • The scribe does not summarize with AI: it stores what was written and sorts it by the agreed prefix.
  • The ticket opened in Jira, ServiceNow or PagerDuty does not sync its state back; Microsoft Teams is not supported.

Status page

Your customers see service status, not what happens backstage

One public page per organization, with no login, showing the components chosen from the engineering catalog, the state of each one and a 90-day history. It starts off, and only the organization owner turns it on or off.

The state of an automatic component follows the service's open incidents and SLOs, only the state, never the text. Public incidents, updates and maintenance windows are written by a person: nothing internal goes out on its own.

How it works

  • Four states: operational, degraded, unavailable and under maintenance. During maintenance, internal signals do not change the state.
  • Titles, alerts, notes, timeline, people, postmortem and internal numbers never go public.
  • Public text containing a secret or personal data is refused on save and redacted again on read.
  • Email subscription with two-step confirmation and one-click unsubscribe, which deletes the email.
  • The screen shows only subscriber counts, never the email list.
  • Every publication, update and maintenance window is recorded in the audit log.
Public page API Routes without a session, with read and subscription limits per IP.
GET /api/status/{endereço}                    # public snapshot in JSON
POST /api/status/{endereço}/subscribe         # { email } → subscription (202)
POST /api/status/confirm                      # { token } → confirms
POST /api/status/unsubscribe?token=           # unsubscribe

What it does not do

  • One page per organization, tied to the workspace where the services live.
  • Email notices to subscribers only go out when sending is configured for the organization; without it, no notice goes out.
  • It publishes nothing on its own: an internal incident only changes the state of the automatic component.
  • A page that is off or does not exist returns the same 404, without revealing that it exists.

AI and limits

What AI does here, and what it never does on its own

Does

  • Suggests the postmortem draft text from the incident's numbered timeline.
  • Cites the timeline items each statement relies on. A citation that does not exist is discarded.
  • Always writes the cause as "Hypothesis (unconfirmed)", and only when there is valid evidence.

Never does

  • Never publishes a postmortem: only a workspace admin approves a version.
  • Never confirms a cause or changes the incident state.
  • Never picks or runs a runbook: the suggestion is rule-based, and people do the execution.
  • Never writes to the status page.

Governance and security

Rules the code enforces

  • Every alert delivery is signed with the source secret and accepted only within a 5-minute window.
  • From the alert, only labels on a fixed list are kept. Title and text are stored as received, without masking.
  • An incident's free text can be deleted on request, and for resolved incidents it is deleted automatically after 400 days.
  • An on-call channel only receives pages after the person confirms the code themselves. Nobody can confirm for someone else.
  • A runbook action that changes something requires another person's approval at that moment, is valid for 30 minutes and runs only once.
  • A postmortem is only published with a workspace admin's approval, and the approved version never changes.
  • Only the owner can turn on the status page, and public text containing secrets or personal data is refused.
  • A Slack command only runs with a valid signature and within the permissions of the workspace member linked to whoever typed it.
  • Incident drills do not page on-call and stay out of DORA and rollout signals.

Integrations

What it connects to

Only integrations that exist in the code. Each one carries the status of the feature that uses it.

  • Prometheus AlertmanagerAlert webhook.Incidents
  • SentryIssue integration webhook.Incidents
  • Generic webhookAny tool that sends JSON.Incidents
  • EmailOn-call page to the address the person confirmed.On-call & runbooks
  • WhatsApp (Voxentra Flow)On-call page through the Flow registered in the workspace, with signed delivery.On-call & runbooks
  • n8nA runbook step that triggers a workflow registered in the workspace.On-call & runbooks
  • MCP toolsA runbook step that calls a reviewed tool. Writes only with approval.On-call & runbooks
  • Slack (your team's app)The /incidente command and the incident channel scribe, with signature verification.Incident response
  • Jira, ServiceNow and PagerDutyA ticket opened from the incident, with the customer credential encrypted.Incident response
  • PrometheusSLO health source: a scheduled query of the good and total series.SLOs & error budgets
  • Event webhooksIncident open, update and resolve, and on-call pages, as signed events.Connectors & webhooks
  • API v1 and MCP serverRead SLOs, incidents and runbooks with an API key.API, CLI & keys

FAQ

Straight answers

What can I use today?

Available: SLOs & error budgets, Incidents, On-call & runbooks, Incident response, Status page. Self-service: add it from your account.

Does it replace my on-call tool?

Available: On-call & runbooks, Incident response. It depends on the channel. On-call & runbooks has schedules with weekly rotation, overrides, a second level, quiet hours and paging by email and by WhatsApp, through the workspace Voxentra Flow. It does not page by SMS or phone call, and there is no mobile app. If your team uses PagerDuty, the incident can be escalated there.

Can I run the incident from Slack?

Available: Incident response. Yes, through your own team's Slack app: the /incidente command opens, acknowledges, mitigates, resolves and assigns roles, with the Slack signature verified on every request and each Slack user linked to a workspace member. The scribe records messages in the incident channel and separates decisions and actions by prefix, with no AI. AIUBY has no Slack app of its own, and Microsoft Teams is not supported.

Does it integrate with Jira, ServiceNow or PagerDuty?

Available: Incident response. Yes, outbound: the incident can open a ticket in Jira, ServiceNow or PagerDuty, one per incident and integration, with the customer credential stored encrypted and only to a public HTTPS address. The external ticket state does not sync back.

Does AI say what caused the incident?

Available: Incidents. Not as a verdict. The recent change linked to the alert appears as a hypothesis, with the evidence, and in the postmortem draft the suggested cause is marked as an unconfirmed hypothesis. Only a workspace admin approves the postmortem.

Does the runbook execute actions on its own?

Available: On-call & runbooks. No. Instructions are marked done or skipped by the responders. An action that changes something, such as an n8n automation or a write MCP tool, waits and only runs after another incident responder approves it at that moment. Every step goes into the timeline and the audit trail.

Does the status page publish my internal incidents?

Available: Status page. No. Public incidents, updates and maintenance are written by a person. From the internal incident, the automatic component inherits only the state, never the title, alerts, notes, people or postmortem. The page starts switched off, and only the organization owner turns it on.

How much does it cost?

Available: SLOs & error budgets, Incidents, On-call & runbooks, Status page. This product has no price of its own published. Its features depend on the Cortex contract, the same one as Engineering Intelligence, and are enabled per organization by the AIUBY team. The AI postmortem draft draws on the organization prepaid balance, like any model call.

Works together with

  • Software DeliveryService deployments appear as nearby changes on the incident timeline and next to the SLO.
  • Developer PortalCatalog services are the same ones behind the SLOs, runbooks and status page components.
  • AI EngineeringThe postmortem draft goes through the same Gateway, with the workspace budget and policy.

Incident Management

Self-service: add it from your account.