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

No annotations are provided, so the description carries the full burden of disclosing behavior. The verb 'Browse' implies a read-only, non-mutating operation, which is helpful, but no further behavioral details such as authentication needs, side effects, or response size are described. This is adequate for a simple lookup tool but not deeply transparent.

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

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

The description is a single, front-loaded sentence with no wasted words. It communicates the tool's core action and target resource efficiently.

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, low-complexity browse tool with an output schema and fully documented optional parameters, the description is mostly sufficient. It lacks explicit guidance on when to choose this tool over siblings, but that gap is already captured under usage guidelines.

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 (tier and limit) with 100% coverage, so the description does not need to add parameter-level detail. The description adds no additional meaning beyond the schema, warranting the baseline score.

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, 'Browse', and identifies the exact resource, the 'BCOS v2 certificate directory'. This clearly sets it apart from sibling tools such as bcos_verify and wallet/beacon tools.

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 intended use is implied by 'Browse the BCOS v2 certificate directory', but there is no explicit statement of when to use this tool versus alternatives. No exclusions or alternative routing are provided, leaving the agent to infer usage 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It only says 'verify', which hints at a read-only operation, but does not explain what verification entails, whether it checks trust/revocation, what failure modes exist, or any side effects. This is a significant gap for a tool with no annotation support.

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, well-front-loaded sentence with no filler or redundant phrasing. For a one-parameter tool, this is appropriately concise and every word contributes to the meaning.

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 single-parameter tool with an output schema, the description is mostly adequate: an agent can call it given a cert_id. However, it lacks any guidance on where certificate IDs come from or how this tool relates to bcos_directory, and the absence of annotations leaves behavioral context incomplete.

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 fully documents cert_id with type and an example, and schema description coverage is 100%. The description adds no additional meaning beyond restating that verification is 'by its ID', so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Verify') with a concrete resource ('a BCOS v2 certificate') and a clear scope ('by its ID'). It is immediately distinguishable from the sibling bcos_directory tool, which likely handles lookup/listing rather than verification.

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

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

The description gives no indication of when to use this tool over alternatives, how to obtain a certificate ID, or whether bcos_directory should be used first. No exclusion criteria or context is provided, leaving the agent to infer usage.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. 'Get' and 'status' imply a read-only lookup, but the description does not state prerequisites, potential errors, or whether any side effects are involved. It is adequate for a simple getter but not rich in 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 a single sentence that is direct and front-loaded. There is no wasted text, and for a tool with one parameter it is appropriately sized.

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 simple and has an output schema, so the description doesn't need to explain return values. Still, it lacks guidance on when to use this tool versus Beacon discovery or network-level stats, and does not clarify what 'detailed status' includes. It is minimally complete but leaves contextual 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 single agent_id parameter with an example, so the description adds no additional param meaning. With 100% schema coverage, 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 uses a clear verb-resource pair: 'Get detailed status of a specific Beacon agent.' The word 'specific' distinguishes this from broader Beacon tools like beacon_discover or beacon_network_stats, though it doesn't explicitly name any sibling.

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 intended use is implied: use this when you need status information about one particular Beacon agent. However, it gives no explicit guidance about when not to use it or how it compares to related tools like beacon_discover, beacon_heartbeat, or beacon_network_stats.

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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It explains that native agents have AI personalities and can respond to messages, which is useful context. However, it doesn't disclose whether the chat is synchronous, whether it consumes credits, or what the response format is. The output schema exists but the description doesn't add much behavioral detail beyond the personality note.

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, with two short sentences. The main action is front-loaded in the first sentence, and the second sentence provides clarifying context about native agents. No wasted words.

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

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

The tool has a simple interface (2 required params, no enums, no nested objects) and an output schema exists. The description covers the core purpose and gives examples of valid agent IDs. However, it doesn't explain what kind of responses to expect or whether there are any limitations (e.g., only certain agents are available). For a chat tool, a bit more context about the interaction model would help.

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 (agent_id and message) are already documented in the schema. The description adds a small amount of value by giving an example agent ID format ('bcn_sophia_elya') and clarifying that agent_id refers to a native agent. This is helpful but not extensive.

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: 'Chat directly with a native Beacon agent.' It identifies the resource (native agents) and the action (chat). It distinguishes from siblings like beacon_send_message by specifying native agents with AI personalities, though it doesn't explicitly name the sibling it differs from.

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 when to use this tool: when you want to chat with a native Beacon agent. It provides examples of agent IDs and notes they have AI personalities. However, it doesn't explicitly state when not to use it or mention alternatives like beacon_send_message, which appears to be a sibling tool for sending messages.

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?

No annotations are provided, so the description must carry the behavioral burden. The verb 'List' implies a read-only operation, and the explanation that contracts are on-chain gives some context. However, it does not mention pagination, authorization, rate limits, or any side effects, offering only minimal transparency.

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

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

The description is two sentences, with the primary action front-loaded and followed by a concise contextual explanation. Every word earns its place; there is no repetition 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 a single optional parameter, a fully documented schema, and an output schema, the description covers the essentials: it identifies the resource and the nature of the data. The only gap is the lack of relationship to sibling tools, but that is more a usage-guideline concern than a completeness issue.

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 100% description coverage for the single parameter `agent_id`, including its default and meaning. The description adds no additional parameter semantics, so the baseline score of 3 applies when the schema does the work.

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

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

The description states a clear verb ('List') and resource ('Beacon contracts'), and briefly defines the resource as on-chain agreements like bounties and service agreements. It does not explicitly differentiate from sibling tools such as bounty_search, but the purpose is 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?

There is no guidance on when to use this tool versus alternatives like bounty_search or beacon_discover. No scenarios, prerequisites, or exclusions are mentioned, leaving the agent to infer usage from the name alone.

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?

With no annotations, the description carries the full burden. It adds useful context: results include both native and relay agents, and membership is open to any AI agent, implying a broad and varied directory. However, it does not disclose list size, pagination, freshness, or authentication needs, leaving some behavioral traits unspecified.

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?

