Detecta los fallos de cron sobre los que tu monitorización guarda silencio. Un servidor MCP que muestra el estado de los trabajos programados (ejecuciones, trabajos retrasados y fallos silenciosos que terminan con código 0 pero no producen nada útil) a cualquier agente compatible con Claude o MCP. Funciona con programadores OpenClaw, cron del sistema y temporizadores de systemd desde el primer momento.
Todo equipo que ejecuta trabajos programados se ha encontrado con al menos uno de estos problemas:
Fallo silencioso: el trabajo se ejecutó, devolvió el código de salida 0, pero no produjo resultados útiles (un cron de búsqueda web que devuelve resultados vacíos, una copia de seguridad que escribió un archivo de 0 bytes, un correo electrónico de resumen enviado con <no rows> en el cuerpo). La monitorización tradicional ve una marca de verificación verde; los datos están rotos de todos modos.
Retraso sin alerta: un trabajo dejó de ejecutarse durante 3 días; nadie se dio cuenta porque nadie estaba vigilando.
Desviación del último éxito: el trabajo se ejecuta cada hora pero solo tuvo éxito una vez en los últimos 12 intentos; todos asumen que está sano porque la ejecución más reciente fue verde.
Brecha en la pista de auditoría: necesitas saber cuándo se completó por última vez un trabajo específico para una verificación de cumplimiento, y el único "registro" es la salida de journalctl que rotó la semana pasada.
silentwatch-mcp expone esa visibilidad como herramientas MCP que tu agente de IA puede consultar directamente. Sin tuberías de métricas, sin paneles separados, sin suscripción SaaS.
> 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-mcpTres cosas que las herramientas existentes (Cronitor, Healthchecks.io, Datadog, Prometheus) no hacen:
Detectar fallos silenciosos, no solo códigos de salida. La monitorización de cron tradicional asume que exit 0 = éxito. Nosotros comprobamos la salida frente a reglas configurables: salida vacía, anomalía de longitud frente a la mediana histórica, palabras clave de error en stdout a pesar del exit 0, anomalía de duración. El trabajo que "se ejecutó con éxito" pero no devolvió nada útil es el modo de fallo que se oculta durante semanas. Nosotros lo detectamos.
Nativo de MCP, sin capa de integración. Claude Desktop, Cline, Continue, agentes de OpenClaw: cualquier cliente compatible con MCP consulta directamente. Sin plugin de Grafana, sin envoltorio de API, sin JSON que analizar manualmente.
Multifuente desde el primer momento. Registros JSONL nativos de OpenClaw, crontab del sistema (/etc/crontab + /etc/cron.d/* + crontab -l por usuario) y temporizadores de systemd (systemctl list-timers + journalctl): los cuatro backends se incluyen en la v0.3, por lo que puedes ejecutar silentwatch-mcp contra cualquier programador que tengas. Sin dependencia de proveedores.
Creado para el autohospedador de PYMES que ejecuta un VPS de 40$ donde Datadog es excesivo y un "MCP de código abierto de 0$/mes" es el punto de precio adecuado, pero la detección de fallos silenciosos es igual de valiosa en infraestructuras empresariales.
El servidor registra estas herramientas MCP (especificación completa en SPEC.md):
Herramienta | Qué hace |
| Enumera todos los trabajos cron conocidos con un resumen de la última ejecución |
| Estado detallado de un trabajo: última ejecución, último éxito, tasa de éxito en el periodo |
| Historial de ejecuciones recientes con tiempo + estado + fragmento de salida |
| Trabajos cuyo horario indica que deberían haberse ejecutado pero no lo han hecho |
| Trabajos que se ejecutaron "con éxito" pero cuya salida parece sospechosa |
| Salida de registro reciente para un trabajo |
Recursos:
cron://jobs — lista de todos los trabajos (manifiesto)
cron://job/{id} — manifiesto de trabajo individual + ejecuciones recientes
cron://run/{id} — instancia de ejecución individual con salida completa
Prompts:
diagnose-overdue — plantilla de prompt de diagnóstico para un trabajo retrasado
summarize-cron-health — resumen diario de la actividad de cron + anomalías
v0.3 beta — los 4 backends incluidos + detección real de retrasos mediante el análisis de cron-schedule (croniter). Los backends Mock, OpenClaw JSONL, crontab y systemd están listos para producción. 74 pruebas superadas. La v1.0 es ahora pulido: lanzamiento en PyPI + CI de GitHub Actions + envíos al registro MCP.
pip install silentwatch-mcp # not yet on PyPI; install from source for now:
pip install -e .Añadir a ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) o %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"silentwatch": {
"command": "python",
"args": ["-m", "silentwatch_mcp"],
"env": {
"SILENTWATCH_BACKEND": "mock"
}
}
}
}Backends (los cuatro incluidos desde la v0.3):
SILENTWATCH_BACKEND=mock — devuelve datos de muestra (predeterminado para desarrollo)
SILENTWATCH_BACKEND=openclaw-jsonl — analiza los archivos JSONL de ejecución de cron nativos de OpenClaw (establece SILENTWATCH_OPENCLAW_LOGS en el directorio, predeterminado ~/.openclaw/cron-runs/); datos más ricos: historial completo de ejecución + detección de fallos silenciosos
SILENTWATCH_BACKEND=crontab — analiza /etc/crontab + /etc/cron.d/* + crontabs de usuario (crontab -l); última ejecución inferida de /var/log/syslog o /var/log/cron (establece SILENTWATCH_SYSLOG para anular)
SILENTWATCH_BACKEND=systemd — analiza systemctl list-timers --all --output=json + journalctl -u <unit> para el historial de ejecución; eleva OnCalendar= al campo de programación
Todos los backends que no son mock devuelven resultados vacíos correctamente en plataformas/hosts donde la herramienta subyacente no está presente, por lo que la configuración es segura de dejar en su lugar en todos los entornos.
El servidor se registra como silentwatch. Prueba:
Muéstrame todos mis trabajos cron y su estado de última ejecución.
Versión | Alcance | Estado |
v0.1 | Conexión de protocolo, backend mock, las 6 herramientas registradas con datos de prueba, pruebas superadas | ✅ Completo |
v0.2 | Backend OpenClaw JSONL implementado (análisis real de ejecución de cron, manejo de líneas mal formadas, enriquecimiento de fallos silenciosos) | ✅ Completo (2026-05-02) |
v0.3 | Backends Crontab + systemd; análisis de cron-schedule para detección real de retrasos (croniter); 35 nuevas pruebas | ✅ Completo (2026-05-02) |
v1.0 | Pulido: lanzamiento en PyPI, CI de GitHub Actions, envíos al registro MCP (Glama + PulseMCP), configuración refinada de reglas de fallo silencioso | ⏳ Objetivo de envío Fase 1 (S3, 18 de mayo) |
v1.x | Backends adicionales (programador Cowork, tareas en segundo plano de Claude Code, configuración JSON genérica), emisor de webhooks para alertas | ⏳ Fase 2+ |
silentwatch-mcp se envía con 4 backends (mock, OpenClaw JSONL, crontab, systemd). Si tu programador es otro (AWS EventBridge, GCP Cloud Scheduler, Hangfire, Sidekiq, Temporal, Apache Airflow, Prefect, Dagster o un ejecutor de trabajos personalizado) y quieres la misma superficie de visibilidad MCP de detección de fallos silenciosos para él, eso es un compromiso de Construcción MCP Personalizada.
Nivel | Alcance | Inversión | Cronograma |
Simple | Adaptador de backend único para un programador existente con API documentada (ej. GCP Cloud Scheduler) | 8.000$–10.000$ | 1–2 semanas |
Estándar | Backend personalizado + reglas de fallo silencioso personalizadas + integración con tu alerta existente (PagerDuty, Slack, etc.) | 15.000$–20.000$ | 2–4 semanas |
Complejo | Multibackend (cron federado entre regiones / clústeres / inquilinos) + RBAC + integración de registro de auditoría + flujo de trabajo de guardia | 25.000$–35.000$ | 4–8 semanas |
Para contratar:
Envía un correo a admin@pixelette.tech con el asunto Custom MCP Build inquiry
Incluye: una descripción de 1 párrafo de tu stack de programador + qué nivel estás considerando
Responderemos en 2 días hábiles con un espacio para una llamada de descubrimiento de 30 minutos
Este servidor también es parte del AI Production Discipline Framework, la metodología subyacente a las auditorías de IA de producción que realizo.
Si ejecutas IA de producción y quieres que un profesional externo evalúe la preparación, encuentre los patrones de fallo que ya están presentes y escriba el plan de acción correctiva, eso es para lo que este MCP está diseñado. El servicio de auditoría independiente:
Nivel | Alcance | Inversión | Cronograma |
Audit Lite | Un sistema, 5 hallazgos principales, informe escrito | 1.500$ | 1 semana |
Audit Standard | Auditoría completa, los 14 patrones, 5 hallazgos Cs, seguimiento de 90 días | 3.000$ | 2–3 semanas |
Audit + Workshop | Auditoría estándar + taller de equipo de 2 días + primera auditoría mensual incluida | 7.500$ | 3–4 semanas |
Mismo canal de correo: admin@pixelette.tech con el asunto AI audit inquiry.
Las PR son bienvenidas. La estructura es intencionalmente plana para facilitar la adición de backends personalizados; consulta src/silentwatch_mcp/backends/ para ver ejemplos existentes.
Para añadir un nuevo backend:
Crea una subclase de CronBackend en backends/<tu_backend>.py
Implementa list_jobs, get_job_runs, tail_logs
Regístralo en backends/__init__.py
Añade pruebas en tests/test_backend_<tu_backend>.py
Informes de errores + solicitudes de funciones: abre un issue en GitHub.
MIT — ver LICENSE.
AI Production Discipline Framework — plantilla de Notion, 29$
SPEC.md — diseño completo del servidor
Model Context Protocol — descripción general del protocolo
Creado por Temur Khan — profesional independiente en sistemas de IA de producción. Contacto: admin@pixelette.tech
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.
