mcp-uptime-kuma

Server Quality Checklist

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

Latest release: v0.11.9
Disambiguation5/5
Tools are clearly separated by resource and action. getMonitor/listMonitors focus on config while getMonitorSummary covers status, and getHeartbeats/listHeartbeats are explicitly one-monitor vs all-monitors. No overlapping purposes.
Naming Consistency5/5
All tools follow a consistent camelCase verb_noun pattern (get, list, create, update, delete, add, pause, resume, test). The pattern is predictable across all resource types.
Tool Count3/5
31 tools is above the typical range, but the server covers a broad domain (monitors, notifications, Docker hosts, tacos, maintenance, status pages). While heavy, the count is justified by the comprehensive feature set and not extreme enough to be chaotic.
Completeness4/5
Core CRUD coverage is strong: monitors have full lifecycle, notifications and Docker hosts have CRUD, and status pages have full management. Minor gaps exist—maintenance windows lack update/delete, and tags have no update operation—but these are non-blocking for typical workflows.
Average 4.2/5 across 31 of 31 tools scored. Lowest: 3.6/5.
See the Tool Scores section below for per-tool breakdowns.
- 20 of 22 community issues answered or closed in the last 6 months
- 29 commits in the last 12 weeks
- Last stable release on August 16, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
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

Behavior2/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 only states that it creates a notification channel and that config fields vary; it does not disclose potential side effects (e.g., overwriting behavior, required permissions, idempotency, or whether existing channels with the same name are rejected). For a mutation tool with zero annotation coverage, this is a significant transparency gap, though the output schema may compensate for return semantics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences and front-loaded with the core purpose. The second sentence provides necessary elaboration on config dependencies without waste. It's compact and easily scannable, meriting a strong score, though it could be slightly more structured with explicit headings or bullet lists.
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, an output schema exists (as indicated by context), so return values are covered elsewhere. The description handles the main purpose and config variability well. However, it lacks prerequisites, usage timing, and any warnings about side effects. For a create operation with no annotations, it's minimally adequate but not comprehensive.
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?
Schema description coverage is 100%, so the baseline is 3. The description adds value by giving concrete examples for type-specific config (slack webhookURL, ntfy ntfyTopic & ntfyServerUrl, discord discordWebhookUrl), clarifying the abstract `config` object. This exceeds what the schema alone provides, earning a 4.
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 starts with 'Creates a new notification channel', clearly identifying the verb and resource. It distinguishes from siblings like updateNotification, deleteNotification, and listNotifications by implying creation. The phrasing is specific and unambiguous.
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 does not explicitly state when to use this tool vs. alternatives (e.g., updateNotification for editing). It implies usage context by focusing on creation, but lacks any explicit 'use this when...' or exclusion guidance. The informative note about type-specific fields provides some context, but not strategic usage advice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must carry the full burden of behavioral disclosure. It only says 'Creates' without mentioning side effects such as uniqueness constraints, potential errors, or idempotency, leaving uncertainty about the mutation behavior.
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, concise sentence that immediately states the action and purpose. It is front-loaded with the verb and contains no superfluous information.
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 simple create operation, the description is adequate but lacks details about error conditions, potential conflicts (e.g., duplicate tag names), or the outcome (e.g., return value). It does add some context by mentioning assignability to monitors, but it is not fully complete.
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?
The input schema fully describes both parameters (name and color), providing clear definitions. The tool description adds no additional parameter information beyond what is already in the schema, so the baseline score applies.
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?
Description clearly states the tool creates a new tag, using a specific verb and resource. It implicitly distinguishes from sibling tools like listTags and deleteTag.
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?
It is evident that this tool is for creating tags, and the context 'that can be assigned to monitors' hints at its application. However, it does not explicitly state when to use it over alternatives or exclude certain scenarios, though the simplicity of the operation makes this acceptable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It implies a read-only operation by saying 'Returns', but does not explicitly mention side effects, permissions, or behavior when no windows exist. Minimal disclosure beyond what the name suggests.
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, direct sentence with no unnecessary words. It is appropriately sized and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is a simple retrieval with no parameters and an output schema available. The description adequately conveys that it returns all maintenance windows, and no additional context is needed given the low complexity.
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?
There are zero parameters, so the description does not need to explain any. Schema coverage is 100% trivially, and the baseline for no params is 4.
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 tool's function: 'Returns all scheduled maintenance windows defined in Uptime Kuma.' It uses a specific verb and resource, and distinguishes itself from sibling tools like createMaintenance (which is for creating rather than fetching).
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, nor any exclusions or context. It simply describes what it does without indicating a preferred usage scenario.
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?
No annotations are provided, so the description carries the burden. It discloses the key behavioral trait: the monitor persists but stops sending notifications and collecting data. This is more transparent than a generic 'pauses monitoring' and directly informs the agent of the state change impact.
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 sentence with a concise, clear structure. It front-loads the action and immediately clarifies the non-destructive nature, making it efficient with no wasted words.
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?
With one parameter, complete schema coverage, and an output schema (although not detailed in context), the description sufficiently covers the tool's purpose and effects. However, it doesn't mention prerequisites or effects on related resources, and with no annotations, a slightly richer context could be expected, but it remains adequate.
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 coverage is 100% and the only parameter 'monitorID' is already described as 'The ID of the monitor to pause.' The description adds no additional meaning beyond the schema, so baseline 3 is appropriate as the schema handles the parameter semantics.
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 function with a specific verb ('Pauses') and resource ('a monitor'), and it distinguishes from siblings by explicitly noting the monitor remains in the system but stops checks, which sets it apart from deletion or other monitor operations. It could further differentiate from 'resumeMonitor' but the action is clear.
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 when to use this tool (when you want to stop checks without removing the monitor) but does not explicitly mention alternatives or when not to use it. Given the sibling 'resumeMonitor' exists, a note about resuming could improve guidance, but the contextual implication is adequate.
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?
With no annotations, the description discloses key behaviors: 'Permanently deletes' and 'URL will no longer be accessible.' This conveys irreversibility and an effect. However, it omits details about permissions, dependent resources, or error handling, which are important for a delete operation. The provided disclosures meet minimum adequacy but lack depth.
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 two short sentences, front-loaded with the action and consequence. There is zero redundancy or filler, making it efficient and easy to parse.
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 simple delete tool with one parameter and an output schema, the description adequately covers the core behavior: permanent deletion and URL unavailability. It doesn't explain the output (rightly delegated to the output schema) or mention prerequisites like existing status page, but these are minor gaps for a tool of this simplicity.
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 coverage is 100% with a clear description of the slug parameter. The description adds no new meaning beyond the schema—it restates 'by slug' but doesn't clarify slug format, source, or uniqueness. Per the baseline rule for high schema coverage, this scores a 3.
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: 'Permanently deletes a status page by slug.' It specifies the resource (status page) and the method (by slug), distinguishing it from sibling tools like updateStatusPage or deleteMonitor. It also adds a consequence (URL no longer accessible), making the purpose unmistakable.
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 when a status page needs to be deleted, but it doesn't explicitly state when to use this tool versus alternatives or provide exclusions. The clear name and action make the primary use case obvious, but there's no direct guidance on alternatives or scenarios where deletion might not be appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/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 only states the return fields and 'all configured status pages,' but does not disclose behavior such as read-only safety, pagination, ordering, or any potential side effects. This is minimal disclosure.
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 sentence, front-loaded with the verb 'Returns,' and contains no redundant information. Every word contributes to understanding the tool's purpose and output.
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 simplicity of the tool (no parameters, output schema present), the description adequately covers its purpose and return fields. It could mention pagination or limits, but these are not critical for a basic list operation with an output schema.
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?
The tool has zero parameters, and the schema is an empty object with 100% coverage. Per the baseline for 0 params, the description need not add parameter semantics, and it does not. No ambiguity exists.
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 uses the specific verb 'Returns' with the resource 'all configured status pages' and lists the exact fields (slug, title, visibility, custom domain). This clearly distinguishes it from the sibling tool getStatusPage, which likely retrieves a single page.
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 when you need to list all status pages, but it does not explicitly mention when not to use it or point to getStatusPage as the alternative for a single page. There is no exclusionary guidance, so the usage context is only implied.
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?
No annotations are provided, so the description carries the burden. It mentions 'updates' which implies a mutation, but does not disclose details like required permissions, whether changes are reversible, partial update semantics (only fields provided are updated), or if there are side effects (e.g., applying to existing monitors if applyExisting is set). The description adds minimal behavioral context beyond the action itself.
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 sentence, short and to the point. It front-loads the core purpose and includes one crucial usage hint (use listNotifications for ID). No fluff or redundancy.
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 mutating tool with no annotations and no output schema explanation, the description is relatively sparse. It covers the basic purpose and the ID retrieval, but does not warn about the effects of applyExisting or config nuances, which are possibly important. Given that there is an output schema (though not shown), some weight is given, but completeness is lacking for a complex tool with nested objects.
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%, meaning all parameters have descriptions in the schema. The description does not add extra parameter information beyond what is in the schema. However, it does note that the notification ID should be obtained from listNotifications, which is a useful hint. Baseline is 3 because schema does the heavy lifting.
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 purpose: 'Updates an existing notification channel.' It uses a specific verb (updates) and resource (notification channel), and it differentiates from siblings like addNotification (which would create) and deleteNotification (which would remove). The description also tells the user to use listNotifications to find the ID, which distinguishes it from other update tools.
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 gives clear context: it updates an existing notification channel and instructs to use listNotifications to find the ID. However, it does not explicitly state when not to use this tool or mention alternatives (e.g., addNotification for new channels, deleteNotification for removal). The usage guidance is clear but not exhaustive.
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?
With no annotations provided, the description carries the full burden. It discloses the key behavioral effect (monitors suppressed and show MAINTENANCE) but does not elaborate on side effects, permissions, or reversibility. This is adequate but minimal; no contradiction with annotations exists since none are 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—two sentences, front-loaded with the primary action and its effect. Every word earns its place, with no redundancy or filler.
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 comprehensive input schema and the presence of an output schema, the description is sufficiently complete for a creation tool. It explains the immediate effect and does not need to elaborate on return values or detailed parameter behavior. It could mention scheduling constraints, but the schema covers those.
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?
The input schema covers 100% of parameters with individual descriptions, so the tool description adds no additional parameter semantics. The baseline of 3 applies because the schema does the heavy lifting and the description does not compensate with extra guidance.
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 uses a specific verb+resource ('Schedules a new maintenance window') and states the behavioral effect (monitors suppressed, show MAINTENANCE instead of DOWN). This clearly distinguishes it from sibling getMaintenanceWindows and other create tools.
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 clearly indicates when to use the tool (to schedule maintenance and suppress monitors) but does not explicitly mention when not to use it or alternative tools. The context is clear enough for basic selection, though it stops short of naming alternatives.
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?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It explicitly says 'Permanently deletes' and 'This action cannot be undone,' effectively conveys irreversibility and destruction. It also mentions the side effect of deleting heartbeat history. This is strong transparency, though it does not cover every potential side effect (e.g., cascading deletion of associated resources).
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 two short sentences with no redundant phrasing. It conveys the action, the irreversible effect, and the scope in a minimal, front-loaded manner. Every word adds value.
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 simple delete operation with one parameter and an output schema, the description is mostly complete. It states what is deleted (monitor and heartbeat history) and the permanence. It does not mention any preconditions (e.g., monitor must exist) or authentication requirements, but these are often implied. Given the tool's simplicity and full schema coverage, the description is adequate, though it could add a note about the necessity of a valid monitorID.
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 coverage is 100% (monitorID), and the schema already describes the parameter as 'The ID of the monitor to delete.' The description adds the context that it deletes heartbeat history, but does not elaborate on the parameter's type, constraints, or format beyond what the schema provides. This meets the baseline for full schema coverage.
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: 'Permanently deletes a monitor and all its heartbeat history.' It specifies the resource (monitor) and distinguishes from sibling tools like deleteNotification and deleteTag. The verb 'deletes' is explicit and the scope (heartbeat history) adds precision.
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 purpose is clear, but there is no explicit guidance on when to use this tool versus alternatives such as pauseMonitor or updateMonitor. The irreversible nature is noted, but no recommendation or exclusion is given. The usage context is implied rather than stated.
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?
With no annotations, the description carries the full burden of disclosing behavior. It states 'permanently deletes' (irreversible) and that monitors will stop sending alerts, revealing a side effect. However, it does not mention any error conditions or prerequisites beyond the operation itself, so it is not fully exhaustive.
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 concise and well-structured, consisting of two clear sentences. It avoids unnecessary detail and gets straight to the point, making it easy for an agent to parse and understand the tool's primary function.
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 simplicity, the description provides adequate context: it defines the action (permanent deletion) and the immediate impact (monitors stop using the channel). It does not explain return values or error handling, but since an output schema is present, that information may be covered elsewhere. The description is sufficiently complete for its complexity.
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?
The input schema has a single parameter with a clear description, and the schema coverage is 100%. The tool description itself does not add additional insight about the parameter beyond what the schema already provides, so it meets the baseline for high schema coverage.
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 that the tool permanently deletes a notification channel. It also explains the consequence (monitors using it will no longer send alerts), which makes the purpose unambiguous. It distinguishes itself from sibling tools by specifying 'notification channel' rather than generic deletion.
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 explains what the tool does and its effect, but does not explicitly state when to use it or provide alternatives. It lacks guidance on scenarios like 'use this when a notification channel is no longer needed' or comparison with other delete tools. This is a clear but minimal usage description.
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?
There are no annotations, so the description carries the transparency burden. 'Retrieves' implies a read-only operation, but the description does not explicitly address side effects, sensitive-data handling, or authentication requirements. The includeSecrets security concern is only present in the schema, not in the tool-level description.
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, front-loaded sentence that immediately states the verb and resource, then provides useful examples. Every word earns its place with no padding or repetition.
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?
This is a simple read tool with no required parameters and an output schema available. The description orients the agent effectively by naming key settings and noting 'other configuration options,' making it complete enough for selection and invocation.
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%, and the includeSecrets parameter is fully documented with a clear security warning. The description adds no additional parameter-level meaning, so the baseline score of 3 applies.
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 uses a specific verb ('Retrieves') and a specific resource ('current Uptime Kuma server settings') with concrete examples of returned fields. It is unambiguous and clearly distinguishes this settings-read tool from the monitor/notification/status-page siblings.
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 clearly scopes this to a server-settings retrieval, which is sufficient context for this simple tool. It does not explicitly name alternatives or exclusions, but none are needed since this is the only settings-getter among the siblings.
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?
No annotations are provided, so the description carries the burden. It clearly indicates a read-only operation ('Returns all') with no side effects, but does not disclose any extra behavioral details such as sorting, filtering, pagination, or secret inclusion behavior (which is left to the parameter schema). For a simple list tool, this is adequate but not rich.
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 two sentences, directly states the action and purpose, and includes a relevant relationship to monitors without wasted words. It is front-loaded and perfectly sized for the tool's simplicity.
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 has one optional parameter, a clear schema, and an output schema (as indicated), the description sufficiently identifies what is returned and its relevance. It does not mention error conditions or output formatting, but these are covered by the output schema. For a straightforward list, completeness is strong, though not exhaustive.
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 a detailed explanation for 'includeSecrets' including default behavior, security implications, and global override. The tool description adds no additional parameter information, so it does not improve on the schema's already comprehensive documentation. 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 it 'Returns all docker daemon connections configured in Uptime Kuma' with context that these are referenced by monitors. The verb 'returns' and resource 'docker daemon connections' are specific, and the mention of monitors distinguishes it from sibling Docker host tools like add/update/delete/test.
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 implies usage for retrieving configured Docker hosts and explicitly notes their role in monitors, but does not name alternative tools or state when not to use this tool. While context is clear, there is no explicit exclusion or comparison to alternatives like listMonitors, which would earn a 5.
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?
No annotations are provided, so the description carries the full burden. It states it returns a list of monitor types but does not elaborate on potential errors, auth requirements, or any side effects. For a simple read-only tool, this is minimally acceptable, but it doesn't go beyond the obvious.
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 succinct with two sentences, front-loading the main action ('Returns a list of all available monitor types') and then providing a clear use case. No fluff.
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 no parameters and an output schema, the description covers the essential purpose and usage hint. It doesn't detail output format, but that's unnecessary given the output schema. It's complete for the tool's simplicity.
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?
Tool has zero parametersпадвал, and schema description coverage is 100% (vacuously). The description doesn't need to explain parameters, but it also doesn't add any info about output structure. Baseline 3 applies.
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 tool's action ('Returns a list') and resource ('all available monitor types supported by Uptime Kuma'). It distinguishes itself from sibling tools like listMonitors and getMonitor by focusing specifically on monitor types, not monitor instances.
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 explicitly states a primary use case: 'Use this to discover valid values for type filters in other tools.' This gives clear context for when to use it, though it doesn't mention exclusions or alternative tools, it's sufficient for a simple list tool.
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?
With no annotations provided, the description carries the full burden of disclosing behavior. It states that deletion is permanent and details the cascading effect on monitors (docker_host cleared, monitors survive). This is meaningful transparency beyond the schema. It misses information about permissions or error handling, but covers the key side effect.
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 two sentences long, front-loads the primary action, and adds a critical side-effect clarification without any verbose or redundant wording. Every sentence contributes value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter delete tool with an output schema, the description is complete: it states the action, permanence, and the consequential effect on related monitors. It does not need to explain return values because an output schema exists, and the low complexity means no other context is required.
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 coverage is 100%, and the only parameter is documented in the schema as "The ID of the docker host to delete." The description adds no further semantic detail about the parameter, so the baseline of 3 applies; the schema already provides adequate meaning.
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 specifies a concrete verb and resource: "Permanently deletes a docker daemon connection." It distinguishes this from sibling delete tools like deleteMonitor or deleteNotification by naming the exact target (docker host connection) and by describing the specific side effect on monitors.
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 does not explicitly state when to use this tool versus alternatives, but it communicates an important behavioral consequence: monitors referencing the host will have their docker_host cleared, while the monitors themselves are not deleted. This implicitly warns users not to expect monitor deletion, providing some usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses an important behavioral nuance: the status may be stale for push monitors that have stopped beating, and advises checking lastBeatTime. It also explains the UTC format without a zone marker. This adds transparency beyond the schema, which has 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.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is overly wordy and repetitive. It repeats the same information multiple times: the first sentence introduces the purpose, the second repeats the retrieval of status, the third gives usage, the fourth lists return fields, the fifth lists filters, and the sixth and seventh repeat the staleness warning. This could be condensed significantly for clarity.
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?
The description is fairly complete: it lists the returned fields (ID, name, pathName, active state, maintenance state, status, message, lastBeatTime, type, tags), explains the filter capabilities, and includes the important staleness warning. It does not mention pagination or limits, but for a summary tool, the key aspects are covered.
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?
The schema descriptions already cover all parameters (100% coverage), so the baseline is 3. The description merely restates the filter options (keywords, type, active/maintenance status, tags, parent group, current status) without adding new examples or clarifications beyond what the schema provides.
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 tool retrieves current status for all monitors with UP/DOWN/PENDING/MAINTENANCE states and includes the most recent heartbeat message. It distinguishes itself by being a summary/overview tool, explicitly marked as 'START HERE' for status questions, which contrasts with sibling tools like getMonitor or listMonitors.
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 provides explicit usage scenarios: 'Use this when asked "how is everything doing?", "what's down?", "what's up?", or for any general status overview.' This clearly indicates when to use the tool, though it does not explicitly mention when to use alternatives, it does position itself as the primary entry point for status queries.
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?
No annotations are provided, so the description carries the burden. It discloses that the page is created empty and that subsequent updates are needed, but does not mention any side effects, permissions, or idempotency. It does not contradict annotations (none exist), but could add more behavioral context like whether creation is idempotent or if there are limits.
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 two sentences, front-loaded with the primary action, and every sentence adds value: the first states what it does, the second provides follow-up guidance and slug constraints. No wasted words.
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 is simple (2 params, no nested objects) and has an output schema, the description is fairly complete. It covers the creation action, the need for follow-up updates, and slug constraints. It could mention what the response contains, but the output schema likely covers that. Slight gap on any prerequisites or side effects, but overall adequate.
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 already documents both parameters. The description adds the slug format constraint (lowercase letters, digits, dashes) which is also in the schema pattern, so it adds minimal extra value. 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 tool creates a new empty status page with title and slug, and explicitly notes it is empty, distinguishing it from updateStatusPage which sets additional properties. This is a specific verb+resource with clear scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs to call updateStatusPage after creation to set description, theme, groups, and monitors, providing clear sequential guidance and distinguishing from the sibling tool. It also specifies slug format constraints, which is useful for correct usage.
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?
With no annotations present, the description carries the behavioral disclosure burden. It explicitly explains a non-obvious default: credentials in `config` are withheld and `redactedConfigKeys` lists the withheld field names. It does not cover auth, rate limits, or pagination, but the security-relevant redaction behavior is valuable and clearly disclosed.
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 two tightly written sentences. It front-loads the action and resource, then adds the most relevant operational detail without repetition or filler.
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 simple list tool with one optional boolean parameter and an output schema present, the description is sufficiently complete: it states what is returned, highlights the key id-based usage, and discloses redaction behavior. It omits only non-essential details like pagination or rate limits.
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 baseline is 3. The description adds context about the `config` redaction and the sufficiency of channel ids, but it does not materially expand on the `includeSecrets` parameter beyond what the schema already documents.
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 opens with a specific verb and resource: 'Returns all configured notification channels,' followed by concrete examples (Slack, ntfy, Discord, email, webhooks). This clearly identifies it as a read/list operation and distinguishes it from siblings like addNotification, updateNotification, and deleteNotification.
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 phrase 'To attach a channel to a monitor you only need its id' provides a concrete use case and tells the agent when this tool is useful. It does not explicitly state when not to use it or name alternatives, so it falls just short of full guidance.
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?
With no annotations provided, the description carries the disclosure burden. It reveals that the tool hits the public `/api/status-page/{slug}` endpoint, requires the page to be published, and returns a specific configuration structure. This is helpful behavioral context, though it does not mention error behavior for unpublished or nonexistent slugs.
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 two sentences, front-loaded with the primary purpose, and every clause adds useful information: what is returned, the ordering/grouping, the inclusion of incidents, and the published-only endpoint constraint.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter read operation with an output schema available, the description gives enough context: what is fetched, from where, under what condition, and what the response contains. No further detail about return values is needed because the output schema handles that.
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?
The schema already fully describes the single `slug` parameter as the status page slug (URL-safe identifier), with 100% coverage. The description adds the retrieval-by-slug context, which matches the schema, but it does not add much beyond it. 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 tool returns the full configuration of a status page by slug, listing the contained groups, monitors, and incidents. This distinguishes it from sibling tools like listStatusPages, which would only list pages, and create/update/delete tools, which mutate.
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 gives clear scoping: it only works for published status pages and fetches the public endpoint. It implies use when you need the full configuration for a specific status page, but it does not explicitly mention alternatives like listStatusPages for page discovery or unpublished pages.
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?
No annotations are provided, so the description carries the burden. 'Returns' implies a read-only operation, and the added detail about fields is useful beyond the tool name. However, it does not disclose any side effects, ordering, or auth requirements. It is adequate but minimal for a simple list operation.
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?
Exactly one sentence that fully conveys the purpose without any redundant wording. It is front-loaded with the action and resource, making it highly scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter list tool with an output schema, the description is complete: it states what is returned (all tags) and the included fields. No further context is needed given the simplicity, and the output schema covers return 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?
The tool has zero parameters, so the baseline is 4. The description adds no parameter info, which is appropriate since none exist. The schema is empty and coverage is 100%, so no additional explanation is needed.
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 tool returns all tags in Uptime Kuma, specifying the exact fields (name, color, ID). This is a specific verb+resource (Returns + tags) and distinguishes it from sibling tools like listMonitors or addTag/deleteTag.
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?
While the description does not explicitly say 'use this when you need all tags', it is implicit and there is no alternative listing tool for tags among siblings. The clear scope (all tags) and unique resource make usage context obvious without needing 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?
No annotations are provided, so the description must carry the burden. It discloses that push monitors get a generated token and the ping URL is returned, and notes timeout default (0.8 x interval). However it does not mention other behaviors like error handling, notification side effects, or that the monitor starts active unless active: false (though that is in schema). Moderate transparency.
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?
Four sentences that are front-loaded with the core purpose, then organized by type requirements. No redundancy or filler. Efficient use of words.
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 (36 params, nested objects) and the presence of an output schema, the description covers type-specific requirements and key return value for push monitors. It doesn't fully describe all return values but the output schema likely handles that. It's reasonably complete without being exhaustive.
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?
Schema covers all 36 parameters with descriptions, so baseline is 3. The description adds value by explaining which params are required per type, and clarifies that pushToken can be omitted for generation, and timeout defaults. This goes beyond schema descriptions and helps with parameter interdependencies.
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?
Starts with 'Creates a new monitor in Uptime Kuma' – a specific verb and resource. Clearly distinguishes from sibling update/delete tools. Also describes type-specific requirements, reinforcing the purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states at minimum name and type, and gives per-type required parameters (HTTP needs url, TCP/port needs hostname/port, json-query needs url/jsonPath etc.). Advises to use listMonitorTypes for supported types, contrasting with alternatives. Also explains push token generation,
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?
With no annotations, the description carries the full burden of disclosing behaviors. It reveals default behavior: 'By default returns only the most recent heartbeat per monitor.' It also discloses a security-relevant behavior: credentials in status message URLs are masked as '***' unless includeSecrets is set, and warns that the output is persisted in logs, adding important context about data exposure. This goes beyond the baseline and provides meaningful transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured logically, leading with the main purpose, then usage guidance, then parameter details, and finally a security note. It is somewhat dense but not verbose; each sentence adds value. The repetition of maxHeartbeats in different contexts is justified for clarity. Overall, it is concise while covering necessary information.
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 output schema exists (though not shown), the description need not explain return values. It covers the tool's scope, default behavior, parameter semantics, and a potential side effect (log persistence). It does not mention error conditions or authorization, but for a list endpoint with a clear schema, the provided information is sufficient to understand and use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers all parameters with descriptions, but the tool description adds crucial semantic detail. For count and limit, it explains they are aliases and recommends maxHeartbeats. For maxHeartbeats, it specifies the default (1) and the maximum (100). For includeSecrets, it clarifies the default (off), the effect on output, and the global configuration option. This enriches the schema and leaves no ambiguity about parameter usage.
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 tool's primary function: 'Retrieves historical heartbeat data for ALL monitors.' It specifies the resource (heartbeat data) and the scope (all monitors), distinguishing it from sibling tools like getHeartbeats which likely target a single monitor. The mention of 'response times, status changes over time' further clarifies what the data contains.
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 provides explicit usage context: 'Use this for analyzing patterns across multiple monitors or correlating events.' It also explains when to adjust parameters: 'By default returns only the most recent heartbeat per monitor; set maxHeartbeats for historical analysis.' While it does not explicitly mention alternative tools, the emphasis on 'ALL monitors' implies that for single-monitor queries, a different tool might be appropriate, giving adequate guidance.
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?
Description discloses it does not persist (non-destructive) and that on success the message includes the number of containers. No annotations are provided, so this behavior disclosure is valuable. Could add details about failure modes or side effects, but it is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the primary purpose and followed by a clear usage hint. No wasted words.
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?
Tool is a simple test with three required parameters, all described in schema, plus output schema exists. The description adds context about usage sequence and result message. Sufficient for the tool's complexity.
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 covers 100% of parameters with descriptions. Description adds overall purpose but does not add extra parameter details beyond schema. Baseline 3 applies because schema is already descriptive.
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?
Clearly states it tests connectivity to a docker daemon without persisting, and distinguishes itself from related tools like addDockerHost by explicitly mentioning it is a pre-check to avoid saving broken configurations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly recommends using this tool before addDockerHost, providing clear when-to-use guidance and implicitly saying when not to (before persisting).
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?
With no annotations, the description must disclose behavior, and it does: 'Only the fields you pass are changed — the others are preserved.' This reveals that it performs a partial update, which is critical for correct invocation. It omits error handling details but such are typical for simple tools.
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 two sentences: the first states the purpose, the second provides the usage hint and behavioral note. It is front-loaded and contains no extraneous information.
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 simplicity (4 params, 1 required, output schema present), the description is adequate. It covers ID discovery and partial update behavior. It could mention error cases, but these are generally implied and the output schema likely covers return values.
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?
Schema coverage is 100%, so the baseline is 3. The description adds value by explaining that optional parameters are applied partially, preserving omitted fields. This goes beyond the individual parameter descriptions and clarifies the semantics of the whole update operation.
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 'Updates an existing docker daemon connection,' specifying the verb and resource. It distinguishes from sibling tools like addDockerHost (creation) and deleteDockerHost (deletion) by emphasizing 'existing.'
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?
It provides explicit guidance to 'Use listDockerHosts to find the docker host ID,' which is a necessary prerequisite. It does not name alternative tools like addDockerHost for creation, but the context from siblings makes the intended use clear.
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?
With no annotations provided, the description must carry the full behavioral burden. It clearly identifies a create/mutation operation but does not disclose behaviors like duplicate handling, permissions required, or whether the connection is validated at creation time. The testDockerHost hint implies validation may be separate, which helps, but more detail on side effects would improve transparency.
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?
Three sentences entirely focused on usage. No filler or repetition, front-loaded with the core verb and resource. Examples are embedded naturally.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a create tool with three parameters, full schema coverage, an output schema, and clear usage examples in the description, this is complete. The suggestion to call testDockerHost first also fills the main operational prerequisite.
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?
The input schema already covers parameter meaning 100%, so baseline applies. The description adds extra value by providing exact pairing of dockerType values with valid dockerDaemon formats (e.g., unix socket vs tcp URL), going beyond the schema docs.
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?
Description clearly states it 'Creates a new docker daemon connection', a specific action on a specific resource. This distinguishes it from sibling tools that list, update, delete, or test Docker hosts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage guidance for both supported dockerType values, with concrete example values for dockerDaemon. It also recommends calling testDockerHost first to verify reachability, which is clear when-to-use advice.
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?
With no annotations provided, the description carries the full burden. It discloses the permanence of the deletion and its cascade to all monitors using the tag, which is key behavioral context. It does not mention permissions or other limitations, but the essential side effects are clear.
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 succinct sentences. The first covers action and consequence; the second provides a useful tip. No filler, each sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter delete tool, the description explains the permanent nature, the impact on monitors, and how to obtain the required ID. No output schema is expected for a delete, and the description fully prepares the agent for invocation.
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?
The schema defines tagID as the ID of the tag to delete (coverage 100%). The description adds a practical hint on sourcing the tag ID via listTags, enhancing the schema without redundancy.
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 tool deletes a tag permanently and specifies the cascading effect on monitors. It uses a specific verb ('deletes') and resource ('tag'), and distinguishes from siblings like addTag or listTags by focusing on deletion and its impact.
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 provides a concrete usage hint ('Use listTags to find the tag ID'), which guides the user on a prerequisite step. It does not explicitly mention when not to use it or alternatives, but for a simple delete operation this is adequate.
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?
No annotations are provided, so the description carries the full burden. It mentions the side effect of restarting checks but does not describe error cases, permissions required, or behavior if the monitor is already running or not paused. Transparency is moderate but not fully comprehensive.
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, using only two sentences to convey the action, effect, and usage context. No fluff or redundancy exists.
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?
The description is sufficient for a simple resume operation: it explains what it does and when to use it. It does not specify the return value or output, but given the absence of an output schema and the straightforward nature of the action, this is not a significant gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter monitorID is fully described in the schema with a clear explanation ('The ID of the monitor to resume'). The tool description does not need to repeat it, and there is no ambiguity about what the parameter represents.
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 (resume a paused monitor) and its effect (restart all checks). It distinguishes from the sibling pauseMonitor by specifying the opposite action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use it: 'Use this to re-enable monitoring after pausing.' This gives a clear context and prerequisite (the monitor must be paused), leaving no ambiguity about when this tool is appropriate.
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?
With no annotations, the description carries the full burden of warning about behavioral traits. It explicitly notes that both the config and publicGroupList 'are replaced wholesale', highlighting the potentially destructive, non-merge nature of the update. It also specifies the group shape and the recommendation to read first, adding meaningful context beyond the schema.
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?
Three sentences, each earning its place. The first states the action, the second explains the wholesale replacement behavior with shape details, and the third gives the recommended preceding call. No filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex tool with nested objects and an output schema, the description fully explains the core workflow: get current state, pass full config, replace publicGroupList with properly shaped groups. Return values are covered by the output schema, so no further detail is needed. It is complete and self-sufficient.
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?
The input schema already has 100% coverage with detailed descriptions, including the immutable slug, config fields, and imgDataUrl behavior. The description adds critical semantics not fully in the schema: must pass the 'full' config and publicGroupList because they are replaced wholesale. This clarifies the mental model for invocation.
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 'Updates an existing status page', a specific verb+resource that distinguishes it from sibling tools like createStatusPage, deleteStatusPage, and getStatusPage. The replacement semantics and mention of existing state eliminate ambiguity.
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?
It provides a clear usage directive: 'Use getStatusPage first to read current state before modifying.' This establishes a necessary prerequisite and contextual workflow. It doesn't explicitly name alternatives like createStatusPage for new pages, but for an update tool the prerequisite guidance is sufficient.
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?
With no annotations provided, the description carries the burden of transparency. It discloses the critical partial-update behavior ('only the fields you provide will be changed') and the need for monitorID. However, it doesn't mention side effects like pushToken invalidation or permission requirements, though these are partly covered in the schema descriptions. A 4 is appropriate as it conveys the core mutation semantics clearly without overstating.
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 three short sentences, front-loaded with the main purpose. Every sentence adds value: purpose, requirement, merge behavior, and a practical tip. Zero filler, perfectly concise.
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 high complexity (38 parameters, nested objects) and the presence of an output schema, the description is sufficient but not exhaustive. It covers the essential usage prerequisites and behavior. It could benefit from a brief example or a pointer to createMonitor for field details, but the combination with the schema makes it complete enough. A 4 balances the need for more context against the schema's richness.
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?
The schema has 100% parameter coverage, so the description doesn't need to explain individual fields. However, it adds the overarching rule that only provided fields are updated (server merge), which is a global semantic not visible in any single parameter description. This goes beyond the schema and clarifies how all parameters interact, earning a 4.
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 'Updates an existing monitor configuration' with a specific verb and resource, distinguishing it from createMonitor and deleteMonitor siblings. It also explicitly requires the monitorID, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides explicit guidance: you must include monitorID, and it recommends using getMonitor first to fetch the current config. It implicitly tells when not to use it (when creating a new monitor) by phrasing as 'existing monitor', and the merge behavior clarifies how partial updates work.
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?
The description explains default output (common fields plus runtime data) and the effect of includeTypeSpecificFields, giving insight into behavior. It implicitly indicates read-only retrieval, though it does not explicitly state permissions or side effects; however, the retrieval wording is sufficient.
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 concise, with clear sentence structure: action, usage, alternative, and parameter behavior. No filler or redundancy, and it remains within a reasonable length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema exists, the description need not detail return structure. It covers default fields, optional inclusion, and the relationship to getMonitorSummary, providing sufficient context for correct usage.
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?
The description adds meaning beyond the schema by explicitly explaining includeTypeSpecificFields with examples (url for HTTP, hostname/port for TCP) and its default behavior. It does not mention includeSecrets, but the schema already provides a description for that parameter, so the description adds value without redundancy.
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 tool retrieves configuration details for a specific monitor by ID, listing example fields (URL, check interval, notification settings). It also distinguishes from getMonitorSummary for current status, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit guidance is provided: 'Use this when you need to examine or modify settings for a specific monitor' and 'For current status, use getMonitorSummary instead,' offering both when-to-use and when-not-to-use with an alternative.
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?
With no annotations, the description carries full behavioral context. It discloses default output fields (common fields + uptime/avgPing), the effect of includeTypeSpecificFields, and a security-relevant detail about includeSecrets persisted in transcripts. It doesn't mention every internal behavior, but for a read-only list tool it's sufficiently transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with purpose, moves to differentiation, then parameter behavior, then filter capabilities. Every sentence contributes useful information without redundancy or filler. It's appropriately sized for a complex list tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers purpose, alternatives, default behavior, field variance, secret exposure, and full filter capabilities—all relevant for an agent to choose and invoke correctly. With no required parameters and an output schema present, this description fully completes the context needed for this tool.
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?
The input schema already has 100% coverage for parameters, but the description enriches semantics by explaining the inclusion of type-specific fields (e.g., url for HTTP, hostname/port for TCP) and emphasizing the privacy implications of includeSecrets. This adds value beyond the schema definitions.
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?
Description clearly states it retrieves configuration details for all monitors with a specific list of content (URLs, intervals, notification settings). It also distinguishes itself from getMonitorSummary, ensuring the agent learns exactly when to choose this tool over a sibling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool (examine/modify settings) versus when to use getMonitorSummary for status checks. This is a clear usage directive with a named alternative, eliminating ambiguity for an agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full behavioral disclosure. It reveals NEWEST-FIRST ordering, the default of one heartbeat, the meaning of important:true (status changes only, not current state), and credential masking unless includeSecrets is set.
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 dense but not bloated; every sentence contributes behavioral or usage guidance. Key caveats are front-loaded and the most critical warnings (important semantics, secrets) are clearly separated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with six parameters and an output schema, the description covers all non-obvious behaviors: ordering, default count, result limits, important-mode semantics, and secret handling. Return values are not described because an output schema exists.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Although the input schema already has full descriptions, the description adds meaningful beyond-schema context: default heartbeat behavior, a practical maxHeartbeats policy, the 'status changes only' trap for important, and the status-message-URL masking behavior for includeSecrets.
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 ('Retrieves historical heartbeat data'), the resource ('heartbeat data'), and the scope ('for a specific monitor'), which distinguishes it from broad monitor-listing tools. The phrase 'for one monitor' reinforces its focused purpose.
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?
It explicitly says 'Use this for analyzing patterns or history for one monitor' and gives usage guardrails like 'Keep maxHeartbeats ≤10 unless user requests more.' It does not explicitly name alternatives or state when not to use it, so it stops short of a 5.
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:

[![mcp-uptime-kuma MCP server](https://glama.ai/mcp/servers/DavidFuchs/mcp-uptime-kuma/badges/card.svg)](https://glama.ai/mcp/servers/DavidFuchs/mcp-uptime-kuma)

Score Badge

Copy to your README.md:

[![mcp-uptime-kuma MCP server](https://glama.ai/mcp/servers/DavidFuchs/mcp-uptime-kuma/badges/score.svg)](https://glama.ai/mcp/servers/DavidFuchs/mcp-uptime-kuma)

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/DavidFuchs/mcp-uptime-kuma'

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