Four concise sentences: purpose, return semantics, filtering options, and network context. Every sentence adds value, with the main purpose front-loaded and no redundancy with the schema.

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 filters and an output schema, the description covers the essentials: what it returns, how to filter, and the network's open membership. Minor omissions like ordering, pagination, or relationship to sibling status tools do not materially hurt a caller's ability to invoke it 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 the baseline is 3. The description merely restates that filtering by provider or capability is possible; it does not add syntax, matching semantics, or examples 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 ('Discover') and a resource ('AI agents on the Beacon network'), and immediately clarifies it returns all registered agents (native + relay). This clearly distinguishes the tool from siblings like beacon_register or beacon_agent_status, which manage or inspect agents rather than list them.

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 clearly states when to use the tool: to discover agents and filter by provider or capability. It does not explicitly name alternative tools or provide when-not-to-use guidance, but the context is clear enough for a straightforward discovery/list operation.

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?

With no annotations provided, the description carries the full behavioral burden. It discloses the core keep-alive contract: 15-minute heartbeat requirement and 60-minute presumed-dead threshold. It does not mention idempotency or recovery after presumed_dead, but the essential behavior beyond the tool name is clearly stated.

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: the first sentence states the purpose, and the following sentences provide concrete operational thresholds. There is no filler 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?

An output schema exists and all parameters are fully described, so the agent has the credential source and cadence needed to call the tool correctly. The only minor omission is explicit behavior for reviving an agent from 'presumed_dead', though that is implied by the keep-alive framing.

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 agent_id, relay_token, and status already well documented in the input schema. The description adds no extra parameter-level meaning beyond what the schema provides, 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 uses a specific action verb and resource: 'Send heartbeat to keep your Beacon relay agent alive.' This clearly identifies the tool as a periodic keep-alive signal and distinguishes it from status-checking siblings like beacon_agent_status by focusing on the signaling action rather than a query.

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 explicit invocation cadence: agents must heartbeat at least every 15 minutes to stay active, and 60 minutes without heartbeat causes 'presumed_dead' status. It does not explicitly mention alternatives or when not to use the tool, but the scheduling context is clear and actionable.

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?

There are no annotations, so the description carries the burden of behavioral disclosure. It implies a read-only operation through 'Get' and 'Returns', and it lists the result contents, which is useful. However, it does not clarify whether the data is live or cached, whether authentication or registration is required, or whether any side effects occur.

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 compact sentences with no filler. The first sentence states the action and resource, and the second lists the return contents, making it easy to parse quickly.

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 no-parameter stats endpoint with an output schema, the description is largely complete: it states the scope and enumerates the meaningful return categories. It could add context about data freshness or distinguish itself from network_health, but nothing critical is missing for 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?

The tool has zero parameters and schema coverage is 100%, so there is no parameter detail for the description to add. The baseline of 4 for a zero-parameter tool applies, and the description appropriately avoids inventing unnecessary parameter guidance.

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 a clear resource ('Beacon network statistics'), then enumerates the exact return categories: total agents, active count, provider breakdown, and protocol health status. It is clear, but it does not explicitly distinguish itself from sibling tools like network_health, which may overlap on health status.

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

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

No guidance is given about when to use this tool versus siblings such as beacon_agent_status, beacon_discover, or network_health. There are no alternatives, prerequisites, or exclusions mentioned, so an agent must infer appropriate usage from the name alone.

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?

No annotations exist, so the description carries the full burden. It does disclose a key behavioral outcome: 'You get an agent_id and relay_token for sending messages and heartbeats,' and clarifies a prerequisite (no beacon-skill package). However, it does not disclose idempotency, side effects of re-registration, or any rate limits/authorization requirements—important for a state-changing registration tool.

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 short sentences, each earning its place: the action, the purpose, and a key prerequisite. Front-loaded with the primary verb and resource. No fluff, no repetition of schema details.

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 registration tool with a moderate 6-parameter schema and an output schema present, the description covers the essential context: what the tool does, why an agent would use it, what it returns (agent_id and relay_token), and that no external package is needed. It doesn't mention duplicate registration behavior, but that gap is minor and partially offset by the output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond the schema; all 6 parameters (name, pubkey_hex, model_id, provider, webhook_url, capabilities) are already well-documented with defaults and formats in the input schema. The description adds no additional semantics.

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

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

States a specific verb+resource: 'Register as a relay agent on the Beacon network.' Clearly differentiates from siblings like beacon_heartbeat and beacon_send_message by framing this as the entry point ('This is how any AI agent joins the Beacon network'). No ambiguity about what the tool accomplishes.

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 says this is the onboarding step for any AI agent, which tells an agent when to use it. Also clarifies a common alternative concern by stating 'No beacon-skill package needed — just this MCP tool.' It does not explicitly say when not to use it or name alternative registration tools, but the context is clear enough given the sibling list.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that a message is sent; it does not mention delivery guarantees, persistence, acknowledgments, or the role of the relay envelope kind. This is thin for a side-effecting operation.

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, efficient sentence that front-loads the action and object. There is no filler, restatement of the title, or unnecessary 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 schema covers all parameters and an output schema exists, so the structural information needed to invoke the tool is largely present. However, the description omits usage context and side-effect expectations for a messaging tool, and there are no annotations to fill that gap. It is adequate but not fully 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 description coverage is 100%, so the parameters are already fully documented and the baseline is 3. The description adds no additional parameter context, such as how content is formatted or how relay_token is obtained, but it is not required to compensate for missing schema 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 identifies the action ('Send a message') and the resource ('another agent via Beacon relay'), avoiding tautology. It is specific enough to convey the tool's core function, though it does not explicitly distinguish it from the similar-sounding beacon_chat sibling.

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

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

There is no guidance on when to use beacon_send_message versus beacon_chat or other messaging/relay tools. No exclusions, prerequisites, or alternative routing are mentioned, so an agent must infer selection context from sibling names alone.

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?

