mcp-klever-vm

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

Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds crucial context: the public profile returns JSON without filesystem changes, while the main description describes the intended side effects. This conditional behavior is clearly disclosed, and there is no contradiction with 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 well-structured: main action, specific side effects, execution location, and a critical caveat about public profile. Every sentence contributes necessary information without 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?

With one optional parameter and no output schema, the description covers the tool's purpose, operational context, and special public profile behavior. It is complete for the tool's 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 schema has 100% coverage for the single parameter contractName, including its default auto-detection behavior. The description adds no additional parameter meaning beyond what the schema already provides.

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 'Add' and clearly identifies the resource ('automation scripts to an existing Klever smart contract project'). It lists concrete deliverables (scripts/ directory, .gitignore update) which distinguishes it from siblings like init_klever_project that create projects.

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 gives an explicit execution instruction ('Run this from the project root directory') and implies use on existing projects, which differentiates it from project-creation tools. However, it doesn't explicitly name alternatives or state when not to use this tool.

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, idempotent, and non-destructive behavior. The description adds value by detailing exactly what checks are performed and the output format (findings with severity and KB links), going beyond annotations without contradicting 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?

Two sentences, front-loaded with the action, and every word earns its place. The first sentence lists the checks and the second describes the output, with no fluff or repetition.

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, the specific checks, and the output format. Since there is no output schema, it appropriately describes return values. It does not mention potential limitations (e.g., false positives) but is sufficiently complete for a static analysis 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?

Schema description coverage is 100%, with both sourceCode and contractName having clear descriptions. The tool description itself does not add parameter-level detail beyond what the schema provides, so a baseline score of 3 is appropriate.

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 ('Analyze') and resource ('Klever smart contract Rust source code'), and enumerates the common issues checked (missing imports, macro, endpoint annotations, etc.). This clearly distinguishes it from sibling tools that query blockchain state 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 clearly implies the tool is for static analysis of Klever contract Rust source, and there are no competing siblings for this purpose. However, it does not explicitly state when to use it over alternatives or exclude other use cases, missing the top tier for explicit 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?

The description goes beyond the annotations by explaining the internal process (keyword extraction, matching entries) and the output format (markdown combining original query with examples/documentation). Since annotations already declare read-only, idempotent, and non-destructive behavior, this added context is valuable and does not 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?

The description is two sentences long, immediately states the core purpose, and includes a practical usage hint. Every sentence contributes meaning without 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?

Given the tool has full schema coverage and no output schema, the description sufficiently conveys the output format (markdown), the processing steps, and the intended use case. It does not over-explain, and the provided context is adequate 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 100%, so both parameters ('query' and 'autoInclude') are already well-documented in the schema. The description reiterates the behavior (combining original query with context) but adds no new parameter-specific semantics beyond what the schema provides.

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 ('Augment a natural-language query') and a specific resource ('with relevant Klever VM knowledge base context'). It further elaborates on the process (extracting keywords, finding entries, returning combined markdown) and distinguishes itself from sibling search tools by focusing on enriching a prompt for downstream use.

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 a clear usage context: 'Use this to enrich a user prompt before answering Klever development questions.' This implies a distinct stage (pre-processing) compared to sibling tools like query_context or search_documentation, but it does not explicitly mention when not to use it or name alternative tools.

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, idempotentHint=true, and destructiveHint=false, covering safety. The description adds behavioral context by explaining the comparison method ('comparing tags and content') and the output ranking ('ranked by similarity score'), providing value beyond the structured 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 with no fluff. The main action is front-loaded, and every phrase adds value: what it does, how it does it, and when to use it.

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 read-only tool with a straightforward purpose and no output schema, the description covers what, how, and when to use it. The input requirements are fully documented in the schema, so no further context is needed.

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%, with both parameters (id and limit) having detailed descriptions. The tool description doesn't add additional parameter semantics beyond the schema, so the baseline score of 3 is appropriate.

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 explicitly states 'Find knowledge base entries similar to a given entry by comparing tags and content,' using a specific verb+resource. It distinguishes from sibling tools like query_context and get_context by focusing on similarity ranking rather than direct search or retrieval.

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 provides a clear use case: 'Useful for discovering related patterns, examples, or documentation after finding one relevant entry.' This implies when to use it, though it doesn't explicitly name alternatives or exclusion scenarios, so it falls short of a perfect score.

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 include readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description need not repeat safety traits. It adds context about the returned account state (nonce, balance, frozen balance, allowance, permissions), which is the core behavioral output. However, it does not disclose edge-case behavior like invalid addresses or network defaults beyond the schema, so a moderate score 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 two sentences, directly stating the purpose and usage guidance without redundant phrasing. It is front-loaded with the action and resource.

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 read-only tool with no output schema, the description adequately conveys the returned fields (nonce, balance, frozen balance, allowance, permissions), the address resource, and usage context. The annotations cover safety, and the schema covers parameters, so the description is complete for selecting and invoking 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 input schema provides complete descriptions for both parameters, covering address format (klv1... bech32) and network options/default. The description adds no parameter-specific meaning beyond a high-level scope, but with 100% schema coverage, the baseline of 3 is appropriate.

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 resource ('full account details for a Klever blockchain address') and explicitly lists the contained fields (nonce, balance, frozen balance, allowance, permissions). It also distinguishes from the sibling get_balance by stating 'beyond just the balance.'

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 an explicit usage scenario: 'Use this when you need comprehensive account state beyond just the balance.' This implies when a simple balance is needed, another tool (e.g., get_balance) would be used, although no alternative is explicitly named.

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 safe-read nature is covered. The description adds valuable behavioral context by warning that string fields (ID, Name, Ticker) are base64-encoded in the raw response, which is not inferable from annotations or schema. This goes beyond 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?

