Chainstack

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description details the pre-call workflow: drafting, showing the user the exact message, asking for confirmation, and including org info when an API key is present. It also lists prohibited content (API keys, wallet addresses, RPC URLs) and clarifies side effects: it posts to the contact form and works with or without an API key. These disclosures complement the annotations (readOnlyHint=false, openWorldHint=true, destructiveHint=true) rather than contradict them.

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?

Though long, the description is organized into clear sections ('Before calling this tool', 'Writing an effective message', 'Args') and front-loaded with the core purpose. Each sentence carries operational instructions (confirmation step, exclusions, parameter details) that are essential for safe invocation.

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 description covers the tool's purpose, exact trigger conditions, exclusions, pre-call user confirmation, sensitive data handling, message-writing best practices, and complete parameter semantics. No gaps remain given the existing annotations and output schema, making it a complete reference 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?

The schema has zero property descriptions, but the description's Args section thoroughly explains each parameter. It defines category with enumeration-like semantics, fallback behavior, and default; specifies that email and name are required and instructs the agent to ask the user; and gives guidance on composing the message with examples. This fully compensates for the schema's lack of documentation.

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 opens with 'Submit a message to Chainstack's sales and support team,' a specific verb+resource, and lists concrete use cases (pricing, custom quote, plan upgrade, support). This clearly distinguishes it from sibling tools like create_node or get_chainstack_pricing.

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 explicitly states 'Use when the user wants to...' followed by scenarios, and provides exclusions: 'Not for incidents or urgent outages — point users to...' and 'For feature requests, do NOT use this tool.' It names alternative channels (support tickets, status page, ideas portal, GitHub), making alternatives unambiguous.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate a write operation (readOnly=false, destructive=false), and the description adds a key behavioral constraint: region cannot be changed after deployment. It also states the need to confirm region with the user, which is meaningful context beyond annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured: a one-sentence purpose, followed by critical usage warnings, then a clear parameter list. Every sentence adds value and is front-loaded with the most important information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the output schema exists and annotations cover safety, the description provides all necessary contextual details: prerequisites, parameter sources, and a deployment constraint that cannot be changed. This is complete for an agent to select and invoke the tool 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?

With 0% schema description coverage, the Args section fully compensates by explaining each parameter and providing example formats and source tools (e.g., project from list_projects, cloud from get_deployment_options). This is essential for correct invocation.

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 begins with a clear, specific action: 'Deploy a new blockchain node.' This distinguishes it from sibling tools like create_project or delete_node, and the resource and verb are explicit.

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?

