InariWatch Docs

Web dashboard

The web dashboard is the fastest way to get started — no install, no card required. Sign up, connect your first integration, and InariWatch starts monitoring in minutes.

1. 1

   Create an account

   Go to inariwatch.com/register and sign up with GitHub or email.
2. 2

   Create a project

   A project groups your integrations and alerts. Give it the name of your app or service.
3. 3

   Connect an integration

   Go to Integrations and connect GitHub, Vercel, or Sentry. See the integration guides below for exactly which token to use.
4. 4

   (Optional) Add your own AI key for auto-fix

   AI analysis works out of the box. To unlock code remediation, chat, and post-mortems, go to Settings → AI analysis and add your key. See AI setup for supported providers.

Local CLI

The CLI runs entirely on your machine — no account needed, data stays local. It's the best option if you prefer a terminal workflow or want zero cloud dependency.

curl -fsSL https://get.inariwatch.com | sh

1. 1

   Create a project

   inariwatch init — walks you through creating a local project interactively.
2. 2

   Add an integration

   inariwatch add github — prompts for your token and owner. Repeat for vercel, sentry, etc.
3. 3

   (Optional) Set an AI key

   inariwatch config --ai-key sk-ant-... — enables AI correlation and auto-remediation in the watch loop.
4. 4

   Start watching

   inariwatch watch — polls every 60s, correlates events, and sends Telegram alerts if configured.

CLI — Installation

The CLI is a single Rust binary with no runtime dependencies.

curl -fsSL https://get.inariwatch.com | sh

irm https://get.inariwatch.com/install.ps1 | iex

git clone https://github.com/orbita-pos/inariwatch
cd inariwatch/cli
cargo build --release
# binary at: ./target/release/inariwatch

After installing, run inariwatch --help to confirm it works. On Linux/macOS the binary is placed in ~/.local/bin/inariwatch. On Windows it installs to %USERPROFILE%\.inariwatch\bin and is added to your user PATH automatically.

CLI — Commands

CLI — Configuration

The CLI stores all config in two files:

[global]
ai_key    = "sk-ant-..."
ai_model  = "claude-haiku-4-5-20251001"
auto_fix  = false   # enable autonomous fix pipeline on critical alerts
auto_merge = false  # auto-merge PRs when all safety gates pass

[[projects]]
name = "my-app"
slug = "my-app"
path = "/home/you/projects/my-app"

[projects.integrations.github]
token         = "ghp_..."
repo          = "my-org/my-app"
stale_pr_days = 2

[projects.integrations.vercel]
token      = "..."
project_id = "prj_..."
team_id    = "team_..."   # optional

[projects.integrations.sentry]
token   = "..."
org     = "my-org"
project = "my-project"

[projects.integrations.uptime]
url       = "https://my-app.com"
threshold = 5000   # ms — optional, alerts if response > threshold

[projects.integrations.cron]
url    = "https://app.inariwatch.com"
secret = "your-cron-secret"

[projects.notifications.telegram]
bot_token = "123456:ABC-..."
chat_id   = "987654321"

CLI — Daemon

Run InariWatch as a background service so it monitors your project 24/7 — even when your terminal is closed. It registers as a systemd user service on Linux, a launchd agent on macOS, and a Task Scheduler task on Windows.

inariwatch daemon install   # register and enable the service
inariwatch daemon start     # start immediately
inariwatch daemon stop      # stop the service
inariwatch daemon status    # check if running + tail recent logs
inariwatch daemon uninstall # remove the service

Logs are written to ~/.inariwatch/daemon.log on all platforms. The daemon runs inariwatch watch in the background — any config you set with inariwatch config applies to it automatically.

CLI — Auto-fix & Auto-merge

When auto_fix is enabled, every critical alert automatically triggers the full AI remediation pipeline: diagnose → read code → generate fix → self-review → push branch → wait CI → open PR. No human needed until the PR appears.

inariwatch config --auto-fix true    # enable autonomous fix pipeline
inariwatch config --auto-merge true  # also merge PRs when all safety gates pass