Two sentences deliver all essential information: the first covers purpose and scope, the second highlights the base64 encoding caveat. There is no redundant phrasing or filler, making it ideal.

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 lacking an output schema, the description enumerates the return contents (supply info, permissions, roles, precision, metadata) and the encoding caveat. Combined with thorough annotations and schema, this provides sufficient context for an agent to understand what will be returned and how to interpret it.

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 already documents both parameters comprehensively (assetId with examples, network with enum values and default), achieving 100% coverage. The description adds no further parameter-level detail, so the baseline of 3 applies.

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

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

The description clearly states the tool gets complete properties and configuration for assets on the Klever blockchain, specifying asset types (KLV, KFI, KDA tokens, NFT collections). This verb-resource-scope combination distinctly differentiates it from sibling tools like get_account or get_balance.

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 what the tool does and the types of assets it covers, but does not explicitly mention alternatives or when not to use it. Since the name and description make its use case self-evident, the lack of exclusions is acceptable.

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 cover safety (readOnlyHint, idempotentHint, destructiveHint). The description adds valuable context about the return unit (smallest unit, 6 decimals) and the behavior when assetId is omitted, going 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?

Three concise sentences, front-loaded with the main purpose, then return unit, then optional parameter behavior. No redundant or unessential 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?

For a simple read-only balance tool with no output schema, the description covers the operation, return unit, and parameter usage. It is complete for the tool's 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?

Schema coverage is 100%, so baseline is 3. The description reinforces the assetId semantics but does not add new meaning beyond what the schema already explains.

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 explicitly states the operation (Get), the resource (KLV or KDA token balance), and the target (a Klever blockchain address), distinguishing it from sibling tools like get_account or get_asset_info.

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?

Clear context is given for querying balances, including the optional assetId for KDA tokens. It does not explicitly exclude alternatives, but the purpose itself implies when to use this tool.

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 signal a safe, read-only, idempotent operation. The description adds value by specifying the returned fields (hash, timestamp, proposer, transaction count) and the latest-block behavior, which are not covered by 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?

Two sentences, front-loaded with the main action and resource. No unnecessary words.

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

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

For a simple read-only tool with two optional parameters and no output schema, the description covers the purpose, return payload, and parameter behavior sufficiently. It's complete for the tool's 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?

Schema coverage is 100%, so parameters are well-documented. The description adds further clarification for the nonce parameter by explaining the behavior when omitted, and the network parameter is already fully described in the schema.

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

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

The description clearly states the tool's function—retrieving block information from the Klever blockchain—and identifies the distinguishing resource (block by nonce) and optional latest-block behavior. This sets it apart from sibling tools like get_transaction or get_account, which target other entities.

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?

Provides clear context on when to use the tool (need block info, optionally by nonce) and explains the fallback to the latest block when nonce is omitted. However, it doesn't explicitly mention alternatives or when not to use it, so it stops short of a 5.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds return format details (content, metadata, tags, related context IDs), which goes beyond the annotations. No contradictions.

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 action verb and resource. Every sentence adds value: purpose, return content, and usage context.

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 retrieval tool with one parameter and no output schema, the description sufficiently covers purpose, return content, and usage context. The annotations cover the safety profile, leaving no significant 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?

