# EZO Watcher (npm · ezo-watcher)

Self-hosted monitoring your coding agent installs, proves and fixes. Alert wall, pager, MCP.

- Trust score: 68/100 (medium)
- Change this week: 0
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- npm · `ezo-watcher`: 68/100 (this document), [markdown](https://verifymcp.io/servers/ezolabs-ezo-watcher/ezo-watcher.md), [page](https://verifymcp.io/servers/ezolabs-ezo-watcher/ezo-watcher)

## Channel facts

- Registry: `npm`
- Package: `ezo-watcher`
- Version: `0.1.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 31 of 94 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 15 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 63/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4504 tokens (~281/item across 16 items; 16 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 16 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 17 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the EZO Watcher MCP server?

EZO Watcher runs locally as an npm package, launched with npx -y ezo-watcher mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add ezolabs-ezo-watcher -- npx -y ezo-watcher mcp
```

### Cursor

```json
{
  "mcpServers": {
    "ezolabs-ezo-watcher": {
      "command": "npx",
      "args": [
        "-y",
        "ezo-watcher",
        "mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "ezolabs-ezo-watcher": {
      "command": "npx",
      "args": [
        "-y",
        "ezo-watcher",
        "mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add ezolabs-ezo-watcher -- npx -y ezo-watcher mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ezolabs-ezo-watcher": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "ezo-watcher",
        "mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ezolabs-ezo-watcher --command npx --arg -y --arg ezo-watcher --arg mcp
```

### Hermes

```yaml
mcp_servers:
  ezolabs-ezo-watcher:
    command: "npx"
    args: ["-y", "ezo-watcher", "mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "ezolabs-ezo-watcher": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "ezo-watcher",
        "mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add ezolabs-ezo-watcher -t stdio -c npx -a -y ezo-watcher mcp
```

### Other

```json
{
  "mcpServers": {
    "ezolabs-ezo-watcher": {
      "command": "npx",
      "args": [
        "-y",
        "ezo-watcher",
        "mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-06 (score 68, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-05 (score 53)

First indexed and scored.

## MCP tools (16)

### `watch_state` (~166 tokens)

Wall summary

The EZO Watcher wall in one answer: how many incidents are firing (by severity, and by who has them: unattended, acknowledged, silenced), how many are parked (a fix or a verdict that is not due yet: not live, never paged, counted in no firing or unattended number), every incident as one row (key, title, severity, attention: none, acked, silenced or parked, who acknowledged or silenced it or why, by whom and until when it is parked, age, comment count, link), and the sources that have gone stale, are erroring, or are configured but not started on this host (`skipped`, with its reason). Start here. The incident `key` it returns is what every other tool takes.

### `list_incidents` (~286 tokens)

List incidents

Incidents, filtered. `state`: firing (default: every live incident, parked ones left out), unattended (firing, nobody has it, never a parked one), acknowledged, silenced, parked (a fix or a verdict that is not due yet: `parkedState`, `parkedUntil`, `parkedBy`, `parkedRef`, `parkedNote` say why, by whom and until when), resolved (episodes that ended in the last `hours`), or all (every incident, parked included). Filter by `severity`, `service` (substring) and `source` (the system that raised it: grafana, prod, sweep, netdata-cloud, ...). Resolved rows say whether a source resolved the incident or someone marked it resolved by hand, and who.

Input parameters:

- `hours` (integer): How far back resolved incidents reach (default 24, most 720: Watch keeps 30 days).
- `limit` (integer): How many rows at most (default 50, most 200).
- `service` (string): Only services whose name contains this, any case.
- `severity` (string): Only this severity.
- `source` (string): Only incidents raised by this source or system, exact name, any case.
- `state` (string): Which incidents. Default firing (live ones, parked left out).

### `get_incident` (~169 tokens)

One incident

One incident, whole: its alerts (rule, host, labels, annotations, value, who reports it and when it last did, evidence links and commands), who acknowledged, silenced and parked it, how it ended if it ended (a source, or someone by hand, and any confirmation), its history of acknowledgements, silences, reopens and resolves with who did each, every comment, and the pager's last sends. Works for a firing incident and for one that resolved in the last 30 days. Raw payloads are left out.

Input parameters:

- `key` (string, required): The incident key exactly as watch_state or list_incidents print it ("<service>|<rule>", or "<service>|<rule>|<instance>" for a rule split per instance). Not an alert key.

### `get_fix_context` (~253 tokens)

Everything needed to fix an incident

One structured brief for fixing an incident without asking a person: the incident (summary, severity, first and last seen, state and who has it), the source and target that raised it (their config, with every credential left as the env-var NAME and never a value), the predicates the rule cell asserts and which one the last run failed, `discovered.foundAt`/`read` (where the endpoint was found in the project and what was read there), the last good observation beside the last bad one (bodies cut), a `reproduce` block with the exact curl/nc/command that re-runs the check locally, the other open incidents on the same service, the evidence links the source offers (a Sentry permalink and culprit, a Netdata chart, Grafana panel links), and `next`: fix, restart/deploy, then verify_fix. Reads only; start here when you are about to fix something rather than triage it.

Input parameters:

- `key` (string, required): The incident key exactly as watch_state or list_incidents print it ("<service>|<rule>", or "<service>|<rule>|<instance>" for a rule split per instance). Not an alert key.

### `incident_history` (~216 tokens)

Incident history

What ended and what was done in a time range: every incident episode that resolved in it (when it started and ended, how long, who had it acknowledged, whether a source or someone by hand resolved it, any confirmation) and, newest first, the acknowledgements, silences, reopens and confirmations people and agents made, each with who. Give `from` and `to` as ISO times, or `hours` back from now (24 by default). Watch keeps 30 days.

Input parameters:

- `from` (string): ISO 8601 start of the range, for example 2026-10-14T00:00:00Z.
- `hours` (integer): Instead of from: this many hours before `to`. Default 24.
- `limit` (integer): How many rows at most (default 100, most 200).
- `service` (string): Only services whose name contains this, any case.
- `to` (string): ISO 8601 end of the range. Default now.

### `list_sources` (~167 tokens)

Sources

Every source this Watcher reads or is pushed by (Grafana, vmalert, Netdata Cloud and the fleet load poll, Sentry, the HTTP and TCP probes, heartbeat, domain expiry, the feeds, the webhooks): its kind, state (ok, error, stale, idle), when it last answered, the error if any, `skipped` when this host did not start it (`missing <ENV>`; absent on a source that runs), how many alerts it reports firing, how many rules it lists, how many of its cells assert more than a nominal 200 (`asserted`) and, where it records one, `discovered`: where its endpoint was found. A source that has gone quiet or was not started means an all clear is not earned.

### `acknowledge` (~253 tokens)

Acknowledge an incident

Say you are working this incident: it shows as acknowledged by you on the tile, in the sheet and in History, its age stops counting as unattended, and the pager stops escalating it. Acknowledge only while you are actively working the issue; it does not fix, hide or resolve anything, and a person can take it off. Re-acknowledging replaces the earlier name. Put what you found or did in a comment, not here: the optional note is one line of context.

Input parameters:

- `by` (string, required): Who is doing this, as "agent: <who>", for example "agent: claude in web-app". Required: it is shown on the tile, in the incident sheet and in History. "agent: " is added when left off. At most 64 cha…
- `key` (string, required): The incident key exactly as watch_state or list_incidents print it ("<service>|<rule>", or "<service>|<rule>|<instance>" for a rule split per instance). Not an alert key.
- `note` (string): A sentence of context, at most 500 characters: a fix commit, a PR, what you found. Longer findings go in a comment.

### `unacknowledge` (~209 tokens)

Take an acknowledgement off

Take the acknowledgement (and any silence) off a firing incident, so it counts as unattended again and the pager resumes. Use it when you stop working an issue you acknowledged and no one else has it. `by` is recorded: History shows who handed it back.

Input parameters:

- `by` (string, required): Who is doing this, as "agent: <who>", for example "agent: claude in web-app". Required: it is shown on the tile, in the incident sheet and in History. "agent: " is added when left off. At most 64 cha…
- `key` (string, required): The incident key exactly as watch_state or list_incidents print it ("<service>|<rule>", or "<service>|<rule>|<instance>" for a rule split per instance). Not an alert key.
- `note` (string): A sentence of context, at most 500 characters: a fix commit, a PR, what you found. Longer findings go in a comment.

### `silence` (~287 tokens)

Silence an incident for a while

Pause the pager for one firing incident, for at most 240 minutes (4 hours; more is refused, not shortened). It drops to the quiet tier of the wall and sends nothing until it runs out or someone takes it off. A silence hides a problem from the people who would act on it: use it only for something you know is expected right now (a deploy, a drill, a host you are rebooting), say why in `reason`, and never to make a real problem go quiet. If you are working the incident, acknowledge it instead.

Input parameters:

- `by` (string, required): Who is doing this, as "agent: <who>", for example "agent: claude in web-app". Required: it is shown on the tile, in the incident sheet and in History. "agent: " is added when left off. At most 64 cha…
- `key` (string, required): The incident key exactly as watch_state or list_incidents print it ("<service>|<rule>", or "<service>|<rule>|<instance>" for a rule split per instance). Not an alert key.
- `minutes` (integer, required): How long, in whole minutes, from 1 to 240 (4 hours).
- `reason` (string, required): Why it is expected or safe to pause this incident, at most 500 characters. Required: it is shown beside who silenced it.

### `park` (~664 tokens)

Park an incident after a fix or a verdict

Take a firing incident off the live wall into the Parked section, for at most 72 hours (more is refused, not shortened), once you have FIXED it or reached a VERDICT on it. `state`: fixed_undeployed (the fix is merged and not live yet), awaiting_source (the fix is live and the source's evaluation window has not caught up, so it still reports the alert), deferred (a person decided to handle it at a later date; the note says who and why). It works for any source, Grafana included. Unlike `resolve` it never reopens or pages while the park holds, and unlike `silence` it states a known cause: the tile reads "Parked until <time> by <you>" with your note, it counts as parked and not firing, and nothing is sent. It ends when the source resolves the alert, when `until` passes (the incident comes back unattended and its clock counts from `until`, so the pager treats it as a new problem), on `unpark`, or on a manual `resolve`; an acknowledgement or silence on the incident still wins over it, and a second park replaces the first. Park only after a fix or a verdict, never to hide a live problem you have not looked at or to quiet one you cannot explain. The park covers only the alerts firing when you park (get_incident lists their keys in `park.alertKeys`): an alert that joins the incident later (another host or instance, a new rule on it) ends the park at once, the incident comes back unattended and pages as a new problem, and History says which alert joined. An alert that resolves and fires again keeps the park.

Input parameters:

- `by` (string, required): Who is doing this, as "agent: <who>", for example "agent: claude in web-app". Required: it is shown on the tile, in the incident sheet and in History. "agent: " is added when left off. At most 64 cha…
- `key` (string, required): The incident key exactly as watch_state or list_incidents print it ("<service>|<rule>", or "<service>|<rule>|<instance>" for a rule split per instance). Not an alert key.
- `note` (string, required): Why it is parked: what you fixed or decided and how you know, at most 500 characters. Required: it is shown on the tile and in the sheet beside your name.
- `ref` (string): A ticket, PR or commit that explains the park, one line, at most 64 characters.
- `state` (string, required): Why it is parked: fixed_undeployed (the fix is merged, not live yet), awaiting_source (the fix is live, the source has not caught up), or deferred (handled at a later date).
- `until` (string, required): When the park ends: an ISO 8601 time with a zone (Z or an offset), for example 2026-10-17T04:00:00Z, after now and at most 72 hours from now. More is refused, not shortened: the refusal names the lat…

### `unpark` (~258 tokens)

End a park now

End a park set by hand with `park` before it runs out: the incident is back in its severity tier, unattended and paging as a new problem would, with its clock starting now. Use it when the fix did not hold or the verdict was wrong. `by` is recorded: History shows who ended it. Refused for an incident that is not firing, one that was not parked by hand (a park the regression sweep states ends when the sweep stops stating it), and one whose park has already ended.

Input parameters:

- `by` (string, required): Who is doing this, as "agent: <who>", for example "agent: claude in web-app". Required: it is shown on the tile, in the incident sheet and in History. "agent: " is added when left off. At most 64 cha…
- `key` (string, required): The incident key exactly as watch_state or list_incidents print it ("<service>|<rule>", or "<service>|<rule>|<instance>" for a rule split per instance). Not an alert key.
- `note` (string): A sentence of context, at most 500 characters: a fix commit, a PR, what you found. Longer findings go in a comment.

### `comment` (~230 tokens)

Comment on an incident

Add a comment to an incident, firing or resolved: what you found, a link, the commit that fixes it, what you ruled out. Markdown, at most 4000 characters (longer is refused, not cut). It is stored on the incident and shows in the incident sheet with your name and the time, and every one is written to the operator log. Comment as you learn things; a comment is the right place for findings, links and fix commits.

Input parameters:

- `by` (string, required): Who is doing this, as "agent: <who>", for example "agent: claude in web-app". Required: it is shown on the tile, in the incident sheet and in History. "agent: " is added when left off. At most 64 cha…
- `key` (string, required): The incident key exactly as watch_state or list_incidents print it ("<service>|<rule>", or "<service>|<rule>|<instance>" for a rule split per instance). Not an alert key.
- `text` (string, required): The comment, markdown, at most 4000 characters.

### `recheck` (~359 tokens)

Re-check now

Ask the sources again instead of waiting for the next poll: with `incident` (an incident key), re-polls the sources that report its alerts and answers what each alert is now; with `alert` (an alert key such as grafana:1a2b3c4d), the same for one alert; with neither, re-polls every pull source and says how many alerts cleared. At most one poll per source every 10 seconds, so a repeat inside it is answered from the last poll. A pushing sender that takes requests (the regression sweep) is asked to run the check again: each firing alert it reports gets one request, an alert that already has an open one reuses it, and the answer's `pushed[].request` says where it stands (asked, picked up, waiting, ran, failed, cannot, or not picked up within 30 min); a repeat while it is open returns the same request, so it only reads where it stands. Any other pushing sender (webhooks) cannot be forced: the answer says when it last reported, when it reports next if it said, and when the alert clears if it stops sending it. It changes no alert except by the sources' own answers.

Input parameters:

- `alert` (string): An alert key, "<origin>:<8 hex>".
- `by` (string, required): Who is doing this, as "agent: <who>", for example "agent: claude in web-app". Required: it is shown on the tile, in the incident sheet and in History. "agent: " is added when left off. At most 64 cha…
- `incident` (string): An incident key: re-check the alerts that make it up.

### `verify_fix` (~325 tokens)

Verify a fix and close the incident

Close the fix loop: re-check the sources now, wait up to `timeoutSec` seconds for the source's fresh observation, and answer { resolved, observation, asserts }. When every alert of the incident is resolved by its source, it records the confirmation (the existing confirm_resolution path) with the note "verified by agent", so History reads "resolution confirmed by <you>" and the incident closes with the attribution. When the source still reports an alert firing it resolves nothing and says which assertion failed and why, so the fix can be repaired rather than guessed at. Never resolves an alert itself: only the source (or a person's resolve) ends an alert. Idempotent: after a green answer a repeat reads the resolved episode and records at most another confirmation.

Input parameters:

- `by` (string, required): Who is doing this, as "agent: <who>", for example "agent: claude in web-app". Required: it is shown on the tile, in the incident sheet and in History. "agent: " is added when left off. At most 64 cha…
- `key` (string, required): The incident key exactly as watch_state or list_incidents print it ("<service>|<rule>", or "<service>|<rule>|<instance>" for a rule split per instance). Not an alert key.
- `timeoutSec` (integer): How long to wait for the source to answer, in seconds (5 to 300; default 60). Each round re-checks the sources no faster than once every 10 seconds, so a shorter wait makes fewer rounds.

### `resolve` (~307 tokens)

Mark an incident resolved by hand

Mark a firing incident resolved now, with a required reason, when you have fixed it and the source has not caught up (a push source repeats only every few hours). It leaves the wall, History records "marked resolved by <you>" with your reason, and the operator log records the write. It does not hide a live problem: if the source reports the alert as firing on its next poll or push, Watch reopens the incident as a NEW firing (unacknowledged, escalating, paging again) and records "reopened: source still firing after manual resolve by <you>". A manual resolve ends any acknowledgement or silence on the incident. You can never resolve, delete or edit an alert itself: only its source resolves alerts. After the source resolves, use confirm_resolution to record that you checked.

Input parameters:

- `by` (string, required): Who is doing this, as "agent: <who>", for example "agent: claude in web-app". Required: it is shown on the tile, in the incident sheet and in History. "agent: " is added when left off. At most 64 cha…
- `key` (string, required): The incident key exactly as watch_state or list_incidents print it ("<service>|<rule>", or "<service>|<rule>|<instance>" for a rule split per instance). Not an alert key.
- `reason` (string, required): Why it is resolved: what you changed and how you know, at most 500 characters. Required.

### `confirm_resolution` (~255 tokens)

Confirm an incident is resolved

Record that an incident a source has already resolved is resolved: "resolution confirmed by <you>", with an optional note (the fix commit, the PR, an evidence link). It shows in the sheet and in History, and the operator log records the write. It changes no state, so it cannot hide anything: use it after you checked that the fix held. Refused for an incident that is firing, one that never resolved, and one that was marked resolved by hand while a source still reports it.

Input parameters:

- `by` (string, required): Who is doing this, as "agent: <who>", for example "agent: claude in web-app". Required: it is shown on the tile, in the incident sheet and in History. "agent: " is added when left off. At most 64 cha…
- `key` (string, required): The incident key exactly as watch_state or list_incidents print it ("<service>|<rule>", or "<service>|<rule>|<instance>" for a rule split per instance). Not an alert key.
- `note` (string): A sentence of context, at most 500 characters: a fix commit, a PR, what you found. Longer findings go in a comment.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/ezolabs-ezo-watcher/ezo-watcher#diagnostics

## Score history

- 2026-11-21: 68
- 2026-11-20: 68
- 2026-11-19: 68
- 2026-11-18: 68
- 2026-11-17: 68
- 2026-11-16: 68
- 2026-11-15: 68
- 2026-11-14: 68
- 2026-11-13: 68
- 2026-11-12: 68
- 2026-11-11: 68
- 2026-11-10: 68
- 2026-11-09: 68
- 2026-11-08: 68
- 2026-11-07: 68
- 2026-11-06: 68
- 2026-11-05: 53

## Common questions

### What is the EZO Watcher MCP server?

EZO Watcher is an MCP server listed in the public MCP registry as io.github.ezolabs/ezo-watcher. Self-hosted monitoring your coding agent installs, proves and fixes. Alert wall, pager, MCP. This page covers its npm package (ezo-watcher).

### Is the EZO Watcher MCP server safe to use?

EZO Watcher scores 68 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the EZO Watcher MCP server expose?

EZO Watcher exposes 16 tools: watch_state, list_incidents, get_incident, get_fix_context, incident_history, and 11 more. Their descriptions and schemas cost roughly 4,404 tokens of context every time the server is loaded.

### Is the EZO Watcher MCP server still maintained?

EZO Watcher is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the EZO Watcher MCP server under?

EZO Watcher declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the EZO Watcher MCP server?

VerifyMCP ran 15 checks on EZO Watcher, covering Malware scan, Known CVEs, Install scripts, Dependency health and 11 more. One item could not be completed, a gap on our side rather than a finding about EZO Watcher: Stability. One category scores 0 for that reason, because we only credit what we can confirm. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/ezo-watcher
- Socket report: https://socket.dev/npm/package/ezo-watcher
- Repository: https://github.com/ezolabs/ezo-watcher
- Website: https://ezo-watcher-demo.pages.dev/
- Changelog RSS feed: https://verifymcp.io/servers/ezolabs-ezo-watcher/ezo-watcher.xml
- Changelog JSON feed: https://verifymcp.io/servers/ezolabs-ezo-watcher/ezo-watcher/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/ezolabs-ezo-watcher/ezo-watcher.json
- HTML version of this page: https://verifymcp.io/servers/ezolabs-ezo-watcher/ezo-watcher