No annotations are provided, so the description carries the full burden. It only states the action without disclosing read-only nature, output format, permissions, or any side effects. This is a minimal disclosure for a getter.

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

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

The description is a single, front-loaded sentence with no fluff. It is appropriately concise for a simple getter, though it could have included more behavioral context without harming readability.

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 simple with one well-documented parameter and an output schema that covers return values. However, with no annotations, the description is sparse and does not mention any prerequisites or edge cases. It is adequate but not comprehensive.

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

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

Schema coverage is 100% and the parameter 'agent_name' has a clear description with examples. The tool description adds no additional meaning beyond what the schema already 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 clearly states the verb 'Get' and the resource 'AI agent's profile on BoTTube'. It is specific and distinguishes itself from sibling tools like bottube_stats or bottube_search by focusing on agent profiles.

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

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

There is no guidance on when to use this tool versus alternatives like bottube_stats or bottube_search. The description implies it is for fetching a profile but does not mention context, 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'post' implies a write/mutation, but the description does not disclose authentication needs, potential side effects, rate limits, or whether comments are reversible. This is a significant gap for a mutation tool.

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

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

The description is a single front-loaded sentence with no filler or redundant clauses. Every word contributes to stating the core action and target resource, making it highly concise for a simple 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 annotations and an authentication-related parameter, the description omits important context such as when and how to provide api_key, any behavioral expectations, and usage guidance. The output schema may cover return values, but the description alone is not complete enough for an agent to call the tool confidently.

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 all three parameters with 100% coverage, so the baseline is 3. The description adds no extra meaning about parameters such as how to obtain api_key or the expected format of video_id, but it also does not need to compensate for schema gaps.

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

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

The description states a specific verb and resource ('Post a comment on a BoTTube video'), making the tool's core purpose immediately clear. It does not explicitly contrast with sibling tools like bottube_vote or bottube_upload, but the comment-specific wording is sufficient to distinguish it from those alternatives.

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

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

No guidance is provided about when to use this tool versus alternatives, nor are prerequisites such as authentication or account requirements mentioned. The description only states what the tool does, leaving the agent to infer when it should be selected.

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?

No annotations are provided, so the description carries the full responsibility for behavioral disclosure. It only states 'Search for videos' without noting read-only status, pagination behavior, result limits, or any side effects. This is a significant gap for a tool with zero annotation coverage.

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, clear sentence with zero wasted words. It is appropriately front-loaded and concise, though it could have included slightly more context without becoming bloated.

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 search tool with 2 parameters and an output schema, the description is minimally adequate. Parameters are fully covered by schema, and return values are covered by output schema. However, it lacks usage context and behavioral details, leaving clear gaps in completeness.

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

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

Schema coverage is 100%, and both parameters are already well described in the input schema (query matches title/description/tags; page for pagination). The description adds no additional meaning beyond what the schema provides, so 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 'Search for videos on BoTTube' clearly states the verb (search) and resource (videos on BoTTube). It does not explicitly differentiate from sibling tools like bottube_trending or bottube_stats, but the core purpose is 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?

No guidance is provided on when to use this tool vs alternatives. The description does not mention any exclusions, prerequisites, or situations that favor search over trending or stats. The agent is left to infer usage context entirely.

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?

With no annotations provided, the description carries the burden of behavioral disclosure. It does explain what BoTTube is and what metrics are returned, which adds context beyond the bare tool name. However, it doesn't disclose whether the stats are real-time, cached, or require any authentication, nor does it describe the output format beyond listing metric names. The description is adequate but not rich in behavioral detail.

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 core purpose ('Get BoTTube platform statistics'), followed by a useful list of returned metrics and a brief context sentence. Every sentence earns its place, though the context sentence about BoTTube being AI-native could be seen as slightly extraneous for a stats tool. Still, it helps an agent understand the domain.

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 tool with an output schema present, the description is largely complete. It lists the key metrics returned and provides domain context. The main gap is that it doesn't specify whether the stats are live or cached, or whether any special access is needed, but given the simplicity of the tool and the presence of an output schema, this is a minor omission.

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 schema is trivially complete (100% coverage). The description doesn't need to explain any parameters, and the baseline for zero-parameter tools is 4. The description adds value by explaining what the returned statistics represent, which is more than the empty 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 the tool returns BoTTube platform statistics and enumerates the specific metrics (total videos, agents, humans, views, comments, likes, top creators). It distinguishes itself from sibling tools like bottube_search and bottube_trending by focusing on aggregate platform stats rather than search or trending content. However, it doesn't explicitly name a sibling alternative, so it loses a point on differentiation.

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

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

The description implies this is the go-to tool for platform-level statistics, and the context of BoTTube as an AI-native video platform helps an agent understand when to use it. However, it doesn't explicitly state when to use this tool versus alternatives like bottube_trending or bottube_search, nor does it mention any exclusions or prerequisites. The usage context is clear but not fully 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?

No annotations are provided, so the description carries the full behavioral burden. The verb 'get' implies a read-only list operation, which is a useful signal, but the description does not clarify pagination, recency, or whether any side effects occur. For a simple read with an output schema, this is acceptable but not richly transparent.

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 one concise sentence with no filler. The key resource and verb are front-loaded, making it easy to scan and parse quickly.

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, an output schema, and a read-only intent—the description plus schema is mostly sufficient for invocation. The only notable gap is the lack of usage guidance relative to sibling BoTTube tools.

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

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

The schema already fully documents the single 'limit' parameter, including default and max values, so the description does not need to add parameter details. 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 a specific resource ('trending videos on BoTTube'), making the operation unambiguous. It also differentiates from sibling tools like bottube_search and bottube_upload by focusing on the trending feed.

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

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

There is no guidance on when to use this tool versus alternatives such as bottube_search or bottube_stats, nor any conditions/exclusions. The agent must infer from the word 'trending' alone that this is for the trending list rather than search or statistics.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Upload a video to BoTTube' and does not mention side effects, authentication requirements, possible errors, or what happens after a successful upload. This is inadequate for a mutating operation.

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 short sentence with no filler, and the key action is front-loaded. However, it is arguably too terse for a tool with five parameters and authentication needs, so it is concise but not fully appropriately sized.

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

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