The input schema fully documents the 'id' parameter with UUID format and source. The description's 'unique ID' adds no new meaning beyond the schema, so baseline 3 is appropriate given 100% 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 'Retrieve a single knowledge base entry by its unique ID,' which is a specific verb+resource. It distinguishes from sibling tools by explaining that it returns full details and is intended for use after query_context or find_similar.

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 this after query_context or find_similar to get complete details for a specific entry,' providing clear when-to-use guidance. It implies this is a follow-up retrieval step rather than a search tool, though it doesn't list explicit when-not-to-use scenarios.

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 read-only and idempotent behavior, and the description adds context about the exact output structure (total count, type breakdowns, sample titles). It does not contradict annotations and provides additional behavioral detail beyond the safety hints, such as the nature of the returned sample entries.

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 core purpose and followed by specific output details. Every sentence adds useful information, with no fluff or redundancy. It is appropriately concise for a simple stats 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?

Since there is no output schema, the description fully explains the return values: total count, breakdown by context type with examples, and a sample title per type. It also provides a use case ('before querying'). For a zero-parameter tool with no output schema, this is complete and sufficient.

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

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

The tool has no parameters, so the input schema is empty. The description does not need to explain parameters, and per the rubric, 0 parameters earns a baseline of 4. It adds value by describing what the returned statistics include, which is relevant for understanding 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 uses a specific verb 'Get' and identifies the resource 'summary statistics of the Klever VM knowledge base', clearly distinguishing it from sibling tools like query_context or search_documentation. It also details what the tool returns (total entry count, counts by context type, sample entry titles), making its 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 states 'Useful for understanding what knowledge is available before querying', providing clear context for when to use it. However, it does not explicitly state when not to use it or name alternative tools, so it lacks explicit exclusions but is still clear about placement in a workflow.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds useful behavioral context beyond that: it mentions the use of the API proxy for indexed data and lists the exact categories of returned data, giving the agent a clearer picture of what to expect. No contradiction exists.

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 concise sentences. The first sentence front-loads the core purpose and return contents; the second adds a relevant detail about the data source. 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?

Given the tool's simplicity (two parameters, no output schema), the description is complete. It covers what the tool does, what it returns, and how it accesses data. The annotations and schema handle safety and parameter details, so nothing critical is missing.

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%, with both parameters (hash and network) fully described in the input schema. The description adds minimal extra meaning beyond the schema—it reiterates that the lookup is 'by hash' but does not provide additional syntax, constraints, or examples. Thus, baseline 3 is appropriate.

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: 'Get transaction details by hash from the Klever blockchain.' It specifies the resource (transaction) and actionable verb ('get'), then enumerates the return fields (sender, receiver, status, block info, contracts, receipts), distinguishing it from sibling tools like get_block or get_account.

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: when you need transaction details by hash. It also mentions the data source ('Uses the API proxy for indexed data'), which implies the appropriate environment. However, it does not explicitly mention alternatives or when not to use it, so it stops short of full 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?

The annotations declare readOnlyHint=true, but the description states 'Creates the Rust project structure' and 'generates automation scripts', which implies filesystem modifications. A note about public-profile behavior does not resolve the contradiction for the default profile, as the main description directly contradicts the read-only annotation. This is an annotation contradiction.

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, then provides the exact command, generated outputs, prerequisites, and a crucial behavioral note about public profile. Every sentence adds value 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?

Covers purpose, generated scripts, SDK requirement, prerequisite verification, and public-profile behavior. With all parameters fully described in the schema and no output schema, the description is nearly complete, though the ambiguity around default side effects is handled under transparency.

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%, and parameter descriptions for name, noMove, and template are already self-sufficient. The tool description adds no parameter-specific details, but given the high schema coverage, the baseline of 3 is appropriate.

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?

Description uses a specific verb 'Scaffold' with a clear resource 'new Klever smart contract project', and explicitly mentions the underlying command `ksc new` and generated automation scripts. This distinguishes it from sibling tools like add_helper_scripts by emphasizing creation of a new 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?