auto_merge requires auto_fix to be enabled. Even then, a PR is only merged when all 8 safety gates pass: auto-merge enabled, CI green, confidence ≥ 90%, self-review score ≥ 70, lines changed ≤ 50, Substrate risk ≤ 40, EAP chain verified, and post-merge monitoring.

CLI — MCP Server

InariWatch exposes an MCP (Model Context Protocol) server that gives your AI editor direct access to your alerts, integrations, and infrastructure actions — without leaving your code. Works with Claude Code, Cursor, Windsurf, VS Code, and any MCP-compatible client.

The MCP server has two tiers of tools: read tools to query alerts and run checks, and action tools that let the AI autonomously fix issues, roll back deploys, and silence alerts.

Connecting to your editor

Add InariWatch to your .mcp.json (project-level) or your editor's global MCP config:

{
  "mcpServers": {
    "inariwatch": {
      "command": "inariwatch",
      "args": ["serve-mcp"]
    }
  }
}

For Cursor: Settings → MCP → Add server → paste the config above.
For Claude Code: save as .mcp.json in your project root or ~/.claude/settings.json globally.
Then reload your editor — InariWatch starts automatically when the AI needs it.

Available tools

CLI — Rollback

When a bad deploy reaches production, inariwatch rollback vercel gives you an interactive list of your last 10 successful deployments so you can pick one and restore it in seconds.

inariwatch rollback vercel

Fetching recent successful deployments for my-app…
? Roll back to which deployment?
> dpl_abc123 a1b2c3d (main) — fix: remove debug log — 2h ago
  dpl_def456 e4f5g6h (main) — feat: add dark mode  — 5h ago
  dpl_ghi789 i7j8k9l (main) — chore: bump deps     — 1d ago

  Deploy:  dpl_abc12345
  Branch:  main
  Commit:  a1b2c3d
  URL:     https://my-app.vercel.app

? Confirm rollback to production? (y/N) y
Rolling back…
✓ Rollback triggered!
  Live at: https://my-app.vercel.app

CLI — Dev Mode

inariwatch dev is a local development companion. It catches errors from your dev server via the capture SDK, diagnoses them with AI, and applies fixes directly to your local files — no GitHub, no PR, no branch.

inariwatch dev

◉ INARIWATCH DEV

◉ Dev mode — my-app | Capture :9111 | Ctrl+C to stop
→ Errors from your dev server will be diagnosed and fixed locally.

  🔴 TypeError: Cannot read 'user' of undefined
     auth/session.ts:84
     💡 Known pattern (confidence: 92%) — add null check
     → Scanning project files... 142 files
     → Diagnosing... 92% confidence
     → Read 1 file(s): auth/session.ts
     → Generating fix... done
     → Self-reviewing... 88/100 (approve)

     Fix: session.user?.id ?? null

     Apply fix? yes
     ✓ Saved auth/session.ts
     ✓ Fix applied. Memory saved.

How it works: the capture server listens on localhost:9111 for errors from @inariwatch/capture. When an error arrives, InariWatch reads your local source files, generates a fix with AI, runs a self-review, and shows you the diff. You confirm with y and the fix is applied directly to disk.

Dev trains prod: every fix you apply locally is saved to the incident memory. When the same error appears in production, InariWatch already knows the pattern — resulting in higher confidence and faster auto-fix.

CLI — Cron Scheduler

The CLI includes a built-in cron scheduler that replaces external services like GitHub Actions for triggering InariWatch cloud endpoints. It runs inside the inariwatch watch loop and fires HTTP requests to your configured cron tasks at their defined intervals.

inariwatch add cron
# Prompts for:
#   Base URL:    https://app.inariwatch.com
#   Cron secret: your-cron-secret

Once configured, the watch loop automatically fires 4 default tasks:

Each request includes an Authorization: Bearer <secret> header. All cron endpoints verify this secret using constant-time comparison.

Integration — GitHub

InariWatch uses a GitHub Personal Access Token (classic or fine-grained) to monitor CI runs, PRs, and commits.

Getting a token

1. 1

   Go to GitHub → Settings → Developer settings → Personal access tokens

   github.com/settings/tokens