With no annotations, minimal description, and rich sibling context, there is insufficient information for an agent to know when to select this tool, what setup is required (e.g., obtaining an API key), or what behavioral implications uploading has. An output schema exists, so return values may be covered, but the operational context is still incomplete.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters with their types and defaults. The description adds no parameter-level meaning beyond the schema, which matches the baseline of 3.

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

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

The description states a specific verb ('Upload') and resource ('a video to BoTTube'), making the primary action clear. It distinguishes itself from siblings like bottube_search or bottube_stats by naming the upload action, but it does not explicitly contrast with any sibling, so it stops short of a 5.

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

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

No guidance is given about when to use this tool versus alternatives such as bottube_search or bottube_trending. There is no mention of prerequisites, such as having a valid API key obtained from bottube.ai, though that detail appears in the parameter schema rather than the description.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses that the tool 'vote[s]' but does not say whether votes are mutate state, whether api_key authentication is required, or whether votes can be changed or retracted. For a mutating action, this is a meaningful transparency gap.

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 short sentence with zero filler and it front-loads the core action. It is appropriately sized for a simple tool, though the brevity contributes to the lack of behavioral detail. On conciseness alone it is well-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?

The tool is low-complexity and the input schema fully documents all parameters, while an output schema is reportedly present, so return-value details are not required. Even so, the absence of behavioral context and usage guidance leaves the definition merely adequate. An agent could invoke the tool but would be guessing about side effects and preconditions.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds nothing about parameters. The schema already documents video_id, direction, and api_key with adequate descriptions. The description does not need to compensate but also does not enrich the parameters.

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 concrete verb and resource: 'Vote on a BoTTube video.' It clearly identifies the action and distinguishes it from related siblings like upload, comment, or search. However, it does not mention up/down semantics or explicitly differentiate itself from sibling voting-related tools, so it stops short of a 5.

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

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

There is no guidance on when to choose this tool over alternatives like bottube_comment or bottube_trending. The description merely names the action without stating preconditions, exclusions, or situational context. The agent must infer applicability from the tool name alone.

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?

With no annotations, the description carries the behavioral burden. It discloses the underlying mechanism ('Queries GitHub Issues labeled bounty') and adds important reward caveats: RTC is paid at an internal reference rate, not a market price, and is not offered for sale. It does not explicitly state 'read-only', but 'queries' strongly implies a non-mutating operation.

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 three sentences, each earning its place: purpose, mechanism, and a caveat about reward interpretation. It is front-loaded with the action and resource, and contains no 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 that all parameters are fully described in the schema and an output schema exists, the description provides the missing context: the GitHub Issues source, the 'bounty' label, the repo scope, and the RTC reward caveat. Nothing essential appears to be missing for an agent to call 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 the parameter baseline is 3. The description adds no parameter-specific semantics beyond what the schema already states; it merely summarizes that search can be by keyword, amount, or difficulty, which overlaps with 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 states a specific verb ('Search') and resource ('open RustChain and BoTTube bounties'), including filter dimensions (keyword, amount, difficulty). It is clear and distinguishes the tool from general BoTTube content search by focusing on bounties, though it does not explicitly name alternatives or state what it is not.

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 context is clear: use this tool when searching for open bounties in the named repositories, with optional filters. It does not mention exclusions or alternative tools, but the search-oriented purpose and repository scope give sufficient practical 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates the operation is a read/lookup by saying 'look up' and 'queries', and it reveals that two external systems are contacted. However, it does not explicitly state that the operation has no side effects, nor does it mention potential external dependencies like GitHub rate limits or network failures.

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

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

The description is two sentences long with no filler. The first sentence front-loads the core purpose, and the second adds essential detail about the two query targets. Every sentence earns its place, making this highly concise and well-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?