Provides explicit prerequisites: requires the Klever SDK at ~/klever-sdk/ and instructs to run check_sdk_status first. This gives clear context for when to use the tool, though it doesn't explicitly state when not to use it or name alternative tools.

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, idempotentHint=true, and destructiveHint=false, covering safety. The description adds the specific return fields but does not mention pagination, limits, or other behavioral traits, so it goes only slightly 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?

One clear sentence with a front-loaded purpose and a concise list of return fields. No filler or 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?

Given the tool's simplicity (one optional parameter, rich annotations, and explicit return-field description), the description is complete enough for an agent to select and invoke the tool correctly. The schema handles the network parameter, and the description covers the output.

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 covers 100% of the parameter (network) with an enum and default description, so the baseline is 3. The description adds no additional parameter semantics beyond what the schema already provides.

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 directly that it lists active validators on the Klever blockchain and enumerates the data fields returned (addresses, names, commission rates, delegation info, staking amounts). This clearly distinguishes it from sibling tools like get_account or get_balance.

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 on when to use vs alternatives; the purpose is clear from the description, but there is no mention of exclusions or other tools for specific validator queries. Usage is implied 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?

Beyond the read-only/idempotent annotations, the description adds that the tool returns structured JSON with matching entries, scores, and pagination, disclosing return format and pagination behavior. 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?

Three sentences, each earning its place: purpose, output format, and usage guidance. Front-loaded with the core action, no 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?

Given no output schema, the description appropriately includes return format and pagination details. The 6 parameters are fully documented in the schema, and the description clarifies the tool's role relative to a key sibling, providing sufficient 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?

Schema coverage is 100%, so each parameter already has a detailed description. The tool description adds only a general reference to filtering by type/tags, which does not significantly enhance the schema-provided semantics, keeping the score at baseline.

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 searches the Klever VM knowledge base for smart contract development context, with a specific verb ('Search') and resource. It distinguishes from search_documentation by noting it is for precise filtering, making the purpose unambiguous.

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

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

Explicitly states when to use this tool ('precise filtering by type or tags') and when to use the alternative ('use search_documentation for human-readable ... answers'). This provides clear when/when-not guidance and names a specific sibling tool.

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, idempotent, and non-destructive behavior. The description adds valuable context: it returns base64-encoded data, requires base64-encoded arguments, and explicitly confirms state is not modified. It goes beyond what annotations provide without contradicting 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?

Three focused sentences, front-loaded with the primary action. Every sentence adds value: what it does, return format, argument encoding, and usage intent. 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?

The description adequately covers the tool's purpose, input requirements (base64), and return type (base64-encoded return data). Given the rich schema and annotations, it provides sufficient context for an agent to invoke it correctly, though it could mention decoding the response or error handling.

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% with detailed parameter descriptions. The description reinforces the base64 requirement but adds no new information beyond the schema. Since schema already explains encoding details for addresses and numbers, the description's contribution is minimal.

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: executing a read-only query against a Klever smart contract via a VM view call. It distinguishes this from sibling tools like get_account or get_balance by specifying the resource (smart contract) and the read-only nature.

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?

Provides clear usage context: 'Use this to read contract state without modifying it.' This implies when to use it, though it doesn't explicitly mention alternatives or exclusions. The read-only hint and view call language effectively guide selection.

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 covered. The description adds behavioral context by stating the return format: 'human-readable markdown with titles, descriptions, and code snippets,' and indicates the tool is optimized for a specific question type. This goes beyond the annotations without contradicting 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?

The description is two sentences, front-loaded with the action and resource, and every sentence earns its place: the first states what the tool does, the second describes output format and provides a usage guideline. No filler or 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?

Given the tool's simplicity, the rich parameter schema, and the read-only annotations, the description is nearly complete. It explains the output format and primary use case. It could mention result limits or pagination, but for a search tool this is not essential. The lack of an output schema is partially compensated by the description of the markdown return format.

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%, with detailed descriptions for both 'query' (with examples) and 'category' (with enum list). The tool description itself does not add further parameter-specific meaning, but the schema fully documents parameters. The baseline of 3 is appropriate since the schema bears most of the burden.

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: 'Search Klever VM documentation and knowledge base.' It specifies the resource (Klever VM docs) and the verb (search), and distinguishes it from the sibling tool query_context by explicitly directing users to use this tool instead when they need formatted developer 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 gives explicit usage context: 'Optimized for "how do I..." questions' and directly names an alternative tool: 'Use this instead of query_context when you need formatted developer documentation.' This tells the agent exactly when to choose this tool over a sibling.

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