2. 2

   Create a new token (classic)

   Click Generate new token → Classic.
3. 3

   Select scopes

   Scope	Why
   repo	Read CI runs, PRs, and commits on private repos
   read:org	Read org membership (if monitoring an org)
   read:user	Identify the token owner for auto-detection

4. 4

   Copy the token

   The token starts with ghp_. Paste it into InariWatch.

What InariWatch monitors

Integration — Vercel

InariWatch monitors your Vercel deployments and can trigger instant rollbacks on production failures.

Getting a token

1. 1

   Open Vercel → Account Settings → Tokens

   vercel.com/account/tokens
2. 2

   Create a token

   Give it a name like inariwatch. No expiry is easiest for long-term monitoring.
3. 3

   (Optional) Find your Team ID

   Go to your Vercel team → Settings. The team ID is shown as team_.... Leave blank if you're on a personal account.

What InariWatch monitors

Integration — Sentry

InariWatch polls Sentry every 5 minutes for new issues and regressions in your projects.

Getting a token

1. 1

   Open Sentry → Settings → Auth Tokens

   sentry.io/settings/account/api/auth-tokens
2. 2

   Create an internal integration token

   Permission	Access
   Issues & Events	Read
   Project	Read
   Organization	Read

3. 3

   Find your org slug

   It's in the URL of your Sentry dashboard: sentry.io/organizations/my-org/

What InariWatch monitors

Integration — Uptime

Uptime monitoring checks your HTTP endpoints at every poll interval and alerts if they return a non-2xx status or respond slower than your threshold.

In the web dashboard, go to Integrations → Uptime → Configure and add your endpoints. Each endpoint has a URL and an optional response time threshold in milliseconds.

Integration — PostgreSQL

InariWatch connects to your PostgreSQL database and monitors for health issues without storing your data.

You only need a read-only connection string. InariWatch runs read-only diagnostic queries — it never writes to your database.

postgresql://user:password@host:5432/dbname?sslmode=require

CREATE USER inariwatch WITH PASSWORD 'your-password';
GRANT CONNECT ON DATABASE your_db TO inariwatch;
GRANT USAGE ON SCHEMA public TO inariwatch;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO inariwatch;

Integration — npm / Cargo

InariWatch audits your package.json or Cargo.toml for known vulnerabilities using the npm and RustSec advisory databases.

Provide a public URL to your manifest file. For private repos, use a raw GitHub URL with a Personal Access Token in the request (paste the full URL including auth).

# npm
https://raw.githubusercontent.com/my-org/my-app/main/package.json

# Cargo
https://raw.githubusercontent.com/my-org/my-app/main/Cargo.toml

Integration — Datadog

InariWatch receives alerts from Datadog monitors via webhooks. When your Datadog monitor triggers (log anomaly, infrastructure spike, APM error), InariWatch creates an alert and optionally runs AI remediation — bridging the gap between detection and resolution.

Getting your keys

1. 1

   Open Datadog → Organization Settings → API Keys

   app.datadoghq.com/organization-settings/api-keys
2. 2

   Copy your API Key

   This is your organization's API key. It starts with a hex string.
3. 3

   Create an Application Key

   Go to Application Keys tab and create a new key. Give it a name like inariwatch. Copy the key — it's only shown once.
4. 4

   Connect in InariWatch

   Go to Integrations → Datadog → Connect. Paste both keys. InariWatch validates your API key automatically.

Setting up the webhook

After connecting, InariWatch generates a unique Webhook URL for your project. You need to configure this URL in Datadog so monitors can send alerts to InariWatch.

1. 1

   Copy the Webhook URL from InariWatch

   It's shown under the Datadog integration card after connecting. Looks like: https://app.inariwatch.com/api/webhooks/datadog/your-integration-id
2. 2

   Open Datadog → Integrations → Webhooks

   app.datadoghq.com/integrations/webhooks
3. 3

   Create a new webhook

   Name it inariwatch, paste the Webhook URL, and leave the payload as the default JSON. Click Save.
4. 4

   Add the webhook to your monitors

   Edit any Datadog monitor → Notify your team section → type @webhook-inariwatch. Now that monitor will alert InariWatch when it fires.

