The silentwatch-mcp server monitors cron jobs for silent failures, overdue runs, and scheduling anomalies. Key capabilities:
List all jobs (list_jobs): Enumerate all known cron jobs with last-run time/status, run and success counts (24h), silent-fail count, and overdue flag.
Get job status (get_job_status): Retrieve detailed status for a specific job, including last run, last success, success rates over 24h/7d, overdue state, and silent-fail indicators.
View run history (get_job_runs): Fetch recent runs (up to 500) with timing, exit codes, status, silent-fail indicators, and output snippets.
Find overdue jobs (find_overdue_jobs): Identify jobs that haven't run on schedule, with a configurable grace window (default 5 minutes).
Detect silent failures (find_silent_failures): Surface jobs that exited with code 0 but show suspicious output — empty output, length anomaly vs. historical median, error keywords in stdout, or duration anomaly — within a configurable lookback window (default 24 hours).
Tail job logs (tail_job_logs): Retrieve the most recent N log lines (default 50) for a specific job.
Supports multiple backends: system crontab, systemd timers, OpenClaw JSONL logs, or mock data. Also includes prompt templates for diagnosing overdue jobs and summarizing overall cron health.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@silentwatch-mcp check for silent failures in my cron jobs"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP server for catching cron silent failures — when scheduled jobs exit 0 with empty output, when retry storms run away, when action budgets leak. Surfaces overdue jobs, length anomalies, and silent-fail patterns to any Claude or MCP-aware agent. Works with system cron, systemd timers, OpenClaw cron logs, and any JSONL run-log out of the box. Keywords: AI agent monitoring, cron health, scheduled-task observability, production AI ops.
Real silent failures from production AI deployments in the last 30 days:
GitHub Issue #54260, anthropics/claude-code — Claude Code Routines: cron triggers fire and the routine state advances (ended_reason: run_once_fired), but the cloud container never reaches prompt execution. This silently affected the operator's routines for at least 28 days before they noticed the output files weren't updating.
GitHub Issue #1243, anthropics/claude-code-action — claude-sonnet-4-6 returns empty assistant turns in a tight loop (stop_reason: null, output_tokens: 8) for ~20 minutes. The workflow step then exits as success with no artifacts produced — the GitHub Actions API can't distinguish "completed cleanly" from "returned empty for 20 minutes burning Claude Max budget."
dev.to: "5 Silent Failure Patterns I Keep Finding in Production AI Systems" — the systematic taxonomy.
These all map to one underlying problem: exit-code monitoring lies. The job returned 0; the data is broken anyway. Any team running scheduled jobs has hit at least one of these:
Silent failure — the job ran, returned exit code 0, but produced no useful output (a web-search cron returning empty, a backup that wrote a 0-byte file, a digest email that sent with <no rows> in the body). Traditional monitoring sees a green checkmark; the data is broken anyway.
Overdue without alert — a job stopped running for 3 days; nobody noticed because nobody was watching
Last-success drift — the job runs every hour but only succeeded once in the last 12 attempts; everyone assumes it's healthy because the most recent run was green
Audit-trail gap — you need to know when a specific job last completed for a compliance check, and the only "log" is journalctl output that rotated last week
silentwatch-mcp exposes that visibility as MCP tools your AI agent can query directly. No metrics pipeline, no separate dashboard, no SaaS subscription.
> claude: which of my cron jobs have silent failures in the last 24 hours?
[MCP tool: find_silent_failures]
3 jobs flagged:
• web-search-refresh — ran 12× successfully but output empty in 8 (66% silent fail rate)
• daily-summary — ran 1× successfully (24× expected); output normal
• audit-snapshot — last success 5 days ago, all subsequent runs returned exit 0 with empty bodyRelated MCP server: task-orchestrator
silentwatch-mcpThree things existing tools (Cronitor, Healthchecks.io, Datadog, Prometheus) don't do:
Detect silent failures, not just exit codes. Traditional cron monitoring assumes exit 0 = success. We check the output against configurable rules: empty output, length anomaly vs historical median, error keywords in stdout despite exit 0, duration anomaly. The job that "ran successfully" but returned nothing useful — that's the failure mode that hides for weeks. We catch it.
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.
Multi-source out of the box. OpenClaw native JSONL logs, system crontab (/etc/crontab + /etc/cron.d/* + per-user crontab -l), and systemd timers (systemctl list-timers + journalctl) — all four backends ship in v0.3, so you can run silentwatch-mcp against whatever scheduler you have. No vendor lock-in.
Built for the SMB self-hoster running a $40 VPS where Datadog is overkill and a "$0/mo open-source MCP" is the right price point — but the silent-failure detection is just as valuable on enterprise infra.
The server registers these MCP tools (full spec in SPEC.md):
Tool | What it does |
| Enumerate all known cron jobs with last-run summary |
| Detailed status for one job: last run, last success, success rate over window |
| Recent run history with timing + status + output snippet |
| Jobs whose schedule says they should have run but haven't |
| Jobs that ran "successfully" but output looks suspicious |
| Recent log output for one job |
Resources:
cron://jobs — list of all jobs (manifest)
cron://job/{id} — individual job manifest + recent runs
cron://run/{id} — individual run instance with full output
Prompts:
diagnose-overdue — diagnostic prompt template for an overdue job
summarize-cron-health — daily digest of cron activity + anomalies
v0.3 beta — all 4 backends shipped + real overdue detection via cron-schedule parsing (croniter). Mock, OpenClaw JSONL, crontab, and systemd backends are all production-ready. 74 tests passing. v1.0 is now polish: PyPI release + GitHub Actions CI + MCP registry submissions.
pip install silentwatch-mcpAfter install, run the bundled demo to see silentwatch catch real silent-failure patterns in the mock backend's hand-crafted cron data:
silentwatch-mcp-demoYou'll see 6 synthetic cron jobs analyzed: 8 silent failures detected on web-search-refresh (output-empty pattern), 1 job overdue 72h, 4 healthy jobs as baseline. No external I/O, no API keys — safe to run anywhere. Useful first-30-seconds check that the install actually works before wiring up Claude Desktop.
Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"silentwatch": {
"command": "python",
"args": ["-m", "silentwatch_mcp"],
"env": {
"SILENTWATCH_BACKEND": "mock"
}
}
}
}Backends (all four shipped as of v0.3):
SILENTWATCH_BACKEND=mock — returns sample data (default for development)
SILENTWATCH_BACKEND=openclaw-jsonl — parses OpenClaw's native cron run JSONL files (set SILENTWATCH_OPENCLAW_LOGS to the directory, default ~/.openclaw/cron-runs/); richest data — full run history + silent-fail detection
SILENTWATCH_BACKEND=crontab — parses /etc/crontab + /etc/cron.d/* + user crontabs (crontab -l); last-run inferred from /var/log/syslog or /var/log/cron (set SILENTWATCH_SYSLOG to override)
SILENTWATCH_BACKEND=systemd — parses systemctl list-timers --all --output=json + journalctl -u <unit> for run history; lifts OnCalendar= into the schedule field
All non-mock backends gracefully return empty results on platforms / hosts where the underlying tooling isn't present, so configuration is safe to leave in place across environments.
The server registers as silentwatch. Test:
Show me all my cron jobs and their last-run status.
Version | Scope | Status |
v0.1 | Protocol wiring, mock backend, all 6 tools registered with stub data, tests pass | ✅ Complete |
v0.2 | OpenClaw JSONL backend implemented (real cron run parsing, malformed-line handling, silent-fail enrichment) | ✅ Complete (2026-05-02) |
v0.3 | Crontab + systemd backends; cron-schedule parsing for real overdue detection (croniter); 35 new tests | ✅ Complete (2026-05-02) |
v1.0 | Polish: PyPI release, GitHub Actions CI, MCP registry submissions (Glama + PulseMCP), refined silent-fail rule configuration | ⏳ Phase 1 ship target (W3, May 18) |
v1.x | Additional backends (Cowork scheduler, Claude Code background tasks, generic JSON config), webhook emitter for alerts | ⏳ Phase 2+ |
silentwatch-mcp ships with 4 backends (mock, OpenClaw JSONL, crontab, systemd). If your scheduler is something else — AWS EventBridge, GCP Cloud Scheduler, Hangfire, Sidekiq, Temporal, Apache Airflow, Prefect, Dagster, or a custom job runner — and you want the same silent-failure-detection MCP visibility surface for it, that's a Custom MCP Build engagement.
Tier | Scope | Investment | Timeline |
Simple | Single backend adapter for an existing scheduler with documented API (e.g., GCP Cloud Scheduler) | $8,000–$10,000 | 1–2 weeks |
Standard | Custom backend + custom silent-fail rules + integration with your existing alerting (PagerDuty, Slack, etc.) | $15,000–$20,000 | 2–4 weeks |
Complex | Multi-backend (federated cron across regions / clusters / tenants) + 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 inquiry
Include: a 1-paragraph description of your scheduler stack + which tier you're considering
Reply within 2 business days with a 30-min discovery call slot
This server is also part of the AI Production Discipline Framework — the methodology underlying production AI audits I run.
If you're running production AI and want an outside practitioner to score readiness, find the failure patterns that are already present, and write the corrective-action plan — that's what this MCP is built into supporting. The standalone audit service:
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.
PRs welcome. The structure is intentionally flat to make custom backends easy to add — see src/silentwatch_mcp/backends/ for existing examples.
To add a new backend:
Subclass CronBackend in backends/<your_backend>.py
Implement list_jobs, get_job_runs, tail_logs
Register in backends/__init__.py
Add tests in tests/test_backend_<your_backend>.py
Bug reports + feature requests: open a GitHub issue.
MIT — see LICENSE.
Production-AI MCP Suite (Gumroad bundle) — this server plus 6 others (openclaw-health-mcp, openclaw-cost-tracker-mcp, openclaw-skill-vetter-mcp, openclaw-upgrade-orchestrator-mcp, openclaw-output-vetter-mcp, bash-vet-mcp) in one curated 7-pack bundle with a decision tree, day-one drill, and Custom MCP Build CTA. $29.
openclaw-health-mcp — deployment health (gateway, CPU/RAM, skills, recent errors)
openclaw-cost-tracker-mcp — token-cost telemetry + 429 prediction (v1.1+)
openclaw-skill-vetter-mcp — ClawHub skill + agent-config security vetting (v1.1+)
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 + action-outcome verifier v1.1+)
bash-vet-mcp — pre-execution shell-command vetting (28 destructive-pattern rules across 8 families)
AI Production Discipline Framework — Notion template, $19 — the full 14-pattern catalog this MCP server is built around
AI Production Auditor (GPT Store) — paste your config or agent setup, get a 5 Cs audit report. Free, ChatGPT-only.
SPEC.md — full server design
Model Context Protocol — protocol overview
Built by Temur Khan — production AI engineer. Contact: hello@temhan.dev
Returns jobs whose schedule indicates they should have run but haven't, beyond a grace window.
| Name | Required | Description | Default |
|---|---|---|---|
| grace_minutes | No | Tolerance to avoid flagging jobs about to run (default 5) |
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 core behavior (returns overdue jobs) but does not mention whether the operation is read-only, performance implications, or pagination. Adequate but not thorough.
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?
A single sentence that is efficient and front-loaded with the core purpose, 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?
For a simple tool with one optional parameter and no output schema, the description is largely complete. It could clarify what 'schedule indicates' means or the output format, but overall it provides sufficient 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?
With 100% schema coverage, the description adds value by explaining 'beyond a grace window' which directly connects to the grace_minutes parameter, providing context beyond the schema's technical description.
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 returns overdue jobs with a grace window, distinguishing it from siblings like find_silent_failures (different failure mode) and list_jobs (all jobs).
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 checking missed jobs but lacks explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Jobs that returned exit code 0 but output was flagged by silent-fail rules (empty output, length anomaly, error keywords, duration anomaly).
| Name | Required | Description | Default |
|---|---|---|---|
| window_hours | No | Lookback window in hours (default 24) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description only lists detection criteria. It does not disclose behavioral traits like read-only nature, prerequisites, or potential 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?
Single sentence efficiently conveys purpose but lists multiple anomaly types in a somewhat dense manner. No wasted words, but readability could improve.
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 one optional parameter and no output schema, the description lacks details on return format, pagination, or usage context. Incomplete for a search/filter 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?
Schema coverage is 100% with clear description for window_hours. The tool description adds no extra meaning beyond the schema, so baseline 3 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 states it finds jobs with exit code 0 flagged by silent-fail rules, using specific verb and resource. However, it does not differentiate from siblings like find_overdue_jobs.
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?
No guidance on when to use this tool vs alternatives. The description implies usage for detecting silent failures but lacks when-not or alternative tool references.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent run history for a job (newest first) with timing, exit code, status, silent-fail indicators, output snippet.
| Name | Required | Description | Default |
|---|---|---|---|
| job_id | Yes | Job identifier | |
| limit | No | Max runs to return (default 20, max 500) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries the full burden. It discloses ordering, data fields, and indicators (e.g., silent-fail), but does not mention side effects, rate limits, access requirements, or return format specifics. This is adequate but not thorough for a tool with no annotations.
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 sentence with all key information front-loaded (recent, newest first, data fields). No wasted words; every part adds value.
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?
No output schema exists, so description should explain return structure. It lists fields but does not specify if results are an array, pagination behavior (beyond limit), or error handling. Adequate for a simple list but incomplete for comprehensive understanding.
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 coverage is 100%, so baseline is 3. The description does not add meaningful information beyond the schema: 'job_id' and 'limit' are already described in the schema with default and max values. No additional context for parameter usage is provided.
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 specifies the resource ('run history for a job'), action ('get'), ordering ('newest first'), and included data fields ('timing, exit code, status, silent-fail indicators, output snippet'). It effectively distinguishes from sibling tools like get_job_status or tail_job_logs.
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?
No explicit guidance on when to use this tool versus alternatives like get_job_status or find_silent_failures. The description implies usage for recent runs but lacks when-not-to-use conditions or comparisons.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Detailed status for one job: last run, last success, success rates over 24h + 7d, overdue state, silent-fail indicators on the last run.
| Name | Required | Description | Default |
|---|---|---|---|
| job_id | Yes | Job identifier from list_jobs |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; the description describes return fields but does not disclose any behavioral traits such as read-only nature, authentication needs, or cost. For a read-like tool, this is a notable gap.
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 entire description is a single concise sentence that front-loads the core purpose and lists specific details without any 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 the tool's low complexity (one parameter, no output schema), the description adequately covers return values. It could mention error handling or prerequisites, but is largely complete.
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?
Input schema has 100% description coverage with 'job_id' documented. The description adds no further parameter information, so a baseline score of 3 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 states 'Detailed status for one job' and enumerates specific fields (last run, success rates, overdue state, silent-fail indicators), distinguishing it from siblings like find_overdue_jobs or get_job_runs.
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 obtaining a comprehensive snapshot of a single job's health, but does not explicitly state when to use this tool over alternatives or provide exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Enumerate all known cron jobs with last-run summary. Returns id, name, schedule, last run time + status, runs/successes in last 24h, silent-fail count, overdue flag.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite lacking annotations, the description transparently lists all returned fields, including last-run summary and overdue flags. This adequately discloses the read-only behavior and output structure.
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, well-structured sentence that efficiently conveys the tool's purpose and output. No extraneous information.
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 the tool's low complexity (no parameters, no output schema), the description covers its functionality and output comprehensively. It could mention it as a read-only operation, but the field list suffices.
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?
With zero parameters, the description adds value by detailing the output fields, compensating for the absence of an output schema. It provides richer semantics than the empty input schema.
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 enumerates all known cron jobs with a last-run summary, specifying the returned fields (id, name, schedule, last run time + status, etc.). It distinguishes itself from sibling tools like find_overdue_jobs and find_silent_failures, which target specific subsets.
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?
While the description implies general-purpose enumeration, it does not explicitly state when to use this tool versus siblings like get_job_status or get_job_runs. No exclusion criteria or alternative recommendations are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Most recent N log lines for a job (newest last).
| Name | Required | Description | Default |
|---|---|---|---|
| job_id | Yes | ||
| lines | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Only states the result order and count, but omits read-only hint, error handling, or limitations like max lines.
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 sentence, no wasted words. Efficient but could include more contextual info without becoming verbose.
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?
Adequate for a simple tool with 2 parameters and no output schema. Lacks details on behavior for edge cases and result format, but core purpose is clear.
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 0%. Description hints at 'lines' parameter ('N log lines') but does not explain 'job_id' or provide format/constraints for either parameter.
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 the action ('Most recent N log lines'), resource ('a job'), and ordering ('newest last'). Distinguishes from siblings like get_job_status or list_jobs.
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?
No explicit guidance on when to use this tool vs siblings. Does not mention exclusions or alternatives despite related tools (e.g., find_silent_failures, get_job_runs).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.3.0find_overdue_jobsfind_silent_failuresget_job_runsget_job_statuslist_jobstail_job_logsScored across 6 tools
Each tool addresses a distinct aspect of job monitoring: overdue detection, silent failure detection, run history, job status, job listing, and log tailing. No overlap in purpose.
All tool names follow a consistent verb_noun pattern with underscores, using clear verbs like find, get, list, and tail. No mixing of conventions.
Six tools cover the core functionality of a job monitoring server: listing, anomaly detection, status, logs. Neither too few nor too many for the scope.
The tool set provides complete coverage for monitoring cron jobs: discovery, anomaly detection (overdue and silent failures), status, history, and logs. No obvious gaps for a read-only monitoring use case.
Monitoring that agents set up for themselves — cron jobs, CI/CD pipelines and AI agent runs.
Control plane for autonomous software labor. Agents claim objectives over MCP with audit trail.
Personal assistant MCP server with search, execute, packages, jobs, secrets, and integrations.
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