The tool is simple (one parameter, output schema present), so the description is nearly complete: it names the input, the two sources, and the two outputs. The only gaps are the absence of explicit usage boundaries and external caveats, which are minor given the availability of the output schema and low 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 description coverage is 100%, and the schema already documents the username parameter with examples. The description adds the semantic link that the username corresponds to a GitHub contributor and that it is used to fetch balance and merges, but it does not add meaning beyond what the schema already provides. Thus the 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 states a clear action ('Look up a contributor's RTC balance and merge history') and explicitly names the two data sources queried: the RustChain network for wallet balance and GitHub for merged pull requests. This is a specific verb+resource statement that clearly distinguishes it from siblings like rustchain_balance, which likely only handles balances. No ambiguity or tautology.

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

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

The description implies the tool should be used when a contributor's combined balance and merge history is needed, but it never explicitly states when to prefer this over alternatives like rustchain_balance or bounty_search. There is no explicit when-not-to-use guidance or mention of alternatives, leaving the agent to infer the boundary between 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?

With no annotations, the description carries the full burden and does convey a read-only intent through 'Get' and 'Returns,' which is reasonably clear. It also adds context about the external data source. However, it does not disclose caveats such as data freshness, rate limits, or whether results are cached.

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 brief and front-loaded, starting with the core action in the first sentence. Each following sentence adds relevant context, including the purpose of the preserved machines and the data source, with no wasted words.

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

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

For a read-only, parameterless tool with an output schema available, the description is complete enough for an agent to understand what it will receive and where the data comes from. Nothing essential is missing for invoking it 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?

The tool has zero parameters and the schema already covers everything at 100% coverage, so the baseline is 4. The description adds appropriate context about what the returned data represents, but no parameter detail is needed.

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 identifies the verb (Get) and resource (fleet of preserved machines from the RustChain green tracker) and explains what is returned: the list of vintage and exotic machines. It does not explicitly contrast itself against sibling tools like rustchain_stats, so it falls short of full sibling differentiation.

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

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

No guidance is provided about when to use this tool instead of the many sibling tools, such as rustchain_stats, rustchain_balance, or network_health. The description explains what the tool returns but not when the agent should select it over alternatives.

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?

No annotations exist, so the description carries the full disclosure burden. It adequately conveys a side-effect-free information retrieval ('Get information...', 'Returns project overview...') and adds context about the data source (GitHub, repo, 48+ stars). It is silent on whether stats are live or cached, but for a read-only info tool this is a minor gap.

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 front-load the verb and resource before enumerating return categories. Every sentence earns its place: action, returned content, and project context. There is 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?

For a 0-parameter info tool that already has an output schema, the description covers the essentials: subject, returned categories, and project identity. The only gap is not clarifying the relationship to the overlapping bounty_search sibling, which also surfaces open bounties.

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. Schema coverage is trivially 100% and there is nothing for the description to document. The project context (repo, stars, RustChain integration) adds flavor but no parameter meaning is required.

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

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

The description is unambiguous: 'Get information about The Legend of Elya' with specific return categories enumerated (project overview, architecture, GitHub stats, open bounties). The subject matter clearly sets it apart from the wallet, beacon, and rustchain siblings. However, it does not explicitly differentiate from the overlapping bounty_search sibling, which likely also surfaces open bounties.

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

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

No guidance is given on when to use this tool versus alternatives. The description states what it returns but never mentions sibling tools such as bounty_search for bounty-specific queries or contributor_lookup for per-person data. With 38 siblings present, an agent must infer the intended use case from the tool name alone.

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?

With no annotations provided, the description carries the full behavioral disclosure burden, and it does so thoroughly. It warns that HTTP 200 alone is insufficient, explains Node 2's self-signed certificate and TLS verification skip, and distinguishes network_ok from all_nodes_ok, preventing common misinterpretations of health-check results.

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 moderately long but well organized, moving from the overall purpose to node-specific details to result interpretation. The bullet-like node list aids scanning, though some node details could arguably be shortened or moved to the output schema.

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 zero parameters, no annotations, and an output schema that likely captures structural fields, the description supplies the contextual warnings that make results interpretable: the HTTP-200 pitfall, the TLS verification caveat, and the meaning of the summary booleans. Nothing critical is missing for an agent to invoke and understand 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 has no propertiesainer, and the description correctly spends no time on parameters. It instead clarifies useful output semantics, which matches the baseline expectation for a zero-parameter tool.

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 and resource: getting aggregate health of the live RustChain attestation nodes, and goes on to define what 'healthy' means. However, a sibling tool named rustchain_health exists, and the description does not explicitly differentiate network_health from it, so an agent may not be able to confidently choose between the two from the description alone.

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

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

No guidance is given about when to use this tool versus rustchain_health or other diagnostic sibling tools. The detailed health semantics imply a monitoring use case, but there are no explicit conditions, exclusions, or alternatives mentioned.

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?

With no annotations provided, the description carries full responsibility for behavioral disclosure. It merely states 'Check balance' without mentioning whether it is a read-only operation, any error conditions, rate limits, or response behavior. The existence of an output schema mitigates return-format ambiguity, but the description adds no behavioral context beyond the basic action.

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 concise sentence with no fluff. It is appropriately sized for a simple balance check, though it could have included a note on usage context without being verbose.

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 check, the description is technically sufficient to convey the core function, especially with a schema and output schema present. However, it lacks contextual guidance to help an agent choose this tool among many similar ones (e.g., wallet_balance), and it doesn't clarify the distinction between 'RTC' and other token balances. This is a minimal viable description but not comprehensive.

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 100% coverage for the single parameter (wallet_id) with a detailed description and examples. The tool description adds no additional parameter meaning beyond what the schema already offers, 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 states a clear verb ('Check') and a specific resource ('RTC token balance for a wallet'). It is unambiguous about the tool's function. However, it does not explicitly distinguish itself from sibling wallet_balance, which might also check balances, though the 'RTC' qualifier implies rustchain-specific context.

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

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

No guidance is provided on when to use this tool versus alternatives like wallet_balance, rustchain_stats, or rustchain_transfer_signed. The description only states the action without any context on selection criteria 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the creation action and the vague 'Zero friction onboarding' phrase. There is no mention of persistence, side effects, uniqueness constraints, or irreversible effects, leaving significant behavioral ambiguity for a mutating operation.

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 and front-loaded with the action. The second sentence 'Zero friction onboarding' is somewhat vague and adds little technical value, preventing a 5, but the overall size and structure are efficient.

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 only one parameter and an output schema exists, a compact description can be sufficient. However, with no annotations and no mention of prerequisites, network context, or whether wallet creation has persistent on-chain effects, the description leaves some gaps in contextual completeness for an agent deciding whether to invoke 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 single parameter 'agent_name' is fully described in the schema (100% coverage), including an example and the slugification behavior. The description adds no additional parameter semantics, but the schema already documents the parameter thoroughly, 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 uses a specific verb and resource: 'Create a new RTC wallet for an AI agent.' This clearly identifies the core action and the target entity. However, it does not explicitly differentiate itself from the sibling tool 'wallet_create', so it lacks explicit sibling-level distinction while still being reasonably clear.

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

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

The description gives no guidance on when to use this tool versus alternatives such as 'wallet_create' or 'wallet_import'. The phrase 'Zero friction onboarding' hints at onboarding context but does not state conditions, exclusions, or alternative tools, providing essentially no usable 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?

With no annotations, the description carries the full disclosure burden and does so well: it lists all returned values, states that total_supply_rtc is fixed at 2^23, and explains slot length, epoch length, and reward distribution. It does not discuss failure modes or freshness, but for a parameterless read-only lookup those are minimal gaps.

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

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

Two compact sentences are front-loaded with the core purpose and followed by a precise return-value summary plus key constants. Every sentence contributes useful information, and the formatting makes the returned fields easy to scan.

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 no-parameter read-only information tool with an output schema, the description is complete: it names each returned field, defines domain-specific terms like slot and epoch, and notes the invariant total supply constant. An agent can call it correctly without additional 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?

There are zero parameters, so parameter documentation is not applicable. The description does not waste space on input semantics; the baseline of 4 applies and no misleading parameter claims are made.

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

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

States a specific verb and resource ('Get current RustChain epoch information') and enumerates the exact fields returned, including epoch number, slot, miners count, reward pot, blocks per epoch, and total_supply_rtc. This is specific enough to distinguish it from siblings like rustchain_stats or rustchain_health, which target different network-wide metrics.

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 makes the intended use clear: call this to retrieve current epoch-level RustChain data, and it defines slot/epoch semantics so an agent knows what context this tool addresses. It does not explicitly name alternatives or exclusion conditions, so it falls short of a 5 but provides clear contextual 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, and it delivers: bounded batches, long-poll semantics, no partial miner results, cursor-based continuation, and the wait_seconds timeout bound. These are non-obvious behaviors beyond the schema and are stated directly, making the tool's runtime behavior transparent.

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: the first sentence states the purpose, and each subsequent sentence adds a distinct behavioral or usage fact. There is no fluff, repetition, or irrelevant detail. Every sentence earns its place.

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 moderate complexity and the presence of an output schema, the description covers all essential operational knowledge: batch semantics, cursor progression, long-poll boundaries, and slot expectations. An agent can call it correctly and reason about progressive consumption without additional inference.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful context: defining wait_seconds as a long-poll wait bounded by RUSTCHAIN_EVENT_LONG_POLL_MAX, explaining that after_cursor is generation-qualified, and instructing the next_cursor loop. This goes beyond simply restating parameter types and defaults.

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 pairing: 'Read a bounded batch of RustChain health, epoch, and miner events.' This clearly distinguishes the aggregate event tool from sibling single-topic tools like rustchain_health, rustchain_epoch, and rustchain_miners. It also immediately signals the batch/long-poll nature, leaving no ambiguity about what this 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?

The description explicitly tells the agent when and how to use the tool: it is cursor-based batch/long-poll, not native MCP streaming; one call does not emit partial results; progressive consumption requires passing next_cursor into subsequent calls; and wait_seconds behavior is bounded. This gives explicit when/when-not guidance and a clear invocation pattern.

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?

No annotations are provided, so the description carries the burden. It discloses the tool is a read-only health check and lists what it returns, which is useful. However, it doesn't mention potential failure modes, latency, or whether it might return partial data if the database is down.

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 waste. The first sentence states the action and the second provides the usage context. Every word earns its place.

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 health check with an output schema, the description is largely complete. It explains what the tool does, what it returns, and when to use it. It could mention that it's a read-only operation, but the absence of annotations and the health-check nature make that implicit.

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 there is no parameter semantics burden. The description adds value by explaining what the tool returns, which is the only meaningful semantic content for a no-arg tool.

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 checks RustChain node health status and lists the specific metrics returned (node version, uptime, database status, backup age). This distinguishes it from sibling tools like rustchain_stats and network_health by focusing on node health verification.

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 to use it to verify the network is operational before other calls, providing clear usage context. It doesn't explicitly name alternatives or exclusions, but the 'before other calls' guidance is strong enough to guide an agent's tool 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?

With no annotations provided, the description carries the burden of behavioral disclosure. 'Check' implies a non-mutating read operation, which is useful, but the description does not clarify what 'eligible' means, whether it queries live chain state, or what happens for invalid or inactive miners. The output schema likely covers return shape, so a moderate score is warranted.

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, clear sentence with no filler. It states the action and the target resource effectively, earning its place 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?

For a one-parameter, single-purpose tool with an output schema present, the description is nearly complete. It lacks usage guidance and behavioral nuance, but the simple scope, fully documented parameter, and output schema reduce the need for additional prose.

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 the description adds no meaning beyond the schema. The schema already documents miner_id as 'The miner wallet address to check eligibility for.' The description does not compensate further, 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 names a specific verb and resource: 'Check if a miner is eligible for epoch lottery rewards.' This is clear and identifies the exact operation without confusing it with other rustchain tools, though it does not explicitly distinguish it from siblings like rustchain_epoch or rustchain_miners.

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

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

There is no guidance about when to use this tool versus alternatives such as rustchain_epoch or rustchain_stats. The description implies a narrow use case, but an agent receives no explicit context, prerequisites, or exclusion criteria.

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?

There are no annotations, so the description carries the behavioral disclosure burden. It explains that the result is bounded to a first page, limited to active miners, and that total_miners appears only under node pagination conditions. It does not describe error behavior or ordering, but it discloses the most important behavioral traits.

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 core purpose. The extra detail about hardware multipliers and the total_miners conditional is relevant and earns its place, though it could trim minor redundancies like repeating the meaning of 'bounded.'

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 parameterless listing tool with an output schema, the description is largely complete: it names the resource, the filtering condition, and the returned fields. It stops short of explaining pagination continuation or edge-case behavior, but those are less critical for a bounded first-page list.

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 and the input schema is empty, so there is nothing for the description to document beyond confirming the call requires no inputs. This matches the baseline for a no-parameter tool.

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 specific verb and resource, 'List ... active RustChain miners' and clarifies the scope is a bounded first page. It is clearly distinct from sibling tools like rustchain_stats or rustchain_health because none of them target the miner list.

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 intended use is implied: call this when you need a bounded first page of active RustChain miners. However, it does not explicitly state when to prefer another tool or when this tool should not be used, so guidance is only 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?

No annotations are provided, so the description carries the full behavioral burden. It transparently discloses that the public front end does not proxy /api/stats, that a 404 causes the tool to compose an equivalent summary from /epoch and /health, and that the result is marked with source='composed'. This goes beyond the structured schema and gives agents important runtime expectations.

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 three sentences with the main purpose front-loaded and the behavioral caveats placed after. Every sentence adds value, and the proxy/fallback explanation is included without unnecessary padding 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?

For a zero-parameter read-only stats tool with an output schema, the description is complete. It covers what the stats contain, the availability constraint, and the fallback behavior with a distinguishing source marker, so an agent has everything needed to invoke and interpret 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?

The tool has zero parameters and 100% schema description coverage, so the description does not need to document parameters. It appropriately adds semantic context by explaining what the returned system-wide stats include, which is all that is needed here.

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 ('Get RustChain network statistics') and enumerates the returned contents (total miners, epoch info, reward distribution, network health metrics). This is clear and not a tautology, though it does not explicitly contrast with sibling tools like rustchain_health, rustchain_epoch, or rustchain_miners.

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 system-wide aggregate stats but does not explicitly say when to choose this tool over rustchain_health, rustchain_epoch, or rustchain_miners. It does provide useful context about the /api/stats endpoint not being proxied by the public front end and the 404 fallback, but that is endpoint behavior rather than tool-selection 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?

No annotations are present, so the description carries the full disclosure burden. The only behavioral fact it adds is the Ed25519 signature requirement, which is genuinely useful. But for a mutating financial operation, it fails to disclose that the transfer permanently changes ledger state, what role nonce plays, or how the result should be interpreted.

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 sentence with the signature constraint neatly parenthesized and the key fact front-loaded. There is zero filler. It loses a point only because the compact form omits usage and behavioral context that a transfer operation needs.

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 output schema covers return values and the schema covers most parameters, which reduces the burden. Still, for a 7-parameter mutating transfer with no annotations, the description omits the meaning of nonce, whether the transaction is broadcast on-chain, and any differentiation from wallet_transfer_signed — real gaps for an agent deciding whether and how to call 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?

Schema description coverage is 86%, so the baseline of 3 applies; the schema already documents from_address, to_address, amount_rtc, signature, public_key, and memo. The description reinforces the signature requirement but adds no parameter-level meaning, and notably fails to clarify the one cryptic parameter, nonce, which has no description 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 names a specific verb ('Transfer') and resource ('RTC tokens between wallets'), and adds the key constraint that an Ed25519 signature is required. This clearly separates it from read-style Rustchain siblings like rustchain_balance and rustchain_stats. However, it never explicitly distinguishes itself from the near-twin sibling wallet_transfer_signed, leaving the agent to guess which 'transfer signed' variant applies.

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 when-to-use guidance or alternative routing appears in the description. With siblings like wallet_transfer_signed, rustchain_create_wallet, and rustchain_balance nearby, the agent gets no direction about prerequisites (existing wallet, sufficient balance, generating the signature first) or which sibling to prefer under other conditions.

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?

No annotations are provided, so the description carries the burden. It discloses that the tool queries the network (implying network dependency) and that it reads from the local keystore. It doesn't mention whether the wallet must exist, what happens if the wallet is not found, or whether this is a read-only operation, but the description's 'check balance' phrasing implies a read operation.

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 waste. The first sentence states the action and resource, and the second provides the mechanism. It's front-loaded 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?

The tool has a single parameter, full schema coverage, and an output schema, so the description doesn't need to explain return values. However, it doesn't clarify the distinction from rustchain_balance or mention error conditions (e.g., wallet not found, network unavailable). For a simple read tool, this is adequate but not 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 description coverage is 100%, so the schema already documents the wallet_id parameter. The description adds the context that the wallet is local and stored in the keystore, which helps clarify the parameter's meaning. However, it doesn't add format or validation details beyond the schema.

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

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

The description clearly states the tool checks the RTC token balance for a local wallet by querying the RustChain network. It distinguishes itself from the sibling 'rustchain_balance' by specifying 'local wallet' and 'local keystore', though it doesn't explicitly name the sibling.

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 context: it's for checking balances of locally stored wallets, not arbitrary addresses. It doesn't explicitly state when to use this over rustchain_balance or other balance-related tools, but the 'local wallet' and 'local keystore' phrasing provides some 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does add valuable context: 'secure key storage in ~/.rustchain/mcp_wallets/' and 'Ed25519 cryptography compatible with RustChain blockchain.' However, it does not mention whether the operation is destructive, whether existing wallets with the same name are overwritten, or what permissions are required. These are notable gaps for a mutation tool with zero annotation support.

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 three sentences and front-loads the core action. There is slight redundancy: 'Create a new Ed25519 wallet' and 'Generates a new wallet' both emphasize the creation aspect. Otherwise, each sentence contributes useful detail (purpose, storage, compatibility), so it earns a high but not perfect score.

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

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

Given the output schema exists and covers return values, the description does not need to explain those. It adequately explains the side effect (file storage location) and the cryptographic standard. It could mention prerequisites or refer to related wallet tools for next steps, but these are covered in other dimensions. Overall, it is sufficiently complete for a simple creation 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% because both parameters have descriptions in the schema. The tool description adds no further meaning to the parameters; it does not elaborate on agent_name or password beyond what is already in the schema. This matches the baseline of 3 for full schema 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 tool's purpose: 'Create a new Ed25519 wallet with BIP39 seed phrase.' This is a specific verb (create) with a resource (wallet) and distinguishing details (Ed25519, BIP39) that set it apart from siblings like wallet_export, wallet_import, and wallet_balance. Even though a sibling named rustchain_create_wallet exists, the description grounds it in RustChain compatibility, making the intent 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 implies when to use the tool – when you need a new wallet – but it does not explicitly contrast it with alternatives such as wallet_import or wallet_export, nor does it state when not to use it. There is no direct routing to sibling tools or exclusions, so usage guidance is only implicit.

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?

No annotations are provided, so the description carries the burden. It discloses that the export is encrypted with the provided password and that it covers all wallets in the local keystore. However, it doesn't mention whether the export is destructive, whether it requires prior wallet creation, or what the output format looks like beyond 'keystore JSON'. The description adds some behavioral context but not rich detail.

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, with two short sentences that front-load the core purpose. The second sentence adds necessary detail about encryption and scope. No wasted words, though it could be slightly more structured with explicit output details.

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

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

The tool has an output schema, so return values are presumably covered there. The description explains the purpose and encryption behavior, but for a backup/export tool with no annotations, it would benefit from stating whether the operation is safe/read-only, whether it overwrites anything, and what the user should do with the output. It's adequate but not 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 description coverage is 100%, so the schema already documents the password parameter. The description adds that the password is used to encrypt the export, which aligns with the schema's default value. It doesn't add new meaning beyond what the schema provides, so 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 exports an encrypted keystore JSON for backup, with a specific verb ('Export') and resource ('encrypted keystore JSON'). It distinguishes itself from siblings like wallet_import and wallet_list by specifying the backup/export purpose.

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 when to use it: when a backup of all wallets is needed. It doesn't explicitly name alternatives or exclusions, but the context of 'backup' and 'all wallets' provides clear usage context. Sibling names like wallet_import and wallet_list help differentiate, though no explicit when-not-to-use guidance is given.

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?

With no annotations provided, the description carries the full burden. It communicates that the operation reads recent transactions (implying read-only), but it does not explicitly state side-effect-free behavior, error conditions, or any prerequisites like wallet existence. It adds moderate context beyond the schema by saying 'recent' and 'from the RustChain network', but stops short of a full behavioral disclosure.

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 redundant words. The primary purpose is front-loaded in the first sentence, and the second sentence adds context without padding. Every word earns its place.

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

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

This is a simple tool with two parameters, an output schema, and no annotations. The description covers the core purpose but omits any mention of whether the wallet must exist, whether the call is read-only, or any pagination behavior (though limit is in schema). For a basic read operation, this is minimally adequate but not complete enough to anticipate common agent uncertainties.

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 wallet_id and limit already described in the input schema. The description adds no additional meaning about the parameters themselves; it only paraphrases 'specified wallet'. According to the rubric, baseline is 3 when schema coverage is high, so this score 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 action ('Get') and the resource ('transaction history for a wallet'), and the second sentence reinforces it with 'Retrieves recent transactions'. This distinguishes it from sibling tools like wallet_balance (balance vs. history) and wallet_transfer_signed (mutating operation).

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 related tools like wallet_balance for current balance or wallet_list for wallet enumeration, nor any exclusions. The agent must infer the use case from the tool name alone.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the types of input (seed phrase or keystore JSON), but doesn't disclose potential side effects like whether this creates a new wallet entry or overwrites an existing one, whether it requires network access, or if success is guaranteed. The 'source' parameter mentions 'from wallet_export' which hints at a companion workflow, but this is minimal.

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, concise sentence with no filler. It efficiently conveys the core purpose without redundancy. There's no fluff or unnecessary 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?

For an import tool with three optional parameters and an output schema present, the description is adequate but not rich. It could explain the expected behavior of 'password' (e.g., required if keystore is encrypted) or mention what happens on invalid input. The output schema likely covers return values, so that's not a gap, but the description lacks behavioral details for edge cases.

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%, but the description adds some value by explicitly stating the two input types (seed phrase and keystore JSON) and their relationship (keystore comes from wallet_export). It doesn't add details about 'password' beyond the schema, and 'wallet_id' is self-explanatory. The description doesn't compensate for any ambiguity in the schema, which is already clear.

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: importing a wallet from a seed phrase or keystore JSON. This is distinct from sibling tools like wallet_export and wallet_create, but does specifically differentiate itself as the import counterpart. It could explicitly mention that it creates a wallet on the system, but the verb 'import' is clear enough.

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 when to use this tool: when you have an existing seed phrase or keystore JSON and want to bring it into the system. It doesn't compare to wallet_create or wallet_export, and doesn't specify when NOT to use it (e.g., if you want to generate a new wallet, use wallet_create). The context is implicit but not 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?

With no annotations, the description carries the burden of behavioral disclosure. It clearly indicates a non-mutating read operation, identifies the storage location, states returned fields, and explicitly warns that private keys and seed phrases are never exposed. This is strong behavioral context for a simple listing tool.

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

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

The description is short and well-structured, with the core action front-loaded and the security note placed at the end. The first two sentences are slightly redundant ('List all wallets' vs 'Returns information about all wallets'), but overall it is tight and scannable.

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 list tool, the description is complete: it states what is listed, where from, what fields are returned, and what sensitive data is not included. An output schema is present, so return-value details do not need to be repeated in the description.

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 and an empty input schema, so no parameter documentation is needed. The description correctly implies that invoking it requires no arguments, satisfying the baseline for parameterless tools.

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 a specific verb and resource: 'List all wallets in the local keystore.' It further names the exact storage directory and the fields returned, distinguishing it clearly from sibling tools like wallet_create, wallet_export, or wallet_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 gives clear context that this is the tool for enumerating all locally stored wallets, with no parameters needed. It does not explicitly mention when not to use it or name alternatives, but for a zero-parameter list operation the intended context is obvious.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It usefully reveals that the private key is loaded from an encrypted keystore, signing uses Ed25519, and the transaction is submitted to the network. However, it does not mention irreversibility, failure modes, or required permissions beyond the schema.

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

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

The description is three short sentences with the core action front-loaded, followed by two compact sentences that add meaningful behavioral detail. Every sentence earns its place, and there is no redundant or filler 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 mutation tool with no annotations, the description covers the high-level workflow but omits usage boundaries, preconditions such as wallet existence or password requirement, and side-effect warnings. It is adequate but not fully complete; the output schema handles return-value details.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds little parameter-specific detail. The description provides general context about local wallet and transfer behavior but does not enrich the meaning of individual parameters beyond what the schema already states.

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 identifies the action (sign and submit an RTC transfer) and resource (a local wallet), with enough detail to convey the core purpose. However, it does not explicitly differentiate from the closely named sibling rustchain_transfer_signed, so it misses the highest bar for sibling distinction.

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

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

No guidance is given on when to choose this tool over alternatives such as rustchain_transfer_signed, nor are any exclusions or prerequisites stated. 'From a local wallet' is only implied context and does not help an agent decide between sibling transfer tools.

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