It explicitly instructs to call get_deployment_options first for valid IDs and warns about region immutability, including a user confirmation step. This provides strong when-to-use and prerequisite guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate this is a mutating operation (readOnlyHint: false), and the description repeats that by saying 'Create'. It adds no extra behavioral context such as permission requirements, idempotency, side effects, or whether existing names are rejected. The description is minimal and does not disclose anything beyond what annotations imply.

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 compact and front-loaded with the main purpose. The Args section is minimal and adds needed parameter context. No wasted words, though the wording of parameter definitions could be more informative.

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 create operation with only two parameters and an output schema, the description is adequate for invoking the tool correctly. However, it lacks any guidance on when to use it, potential errors, or relationships to sibling tools, which would make it more contextually complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must compensate. It lists both parameters with brief definitions ('Project name', 'Optional description'), but these are largely tautological. It does clarify that description is optional, which adds slight value beyond the default '', but it does not elaborate on format, constraints, or validation rules.

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 'Create a new project' uses a specific verb and resource, clearly distinguishing it from siblings like create_node, update_project, and delete_project. No ambiguity in what the tool does.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The only usage hint comes from the tool name and description, which is not sufficient for choosing between create_project and update_project in context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already set destructiveHint=true, so the destructive nature is known. The description adds 'irreversible', which goes slightly beyond the annotation by indicating permanence, but it does not mention side effects on related resources or whether confirmation is required. This is acceptable but not highly detailed.

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 compact, consisting of a clear action line and a parameter line with an example. Every word serves a purpose, and the irreversibility warning is front-loaded before the args.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool is a simple delete operation with one parameter, the description covers the essential details: the action, irreversibility, and the parameter format. The annotations and output schema fill in the safety and response-handling aspects, so 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.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema only defines node_id as a string with no further description. The description compensates by providing a concrete example format 'ND-123-456-789', which helps clarify what a valid Node ID looks like. With 0% schema description coverage, this is a valuable addition.

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 starts with 'Delete a node (irreversible)', using a specific verb and resource. This clearly distinguishes it from sibling tools like delete_project, update_node, and get_node, and the irreversibility warning adds important semantic scope.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance is provided about when to use this tool versus alternatives like update_node or delete_project. The description states what it does but not when it should be chosen, nor any prerequisites or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare destructiveHint=true, so the destructive nature is known. The description adds the crucial context that deletion is 'irreversible,' going beyond the annotation's generic destructiveness. It does not disclose secondary effects like cascading deletion of associated resources, but the 'irreversible' note plus the annotation covers the core behavioral risk.

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: the first states the purpose and irreversibility, the second documents the parameter. It is front-loaded, contains no redundant filler, and every sentence contributes useful information. Ideal conciseness.

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 delete tool with one parameter, the description is largely complete, especially given the presence of an output schema and annotations. The main gap is the lack of information about what happens to associated resources (e.g., nodes) upon project deletion, but given the tool's simplicity and the openWorldHint annotation, this is a minor omission rather than a fatal flaw.

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 input schema provides only a string type with no description, so the description's parameter documentation is essential. It explains 'project_id' and gives a concrete example format ('e.g., PR-123-456-789'), which is valuable for correct invocation. This compensates well for the 0% schema description coverage.

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 action ('Delete a project') and explicitly notes irreversibility, which distinguishes it from sibling tools like delete_node and update_project. The verb 'Delete' plus the specific resource 'project' 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 use case is implied by the tool name and description—use when you need to delete a project. However, there is no explicit guidance on when not to use it (e.g., if nodes depend on the project) or mention of alternative tools like delete_node. The description lacks any contextual prerequisites or side-effect warnings beyond irreversibility.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations (readOnlyHint, openWorldHint, destructiveHint), the description discloses the tool's freshness (fetches both sources fresh, no caching), lack of auth requirements, and best-effort behavior with warnings on source failures. This exceeds what annotations provide.

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 dense but well-structured, front-loaded with purpose and usage, then design rationale and return field semantics. Every sentence adds value, but the length is substantial; no fluff, but could be more compressed for a zero-param tool.

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 parameters and a rich output, the description is complete. It covers what the tool returns, how to interpret the fields (e.g., region_legend[slug]), error handling, and points to alternatives for RU rates. Even with an output schema, the semantic detail here is necessary.

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 input schema has zero parameters, so the description doesn't need to add parameter meaning. The baseline for 0 params is 4. The description includes relevant context (no API key required, fresh fetch) but nothing parameter-specific.

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 'Fetch Chainstack's public pricing and return a normalized snapshot.' It distinguishes from siblings by naming specific pricing use cases (plan fit, overage math, per-chain dedicated-node costs) and explicitly contrasts with search_docs for method-level billing.

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?

