HostAtlas · Solutions · For SREs
Solutions · For SREs

The on-call cockpit
that respects your sleep.

Auto-recovery before the page fires. Anomaly detection before the threshold catches up. Postmortems with the evidence already attached. A signed audit trail you can actually defend. The serious parts of the SRE job — built in, not bolted on, not three SaaS subscriptions duct-taped together.

incident · #4827 · 2026-04-09 03:42 UTC
03:42:11● php-fpm exit · signal 11
03:42:14● rule auto_limited matched · cooldown 10 m
03:42:15● agent: systemctl restart php-fpm
03:42:18● probes recovering · 5xx clearing
03:42:21● recorded · audit + timeline
— no page fired —
~6 sec
Typical MTTR for service-crash incidents with Auto-Recovery — agent acts before the human is paged.
5 min
Pre-fire log buffer auto-attached to every incident. Captures the smoking gun your host-side retention threw away.
0 exporters
Service plugins ship inside the agent. No prometheus-postgres-exporter zoo to deploy and forget.
HMAC
Every audit entry signed and chain-linked. Tamper-evident by design — defensible under audit.
— The on-call truth

Most of the SRE job is the same five problems.

We’ve carried pagers. The list looks the same everywhere. HostAtlas is built around exactly this list.

01

Most pages are for things that fix themselves.

A worker crashes. A connection pool exhausts. PHP-FPM gets a SIGSEGV. The playbook is three steps and you’re back. Auto-Recovery runs those three steps within seconds, bounded by per-service limits. The page only fires if the loop trips the limit.

02

By the time you’re paged, the smoking gun is gone.

On-host log rotation runs in minutes. The lines from just before the crash are the ones you need, and they’re usually gone by the time you SSH in. The platform keeps a rolling pre-fire buffer per host so the lines are already attached to the incident when it opens.

03

Three alerts firing aren’t three problems.

A database hiccup pages CPU on the API, p95 on the load balancer and queue-depth on the worker pool. AI Triage recognises the dependency chain and groups them into one incident with a root-cause hypothesis — not three separate "what now" tickets.

04

The postmortem is the first time you reconstruct the timeline.

That reconstruction takes hours and goes in a Notion page that nobody reads. HostAtlas keeps a signed, chronological record of every event — alert, deploy, restart, comment, command — and exports it as a draft postmortem the moment the incident resolves.

— What HostAtlas does about it

Five capabilities that earn their place on the pager.

Not 50 dashboard widgets. Five tools that you reach for during an incident and a quiet Monday morning equally.

01 · Self-heal

Auto-Recovery, bounded by policy.

Read the deep page →

Per-service policies: manual, auto_once, auto_limited. The agent acts on its own host (no SSH round-trip), runs the matching systemctl unit, observes recovery, records the action. If the loop trips its limit, then the page fires — with the full restart history attached.

  • Default policy for new rules is conservative. Nothing self-heals without you opting it in.
  • Coverage out of the box: nginx, apache, caddy, php-fpm, redis, memcached, supervisord, docker, postgresql (manual only), mysql (manual only), custom systemd units via one-form add.
  • Every action audit-logged, replay-traceable, blocked during maintenance windows you flag.
02 · Signal over noise

Smart Alerts + Anomaly Detection.

Anomaly detection →

Smart Alerts add the boring things that turn a noisy alert into a useful one: durations, anti-flapping hysteresis, include / exclude target selectors, composite rules across sources. Anomaly Detection layers statistical baselines per metric on top — z-score severity, classified automatically.

Real-world effect: the rule "page when 5xx rate > baseline + 3σ for 90 seconds on hosts tagged env:prod AND not under maintenance" is two clicks to build and stops paging on every 30-second blip.

03 · Incident in one place

Incident Management with the evidence pre-attached.

Incident management →

An incident opens when its first alert fires. Pre-fire logs (rolling 5 / 15 / 30 minute buffer, plan-dependent), the matching metric chart, recent deploys, recent recipe runs — all attached at t = 0. Ownership, severity, status, comms thread, Slack channel (auto-created on Pro) all live on the same page.

  • Resolve → one click to generate a draft postmortem with the timeline filled in.
  • Export to signed JSON / PDF for SOC 2 / ISO 27001 evidence.
  • Two-way sync with PagerDuty / OpsGenie if those still hold your on-call schedules.
04 · Compress the reading

AI Triage groups, ranks, summarises.

AI Triage →

Five alerts firing across three hosts collapse into one incident with a root-cause hypothesis, ranked by impact. Severity is scored from downstream effect, not metric thresholds — CPU spiking alone doesn’t outrank queue backlog rising at the same time.

The model has access to the metrics, the logs (redacted), the recent changes — nothing else. Every output cites the evidence it grounded on. Per-tenant choice of managed or self-hosted model.

05 · Defensible audit

Signed timeline, end to end.

Audit log signing →

