Uptime monitoring: monitors, incidents, alerts, maintenance, on-call, status pages and telemetry.
Scored across 2 tools
The two tools have entirely distinct purposes: search_tools discovers available Uptimely tools, while execute_typescript runs code that invokes them. There is no functional overlap or plausible misselection between them.
Both names follow a strict verb_noun snake_case convention (search_tools, execute_typescript). The pattern is predictable and readable throughout.
Two tools is below the typical 3-15 range, but for a code-mode gateway that dynamically exposes arbitrary Uptimely tools, a search+execute pair is a reasonable minimal interface. It is slightly thin but each tool clearly earns its place.
The server's domain is dynamic tool orchestration, and the surface covers the full loop: discovery via search_tools and invocation via execute_typescript. No obvious discovery or execution gap remains.
Run a short TypeScript program that orchestrates Uptimely MCP tools (found via search_tools) in an isolated sandbox. See the server instructions for the full contract.
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | A TypeScript program body run in an isolated sandbox. Call the external_* functions search_tools declared; the program must `return` its result. |
| Name | Required | Description |
|---|---|---|
| logs | No | |
| error | No | |
| result | No | |
| success | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true, openWorldHint=true, and readOnlyHint=false, so the safety profile is covered structurally. The description adds useful context ("isolated sandbox", program must return its result), but it does not disclose what the destructive capability actually affects or any rate/permission constraints, and it defers the "full contract" to external server instructions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences, front-loaded with the core action and scope. No filler, and the pointer to server instructions is at the end rather than padding the opening.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be re-explained. But for a destructive, open-world code-execution tool built on a non-obvious contract (how to call external_* functions, limits, error behavior), the description offloads the essential contract to "server instructions" instead of making the definition self-sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter, and schema coverage is 100% — the schema already explains that `code` is a TypeScript program body calling external_* functions and returning a result. The description adds "short" as a size qualifier but little else beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ("Run a short TypeScript program") plus the orchestration scope (Uptimely MCP tools discovered via search_tools) and the environment (isolated sandbox). It clearly distinguishes itself from its only sibling by naming search_tools as the discovery mechanism that feeds this tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied: use search_tools to find tools, then orchestrate them here. However, there is no explicit when-to-use vs. calling tools directly, no exclusions, and the operative guidance is punted to "the server instructions for the full contract" rather than stated here.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find the Uptimely MCP tools this connection can reach, returned as TypeScript declarations to call from execute_typescript. See the server instructions for the full contract.
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | Case-insensitive substring matched against each tool's name, title and description. Omit to return every tool this connection can reach. |
| Name | Required | Description |
|---|---|---|
| count | Yes | |
| declarations | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description usefully adds the return format (TypeScript declarations callable from execute_typescript) and the reach scope, but defers the operational contract to server instructions rather than disclosing it.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with the core action and return shape front-loaded. The trailing pointer to server instructions is a minor deferral rather than wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need no explanation, and the description covers scope and the discovery-to-execution wiring. The gap is the handoff of the "full contract" to server instructions, which leaves the description alone insufficient for an agent that has not read them.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single query parameter is fully documented in the schema, including the omit-to-return-all behavior. The description adds nothing about the parameter, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ("Find") and resource ("the Uptimely MCP tools this connection can reach") and adds the return shape ("TypeScript declarations to call from execute_typescript"), which implicitly positions it as the discovery step before its only sibling. It does not explicitly say "use this instead of execute_typescript when you need discovery," so differentiation is inferred rather than stated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The mention of execute_typescript implies this is used first to discover tools, but no explicit when-to-use or when-not-to-use guidance is given. The phrase "See the server instructions for the full contract" pushes the actual usage contract out of the description entirely.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
execute_typescriptsearch_toolsUptime monitoring and public status page: HTTP monitors, down/up alerts and incidents.
Uptime, API and server monitoring with outages, reporting, on-call and status pages.
Website uptime monitoring: run checks from 300+ locations, manage monitors, alerts and incidents
Uptime monitoring for developers — monitors, incidents, heartbeats, maintenance, status pages
Add one secure layer between your agents and this server.