It explicitly says 'Use this to answer pricing questions before quoting the user' and provides exclusions: 'Per-method RU billing rules are NOT in these sources' with direct alternatives (search_docs, get_doc_page). Also clarifies the division of labor ('this tool returns the menu, not the bill').

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds the context that the tool returns valid IDs for create_node, which is useful but minimal additional behavioral insight beyond the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the primary action, and the second sentence delivers essential usage context. Every word earns its place with no redundancy.

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 zero-parameter, read-only tool with a defined output schema and clear annotations, the description adequately covers purpose and usage. The 'call before create_node' guidance completes the picture, making the tool self-explanatory within its context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so schema coverage is trivially 100%. Per the baseline for 0 params, the description need not add parameter details. Its mention of 'valid blockchain and cloud IDs' provides relevant context for the tool's output.

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 function with a specific verb ('List') and a precise resource ('blockchain/cloud/network combinations for node deployment'). It distinguishes itself from sibling tools like list_nodes and get_chainstack_pricing by focusing on deployment options rather than existing nodes or pricing.

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 explicitly directs users to 'Call before create_node to get valid blockchain and cloud IDs', providing a clear when-to-use instruction. It lacks explicit when-not or alternative tool guidance, but the prerequisite relationship is unambiguous.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare the operation as read-only, so the description doesn't need to restate that. It adds valuable behavioral context by explaining that the page path is normalized—leading slash, .mdx extension, and URL prefix are 'optional and stripped if present.' This goes beyond the structured annotations and helps the agent understand input flexibility.

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 concise and front-loaded, starting with a one-sentence purpose statement, followed by a usage guideline and parameter details. Each sentence contributes meaningfully; there is no wasted text or repetition of schema information. The structure is easy to parse and the ARGS section clearly explains the single parameter.

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 description, combined with the existing output schema and annotations, provides a complete picture for a low-complexity tool. It covers the input parameter fully, specifies usage context, and does not need to explain return values because the output schema exists. The tool's behavior is well-scoped and safe, with no missing critical information.

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 the schema has no description for the 'page' parameter, the tool description provides comprehensive guidance: pass the `page` field from a search_docs result, with an example path and explicit clarification about optional prefixes and extensions. This fully compensates for the 0% schema coverage and makes the parameter unambiguous.

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 function: 'Get the full content of a Chainstack documentation page.' It uses a specific verb and resource, and distinguishes itself from the sibling search_docs by emphasizing retrieval of the complete page rather than snippets. This differentiation is explicit in the usage note.

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 explicitly says 'Use after search_docs to fetch the complete page when a snippet isn't enough,' providing clear when-to-use guidance and naming the relevant sibling tool. It implies a sequential workflow and indicates the alternative (search_docs) returns partial content, making it easy for the agent to choose correctly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The annotations already declare readOnlyHint=true and destructiveHint=false, providing the safety profile. The description adds that the tool returns endpoints and cloud info, but does not disclose additional behavioral traits (e.g., pagination, permission requirements). This is acceptable given the annotation coverage, matching the baseline for useful but not rich behavioral context.

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: the first clearly states the tool's purpose, and the second concisely documents the only argument with an example. No wasted words or irrelevant detail.

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 is a simple single-parameter read operation, and the description covers purpose, parameter format, and return content. With an output schema and annotations present, no significant information is missing for selecting and invoking the tool 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?

With schema description coverage at 0%, the description must compensate, and it does by including an 'Args' section that provides the parameter name and an example format ('ND-123-456-789'). This adds meaningful semantics beyond the bare schema, though it could offer more detail on sourcing or validation.

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 uses a specific verb 'Get' and clearly identifies the resource 'node' with a defined scope 'full details including endpoints and cloud info'. This effectively distinguishes it from sibling tools like list_nodes, which would return a summary collection.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for retrieving comprehensive details of a single node ('full details'), giving clear context on when to use it. However, it does not explicitly mention alternatives or exclusions, such as 'use list_nodes to list nodes', so it falls short of a perfect 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds the specific return fields (name and ID), which is mildly useful, but it does not disclose any additional behavioral traits like rate limits, authentication requirements, or the fact that this returns the currently authenticated organization. It neither contradicts nor significantly enriches the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, succinct sentence: 'Get organization name and ID.' It is front-loaded with the verb and resource, and contains no extraneous or redundant wording.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (no parameters, read-only, output schema present), the description is adequately complete. It clearly names the return values, and the presence of an output schema means it need not explain the full structure. However, it could have mentioned what 'organization' refers to (e.g., current authenticated organization) to fully round out the context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameters, and the schema already shows an empty object. There is no gap in parameter understanding.

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 'Get organization name and ID' clearly states the action (get) and the resource (organization), and specifies the two pieces of data returned. It is distinct from sibling tools like get_project or get_node, which target different resources.

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 provides no guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or context such as 'use this for the current organization' or 'see get_project for workspace details.' The tool's purpose is obvious, but explicit usage guidance is absent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds behavioral detail about the network parameter's effect on the response (overall status and incidents only when omitted), which is valuable beyond the annotations. No contradictions with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise: two sentences plus a parameter line. It front-loads the primary purpose and then clarifies the optional argument. Every word earns its place, with no redundancy or fluff.

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 the presence of an output schema (which shifts return-value explanation to schema), the description covers the tool's purpose, the optional filter, and the conditional behavior of that filter. The tool's complexity is low (one optional param), and the description is complete for proper selection and 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 sole parameter 'network' has zero schema description coverage, so the description fully compensates by explaining it as an optional filter, providing an example ('ethereum'), and stating the behavior when omitted. This gives complete semantic meaning that the bare schema lacks.

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 opens with a clear verb ('Check') and specific resources ('platform status, active incidents, and maintenances'), making the tool's function unambiguous. It clearly distinguishes from siblings, as it is the only tool focused on platform health rather than resource CRUD or documentation.

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 provides clear context for when to use the tool (to check platform health and incidents) without explicit alternative comparisons. Sibling tools are obviously different (CRUD, docs, pricing), so the usage context is clear. It lacks an explicit 'when not to use' clause, but this is not critical given the distinct purpose.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, indicating a safe read operation. The description adds no further behavioral context beyond the project_id format, and does not contradict annotations. This is adequate given annotation coverage, so a baseline of 3 is appropriate.

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 concise and front-loaded, consisting of a short purpose statement and a clear argument specification. No filler or redundant content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simple single-parameter interface, presence of an output schema, and strong annotations, the description is nearly complete. It could explicitly note that it retrieves a single project's full detail set or reference list_projects for multiple projects, but that is a usage guideline rather than a completeness gap.

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 has no description for project_id, and the description compensates with an explicit example format ('PR-123-456-789') and labels it as a Project ID. This fully covers the parameter's meaning beyond the bare string type.

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 'Get project details' with a project_id parameter, distinguishing it from siblings like list_projects and get_node. The verb-resource pair 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.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives such as list_projects or get_organization. It only states the function, with no exclusions or alternative recommendations.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only and non-destructive behavior. The description adds valuable context beyond annotations, such as the scope of results ('all nodes in the organization' when no filter) and the contents of the response ('status and connection endpoints'). This gives the agent useful behavioral expectations without contradicting the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and front-loaded with the main action. The Args section is structured and uses a clear, minimal format. Every sentence adds value without unnecessary fluff, making it highly efficient and easy to parse.

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 read-only list tool with one optional parameter, the description covers purpose, filter behavior, and scope. The presence of an output schema means return value details need not be in the description. It is sufficiently complete for an agent to select and invoke the tool 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?

