Skip to content

Open-source status page, incident response and uptime monitoring

chore: blog from clickops to chatops (#2157)

Maximilian Kaske478137dbb38e
diff --git a/apps/web/public/assets/posts/from-clickops-to-chatops/chat-assistant.png b/apps/web/public/assets/posts/from-clickops-to-chatops/chat-assistant.png
new file mode 100644
index 000000000..7e1b6d914
Binary files /dev/null and b/apps/web/public/assets/posts/from-clickops-to-chatops/chat-assistant.png differ
diff --git a/apps/web/public/assets/posts/from-clickops-to-chatops/chat-confirm-box.png b/apps/web/public/assets/posts/from-clickops-to-chatops/chat-confirm-box.png
new file mode 100644
index 000000000..cee39dd5a
Binary files /dev/null and b/apps/web/public/assets/posts/from-clickops-to-chatops/chat-confirm-box.png differ
diff --git a/apps/web/public/assets/posts/from-clickops-to-chatops/chat-tool-list-response-logs.png b/apps/web/public/assets/posts/from-clickops-to-chatops/chat-tool-list-response-logs.png
new file mode 100644
index 000000000..a65001969
Binary files /dev/null and b/apps/web/public/assets/posts/from-clickops-to-chatops/chat-tool-list-response-logs.png differ
diff --git a/apps/web/public/assets/posts/from-clickops-to-chatops/chat-tool-part-collapsed.png b/apps/web/public/assets/posts/from-clickops-to-chatops/chat-tool-part-collapsed.png
new file mode 100644
index 000000000..8cf3d3fda
Binary files /dev/null and b/apps/web/public/assets/posts/from-clickops-to-chatops/chat-tool-part-collapsed.png differ
diff --git a/apps/web/public/assets/posts/from-clickops-to-chatops/chat-tool-part-raw.png b/apps/web/public/assets/posts/from-clickops-to-chatops/chat-tool-part-raw.png
new file mode 100644
index 000000000..17ff211fb
Binary files /dev/null and b/apps/web/public/assets/posts/from-clickops-to-chatops/chat-tool-part-raw.png differ
diff --git a/apps/web/public/assets/posts/from-clickops-to-chatops/chat-tool-part-rich.png b/apps/web/public/assets/posts/from-clickops-to-chatops/chat-tool-part-rich.png
new file mode 100644
index 000000000..1f0d594de
Binary files /dev/null and b/apps/web/public/assets/posts/from-clickops-to-chatops/chat-tool-part-rich.png differ
diff --git a/apps/web/public/assets/posts/from-clickops-to-chatops/chatops.png b/apps/web/public/assets/posts/from-clickops-to-chatops/chatops.png
new file mode 100644
index 000000000..eb40cce34
Binary files /dev/null and b/apps/web/public/assets/posts/from-clickops-to-chatops/chatops.png differ
diff --git a/apps/web/src/content/pages/blog/from-clickops-to-chatops.mdx b/apps/web/src/content/pages/blog/from-clickops-to-chatops.mdx
new file mode 100644
index 000000000..4cbb2b4ec
--- /dev/null
+++ b/apps/web/src/content/pages/blog/from-clickops-to-chatops.mdx
@@ -0,0 +1,175 @@
+---
+title: "From ClickOps to ChatOps"
+description: "Stop clicking. Start chatting. The new openstatus AI chat turns the dashboard into a conversation — with pretty tool cards and an MCP server for your own agents."
+author: "Maximilian Kaske"
+publishedAt: "2026-05-15"
+category: "engineering"
+image: "/assets/posts/from-clickops-to-chatops/chatops.png"
+---
+
+Dashboards are great until you've clicked the same four buttons thirty times this week. The job was always _"tell me which monitors are flaky"_ — not _"navigate three nested tabs to find out"_. So we did the obvious-in-2026 thing: we glued an LLM to our existing service layer and called it Assistant.
+
+It lives at `/chat` in the dashboard. Type. Hit enter. Watch openstatus assistant do the clicking.
+
+Or anywhere else you already chat — the same tools are exposed over [MCP](/tooling/mcp-server), so you can drive openstatus from [Claude Desktop](/guides/connect-openstatus-to-claude-desktop), [Claude Code](/guides/connect-openstatus-to-claude-code), Cursor, ChatGPT, or any other MCP-compatible client. One tool registry, two front doors.
+
+> **PS:** if you're allergic to clicking _and_ chatting, we also have [Terraform](/tooling/terraform) for full GitOps. ClickOps · ChatOps · GitOps — the trifecta is complete.
+
+## The pitch, in one paragraph
+
+Assistant sits on top of the same service verbs that already power the dashboard, the [API](/tooling/api), and the [MCP server](/tooling/mcp-server). Same workspace scoping. Same [audit log](/blog/audit-humans-and-agents). Same read/write scopes. Just… a chat box. You're not bypassing the product — you're driving it from the passenger seat.
+
+<Image
+ alt="openstatus assistant at /chat showing a conversation with tool calls"
+ src="/assets/posts/from-clickops-to-chatops/chat-assistant.png"
+ width={1600}
+ height={900}
+/>
+
+## What you can ask it
+
+Type the question, watch the tool calls roll in.
+
+- _"Which monitors degraded in the last hour?"_
+- _"Show me the recent response logs for the checkout monitor."_
+- _"Create an incident on the public status page — checkout API is throwing 502s."_
+- _"Resolve it."_
+- _"Schedule maintenance Sunday 02:00–04:00 UTC for the API monitor."_
+
+<Image
+ alt="list_response_logs rendered as a table in chat, with timestamps, regions, status codes, and latencies"
+ src="/assets/posts/from-clickops-to-chatops/chat-tool-list-response-logs.png"
+ width={1200}
+ height={700}
+/>
+
+The model has context for your workspace — your monitors, your status pages, your notifications — so you don't have to feed it IDs. Speak in nouns; the agent figures out the verbs.
+
+## The toolbox
+
+There are seventeen tools today, split into two camps.
+
+**Read tools** fire immediately. No approval needed — they only ever query.
+
+- `list_status_pages` · `list_status_reports` · `list_maintenances`
+- `list_monitors` · `list_notifications` · `list_response_logs` · `list_audit_logs`
+- `get_monitor` · `get_monitor_status` · `get_monitor_summary` · `get_response_log` · `get_audit_log`
+
+**Write tools** always pause on a human-in-the-loop approval card before touching the database.
+
+- `create_status_report` · `add_status_report_update` · `update_status_report` · `resolve_status_report`
+- `create_maintenance`
+
+All seventeen are declared once in `@openstatus/services/agent-tools`. The same registry powers the chat UI **and** the MCP server — shape-equivalence tests keep them honest. We'll add more (notification CRUD, monitor mutations, status-page editing) as we go.
+
+## The pretty part — how a tool call renders
+
+This is the bit we obsessed over.
+
+Every tool call is a collapsible card with three things happening at once.
+
+### 1. A status dot
+
+It pulses while the model is thinking, turns green on success, amber while waiting on your approval, red on error, grey when you've cancelled it.
+
+### 2. A one-line summary
+
+So you skim the conversation instead of reading JSON.
+
+<Image
+ alt="Collapsed list_monitors tool card with a green pulse dot and a one-line summary"
+ src="/assets/posts/from-clickops-to-chatops/chat-tool-part-collapsed.png"
+ width={900}
+ height={120}
+/>
+
+`list_monitors · 12 results`. `get_monitor_summary · 4322 checks · p95 184ms`. `create_status_report · ID 4711`. The summary is per-tool, hand-tuned, optimised for "what would I want to see if I were scrolling past this".
+
+### 3. A rich-vs-raw view toggle
+
+Click the card open and you get two tabs.
+
+The **Rich** tab renders the result as a real React table — the same `ResultTable`, `DetailsTable`, and `ChangesTable` primitives the dashboard uses everywhere else. A monitor row in chat looks similar to a monitor row on the monitors page.
+
+The **Raw** tab shows you the JSON `Parameters` (what the model sent) and `Result` (what it got back). For when you don't trust the pretty version. Or when you're debugging the tool itself. Or when you just want to see what's really under there.
+
+<Grid cols={2}>
+<div>
+
+<Image
+ alt="Expanded list_monitors card in Rich view, rendering monitor rows in a ResultTable"
+ src="/assets/posts/from-clickops-to-chatops/chat-tool-part-rich.png"
+ width={1200}
+ height={600}
+/>
+
+</div>
+<div>
+
+<Image
+ alt="Same list_monitors card in Raw view, showing JSON Parameters and Result blocks"
+ src="/assets/posts/from-clickops-to-chatops/chat-tool-part-raw.png"
+ width={1200}
+ height={600}
+/>
+
+</div>
+</Grid>
+
+We default to Rich. The toggle remembers itself for the next card.
+
+## Human-in-the-loop, but make it keyboard
+
+Every write tool pauses on an **approval card** before committing anything.
+
+The card shows you the change as a _diff_ — not a wall of JSON. Title, status, target page, message: each one a row, each one auditable in your head before you commit. ⌘↵ to apply. Esc to cancel. Or click the buttons if you're a mouse person, we won't judge.
+
+If you cancel, the card writes an `output-denied` part into the transcript with your reason. The model sees it, apologises (sometimes), tries again.
+
+If you approve, the same diff stays in the conversation as the receipt — except now with the new `id` and `createdAt` filled in.
+
+The AI cannot publish anything without explicit human approval. Same pattern as our [Slack agent](/blog/openstatus-slack-agent) — it's earned its keep there, and we're glad to lean on it again.
+
+<Image
+ alt="Approval card for create_status_report with a diff of fields and ⌘↵ / Esc keyboard hints"
+ src="/assets/posts/from-clickops-to-chatops/chat-confirm-box.png"
+ width={1100}
+ height={700}
+/>
+
+## Under the hood
+
+For the engineers in the room — here's the stack.
+
+**Vercel AI SDK** runs the agent loop. We use Claude Sonnet by default; tool parts stream into the UI as they go, so you see the status dot pulse and the summary fill in live.
+
+**One tool registry, two frontends.** Every tool lives in `packages/services/src/agent-tools/`. Each entry has a Zod schema, a service-verb call, and a `scope: 'read' | 'write'` flag. The chat UI consumes the registry over Next.js Edge tRPC. The MCP server consumes the same registry over HTTP. A shape-equivalence test suite asserts that both surfaces see the same inputs and outputs.
+
+**Edge-safe by construction.** All service code avoids `node:*` imports, because the same verbs run on Next.js Edge and on our Hono backend. No "works locally, breaks in production" surprises.
+
+**RBAC scopes.** Read-only API keys see only read tools. Write tools refuse to register for them — not "they see them and 403", they _don't exist in `tools/list`_. Same `requireScope('write')` guard that already gates the V1 API.
+
+**Audit log.** Every successful mutation emits an `audit_log` row inside the same transaction as the write. Your AI sidekick leaves footprints. So do you.
+
+**Per-tool renderers are typed.** The renderer registry in `tool-renderers/index.tsx` is keyed by the `AgentToolName` union — adding a tool to the agent without a matching renderer is a TypeScript error. No silent JSON fallbacks ship to prod by accident.
+
+## Bring your own agent
+
+Don't like our chat UI? That's fine. The exact same tools are exposed over [MCP](/tooling/mcp-server) at `https://api.openstatus.dev/mcp`. Same scope rules. Same audit log. Same shape-equivalence tests keeping it honest.
+
+Step-by-step setup guides:
+
+- [Connect openstatus to Claude Desktop](/guides/connect-openstatus-to-claude-desktop)
+- [Connect openstatus to Claude Code](/guides/connect-openstatus-to-claude-code)
+
+Anything else that speaks MCP — Cursor, ChatGPT custom connectors, Zed, LangChain, your own rig — works the same way.
+
+The chat UI is the reference frontend. The agent layer is the product.
+
+## Try it
+
+Open the dashboard → **Assistant** in the sidebar. Ask it something obvious first (_"list my monitors"_). Then ask it something you'd normally have to click for.
+
+The dashboard you already pay for, now with a mouth. We think you'll like it.
+
+_Try the assistant from your [openstatus dashboard](https://app.openstatus.dev?ref=blog-clickops-to-chatops) — and tell us what you broke._
diff --git a/apps/web/src/content/pages/product/tooling/mcp-server.mdx b/apps/web/src/content/pages/product/tooling/mcp-server.mdx
index ac04edefb..1c7ae3672 100644
--- a/apps/web/src/content/pages/product/tooling/mcp-server.mdx
+++ b/apps/web/src/content/pages/product/tooling/mcp-server.mdx
@@ -6,16 +6,16 @@ description: "Connect Claude, ChatGPT, Cursor, and any other Model Context Proto
category: "Product"
faq:
- question: "What does the MCP server let an assistant do?"
- answer: "The MCP server exposes 8 tools scoped to your workspace: list status pages, list and create status reports, append updates, resolve reports, edit metadata, and schedule maintenance windows. Every mutation writes to the audit log and the assistant must explicitly confirm whether to notify subscribers."
+ answer: "The MCP server exposes 17 read and write tools scoped to your workspace: list status pages, monitors, response logs, notifications, and audit logs; inspect a single monitor or response log; create, update, and resolve status reports; schedule maintenance windows. Every mutation writes to the audit log, and publishing tools require an explicit notify decision."
- question: "Are skills different from the MCP server?"
answer: "Skills are prompt and command bundles installed into your local agent (Claude Code, etc.) that wrap the openstatus CLI. The MCP server is a remote endpoint that any MCP-compatible client can connect to. Skills are great for terminal-shaped workflows; MCP is great for chat-shaped workflows."
- question: "Do I need a separate MCP credential?"
answer: "No. We don't implement the MCP OAuth flow — there's no consent screen and no extra credential to manage. Authentication is the x-openstatus-key header, the same key the CLI, API, and Terraform use."
- question: "Can the assistant accidentally notify subscribers?"
- answer: "No. Every mutation tool requires the assistant to set notify: true | false explicitly. Models can't quietly fan out an alert by omitting the flag — and every call lands in the audit log under actor_type = 'mcp' so you can see exactly what happened."
+ answer: "No. Every publishing tool requires the assistant to set notify: true | false explicitly — there's no default. Metadata-only edits like update_status_report can't notify at all. Every call lands in the audit log under actor_type = 'mcp', so you can see exactly what happened."
---
-The openstatus MCP server connects Claude Desktop, ChatGPT, Cursor, and any other [Model Context Protocol](https://modelcontextprotocol.io) client to your workspace — so an AI assistant can read and update status pages, status reports, and maintenance windows directly from a conversation.
+The openstatus MCP server connects Claude Desktop, ChatGPT, Cursor, and any other [Model Context Protocol](https://modelcontextprotocol.io) client to your workspace — so an AI assistant can read monitors, response logs, and audit history, and drive status pages, status reports, and maintenance windows directly from a conversation.
## Quickstart
@@ -37,25 +37,32 @@ Drop the snippet into your client's MCP config (`claude_desktop_config.json`, Cu
## What you can do
-The server exposes **8 tools** scoped to your workspace:
+The server exposes **17 tools** scoped to your workspace, grouped by entity:
-- `list_status_pages` — discover the pages your assistant can act on.
-- `list_status_reports` / `create_status_report` — read and post incidents.
-- `append_status_report_update` / `resolve_status_report` — drive an incident through its lifecycle.
-- `update_status_report` — edit metadata after the fact.
-- `create_maintenance` / `update_maintenance` — schedule and adjust planned downtime.
+- **Status pages** — `list_status_pages`
+- **Status reports** — `list_status_reports` · `create_status_report` · `add_status_report_update` · `update_status_report` · `resolve_status_report`
+- **Maintenance** — `list_maintenances` · `create_maintenance`
+- **Monitors** — `list_monitors` · `get_monitor` · `get_monitor_status` · `get_monitor_summary`
+- **Response logs** — `list_response_logs` · `get_response_log`
+- **Notifications** — `list_notifications`
+- **Audit log** *(workspaces on the audit-log plan only)* — `list_audit_logs` · `get_audit_log`
-Every mutation tool requires `notify: true | false` — the assistant must explicitly choose whether to notify subscribers, so an LLM cannot quietly fan out an alert.
+The four **publishing** tools (`create_status_report`, `add_status_report_update`, `resolve_status_report`, `create_maintenance`) require `notify: true | false` — the assistant must explicitly choose whether to notify subscribers, so an LLM cannot quietly fan out an alert. `update_status_report` is metadata-only and cannot notify.
-## Auth & audit
+The same tool registry powers the [in-app assistant](/blog/from-clickops-to-chatops) — every tool you see in `/chat` is the same tool you call over MCP, kept in sync by shape-equivalence tests.
+
+## Auth & scopes
Authentication is the `x-openstatus-key` header — the same API key the CLI, API, and Terraform use. We don't implement the MCP OAuth flow: no separate credential to manage, no consent screen, just one key from **Settings → API Tokens**.
+API keys carry a `read` or `write` scope. Read-only keys never see write tools in `tools/list` — they don't exist for that session. Write tools throw a clean error if a read-only key somehow attempts them.
+
Every mutation lands in the audit log under `actor_type = 'mcp'`, so you can trace any change back to a key, a user, and a transport.
## Other surfaces
-- Want a terminal interface for AI agents (Claude Code, etc.) instead of chat? See [skills](/tooling/cli#ai-skills) on the CLI page.
+- Want chat inside the dashboard instead of an external client? See the [in-app assistant](/blog/from-clickops-to-chatops).
+- Want a terminal interface for AI agents (Claude Code, etc.)? See [skills](/tooling/cli#ai-skills) on the CLI page.
- Building an in-app integration? Call the [API](/tooling/api) directly.
- Want Slack instead of Claude or ChatGPT? See the [Slack agent](/status-page#slack-agent).