cronalert-mcp

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.1
Disambiguation5/5
Every tool has a clearly distinct purpose with no ambiguity. The tools are well-organized around specific resources (monitors, incidents, status pages) and actions (create, delete, get, list, update), making it easy for an agent to select the correct tool without confusion.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern (e.g., create_monitor, list_incidents, update_monitor). The naming is uniform throughout, using snake_case and clear, descriptive verbs that align with the action each tool performs.
Tool Count5/5
With 9 tools, the server is well-scoped for uptime monitoring and alerting. Each tool serves a distinct and necessary function, covering core operations like CRUD for monitors, incident management, and status page listing, without being overly sparse or bloated.
Completeness5/5
The tool surface provides complete CRUD/lifecycle coverage for the uptime monitoring domain. It includes creation, retrieval, updating, and deletion of monitors, along with incident tracking and status page management, leaving no obvious gaps for agent workflows.
Average 3.6/5 across 9 of 9 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 1 commit in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate it's read-only, non-destructive, and closed-world, so the description adds value by specifying the type of data returned (response times, status codes, uptime percentage) and implying pagination ('recent' suggests limited results). However, it doesn't disclose rate limits, auth needs, or detailed behavioral traits beyond what annotations cover.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose and lists key data points without unnecessary words. Every part earns its place by clarifying scope and output.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema) and rich annotations, the description is adequate but incomplete. It covers what data is returned but lacks details on output format, error handling, or how 'recent' maps to pagination, leaving gaps for an agent to infer usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are fully documented in the schema. The description adds no additional meaning beyond implying 'recent' results, which relates to pagination but doesn't clarify parameter usage or constraints beyond the schema's technical details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('recent check results for a monitor'), specifying the data returned (response times, status codes, uptime percentage). It distinguishes from siblings like 'get_monitor' (which likely returns monitor metadata) by focusing on check results, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'get_monitor_incidents' or 'list_incidents', nor does it mention prerequisites (e.g., needing a monitor ID). The description implies usage for retrieving performance data but lacks explicit context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, covering safety and scope. The description adds that it retrieves 'detailed information' and 'current status', which provides useful context beyond annotations. However, it doesn't disclose behavioral traits like rate limits, authentication needs, or response format details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get detailed information about a specific monitor') and adds key specifics ('including its current status'). There is no wasted wording, and it's appropriately sized for a simple retrieval tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no output schema) and rich annotations (covering read-only, non-destructive, closed-world), the description is minimally adequate. It specifies what information is retrieved but lacks details on output format or error handling. For a simple read tool, this is acceptable but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'id' documented as 'Monitor ID'. The description doesn't add any semantic details beyond what the schema provides, such as format examples or where to find the ID. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but doesn't need to.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get') and resource ('monitor'), specifying it provides 'detailed information' and 'current status'. It distinguishes from siblings like 'list_monitors' by focusing on a single monitor, but doesn't explicitly contrast with 'get_check_results' or 'get_monitor_incidents' which might provide related data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose 'get_monitor' over 'list_monitors' for overviews, or how it differs from 'get_check_results' or 'get_monitor_incidents' for related monitor data. Usage is implied by the name but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, non-destructive, and closed-world behavior. The description adds minimal behavioral context by clarifying that incidents represent 'periods when the monitor was down,' which helps interpret the data. However, it lacks details on rate limits, authentication needs, or response format, keeping the score at a baseline level with annotations present.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded, consisting of a single, clear sentence: 'Get incidents for a specific monitor — periods when the monitor was down.' Every word contributes to understanding the tool's purpose without any redundancy or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema), the description is minimally adequate. It explains what the tool does but lacks details on output structure, error handling, or integration with sibling tools. With annotations covering safety and world hints, the description meets basic needs but leaves gaps for full agent understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents parameters like 'id' (Monitor ID), 'page', and 'limit'. The description does not add any parameter-specific semantics beyond what the schema provides, such as format examples or usage tips, resulting in the baseline score for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get incidents for a specific monitor — periods when the monitor was down.' It specifies the verb ('Get'), resource ('incidents'), and scope ('for a specific monitor'), but does not explicitly differentiate it from sibling tools like 'list_incidents' or 'get_check_results', which would require a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention sibling tools like 'list_incidents' (which might list all incidents) or 'get_check_results' (which could provide different data), nor does it specify prerequisites or exclusions, leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=false, and destructiveHint=false, covering the core safety profile. The description adds the scope constraint ('active incidents across all monitors') which provides useful behavioral context beyond annotations, but doesn't address other aspects like pagination, sorting, or response format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the essential purpose without any wasted words. It's appropriately sized for a simple list operation with no parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only list operation with good annotations but no output schema, the description provides adequate but minimal context. It specifies scope ('active incidents across all monitors') but doesn't explain what constitutes an 'active' incident, return format, or how results are organized. The annotations help but don't fully compensate for the missing output details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the schema fully documents the input structure (none required). The description appropriately doesn't need to explain parameters, and the baseline for this situation is 4 since there are no parameters to document.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and resource ('all active incidents across all monitors'), providing a specific verb+resource combination. However, it doesn't explicitly distinguish this tool from its sibling 'get_monitor_incidents', which appears to be a more targeted version of incident retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_monitor_incidents' or 'get_check_results'. It doesn't mention prerequisites, exclusions, or comparative use cases with sibling tools, leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a read-only, non-destructive, closed-world operation. The description adds minimal behavioral context by specifying 'public status pages' and 'for your account', which clarifies scope but doesn't detail aspects like pagination, rate limits, or response format. No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function without any unnecessary words. It is appropriately sized and front-loaded, making it easy to understand at a glance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, read-only operation) and lack of an output schema, the description is adequate but has clear gaps. It doesn't explain what the output looks like (e.g., list format, fields included) or mention any limitations like pagination, which could be important for an agent using this tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the schema fully documents the inputs. The description adds no parameter information, which is acceptable here since there are no parameters to explain. A baseline of 4 is appropriate as the description doesn't need to compensate for any gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all public status pages configured for your account'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_monitors' or 'list_incidents', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'list_monitors' or 'list_incidents', nor does it mention any prerequisites or contextual constraints. It simply states what the tool does without usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate destructiveHint=true (mutation) and readOnlyHint=false, which the description aligns with by using 'Update'. The description adds context about what gets modified ('configuration') and examples of fields (name, URL, interval, method), providing useful behavioral details beyond annotations, though it doesn't cover rate limits or auth needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action ('Update an existing monitor's configuration') and includes relevant examples without unnecessary details. Every word earns its place, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, destructive operation) and lack of output schema, the description is adequate but incomplete. It covers the action and examples of configurable fields, but doesn't address return values, error conditions, or dependencies on other tools, leaving gaps for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are well-documented in the schema. The description lists example fields (name, URL, interval, method, etc.), which adds marginal semantic context but doesn't provide additional meaning beyond what the schema already specifies for each parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Update') and resource ('existing monitor's configuration'), making the purpose evident. It distinguishes from siblings like 'create_monitor' by specifying 'existing', but doesn't explicitly differentiate from other update-related tools (though none are listed).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. While it implies usage for modifying monitors, there's no mention of prerequisites (e.g., needing monitor ID), exclusions, or comparisons to siblings like 'get_monitor' for checking current configuration.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, covering safety and scope. The description adds useful context about optional filtering and pagination, which are behavioral traits not captured in annotations. However, it doesn't mention rate limits, authentication needs, or what happens with large result sets beyond pagination.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('List all uptime monitors') and then succinctly adds optional features. Every word earns its place with zero redundancy or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only list tool with good annotations and full schema coverage, the description is reasonably complete. It covers the core functionality and optional features. The main gap is the lack of output schema, so the description doesn't explain return values (e.g., structure of monitor objects), but this is mitigated by the tool's simplicity and clear annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear parameter descriptions in the schema itself. The description adds marginal value by mentioning the optional filtering and pagination, but doesn't provide additional semantics beyond what the schema already documents (e.g., format details or usage examples). Baseline 3 is appropriate given high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all uptime monitors'), making the purpose immediately understandable. It distinguishes from other list operations by specifying the resource type (monitors vs incidents or status pages). However, it doesn't explicitly differentiate from 'get_monitor' which retrieves a single monitor, leaving some sibling ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage through the optional filtering parameters (status and pagination), suggesting when to use these features. However, it doesn't explicitly state when to use this tool versus alternatives like 'get_monitor' (single monitor) or 'get_check_results' (detailed results), nor does it mention any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate destructiveHint=true and readOnlyHint=false, which the description aligns with by describing a creation action. The description adds useful context beyond annotations: it specifies the monitor's purpose (periodic URL checks and alerting on failure), which isn't covered by annotations. However, it doesn't detail rate limits, authentication needs, or specific alert mechanisms.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
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 without unnecessary words. It's front-loaded with the main action and includes essential details (URL checking, alerting) in a compact form.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (creation with 5 parameters), annotations cover safety (destructive), and schema fully describes inputs, the description provides adequate context. It explains what the monitor does (checks URL, alerts) but lacks output details (no output schema) and doesn't mention error handling or response format, leaving minor gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all 5 parameters. The description doesn't add any parameter-specific details beyond what's in the schema (e.g., it doesn't explain 'checkInterval' or 'method' further). Baseline is 3 as the schema does the heavy lifting, but no extra value is provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('create a new uptime monitor') and specifies the resource ('that periodically checks a URL and alerts on failure'). It distinguishes from siblings like 'get_monitor' or 'update_monitor' by emphasizing creation rather than retrieval or modification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for setting up URL monitoring but doesn't explicitly state when to use this vs. alternatives like 'update_monitor' or prerequisites. It mentions 'alerts on failure' which hints at its purpose, but lacks explicit guidance on when-not-to-use or comparisons with sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true, but the description adds valuable context about what gets destroyed ('all its check history') and the permanence ('cannot be undone'). This goes beyond the annotations by specifying the scope of destruction and irreversible nature.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero waste - the first states the action and scope, the second warns about irreversibility. Every word earns its place and the most critical information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive operation with good annotations and simple parameters, the description provides adequate context about what gets deleted and the permanence. However, without an output schema, it doesn't describe what the tool returns upon success/failure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with the single 'id' parameter fully documented. The description doesn't add any parameter-specific information beyond what the schema provides, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Permanently delete') and resource ('a monitor and all its check history'), distinguishing it from sibling tools like update_monitor or get_monitor. It provides explicit scope beyond just the monitor itself.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly indicates this should be used for permanent removal of monitors, but doesn't explicitly state when to choose this over alternatives like update_monitor or when not to use it. The irreversible nature is mentioned, which provides some contextual guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![cronalert-mcp MCP server](https://glama.ai/mcp/servers/jaredhobbs/cronalert-mcp/badges/card.svg)](https://glama.ai/mcp/servers/jaredhobbs/cronalert-mcp)

Score Badge

Copy to your README.md:

[![cronalert-mcp MCP server](https://glama.ai/mcp/servers/jaredhobbs/cronalert-mcp/badges/score.svg)](https://glama.ai/mcp/servers/jaredhobbs/cronalert-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/jaredhobbs/cronalert-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server