Schema description coverage is 0%, so the description carries full responsibility for parameter meaning. It fully explains project_id as an optional filter, provides a format example ('PR-123-456-789'), and describes the default behavior when omitted. This is complete and adds significant value over the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('List') and resource ('nodes') and details the included information ('status and connection endpoints'). It clearly distinguishes from sibling tools like get_node (single node) and list_projects (different resource), making the tool's 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 provides clear context on when to use the tool: to list nodes, with optional project filtering. It explains the behavior when project_id is omitted (returns all nodes in the organization). However, it does not explicitly mention alternatives or when not to use this tool, so it misses the highest tier.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is covered. The description adds only the conceptual note 'Projects are containers for nodes' and essentially restates the tool's name, providing no extra behavioral information such as pagination, ordering, or filtering 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 two sentences with no wasted words. It front-loads the purpose ('List all projects') and the second sentence adds relevant domain context, making it appropriately sized and structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (no parameters), existing annotations, and the presence of an output schema, the description is complete. It clearly states the action and resource, and the sibling tool context makes its role unambiguous without needing further elaboration.

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 tool has zero parameters (empty input schema), so there are no parameter semantics to describe. The description appropriately omits parameter details, and the baseline for 0 parameters is 4.

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 'List all projects' with a specific verb and resource, clearly distinguishing it from sibling tools like get_project (which retrieves a single project) and list_nodes (which lists a different resource). The added context 'Projects are containers for nodes' helps clarify the domain.

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 clear context: this tool lists all projects. However, it does not explicitly mention when not to use it or reference alternatives such as get_project or list_nodes. For a simple list tool, the usage is implied effectively.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations are minimal (readOnlyHint false, openWorldHint true, destructiveHint true), so the description carries the burden of behavioral disclosure. It goes far beyond: explains the non-fixed amount behavior, per-network caps, cooldown with nextFaucetAvailable timestamp, amountSent in native units, API key requirement and rate-limiting identity, and the instruction to describe the action as 'top up' rather than 'give' to set user expectations. No contradiction with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but efficiently organized into sections: intro, behavior, network list, cooldown, auth, Args, Returns. Every sentence provides actionable information—even the phrasing guidance for user interaction. The front-loaded purpose makes the tool easily identifiable, and the structure supports quick reference.

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 faucet tool with two parameters and no formal output schema, the description is remarkably complete. It covers return structure (network, amountSent, transaction), error conditions (cooldown timestamp, cap exceeded, format errors), supported networks, and authentication requirements. An agent has all information needed to select, invoke, and interpret the tool's result 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?