What InariWatch receives

Integration — @inariwatch/capture

The @inariwatch/capture SDK captures errors, logs, and deploy markers from your app and sends them to InariWatch. Zero dependencies, zero config. Works as a standalone Sentry replacement or alongside your existing integrations.

Quick start (zero config)

npx @inariwatch/capture

Auto-detects your framework (Next.js, Express, Node.js), installs the SDK, and sets up instrumentation. If you have an InariWatch account, the CLI opens a browser to authorize and automatically writes INARIWATCH_DSN to your .env — no manual copy-paste.

1. 1

   Framework setup

   Detects Next.js, Express, or plain Node.js. Installs the package, modifies next.config.ts, and creates instrumentation.ts automatically.
2. 2

   Browser authorization

   Opens app.inariwatch.com/cli/verify in your browser. Click Authorize — takes 5 seconds.
3. 3

   DSN written automatically

   INARIWATCH_DSN is written to .env.local (or .env). No signup or dashboard visit required.

Next.js setup

One line in your existing config file:

import { withInariWatch } from "@inariwatch/capture/next"
export default withInariWatch(nextConfig)

And create instrumentation.ts:

import "@inariwatch/capture/auto"
import { captureRequestError } from "@inariwatch/capture"

export const onRequestError = captureRequestError

Any Node.js app

node --import @inariwatch/capture/auto app.js

Or in your package.json:

{ "scripts": { "start": "node --import @inariwatch/capture/auto src/index.js" } }

Environment variables

Config is driven by environment variables — no DSN in source code. Omit INARIWATCH_DSN for local mode (terminal output).

Substrate I/O recording

Capture every HTTP call, DB query, and file operation alongside your errors. When captureException() fires, the last 60 seconds of I/O are uploaded automatically.

npm install @inariwatch/substrate-agent

INARIWATCH_SUBSTRATE=true

Or programmatically:

init({ substrate: true })

API

Import paths

AI setup — Overview

Alert analysis and correlation work out of the box — no AI key required. InariWatch provides built-in AI for basic alert analysis so you get value from day one.

Adding your own AI key (Bring Your Own Key) unlocks advanced features:

• AI code remediation — writes the fix, pushes a branch, waits for CI, opens a PR
• Pre-deploy PR risk scoring (GitHub integration required)
• Auto post-mortems when an incident is resolved
• Ask Inari — chat with your live monitoring data

AI — Claude (Anthropic)

Claude is the recommended provider — InariWatch's AI features are tuned for Claude's output style.

1. 1

   Create an API key

   console.anthropic.com/settings/keys
2. 2

   Copy the key

   Starts with sk-ant-api03-...
3. 3

   Paste into InariWatch

   Settings → AI analysis → Add key → Select Claude.

inariwatch config --ai-key sk-ant-api03-... --model claude-sonnet-4-5-20251022

AI — OpenAI

1. 1

   Create an API key

   platform.openai.com/api-keys
2. 2

   Copy the key

   Starts with sk-proj-... (new format) or sk-... (legacy).
3. 3

   Paste into InariWatch

   Settings → AI analysis → Add key → Select OpenAI.

inariwatch config --ai-key sk-proj-... --model gpt-4o

AI — Grok (xAI)

1. 1

   Create an API key

   console.x.ai
2. 2

   Copy the key

   Starts with xai-...
3. 3

   Paste into InariWatch

   Settings → AI analysis → Add key → Select Grok.

inariwatch config --ai-key xai-... --model grok-beta

AI — DeepSeek

1. 1

   Create an API key

   platform.deepseek.com/api_keys
2. 2

   Copy the key

   Starts with sk-...
3. 3

   Paste into InariWatch

   Settings → AI analysis → Add key → Select DeepSeek.

inariwatch config --ai-key sk-... --model deepseek-chat

AI — Gemini (Google)

1. 1

   Create an API key

   aistudio.google.com/app/apikey
2. 2

   Copy the key

   Starts with AIza...
3. 3

   Paste into InariWatch

   Settings → AI analysis → Add key → Select Gemini.