Every action — UI click, API call, MCP tool call, agent action — lands in one tenant-wide audit log. HMAC-SHA256 chain, each entry signed including the hash of the previous. A modification anywhere in the chain produces a verification mismatch instantly.

Auditors stop asking "how do you know nothing was deleted?" because the answer is a green / red badge in the UI. Export to your own object store for retention beyond plan limits.

06 · Map under pressure

Atlas Graph for impact analysis.

Atlas Graph →

Live cross-host dependency graph, built from the connections the agent already observes — no YAML to maintain, no diagrams to redraw. During an incident, "what else does db-prod-01 serve?" is a click, not a tribal-knowledge poll.

— Incident replay

A Tuesday 03:42, narrated.

Anatomy of one mid-night incident from agent event to closed postmortem. Real cadence, real shape, no nobody-was-paged.

03:42:11 eventphp-fpm on api-prod exits with signal 11. Agent observes via systemd dbus subscription.
03:42:14 matchRecovery rule php-fpm matches policy auto_limited · max 3 / hour · cooldown 10 min. Within budget; proceed.
03:42:15 actAgent runs systemctl restart php-fpm. Polkit policy permits; sudo not required.
03:42:17 recoverService back. Uptime checker probes return 200. 5xx rate falls below baseline.
03:42:18 logEvent written to the tenant audit log. Hash-chained, HMAC-signed.
03:42:18 logIncident #4827 auto-created. Pre-fire log buffer (last 5 min) attached. Severity warn; no page.
— quiet — No human paged. Cooldown holds.
08:14 reviewMorning standup: SRE on call sees one new incident in the bell. AI Triage hypothesis: "OPcache miss after deployment 03:38, file cache cold-restart."
08:19 closePostmortem draft generated. Timeline filled, evidence attached, follow-up: add OPcache pre-warm step to deploy recipe. Approved, closed. Total human-time: 5 minutes.
— vs. the existing stack

Where the seams used to be.

Most teams arrive with PagerDuty + Datadog + Grafana + a Notion runbook. HostAtlas doesn’t replace each of those individually — it removes the seams between them.

HostAtlas
Datadog + PagerDuty
Grafana + alertmanager
Auto-recovery before paging
Built in. Bounded by policy.
Bring your own webhook + scripts
Bring your own everything
Pre-fire log auto-attach
5–30 min rolling buffer on the agent
Log retention only; no incident attachment
Loki + manual query at incident time
Service plugins (DB / Redis / Nginx)
Ship inside the agent
Datadog Agent + 1 integration per service
Per-service exporter zoo
Signed audit log
HMAC chain, verifier built in
Audit log present, signing add-on
Not in scope
Postmortem from timeline
One click on resolve
Notion / Confluence template
Notion / Confluence template
Coexistence
Runs alongside; PagerDuty + Datadog integrations supported
—
—
— From here

Three steps to a quieter pager.

01

Enrol one host.

Free tier covers a single server forever. Install the agent on the box that gets the most pages. Watch what gets auto-discovered.

Install guide →
02

Turn on Auto-Recovery for one service.

Pick the one that keeps waking you up. Start with auto_once. Watch it act, watch the audit log, watch the cooldown. Then escalate.

Auto-Recovery →
03

Scale by tag, not by host.

Once one host behaves, add the env:prod tag selector to your recovery rule and let the policy follow your fleet around as it grows.

Tagging →
— FAQ

Questions SREs actually ask.

Does HostAtlas replace PagerDuty or coexist with it?+
Coexist. HostAtlas opens incidents, captures timelines, runs auto-recovery and drafts postmortems. PagerDuty / OpsGenie handle the on-call schedule, escalation policies and the actual phone call. Native two-way sync; one incident, two systems, no duplicate noise.
Can I run AI Triage with a model I host myself?+
On Enterprise, yes. Bring-your-own model URL with the same prompt scaffolding. The platform sends redacted context and gets ranked output back — no raw logs leave the tenant if you don’t want them to.
What happens during an extended outage on your side?+
The agent buffers locally and continues acting on its own host. Auto-Recovery does not require platform reachability — it’s a local agent decision. Telemetry catches up when connectivity returns; the audit chain stays intact.
SLO tracking and error budgets?+
Basic SLO dashboards ship today (multi-window, error-budget remaining). PromQL-style queries planned. For sophisticated SLO work right now, run Nobl9 / Sloth alongside; HostAtlas feeds the metrics.
Open-source / self-host?+
The agent + its plugins are Apache 2.0. The platform (the part this page is about) is HostAtlas’s product. Self-hosted platform is available for air-gapped / sovereign deployments on Enterprise.
Do you have an on-call rotation feature?+
Basic rotations + escalations ship today — enough for small teams. For complex schedules (handoffs across timezones, per-service rosters, follow-the-sun) use PagerDuty / OpsGenie; HostAtlas integrates with both.

Start with one host. Scale at your pace.

Free tier covers a single server forever. Pro is where the recipe library and AI features unlock.

Get early access See pricing