Schema coverage is only 50% (address has no schema description). The description compensates fully: it explains network value normalization (case-insensitive, aliases), and details address format expectations per network (EVM hex, TON address, Solana base58), plus server-side validation yielding 400 errors. This adds significant meaning beyond the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb+resource: 'Top up a testnet address from Chainstack's faucet.' It clearly identifies the tool's function and distinguishes it from sibling tools like create_node or list_nodes, which manage infrastructure rather than dispense testnet funds. The supported network list further clarifies scope.

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 provides clear context on when to use the tool, including supported networks, required API key, and failure conditions (cap exceeded, cooldown). It does not explicitly name alternatives, but no direct alternative exists among siblings, so this is a minor gap. The guidance to never ask for the API key in chat is a valuable usage constraint.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the agent knows this is a safe read operation. The description adds some behavioral context by listing the topical scope of the docs, but it does not disclose details about result format, ranking, or pagination. Given the annotations cover safety, 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise: two lines of purpose plus an Args section. The purpose is front-loaded, and every word adds value. The example queries are useful and not repeated elsewhere. No redundancy or filler.

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 this is a simple single-parameter search tool with annotations and an output schema (even though not shown here), the description covers the essentials: what is searched and the nature of the query. It does not need to explain return values because an output schema exists. It could benefit from a note about result limits or sorting, but current completeness is sufficient for this tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 0% coverage for the query parameter (no description in schema). The description compensates by explaining 'query: Search query' and providing two concrete examples ('deploy ethereum node', 'eth_call'). This gives the agent a clear semantic understanding beyond the bare type definition.

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: 'Search Chainstack docs' – a specific verb and resource. It also enumerates the types of content searched (RPC methods, node infrastructure, Web3 APIs, deployment guides, code examples), which distinguishes it from sibling tools like get_doc_page that fetch a specific page rather than search across documentation.

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 use for finding documentation via a search query, providing example queries. However, it does not explicitly state when to use this tool versus get_doc_page (e.g., 'use get_doc_page if you already know the page URL or title'). The guidance is minimal and relies on the tool name and sibling context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The annotations already indicate a non-read-only, destructive operation, and the description does not contradict this. It provides no additional behavioral context beyond 'rename,' such as side effects or irreversibility, but with annotations present, the bar is lower and the description is consistent.

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: one sentence for purpose and a brief args list. Every word is functional, and the most important information is front-loaded.

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 rename tool, the description is sufficient: it states the operation, covers both parameters, and the output schema (which exists) handles return values. It lacks additional context like error conditions, but the annotations provide the safety profile.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the 'Args' section compensates by explaining node_id (with example format) and name (new name). This adds meaning beyond the bare schema, covering both parameters concisely and clearly.

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 says 'Rename a node.' This is a specific verb and resource, clearly distinguishing it from sibling tools like create_node, delete_node, and update_project. It also provides the node_id format example, reinforcing the tool's identity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage: use when you want to rename an existing node. However, it does not explicitly mention when not to use it or provide alternatives, making the guidance implicit rather than explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description adds some behavioral context beyond the annotations by specifying that only the name and description can be updated, implying a partial update. It does not contradict the destructiveHint and readOnlyHint annotations, but it doesn't detail other effects, such as what happens if neither field is provided or whether changes are reversible.

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 concise and well-structured. It leads with a one-sentence purpose, followed by an Args block listing each parameter with a brief, clear definition. No unnecessary words or repetitive content.

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 update tool with three parameters, an output schema, and annotations, the description is nearly complete. It covers the core operation and parameter meanings. However, it could benefit from mentioning behavior when both name and description are null (e.g., no-op or error), but this is a minor gap given the tool's simplicity.

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 description provides meaningful explanations for all three parameters, including a concrete example format for project_id ('PR-123-456-789') and clear definitions for name and description. This adds significant value since the input schema has 0% description coverage and parameter descriptions are absent. It doesn't explicitly state that name and description are optional, but the schema's defaults convey 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 the tool's function: 'Update a project's name or description.' It uses a specific verb ('update') and resource ('project'), and lists the exact fields it modifies, distinguishing it from sibling tools like update_node or delete_project.

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: the tool is for updating a project's name or description. However, there is no explicit guidance on when to use this over alternatives, when not to use it, or any exclusions. The description is clear enough for a basic use case but doesn't provide proactive direction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.