inariwatch config --ai-key AIza... --model gemini-2.0-flash

Autonomous Mode — Auto-Remediate

When enabled, InariWatch automatically triggers the full AI remediation pipeline on critical alerts — no human click needed. The developer wakes up to: "We had an incident at 3 AM. It's already fixed."

1. 1

   Enable

   Project Settings → Auto-Merge → toggle Autonomous mode (amber).
2. 2

   Critical alert arrives

   AI diagnosis runs automatically, then the full pipeline: read code → generate fix → self-review → push → CI → PR.
3. 3

   Safety gates apply

   All 8 gates must pass for auto-merge. If any gate fails, a draft PR is created for manual review instead.

Autonomous mode suggestion

You don't need to enable autonomous mode manually. InariWatch watches your approval history and suggests it automatically when the data justifies the trust.

After each approved fix, InariWatch checks the last 30 days of remediation sessions for that project. If 5 or more sessions exist and the approval rate is ≥ 90%, a banner appears at the top of the project page:

Clicking Enable sets autoRemediate: true and clears the banner. Dismissing hides it permanently for that project. The suggestion never reappears once dismissed.

Auto-tune confidence threshold

The minimum confidence threshold (minConfidence) controls which AI fixes are eligible for auto-merge. InariWatch adjusts this threshold automatically based on your project's actual approval history — no manual tuning needed.

When auto-tune adjusts the threshold, the new value is shown in Project Settings → Auto-Merge next to the confidence input: Auto-tuned 70 → 65 · 3 days ago with a trend arrow.

Autonomous Mode — Auto-Heal

When your site goes down, InariWatch automatically rolls back to the last successful deploy and starts an AI fix in the background. Total downtime: ~90 seconds.

1. 1

   Enable

   Project Settings → Auto-Merge → toggle Auto-heal (red). Requires a Vercel integration for rollback.
2. 2

   Uptime detects failure

   3 consecutive ping failures (not just 1) confirm the site is down. Prevents false positives.
3. 3

   Rollback

   Automatically rolls back to the last successful Vercel deploy. Site is back online in ~30 seconds.
4. 4

   AI fix

   Remediation starts in background. When the fix is ready, a new deploy replaces the rollback with everything + the fix.
5. 5

   Cooldown

   10-minute cooldown between auto-heal triggers prevents loops if the issue is not code-related (DB down, DNS, etc.).

Autonomous Mode — Community Fixes

Every fix that gets approved is automatically and anonymously contributed to the community network. When a new error matches a known pattern, the fix appears instantly on the alert with its success rate — no AI generation needed.

Example: "47 teams hit this error. Fix success rate: 96% (44/46 deployments)."

Click Apply Community Fix to use the proven fix instead of generating a new one. The more teams use InariWatch, the faster everyone's errors get fixed. This is the network effect.

How auto-contribute works

1. 1

   Fix approved

   When you approve an AI-generated fix, it is automatically contributed to the network. No action required.
2. 2

   Anonymization

   All PII, secrets, API keys, IPs, URLs, and file contents are stripped before contribution. Only file paths, the fix approach, and confidence score are shared.
3. 3

   Deduplication

   If another team already contributed a fix for the same error fingerprint with the same approach, the success count is incremented instead of creating a duplicate.
4. 4

   Network effect

   As more teams use InariWatch, common framework errors accumulate high-confidence fixes. New errors skip AI generation entirely and resolve in seconds.

Slack Bot — Setup

The InariWatch Slack bot brings error monitoring, AI diagnosis, and auto-remediation directly into Slack. No more switching tabs — see errors, read the diagnosis, trigger fixes, and merge PRs without leaving your chat.

1. 1

   Install to Slack

   Go to Settings → Slack → click Install Slack Bot. Authorize InariWatch in your Slack workspace.
