openclaw-health-mcp
openclaw-health-mcp is an MCP server providing a single-tool, read-only health snapshot of AI agent deployments (especially OpenClaw), surfacing infrastructure-layer metrics directly to MCP-aware clients like Claude Desktop, Cline, or Continue.
Core tool: health_overview
Returns an overall HEALTHY/DEGRADED/CRITICAL/UNKNOWN rollup with per-component breakdowns and ranked critical findings across all subsystems.
Key capabilities:
Gateway status: Checks if the OpenClaw gateway process is alive, its uptime, restart count (distinguishing intentional vs. crashes), PID, and flags dangerous
0.0.0.0bind address misconfigurations.CPU, memory & swap health: Reports current usage percentages, load averages, and 24h kernel OOM-kill count, with CRITICAL flagging when OOM conditions are imminent or have occurred.
Recent error logs: Fetches log entries from gateway, skills, and cron, filterable by lookback window (up to 168h) and minimum severity (debug → critical).
Skill registry integrity: Audits total skills, recently added/modified skills, skills with external HTTP endpoints, and applies heuristic flags for suspicious behavior (e.g., possible exfiltration patterns).
Last upgrade status: Shows from/to versions, outcome (success/rollback/failure/in_progress), post-upgrade regression markers (e.g.,
websocket_stalls,cpu_spike), and available upstream version.Cron job health: Summarizes total jobs, overdue count, and 24h success rate; recommends
silentwatch-mcpfor richer silent-failure detection.Disk usage: Reports root-disk usage%, log-directory size, 24h growth, and largest log files, with DEGRADED (>85%) and CRITICAL (>95%) thresholds.
Additional features:
Resources: Static endpoints
health://overview,health://gateway, andhealth://resourcesfor targeted queries.Diagnostic prompts:
diagnose-degraded-healthfor guided troubleshooting andsummarize-health-trendfor operational digests.Multiple backends:
mock(default, for quick verification),linux-proc(system metrics on Linux/macOS/Windows), andopenclaw(OpenClaw-specific parsing, planned for v1.1).Composable: Pairs with
silentwatch-mcp(cron silent-failure detection) and plannedopenclaw-skill-vetter-mcp(deep skill analysis).
openclaw-health-mcp
MCP server for AI agent deployment health — gateway status, CPU/RAM/swap, recent errors from journalctl/dmesg, skill-registry integrity, upgrade outcomes, cron + disk usage in a single tool call. Each component gets a HEALTHY/DEGRADED/CRITICAL classification, with overall rollup + ranked critical findings. Linux-proc backend works on any Linux/macOS/Windows host; OpenClaw operators get native
~/.openclaw/parsing as a built-in reference implementation. Keywords: AI agent health, production AI monitoring, deployment readiness, MCP infrastructure observability.
What it does
Anyone running production AI agents needs a single tool that answers "is this deployment healthy right now?" without SSH'ing in to run six separate commands. The HN front-page thread Ask HN: How are you monitoring AI agents in production? (March 2026) made the gap explicit — the most-upvoted comments described:
"observability and governance cannot live inside the agent framework. They have to live in an independent execution layer" — the framework-level monitoring leaks audit trail when teams use multiple frameworks
"agent makes 10,000 correct $0.02 decisions that collectively don't make sense" — per-call rate limits miss systemic patterns
The gap that "actually hurts during post-mortems" — knowing whether a model drifted, context window failed, or tool misbehaved
Existing options (LangSmith, Langfuse, AgentShield, OTEL/LGTM) sit at the framework or proxy layer. openclaw-health-mcp sits one level closer to the agent runtime — read-only, local, MCP-native — surfacing infrastructure-layer health (gateway, CPU/RAM, recent errors, skill-registry, upgrade outcome, cron, disk) to the same Claude conversation that's running the agent. Works on any Linux/macOS/Windows host out of the box via the linux-proc backend; OpenClaw operators get an additional native backend that parses ~/.openclaw/ paths.
> claude: is my OpenClaw deployment healthy?
[MCP tool: health_overview]
overall_health: critical
component_summary:
gateway: degraded (bound to 0.0.0.0, 1 crash in 24h)
resources: degraded (memory at 78%, swap at 12%)
skill_registry: critical (skill 'clawhub-trending-bot-v2' flagged suspicious)
upgrade: degraded (last upgrade rolled back)
cron: degraded (1 overdue job)
disk: degraded (root at 82%, log dir +187 MB/24h)
critical_findings:
[CRITICAL] Skill 'clawhub-trending-bot-v2' flagged — possible exfiltration. Disable.
[DEGRADED] Last upgrade 2026.4.23→2026.4.26 rolled back: websocket_stalls, cpu_spike.
[DEGRADED] Root disk at 82% — set up log rotation before reaching 95%.
[DEGRADED] 1 cron job(s) overdue. Install silentwatch-mcp for silent-failure detection.Related MCP server: DivLens MCP
Why openclaw-health-mcp
Three things that existing tools (Datadog, Prometheus, raw top/free/df) don't do for OpenClaw specifically:
OpenClaw-aware probes. Detects 0.0.0.0-binding (the default-publicly-exposed misconfig per the 135k exposed-instances stat), parses ClawHub skill-registry diffs, recognizes named upgrade-regression patterns (
websocket_stalls,cpu_spikepost-2026.4.26), distinguishes intentional restarts from crashes.MCP-native, no integration layer. Claude Desktop, Cline, Continue, OpenClaw agents — any MCP-aware client queries directly. No Grafana plugin, no API wrapper, no JSON to parse manually.
Composable with the rest of the production-AI MCP stack. Pairs with silentwatch-mcp (cron silent-failure detection —
cron_healthhere is intentionally basic and defers to silentwatch when present). Skill-registry vetting in this server is light heuristics; deep static analysis goes inopenclaw-skill-vetter-mcp(planned).
Built for the SMB self-hoster running OpenClaw on a $40 VPS where Datadog is overkill — but the OpenClaw-specific patterns are valuable on enterprise infra too.
Tool surface
The server registers these MCP tools (full spec in SPEC.md):
Tool | Returns |
| Full snapshot — every component + overall HealthLevel + ranked critical findings |
| Gateway alive/dead, uptime, restarts, crashes, bind address |
| CPU/memory/swap snapshot + 24h OOM count + load averages |
| Recent error/warning entries, filterable by lookback + severity |
| Skill counts, recent additions/modifications, light heuristic flags |
| From-version, to-version, outcome, regression markers, available upgrade |
| Basic cron summary (defers to silentwatch-mcp when richer detection wanted) |
| Root disk + log directory size + 24h growth + largest log files |
Resources:
health://overview— full snapshot (same ashealth_overviewtool)health://gateway— gateway-onlyhealth://resources— CPU/memory-only
Prompts:
diagnose-degraded-health— diagnostic walk-through, ranked corrective actionssummarize-health-trend— daily operational digest
Quickstart
Install
pip install openclaw-health-mcpQuick verify (~30 seconds, no config)
After install, run the bundled demo to see all 7 health checks fire against the mock backend:
openclaw-health-mcp-demoYou'll see a one-page health overview with gateway / CPU+memory / errors / skills / upgrade / cron / disk sections — typically a CRITICAL verdict driven by the mock backend's ClawHavoc-pattern skill exfiltration flag + post-rollback degradation. No external I/O, no API keys — safe to run anywhere. Useful first-30-seconds check before wiring up Claude Desktop or pointing at a real ~/.openclaw/ directory.
Configure for Claude Desktop
Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"openclaw-health": {
"command": "python",
"args": ["-m", "openclaw_health_mcp"],
"env": {
"OPENCLAW_HEALTH_BACKEND": "mock"
}
}
}
}Restart Claude Desktop. Test:
Show me a full health snapshot of my OpenClaw deployment.
The mock backend returns deliberately mixed data (gateway DEGRADED, skill registry CRITICAL, etc.) so the response demonstrates the full schema.
Backends
Backend | Status | Description |
| ✅ v1.0 | Sample data for protocol-wiring verification (default) |
| ✅ v1.0 | psutil-based system metrics (CPU/memory/swap/load/disk) cross-platform; Linux-specific OOM-event detection via |
| ⏳ v1.1 | Parses OpenClaw config + log directory + ClawHub manifest + upgrade journal |
Select via OPENCLAW_HEALTH_BACKEND env var. Multi-backend support (federating linux-proc system metrics + openclaw application-specific) is planned for v1.2.
Roadmap
Version | Scope | Status |
v0.1 | Protocol wiring, mock backend, 8 tools / 3 resources / 2 prompts, 40 tests | ✅ |
v1.0 |
| ✅ |
v1.1 |
| ⏳ |
v1.2 | Backend federation ( | ⏳ |
v1.x |
| ⏳ |
Need this adapted to your stack?
openclaw-health-mcp ships with a mock backend at v0.1 (Linux + OpenClaw backends in v0.2). If your AI agent runtime is different — Claude Code, Cowork, custom Python services, agent harnesses on AWS / GCP — and you want the same single-pane health visibility for it, that's a Custom MCP Build engagement.
Tier | Scope | Investment | Timeline |
Simple | Single backend adapter for an existing runtime with documented logging/metrics | $8,000–$10,000 | 1–2 weeks |
Standard | Custom backend + custom severity rules + integration with your existing alerting | $15,000–$20,000 | 2–4 weeks |
Complex | Multi-backend federation + RBAC + audit-log integration + on-call workflow | $25,000–$35,000 | 4–8 weeks |
To engage:
Email hello@temhan.dev with subject
Custom MCP Build inquiryInclude: a 1-paragraph description of your stack + which tier you're considering
Reply within 2 business days with a 30-min discovery call slot
This server is part of a production-AI infrastructure MCP suite — companion to silentwatch-mcp (cron silent-failure detection) and the upcoming AI Production Discipline Framework Notion template (the methodology these tools operationalize).
Production AI audits
If you're running production AI and want an outside practitioner to score readiness, find the failure patterns already present, and write the corrective-action plan — that's what this MCP is built into supporting:
Tier | Scope | Investment | Timeline |
Audit Lite | One system, top-5 findings, written report | $1,500 | 1 week |
Audit Standard | Full audit, all 14 patterns, 5 Cs findings, 90-day follow-up | $3,000 | 2–3 weeks |
Audit + Workshop | Standard audit + 2-day team workshop + first monthly audit included | $7,500 | 3–4 weeks |
Same email channel: hello@temhan.dev with subject AI audit inquiry.
Contributing
PRs welcome. Backends are intentionally pluggable — see src/openclaw_health_mcp/backends/ for the contract.
To add a new backend:
Subclass
HealthBackendinbackends/<your_backend>.pyImplement the 7 abstract probe methods (one per component)
Register in
backends/__init__.pyAdd tests in
tests/test_backend_<your_backend>.py
Bug reports + feature requests: open a GitHub issue.
License
MIT — see LICENSE.
Related
Production-AI MCP Suite (Gumroad bundle) — this server plus 6 others in one curated 7-pack bundle with a decision tree, day-one drill, and Custom MCP Build CTA. $29.
silentwatch-mcp — cron silent-failure detection. Install alongside this server for richer
cron_healthdata.openclaw-cost-tracker-mcp — token-cost telemetry + 429 prediction (v1.1+)
openclaw-skill-vetter-mcp — ClawHub skill security vetting
openclaw-upgrade-orchestrator-mcp — read-only upgrade advisor + provider-side regression detection (v1.2+)
openclaw-output-vetter-mcp — agent claim verification (inline grounding-check + swallowed-exception scanner + multi-turn transcript review)
AI Production Discipline Framework — Notion template, $19 — the methodology these MCP tools implement.
SPEC.md — full server design.
Model Context Protocol — protocol overview.
Built by Temur Khan — production AI engineer. Contact: hello@temhan.dev
Available Tools
8 toolscpu_memory_healthA
CPU% + memory% + swap% snapshot, kernel OOM-kill count over 24h, load averages. Each component gets a HealthLevel; CRITICAL when OOM-imminent or already triggered.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes the tool as taking a 'snapshot' (non-destructive), and indicates CRITICAL levels for OOM-imminent conditions. This provides good behavioral insight, though it does not explicitly state read-only or side-effect-free behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with three sentences, each adding distinct value. It front-loads the core purpose ('CPU% + memory% + swap% snapshot') and then elaborates with additional components and HealthLevel semantics. No redundancy or wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and zero parameters, the description adequately covers the tool's functionality and behavioral traits. However, it lacks details about the exact response structure or the HealthLevel range, which could be helpful for an agent. Still, it is sufficiently complete for a simple health snapshot tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters and 100% description coverage. According to the guidelines, 0 parameters gives a baseline of 4. The description does not add parameter info (none needed), so this score is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly defines the tool as a health snapshot of CPU, memory, swap, OOM-kill count, and load averages with HealthLevel classifications. It distinguishes itself from sibling health tools by focusing specifically on CPU/memory/swap health, while 'health_overview' suggests a broader summary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide any guidance on when to use this tool versus siblings like 'health_overview' or 'disk_usage'. It only describes what it does, leaving the agent to infer usage context without explicit when-to-use or when-not-to-use instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
cron_healthA
Basic cron summary: total jobs, overdue count, 24h success rate. For richer detection (silent failures, output anomalies, duration drift), install silentwatch-mcp alongside this server. When silentwatch_available=True, the caller should query that server too.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, but description is transparent about being a basic summary and doesn't hide any behavioral traits. It implies a safe read-only operation without side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three concise sentences: first states purpose, second advises on alternative tool, third gives conditional usage. Front-loaded with essential info.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Complete for a zero-param tool: describes what it returns (three metrics) and references the richer detection tool, covering all necessary context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters, so baseline 4. Description adds meaning by explaining the output provided, even though no params exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it provides a 'Basic cron summary' with specific metrics: total jobs, overdue count, 24h success rate. Distinguishes from richer detection tools by naming silentwatch-mcp.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly directs to use silentwatch-mcp for richer detection and instructs to query that server when silentwatch_available=True, providing clear when-to-use and when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
disk_usageA
Root-disk usage% + log-directory size + 24h growth + largest log files. Flags >85% as DEGRADED, >95% as CRITICAL.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the threshold-based flagging (DEGRADED/CRITICAL) but does not describe the output format or any potential side effects. Still, it provides sufficient behavioral context for a monitoring tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no redundant words. Every sentence earns its place, conveying key metrics and thresholds efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
While the description covers what data is reported, it omits the return format (e.g., structured object or text). With no output schema, the description should clarify what the agent can expect in the result.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, and schema description coverage is 100%. The description correctly adds no parameter details, and the baseline for zero parameters is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool reports root-disk usage percentage, log-directory size, 24h growth, and largest log files, with clear flagging thresholds. This is a specific verb+resource that clearly distinguishes it from sibling tools like cpu_memory_health or cron_health.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for checking disk health and thresholds, which is clear in context. However, it lacks explicit guidance on when not to use it compared to alternatives, so it doesn't fully meet the top score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
gateway_statusA
Status of the OpenClaw gateway process: alive/dead, uptime, recent restarts (intentional vs crashes), bind address, PID. Flags 0.0.0.0 binding (default-publicly-exposed config).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the tool reports status including whether the process is alive/dead and flags a security-relevant binding. It does not mention auth requirements or rate limits, but for a read-only status tool, this is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short, dense sentences contain all necessary information without wasted words. The structure is efficient and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no input parameters and no output schema, the description provides a comprehensive list of output fields and a notable security flag. It is sufficiently complete for the agent to understand the tool's function and return value.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, so the baseline is 4. The description adds value by listing the expected output fields (uptime, restarts, etc.), exceeding the baseline by providing concrete details about what the tool returns.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states that the tool returns the status of the OpenClaw gateway process, listing specific attributes (alive/dead, uptime, restarts, bind address, PID). It also uniquely flags a security concern (0.0.0.0 binding), clearly distinguishing it from sibling health check tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage context is implied through the description of the tool's purpose (gateway status) among sibling health tools, but no explicit guidance on when to use this vs alternatives or when not to use it is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
health_overviewA
Full deployment health snapshot — gateway + resources + skill registry + upgrade status + cron + disk in one call. Returns overall HealthLevel (healthy/degraded/critical/unknown) plus per-component breakdown plus ranked critical_findings list. Use this first for a single-pane summary.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description states it makes 'one call' and returns aggregated data, but does not disclose potential performance impact, rate limits, or whether the call is read-only. With no annotations, the agent must infer safety from naming. Adequate but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two precise sentences with no filler. Purpose and return type are front-loaded, making it quick to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Without an output schema, the description outlines the structure (overall level, per-component, critical findings). This provides sufficient context for a health snapshot, though exact field names or formats are omitted.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so schema coverage is 100% by default. The description confirms no params are needed, adding no further meaning. Baseline 4 for zero-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it is a full deployment health snapshot listing all components (gateway, resources, skill registry, etc.) and return types (overall HealthLevel, per-component breakdown, critical_findings list). This distinguishes it from sibling tools that focus on single components.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises 'Use this first for a single-pane summary,' indicating it is the initial tool to invoke. However, it does not specify when to use sibling tools for deeper investigation, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
last_upgrade_statusA
Last OpenClaw upgrade attempt: from-version, to-version, outcome (success/rollback/failure/in_progress), regression markers detected post-upgrade (e.g., websocket_stalls, cpu_spike). Includes available-upstream-version.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses all returned fields and the read-only nature of the tool. Without annotations, this is sufficient behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single efficient sentence with front-loaded key information. No redundant words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Fully describes the tool's output for a zero-parameter, no-output-schema tool. Includes all relevant fields.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters, schema coverage is 100% empty, so description adds all necessary meaning beyond schema. Baseline 4 for 0 params.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it reports the last upgrade attempt with specific details (from/to versions, outcome, regression markers, upstream version). It is distinct from health-check sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies usage for checking upgrade history, but no explicit guidance on when to use vs alternatives or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
recent_errorsA
Recent error/warning log entries from gateway + skills + cron. Filterable by lookback window and minimum severity.
| Name | Required | Description | Default |
|---|---|---|---|
| window_hours | No | Lookback window in hours (default 24, max 168) | |
| min_severity | No | Minimum severity to return (debug/info/warning/error/critical, default warning) | warning |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description lacks behavioral details such as read-only nature, rate limits, or handling of empty results, which are important for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that conveys the tool's purpose and key features without unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with two optional parameters and no output schema, the description is mostly complete but could mention the return format or typical content of entries.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the description adds no new meaning beyond the parameter definitions; it merely echoes 'filterable' without additional context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as retrieving recent error/warning log entries from specific sources (gateway, skills, cron) and mentions filtering options, distinguishing it from health/status sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for debugging via log entries, but does not explicitly state when to use this tool over siblings or provide exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
skill_registry_checkA
ClawHub / skill-registry integrity: total skills, recently added/modified, skills with external HTTP endpoints, light heuristic flags. For deep static analysis (prompt-injection patterns, exfiltration), install openclaw-skill-vetter-mcp.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses what the tool returns (counts, recent changes, endpoints, flags) and implies read-only behavior. Lacks mention of side effects, but given the context, it's sufficiently transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. First sentence describes the tool's output, second sentence directs to an alternative for deeper analysis. Well-structured and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no parameters, the description covers the essential information: what the tool checks and returns. It could be slightly more explicit about output format, but it is complete enough for an agent to understand its value.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameters, and schema description coverage is 100%, so the baseline is 3. The description adds no parameter semantics because there are none to describe.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: checking ClawHub skill-registry integrity, listing total skills, recently added/modified, external HTTP endpoints, and light heuristic flags. It distinguishes itself from deep static analysis by naming an alternative tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance: use this for light integrity checks and flags, and recommends the openclaw-skill-vetter-mcp for deep analysis, effectively telling when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
8 tool updates
v1.0.3- First observed
cpu_memory_health - First observed
cron_health - First observed
disk_usage - First observed
gateway_status - First observed
health_overview - First observed
last_upgrade_status - First observed
recent_errors - First observed
skill_registry_check
TDQS
Scored across 8 tools
Each tool targets a distinct aspect of system health: CPU/memory, cron, disk, gateway, overall snapshot, upgrades, errors, and skill registry. There is no overlap in purpose, and even the overview tool aggregates rather than duplicates.
All tools use a consistent snake_case naming pattern with a descriptive noun_health or noun_status or noun_check suffix. The names clearly indicate the resource and action, e.g., cpu_memory_health, health_overview, recent_errors.
With 8 tools, the server covers essential health monitoring dimensions for an OpenClaw deployment without being overwhelming. Each tool serves a clear purpose, and the count is typical for a focused MCP server.
The tool set covers CPU, memory, disk, cron, gateway, upgrade status, errors, and skill registry—comprehensive for common health checks. Minor gaps like network connectivity may exist, but references to companion MCPs (silentwatch-mcp, openclaw-skill-vetter-mcp) indicate thoughtful scoping.
Maintenance
Related MCP Connectors
Monitoring for the agent economy — liveness, latency, trust scoring for MCP endpoints
Live health and AI-readable metadata of invokera.com. Demo of an Invokera-hosted MCP server.
- UnifAPIOAuthcom.unifapi
Hosted MCP server for live public-data APIs and Skills for AI agents.
- SpanlyOAuthcom.spanly
MCP observability. Query live traffic, errors, duration, and alerts from your AI agent.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server for agent network monitoring. Aggregates real-time population counts, transaction volume, and health metrics across multi-service agent infrastructure.MIT
- FlicenseNot gradedqualityCmaintenanceA real-time system diagnostics MCP server that gives AI agents live access to CPU, RAM, disk, network, processes, and hardware health metrics, with zero cloud dependency.7-
- AlicenseAqualityAmaintenanceAn MCP server that surfaces scheduled-job state and detects silent failures (exit 0 but no useful output) for cron, systemd timers, and OpenClaw schedulers, enabling AI agents to query job health and overdue status directly.627 PyPIMIT
- AlicenseAqualityDmaintenanceLinux system administration via AI agents — MCP server for managing services, processes, disk, network and logs on Linux systems.15MIT