Whether 22 is a common TCP/UDP port.
Most tools have distinct outputs, but citation and normalize-url both consume URLs and return overlapping components, which could cause misselection. compatibility is also too vague to clearly place, while timezone/utc-time/iana-zones are related but reasonably distinct.
All tool names are lowercase and hyphenated, which keeps them visually consistent, but they mix bare nouns like timezone and citation with verb-object names like normalize-url and validate-json. This is readable but not a consistent naming pattern.
Eleven tools is a reasonable count, but the set feels like a miscellaneous utility bag rather than a tightly scoped server. Several one-off tools such as port-22, validate-json, and utc-time appear unrelated to each other and to the apparent 'Port 22' theme.
There is no coherent domain established, making coverage hard to assess. URL tools lack header or content retrieval, time tools lack conversion capabilities, and the overall surface has no clear lifecycle or operation pattern. Significant expected functionality for a network/utility server is missing.
Return host, scheme, and HTTP status for a URL. Page content is not stored.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | HTTPS URL to normalize or cite | |
| host | No | Public hostname | |
| json | No | JSON text to validate; discarded after the check | |
| zone | No | IANA timezone name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. It adds a useful disclosure ('Page content is not stored'), indicating a stateless, non-persistent operation. However, it does not state whether the tool makes an HTTP request, follows redirects, or handles failures, leaving meaningful behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with the core purpose front-loaded and a relevant privacy caveat following. It is concise and scannable, though it sacrifices completeness, especially regarding the json and zone parameters.
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?
Despite having four optional parameters and no output schema, the description only addresses the url-related behavior. The json and zone parameters are ignored in the prose, making the tool's full scope ambiguous. An agent would need to infer the tool's multi-purpose nature solely from the schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameters url, host, json, and zone are each documented in the schema. The description adds no parameter-level meaning beyond mentioning 'URL', and it notably omits the json and zone parameters entirely, though the schema compensates for this.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Return host, scheme, and HTTP status') and resource ('URL'), which aligns with the tool name 'citation'. However, it does not differentiate from sibling tools like 'normalize-url' or 'http-status', so an agent may not know this is the right tool among alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as normalize-url, validate-json, or timezone. The description lacks any mention of context, exclusions, or conditions that would direct an agent to choose citation over its siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Show how this request is classified. No identifiers are retained.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | HTTPS URL to normalize or cite | |
| host | No | Public hostname | |
| json | No | JSON text to validate; discarded after the check | |
| zone | No | IANA timezone name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It adds one meaningful trait—'No identifiers are retained'—but does not explain side effects, request handling, failure behavior, or what the classification output looks like.
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 short sentences with no filler, and the privacy guarantee is placed efficiently after the main action. However, the first sentence's vagueness slightly reduces the value of that efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no output schema and no annotations, the description is too thin to tell an agent what to supply, what result to expect, or how the parameters relate to the classification. The missing return semantics and ambiguous purpose make it incomplete for reliable invocation.
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?
The schema already documents all four parameters with 100% coverage, so the baseline is 3. The description adds no additional meaning about how url, host, json, and zone are used or combined in the compatibility classification.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a verb and object ('Show how this request is classified') but never defines what 'compatibility' means or what classification dimensions are involved. It is not a tautology, yet it remains vague and does not distinguish itself from sibling tools like validate_json or normalize_url.
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?
There is no guidance about when to use this tool versus its siblings, and no exclusions or alternative routes are mentioned. The only contextual hint is 'No identifiers are retained,' which addresses privacy, not usage conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Split a hostname into labels without WHOIS or ownership data.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | HTTPS URL to normalize or cite | |
| host | No | Public hostname | |
| json | No | JSON text to validate; discarded after the check | |
| zone | No | IANA timezone name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals a pure transformation ('split a hostname') and a negative scope ('without WHOIS'), but says nothing about return value, side effects, permissions, or edge-case behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single tight sentence with no filler, front-loading the core action and object. It is concise, though it omits meaningful context about the full parameter set.
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?
The tool has no annotations, no output schema, and four parameters, yet the description only addresses one function. It fails to explain how json and zone fit into the tool, leaving an agent uncertain about selecting it for those inputs.
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 descriptions cover 100% of parameters, so the baseline is 3. The description adds minimal meaning by implying that host or url are the inputs for hostname splitting, but the json and zone parameters remain unexplained and appear unrelated to the stated purpose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Split a hostname into labels', and adds the exclusion 'without WHOIS or ownership data' to distinguish it from enrichment tools. However, it does not mention the json and zone parameters, so the overall purpose is only partially delimited.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives. It does not name sibling tools like normalize-url or validate-json, nor does it state conditions, prerequisites, or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Common IANA timezone names for clock calls.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | HTTPS URL to normalize or cite | |
| host | No | Public hostname | |
| json | No | JSON text to validate; discarded after the check | |
| zone | No | IANA timezone name |
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 labels the content ('common IANA timezone names') without describing what the call does (returns a list, checks a name, loads zones), and three schema parameters (url, host, json) with descriptions about normalizing/citing/validating are never accounted for, so an agent cannot predict the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single seven-word sentence with zero filler, so it is concise and front-loaded. But it is under-specified to the point of reading like a catalog label rather than a tool definition, so it does not earn a high structural score.
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?
With no annotations, no output schema, and four optional parameters, the description must supply most of the context, and it does not: it omits return shape, which parameters are relevant, and the underlying operation. The unrelated url/host/json parameters make this omission actively costly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3; each parameter has its own description. But the parameter descriptions appear imported from sibling tools (url: 'normalize or cite', json: 'validate; discarded'), and only `zone` matches the tool's stated purpose — the description offers no help resolving that mismatch.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the resource ('IANA timezone names') and the intended context ('for clock calls'), so an agent can guess the tool returns common zone names. However, it lacks a verb and never states the operation (list, lookup, validate), and the schema's url/host/json parameters suggest unrelated behavior, weakening clarity.
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 only guidance is the phrase 'for clock calls,' which implies the tool is the source of timezone names when invoking clock tools. There is no explicit when-to-use versus alternatives like citation/normalize/validate/json, and no exclusionary guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch a public robots.txt and return group counts only.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | HTTPS URL to normalize or cite | |
| host | No | Public hostname | |
| json | No | JSON text to validate; discarded after the check | |
| zone | No | IANA timezone name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. It clearly indicates a network read operation ('Fetch a public robots.txt') and a limited return ('group counts only'), which is useful. However, it does not mention error behavior, missing robots.txt handling, or any rate/access limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no filler. Every word contributes: the fetch action, the resource, and the constrained return type.
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?
There is no output schema and no annotations, and the four parameters are irrelevant or ambiguous in context. The description leaves critical gaps: which parameter to use, what happens when robots.txt is unavailable, and the exact shape of the returned group counts. It is too sparse to make the tool safe to invoke correctly.
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?
Although schema coverage is 100%, the parameter descriptions are generic and appear reused from other tools: 'HTTPS URL to normalize or cite', 'JSON text to validate', and 'IANA timezone name'. The description does not say which parameter identifies the robots.txt target, so an agent cannot reliably map the four unrelated parameters to the operation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Fetch'), a specific resource ('public robots.txt'), and a precise return scope ('group counts only'). This clearly differentiates it from siblings like normalize-url, citation, and validate-json, which are not about robots.txt inspection.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool versus alternatives, nor does it mention any conditions or exclusions. The name implies a focused use, but there is no explicit when-to-use or when-not-to-use information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return origin, host, and path for a URL. Query and fragment are dropped.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | HTTPS URL to normalize or cite | |
| host | No | Public hostname | |
| json | No | JSON text to validate; discarded after the check | |
| zone | No | IANA timezone name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses a key behavioral trait: query parameters and fragments are dropped, which is essential for an agent to predict output. It does not mention what happens with invalid URLs, whether the input is validated, or whether the output is returned as a single string or separate fields, but the core behavior is honestly and usefully disclosed. The description itself is not misleading and adds meaningful behavioral context beyond just 'normalize'.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long with zero waste. The primary behavior is front-loaded ('Return origin, host, and path') and the most important behavioral detail ('Query and fragment are dropped') is stated immediately after. Every word earns its place and the structure makes the tool's core function immediately clear.
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?
There is no output schema, so the description should clarify what output the agent can expect. It says what parts are returned but not the format (e.g., a string, an object, separate fields). The tool also accepts four parameters including 'host', 'json', and 'zone', which are not explained in the description at all; their presence is confusing given the stated purpose. For a simple tool the core behavior is clear, but the mismatch between the description's focus on URL normalization and the full parameter list leaves an agent with gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so every parameter has a description in the schema: url, host, json, and zone. However, the schema descriptions are thin and the tool description explains none of them beyond implying 'url' is the primary input. The description adds no extra meaning about parameter formats, defaults, or how the 'host', 'json', and 'zone' parameters relate to the tool's stated purpose of returning origin/host/path. The description does not help an agent understand why 'json' and 'zone' parameters exist, which is a significant gap given they seem unrelated to URL normalization.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Return origin, host, and path for a URL') and the scope of that action ('Query and fragment are dropped'). It tells the agent exactly what the tool computes and what it discards, which fully distinguishes it from generic URL utilities. The verb 'Return' plus the explicit list of components (origin, host, path) makes 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.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly conveys when to use the tool: when you need the origin, host, or path of a URL and want query strings and fragments removed. It does not explicitly name alternative tools or state when NOT to use it, but for a simple normalization tool the usage context is clear from the behavior described. The absence of explicit exclusions is a minor gap given the tool's simplicity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Whether 22 is a common TCP/UDP port.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | HTTPS URL to normalize or cite | |
| host | No | Public hostname | |
| json | No | JSON text to validate; discarded after the check | |
| zone | No | IANA timezone name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses nothing about side effects, network access, input handling, or what the result represents. The disconnected parameters (url, host, json, zone) make the behavior even more opaque.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short and contains no redundant words. However, it is only a fragment starting with 'Whether', and it omits essential structural elements like a clear verb or subject, so brevity comes at the cost of clarity.
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?
This tool has four parameters, no annotations, and no output schema, so the description must explain how inputs relate to the tool's behavior and what the agent should expect. It does neither, making it impossible to call correctly with confidence.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so each parameter has a basic documented meaning, giving a baseline of 3. However, the tool description adds no connection between these parameters and the port-22 check, so an agent cannot understand why 'json' or 'zone' would be relevant.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description reads as a fragment ('Whether 22 is a common TCP/UDP port') rather than naming an action. It references port 22 but gives no verb such as 'check', 'verify', or 'look up', so the agent cannot tell what operation the tool performs. It also does not distinguish itself from siblings such as citation, compatibility, or status-catalog.
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?
There is no guidance about when to use this tool versus its siblings. The description does not mention alternatives, exclusions, or conditions under which port-22 is the correct choice, leaving the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Short catalog of common HTTP status codes.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | HTTPS URL to normalize or cite | |
| host | No | Public hostname | |
| json | No | JSON text to validate; discarded after the check | |
| zone | No | IANA timezone name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. The description is brief and does not disclose any side effects or return format. It is a catalog, implying read-only behavior, but leaves behavioral details to inference.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single short sentence, front-loaded purpose, no waste. Very concise and to the point.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple catalog tool with full schema coverage, the description is minimal but sufficient. It does not explain return values but no output schema is present; still, the scope is clear.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% of parameters, so the description does not need to repeat them. The description adds no value beyond the schema but matches the schema's completeness.
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 clear purpose: a short catalog of common HTTP status codes. The verb 'catalog' names the resource and the subject matter. It lacks explicit distinction from siblings, but the title and description are self-explanatory.
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?
Implies use when one needs a compact reference of HTTP status codes, but does not state when to use it instead of the sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Current time in a named IANA timezone.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | HTTPS URL to normalize or cite | |
| host | No | Public hostname | |
| json | No | JSON text to validate; discarded after the check | |
| zone | No | IANA timezone name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the burden. It implies a read-only operation but omits what time format is returned, how invalid timezones are handled, and importantly that the schema also accepts url, host, and json inputs whose behavior is undisclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence with no filler. It communicates the core function immediately.
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?
With four optional parameters, no output schema, and no annotations, a one-sentence description is insufficient. It does not explain how the url, host, and json parameters relate to the timezone function, or what happens if none are provided.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so each parameter is already documented. The description only reinforces the zone parameter and gives no additional context for the other parameters, but per the high-coverage baseline, the schema carries the load adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the current time for an IANA timezone, which distinguishes it from siblings like normalize-url or validate-json. However, the input schema includes url, host, and json parameters that the description does not mention, making the tool's actual scope ambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, nor any exclusions or prerequisites. The agent cannot tell from the description when this tool is preferred over, say, a generic clock or date utility.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Current UTC timestamp.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | HTTPS URL to normalize or cite | |
| host | No | Public hostname | |
| json | No | JSON text to validate; discarded after the check | |
| zone | No | IANA timezone name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state whether the response is an ISO-8601 string, a Unix epoch, whether timezone conversion is supported, or whether the operation is side-effect-free.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and front-loaded, but it is under-specified rather than efficiently concise. A four-word fragment is not enough structure for a tool with four parameters and no annotations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given four parameters, no output schema, and no annotations, the description should specify what the caller receives and how the parameters relate to the operation. It does neither, leaving the invocation contract essentially undefined.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter information. However, the schema's parameters (url, host, json, zone) appear unrelated to fetching a UTC timestamp, and the description provides no bridge to clarify their relevance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is a noun phrase ('Current UTC timestamp') with no verb, so it only vaguely states that the tool produces a UTC timestamp. It does not specify the operation being performed, the output format, or how it differs from siblings like citation or compatibility.
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?
There is no guidance on when to use this tool, when not to use it, or which alternative to prefer. An agent must infer usage entirely from the tool name and a four-word fragment.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check whether a body is valid JSON. The body is discarded.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | HTTPS URL to normalize or cite | |
| host | No | Public hostname | |
| json | No | JSON text to validate; discarded after the check | |
| zone | No | IANA timezone name |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are none, so the description carries the full burden. It discloses the key behavior that the body is discarded, which is a notable side-effect (no persistence). However, it does not disclose other behaviors such as whether the JSON is parsed, what 'valid' means exactly (e.g., strict vs. lenient), error handling, or rate limits. For a tool with no annotations, this is a minimal but useful disclosure, yet incomplete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences communicate the core function and the side-effect of discarding the body. Every word earns its place. It is front-loaded with the main purpose and the discarding note is a critical behavioral caveat. There is zero waste.
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?
The tool has 4 parameters, none required, no output schema, and no annotations. The description is simple and covers the main purpose, but it leaves gaps: what does 'valid' mean, what happens on invalid JSON (error? silent false?), and what the output format is (boolean, error message, etc.). Without an output schema or annotations, the agent is left uncertain about the return behavior, which is essential for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all four parameters already have descriptions: url, host, json, zone. The description adds no new parameter semantics beyond the schema, but the schema itself is clear. The parameter descriptions seem generic and may not fully align with the tool's purpose (why would a JSON validator need url, host, zone?), which could confuse, but the baseline 3 applies because schema coverage is high.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Check whether a body is valid JSON' and that 'the body is discarded'. It identifies the specific verb (check) and resource (JSON body), which is understandable. However, it doesn't explicitly differentiate from siblings, though the sibling names (normalize-url, cite, etc.) suggest different domains, so the clarity is sufficient without explicit differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used for validating JSON and discarding it, but does not provide explicit guidance on when to use this tool versus alternatives. It mentions no exclusions or conditions. The context of sibling tools suggests validation is a distinct action, but the description itself offers no when-to-use or alternative comparisons, leaving it to the agent to infer.
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. Dates show when Glama detected each change.
citationcompatibilitydomain-shapeiana-zonesinspect-robotsnormalize-urlport-22status-catalogtimezoneutc-timevalidate-jsonClaiming proves that you control a remote MCP connector. It does not move, proxy, or interrupt the server.
Open the connector listing, choose Claim ownership, and sign in to Glama.
Complete one verification method:
GitHub identity – fastest for official registry listings. For a namespace such as io.github.alice/server, link the matching GitHub user, then choose Claim with GitHub. An organization namespace such as io.github.acme/server also needs that organization to have installed the Glama AI GitHub App and approved its permissions, because GitHub discloses organization membership only to apps it has installed. Use HTTP or DNS when it has not.
HTTP challenge – works when you can deploy a public file. Generate a token, publish the exact JSON Glama shows at /.well-known/glama.json on the same origin as the connector, then choose Check HTTP challenge.
DNS challenge – works when you control DNS but cannot change the server. Generate a token, create the exact TXT record Glama shows, wait for it to propagate, then choose Check DNS challenge.
After verification, Glama sends a confirmation email and gives you access to listing details, thumbnails, health checks, and analytics. Keep the HTTP file or DNS record in place: Glama periodically checks it and ownership remains verified while the token is discoverable.
The HTTP ownership file has this structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"claim": "glama_claim_..."
}Claim tokens are opaque, stable, and bound to the signed-in Glama account. They contain no email address or other personal information. If Glama can no longer discover a verified HTTP or DNS token, it starts a seven-day grace period before removing claim-based access. Restore the same token during that period to keep ownership verified. Never publish an email address, Glama session token, GitHub token, or connector credential as ownership proof.
If verification fails, confirm that you copied the current token exactly. The HTTP file must be public, return valid JSON with a successful HTTP response, and stay on the connector's origin. DNS changes may need more time to propagate. A claim cannot transfer to a different origin or hostname: if the connector target changes, Glama starts the grace period and the new target must be claimed separately after the previous claim is released.
For a connector linked to the official MCP Registry, registry updates continue to replace its name, description, and URL by default. After claiming, open Manage connector and enable Use Glama listing details as the source of truth if edits made on Glama should be preserved. Categories and thumbnails are always managed on Glama; registry linkage and technical connection settings continue to sync.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
To improve your MCP server's ranking:
Claim ownership of the server listing
Complete the server profile with an accurate description and thumbnail
Provide a test profile so Glama can connect to and evaluate the server
Keep tool definitions clear and complete to earn a high Tool Definition Quality Score (TDQS)
Route real usage through the Glama Gateway; more recorded successful server uses also improve the ranking
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
No comments yet. Be the first to start the discussion!
Honeypot probe data: IP reputation, scanners, CVE probing, TLS and SSH fingerprints.
Scan the open TCP ports of your own public IP. Fast (32) or deep (65535). No key, no signup.