2. 2

   Map channels

   After installing, map each project to a Slack channel (e.g. api-service → #alerts-api). Alerts for that project will appear in the mapped channel.
3. 3

   Link your account

   In Slack, run /inariwatch link your@email.com to connect your Slack user to your InariWatch account. This enables interactive actions.

Slack Bot — Commands

Slack Bot — Fix from Slack

When an alert appears in Slack, click Fix It to trigger the full AI remediation pipeline. Progress updates appear as thread replies in real-time:

1. 1

   Analyzing repository

   The AI connects to your GitHub repo and reads the codebase.
2. 2

   Diagnosing root cause

   AI analyzes the error with context from Sentry, Vercel, Substrate recordings, and past fixes.
3. 3

   Generating fix

   Code changes are generated, self-reviewed, and pushed to a new branch.
4. 4

   Waiting for CI

   The bot waits for GitHub Actions to pass (retries up to 3 times on failure).
5. 5

   PR created

   A PR appears in the thread with confidence score and EAP verification. Click Approve & Merge to merge from Slack.

If Substrate is enabled, the recording (HTTP calls, DB queries, file operations) is automatically attached to the thread.

Slack Bot — Ask Inari

Mention @InariWatch in any channel or send a DM to ask questions about your errors:

@InariWatch what broke today?
@InariWatch why does the payment endpoint fail on Fridays?
@InariWatch summarize this week's incidents

If you ask in an alert thread, the AI automatically includes that alert's full context (stack trace, AI diagnosis, remediation history). Responses use your BYOK AI key from Settings.

Slack Bot — On-Call in Slack

When a critical alert arrives, the bot automatically tags the on-call engineer in the thread. Use /inariwatch oncall to see rotations and /inariwatch oncall swap @user to hand off.

Slack Bot — Deploy Monitoring

When a Vercel deploy succeeds, the bot posts a notification and monitors error rates for 15 minutes. After the monitoring window, it posts a follow-up: healthy or unhealthy with error count.

VS Code Extension — Setup

The InariWatch VS Code extension shows errors inline in your editor with AI diagnosis on hover. No need to open a dashboard — errors appear as squiggly lines right where the code is.

1. 1

   Install the extension

   Search for InariWatch in the VS Code marketplace, or install from the command line: code --install-extension inariwatch.inariwatch
2. 2

   Sign in

   Open the command palette and run InariWatch: Sign In. Paste your API token from Settings → API Keys.
3. 3

   Alerts appear

   Unresolved alerts from your projects appear as inline diagnostics, in the sidebar, and in the status bar.

VS Code Extension — Features

The extension polls the InariWatch API every 30 seconds (configurable) and supports real-time updates via SSE.

VS Code Extension — Local Mode

The extension can work without a cloud account. Set inariwatch.mode to local in VS Code settings. It runs a local server on port 9222 that receives errors directly from the capture SDK.

# Set your app's DSN to the local extension server
INARIWATCH_DSN=http://localhost:9222/ingest

Errors appear instantly in your editor. No account, no cloud, no signup.

Notifications — Telegram

Telegram is supported in both the CLI and the web dashboard. It's the fastest setup — no server, no webhook config.

1. 1

   Create a Telegram bot

   Open Telegram → search @BotFather → send /newbot. Copy the token it gives you.
2. 2

   Find your chat ID

   Send a message to your bot, then open: https://api.telegram.org/bot<TOKEN>/getUpdates. The chat.id field is your ID.
3. 3

   Connect in InariWatch

   Web: Settings → Notification channels → Telegram. CLI: inariwatch connect telegram.

inariwatch connect telegram
# Prompts for bot token and chat ID

Notifications — Email

Email delivery is handled by InariWatch — you just provide your address. Critical alerts are sent immediately; warning and info alerts are batched into a daily digest.

1. 1

   Go to Settings → Notification channels → Email

   Enter your email address and click Send verification.
2. 2

   Verify your address

   Click the link in the verification email. Alerts won't send until verified.
3. 3

   Set minimum severity (optional)

   You can filter to Critical only to reduce noise.

Notifications — Slack

1. 1

   Create an Incoming Webhook in Slack

   api.slack.com/apps → Create App → From scratch → Incoming Webhooks → Add new webhook to workspace.
2. 2

   Select a channel

   Choose the channel where alerts should appear (e.g. #incidents). Copy the webhook URL.
3. 3

   Paste into InariWatch

   Settings → Notification channels → Slack → paste the webhook URL.

Notifications — Push (browser)

Browser push sends OS-level notifications to your desktop or mobile browser — no app needed.

1. 1

   Go to Settings → Notification channels → Push

   Click Enable push notifications.
2. 2

   Allow browser permissions

   Your browser will prompt to allow notifications. Click Allow.
3. 3

   Done

   InariWatch will send a test notification immediately to confirm it works.

Notifications — On-Call Schedules

InariWatch allows you to configure timezone-aware daily on-call rotations for your team. Instead of paging the entire team with critical alerts, Escalation Rules can dynamically route the notification to the specific developer currently on-call.

1. 1

   Go to your Project → On-Call Schedule

   Click Add schedule and set your project's timezone.
2. 2

   Add members to slots

   Select a user and choose their day and hour ranges (e.g. Mon-Fri, 09:00-17:00).
3. 3

   Enable in Escalation Rules

   Escalation rules will automatically use the on-call schedule before falling back to fixed channels.

Notifications — Schedule Overrides

Schedule Overrides let you temporarily replace the on-call person without modifying the base rotation. Perfect for sick days, vacations, or emergencies.

1. 1

   Go to your Project → On-Call Schedule

   Find the schedule you want to override.
2. 2

   Click 'Add Override'

   Select the substitute user and choose a start and end date/time.
3. 3

   Done

   During the override window, the substitute receives all escalation notifications instead of the original on-call person.

Notifications — Incident Storm Control

When a major infrastructure failure occurs (e.g. database crash), dozens of monitors can trigger simultaneously. Without grouping, the on-call engineer gets 50 notifications in seconds — causing alert fatigue and panic.

Incident Storm Control detects when more than 5 alerts arrive for the same project within a 5-minute window. Instead of sending individual notifications, InariWatch groups them into a single "Incident Storm" message:

🚨 [INCIDENT STORM] 14 alerts detected in 5 min
Project: my-production-app

Likely a cascading failure.
Resolve the root cause — all grouped alerts will clear together.

Notifications — Interactive ACK

When InariWatch sends a critical alert to Telegram, the message includes interactive inline buttons that let you take action directly from your phone:

• 👁️ Acknowledge — Stops the escalation timer. Your team knows you're looking at it.
• ✅ Resolve — Marks the alert as resolved. No more follow-up notifications.

Desktop app — Setup & token

The InariWatch desktop app is a lightweight tray app that polls your account in the background and shows OS notifications — even when you're not in the browser.

1. 1

   Download the desktop app

   Download the installer for your OS from the releases page. Supports macOS, Windows, and Linux.
2. 2

   Generate a desktop token

   Go to Settings → Desktop app → Generate token. This creates a token starting with rdr_....
3. 3

   Add the token to the config file

   Create or edit ~/.config/inari/desktop.toml with the values below.
4. 4

   Start the app

   The tray icon appears (◉). Alerts will show as OS notifications. Click the icon to open the dashboard.

Desktop app — desktop.toml

api_url   = "https://inariwatch.com"
api_token = "rdr_your_token_here"

The app polls /api/desktop/alerts every 60 seconds using this token. Alerts are shown as OS notifications and marked as read in the dashboard.

Analytics

The Analytics page (/analytics) gives you a 14-day view of alert trends and a 30-day view of AI remediation performance. All metrics update in real time as alerts arrive and fixes are approved.

MTTR comparison

InariWatch tracks two resolution times separately:

When AI MTTR is at least 2× faster than human MTTR, a speedup banner appears: "AI resolves incidents 15× faster than manual review."

Cost savings

InariWatch estimates the engineering cost recovered by AI remediation using a simple formula:

hours_saved  = ai_resolved_alerts × (human_mttr − ai_mttr) / 3600
cost_saved   = hours_saved × $150 / hr

The $150/hr rate is a conservative industry average for senior engineering time. The card appears in the Response time comparison section and only renders when there is enough data to show a meaningful difference.

AI Remediation stats

Weekly Digest

Every Monday InariWatch sends a weekly summary to all active notification channels — email and Slack. The digest covers the last 7 days and includes an optional AI-generated commentary if you have an AI key configured.

What's included

Delivery channels

The digest is sent to every verified email channel and every active Slack channel mapping on your account. A user with both email and Slack configured receives both. Users with no alerts in the past 7 days are skipped.

Public API — Fix Marketplace

The Fix Marketplace API exposes the community fix database as a public, CORS-open REST API. No authentication required. Any tool can query it to look up fixes for known error patterns.

List fixes

GET /api/community/fixes
  ?category=runtime_error   # runtime_error | build_error | ci_error | infrastructure | unknown
  &framework=nextjs          # any framework string
  &language=typescript       # any language string
  &min_success_rate=70       # integer 0–100
  &sort=success_rate         # success_rate | occurrences | recent
  &limit=50                  # max 100
  &offset=0                  # pagination

{
  "fixes": [
    {
      "id": "uuid",
      "successRate": 94,
      "totalApplications": 47,
      "successCount": 44,
      "failureCount": 3,
      "fixApproach": "Wrap the async call in a try/catch and...",
      "fixDescription": "Unhandled promise rejection in middleware",
      "avgConfidence": 87,
      "createdAt": "2025-03-10T12:00:00Z",
      "pattern": {
        "id": "uuid",
        "fingerprint": "abc123",
        "patternText": "UnhandledPromiseRejection...",
        "category": "runtime_error",
        "framework": "nextjs",
        "language": "typescript",
        "occurrenceCount": 312
      }
    }
  ],
  "total": 150,
  "limit": 50,
  "offset": 0
}

Get a single fix

GET /api/community/fixes/uuid-of-fix

Returns the same shape as a list item, plus updatedAt and full pattern details.

Report outcome

After applying a fix, report whether it worked. This updates the community success rate so future teams benefit from your experience.

POST /api/community/fixes/uuid-of-fix/report
Content-Type: application/json

{ "worked": true }

{ "ok": true }

Public API — Status Widget

Embed a live status badge on any website — your landing page, README, or documentation. The badge shows current system status, optional uptime percentage, and links to your public status page.

Embed code

Place a div with a data-inariwatch-slug attribute wherever you want the badge to appear, then load the script once.

<div data-inariwatch-slug="your-project-slug"></div>
<script src="https://app.inariwatch.com/embed.js" async></script>

Alternatively, use the manual config for more control over the target element:

<div id="my-status"></div>
<script>
  window.__INARIWATCH__ = {
    slug: "your-project-slug",
    container: "#my-status"
  };
</script>
<script src="https://app.inariwatch.com/embed.js" async></script>

Appearance

The badge shows uptime percentage when uptime monitors are configured for the project (e.g. All Systems Operational · 99.8% uptime). Clicking the badge opens the full public status page. The widget polls for updates every 60 seconds automatically.

Data endpoint

The widget fetches from a lightweight CORS-open endpoint you can also use directly:

GET /api/status/your-project-slug/widget

{
  "status":          "operational",
  "label":           "All Systems Operational",
  "uptimePct":       99.8,
  "activeIncidents": 0,
  "slug":            "your-project-slug",
  "pageUrl":         "https://app.inariwatch.com/status/your-project-slug"
}

Reference — Alert types & severity

Deduplication

Before creating a new alert, InariWatch checks whether an open, unresolved alert with the same title already exists for the same project within the last 24 hours. If one does, the new alert is silently dropped — you won't get spammed by the same event.

To force a new alert (e.g. after resolving), mark the existing alert as Resolved first.

Reference — REST API

InariWatch exposes one public REST endpoint — used by the desktop app and any custom tooling.

GET /api/desktop/alerts

Returns the most recent unread alerts for the authenticated user.

GET /api/desktop/alerts
Authorization: Bearer rdr_your_token_here

{
  "alerts": [
    {
      "id":          "uuid",
      "title":       "CI failing on main",
      "severity":    "critical",
      "isResolved":  false,
      "createdAt":   "2025-03-17T03:12:00Z",
      "sourceIntegrations": ["github"]
    }
  ]
}