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 does disclose something useful beyond the name: that both full-access and function-call keys are returned. However, it says nothing about permissions required, pagination, or ordering, so coverage of the behavioral profile is partial.

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

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

One front-loaded sentence with no filler; the scope qualifier about key types is placed immediately after the core action. Nothing could be trimmed without losing information.

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

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

For a simple single-parameter read tool with no output schema, the description conveys the action and the shape of the results at a coarse level. It is adequate to call the tool correctly, though it could note that the keys are returned per account rather than per contract.

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% for the single account_id parameter, which the schema documents as a NEAR account ID. The description adds no additional parameter meaning, so the baseline of 3 applies when the schema does the heavy lifting.

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 ('List all access keys for an account') and further narrows the scope by naming the two key categories returned. It is unambiguous, though it does not explicitly differentiate itself from the sibling read tools, which it doesn't need to since they target different resources.

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

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

Usage is reasonably implied by the description — an agent would call this when it needs key information for an account — but there is no explicit when-to-use guidance, no prerequisites, and no named alternatives among the siblings. The parentheses hint at completeness of results but do not guide selection.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the composition of the returned balance (available vs staked vs storage-locked), which is real context beyond the schema. However, it says nothing about read-only semantics, error behavior for nonexistent accounts, or the units returned (yoctoNEAR vs NEAR).

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

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

A single front-loaded sentence with the verb and scope leading, and the return breakdown appended. No filler, no repetition of the tool name.

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 read tool with no output schema, the description covers the essential question of what the balance consists of. It is nearly complete but omits the return unit/format, which matters for a balance tool an agent may need to format or compare.

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 single parameter (account_id) is documented in the schema with an example ('alice.near'), so the description does not need to compensate. It adds no additional parameter meaning beyond what the schema already provides — baseline 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?

States a specific verb and resource ('Get the NEAR balance of an account') and enumerates the three balance components returned (available, staked, storage-locked). This distinguishes it from siblings like get_ft_balance (fungible tokens) and get_staking_info without the agent needing to open any schema.

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

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

Usage is implied by the purpose statement — an agent can infer this is the tool for native NEAR balances — but there is no explicit when-to-use guidance, no mention of prerequisites (e.g., account must exist), and no direct routing to or away from siblings such as get_ft_balance or get_staking_info.

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 discloses the return content (code hash, storage usage, block height), which is useful, but does not explicitly state that this is a read-only operation, whether authentication is required, or any rate limits. The verb 'Get' implies read-only, but the description stops short of full behavioral 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?

One concise, front-loaded sentence with no wasted words. It could be slightly more structured by explicitly separating return fields, but it is 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 simple read operation, one required parameter, and no output schema, the description adequately lists the key return fields. It does not explain every possible return value, but 'including' signals a non-exhaustive list, which is acceptable for an account info 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% and the single parameter account_id is fully documented in the schema. The description does not add any meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

Specific verb 'Get' and resource 'account information', and it enumerates the fields returned (code hash, storage usage, block height), which helps distinguish it from sibling tools like get_account_balance or get_access_keys. However, it does not explicitly state what it is not or name an alternative, so it is clear but lacks 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 when-to-use guidance is provided. It does not mention alternatives like get_account_balance or get_access_keys, nor does it state prerequisites or appropriate contexts. An agent has to infer usage 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, yet it discloses nothing about what 'information' is returned, whether the call is read-only, error behavior for unknown hashes, or finality caveats for the latest block. It only implies a safe lookup via the verb 'Get'.

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

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

A single short sentence with zero padding, front-loading the action and the two supported scopes. Nothing in it is redundant.

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 read tool with no output schema and no annotations, the description is minimally viable but leaves the return shape and edge-case behavior unspecified. An agent can call it correctly, but cannot predict what it gets back.

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 schema already states 'Block hash or height (omit for latest)'. The description's 'or the latest block' reinforces the default but adds no format, range, or validation detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Get) and resource (block info) with an explicit scope: a specific block or the latest block. That scope distinguishes it from siblings like get_transaction_status or get_account_info, though it never names an alternative directly.

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 siblings, nor any prerequisites or exclusions. The only usage cue is 'omit for latest', which is really parameter behavior rather than routing advice.

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 implies a read operation but never states read-only safety, what happens for accounts with zero balance or unknown contracts, or whether the result is a raw amount or a formatted value.

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

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

A single sentence that front-loads the verb, resource, and scope with no filler. 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 simple two-parameter read tool with fully documented params, the description is nearly sufficient. The only gap is the unstated return representation (raw integer vs decimal-adjusted), which matters since no output schema exists, but 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?

Schema description coverage is 100% and includes concrete contract ID examples ('wrap.near', 'usdt.tether-token.near'), so the schema already documents both parameters. The description adds no syntax, format, or validation detail beyond that, 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 gives a specific verb ('Get'), resource ('fungible token (FT/NEP-141) balance'), and scope ('for an account on a specific token contract'). The FT/NEP-141 qualifier implicitly separates it from the sibling get_account_balance (native NEAR), though it never names that alternative. Clear but not explicitly differentiated.

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 get_account_balance or get_ft_metadata, and no prerequisites or exclusions are stated. The agent must infer the use case from the tool name and description 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. The verb 'Get' and the enumeration of returned fields make it clear this is a safe read with a predictable return shape, which is genuinely useful. However, it says nothing about behavior on an invalid/nonexistent contract, caching, or rate limits.

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

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

A single tight sentence with the purpose front-loaded and the returned fields parenthesized for quick scanning. No wasted words, though it is arguably too terse to carry usage context.

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

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

For a one-parameter read tool with no output schema, listing the returned fields (name, symbol, decimals, icon) is a reasonable stand-in for a return-value contract. It still leaves an agent guessing about error behavior and the exact contract-ID format, so it is adequate rather than 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?

Only one parameter (token_contract) and schema description coverage is 100%, so the schema already documents it fully. The description adds no format hints (e.g., whether it expects a hex account ID or a NEAR-format 'name.near' contract), 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?

States a specific verb (Get) and resource (fungible token metadata) and even enumerates the fields returned, so the agent knows exactly what it retrieves. It implicitly distinguishes itself from the sibling get_ft_balance (metadata vs balance), though it never names that alternative explicitly.

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 and no mention of alternatives. With siblings like get_ft_balance and get_account_info in the same namespace, the description should say something like 'use this to resolve token decimals/symbol, not to read balances,' but it offers nothing.

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. 'Current' usefully signals a live/fresh read with no historical parameter, which is the key behavioral trait here. However, it does not disclose return units (e.g. yoctoNEAR per gas), whether it hits the network or a cache, or any rate-limit behavior — gaps that matter for interpreting the result.

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

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

A single front-loaded sentence with the resource immediately after the verb and zero filler. Every word earns its place and nothing essential is buried.

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-argument read tool the description is minimally sufficient, but with no output schema and no annotations, nothing anywhere tells an agent what the response looks like or in what unit the gas price is expressed. That single missing detail is the difference between adequate and complete for this tool.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; the description correctly does not waste space inventing parameter detail.

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?

Clear verb+resource+scope: 'Get the current gas price on NEAR network' names both the action and the exact datum returned, and no sibling tool (block info, protocol config, account balance) overlaps with gas price retrieval. It does not explicitly contrast itself with siblings, but the resource is distinctive enough that an agent can select it unambiguously.

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

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

Usage is only implied — an agent infers it should call this when a gas price is needed, but the description offers no explicit when-to-use statement, no mention of alternatives (e.g. protocol config may expose gas parameters), and no guidance on freshness or caching. The word 'current' hints at live retrieval but nothing more.

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; 'Get' implies a read-only call, and it does disclose what content is returned (runtime and economics parameters), which is real behavioral value. It stops short of stating idempotency, caching, or whether the config is a static snapshot, leaving gaps a zero-annotation tool must otherwise cover.

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

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

A single front-loaded sentence with no wasted words. The action and the resource lead, and the returned scope follows immediately.

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

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

There is no output schema, so the description is the only source of return-value information, and it only gestures at 'runtime and economics parameters' without naming the concrete fields or shape. Adequate for routing, thin for consumption.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate beyond the schema. Baseline of 4 applies for a parameterless 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?

States a specific verb ('Get') and resource ('NEAR protocol configuration') and enumerates the scope ('runtime and economics parameters'). A sibling like get_gas_price or get_validators is clearly a narrower slice, but the description never explicitly says it is the umbrella config call, so differentiation is implied rather than stated.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance at all. An agent cannot tell whether to prefer this over the more specific protocol getters (get_gas_price, get_validators) or when a full config fetch is warranted versus a targeted one.

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. 'Get' implies a read, and it does say what is returned (pool info + staked balance), but it omits read-only confirmation, behavior when the account has no stake or the pool ID is invalid, and whether results are cached or live.

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

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

A single front-loaded sentence with zero filler. The purpose is delivered in the first few words and nothing is repeated from the schema or title.

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 two-parameter read tool with complete schema coverage and no output schema, the description covers the essentials. However, with zero annotation coverage it leaves the agent without any safety or error-behavior signal, which is a real but modest gap at this complexity level.

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%: both pool_id (with an example contract ID) and account_id are fully documented in the schema. The description adds no parameter-level meaning beyond that, 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?

Specific verb ('Get') plus two concrete resources (staking pool information and staked balance) scoped to an account. It distinguishes itself reasonably from get_account_balance, though it never names a sibling explicitly, so an agent must infer the boundary.

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 statement of when to use this versus get_account_balance, get_validators, or the other account/validator tools, and no prerequisites or conditions given. Usage is implied only by the tool name.

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 implies a read operation but says nothing about behavior when a transaction is not found, whether an unconfirmed/pending transaction behaves differently, or what 'status' values are returned — meaningful gaps for a transaction-status 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?

A single front-loaded sentence with no filler; the resource and lookup key come first. 'and details' is slightly vague but does not waste space.

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 two-parameter getter with full schema coverage this is minimally adequate. However, with no output schema and no annotations, the description could profitably say what 'status' and 'details' encompass (e.g., success/failure, finality) to be 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 schema already documents both tx_hash and sender_id, setting the baseline at 3. The description adds no syntax or format detail, and its 'by its hash' phrasing omits the required sender_id, though the schema compensates.

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 ('Get') and resource ('status and details of a NEAR transaction') and scopes it to a lookup by hash, so the agent can distinguish it from siblings like get_block_info or get_account_info. It stops short of explicitly naming an alternative or contrasting 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?

There is no when-to-use guidance, no mention of prerequisites, and no routing to alternative tools. The agent must infer that this is the tool for post-submission transaction lookup 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, and it does disclose the read surface (validator set, stake, status). However, it says nothing about size of the result, pagination, or any permission requirements, which for a potentially large set is a gap. Adequate but not rich.

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

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

A single front-loaded sentence with no filler; every word carries information. It is terse to the point of omitting useful context, but nothing is wasted.

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 zero-required-parameter read tool with full schema coverage and no output schema, the description covers what is returned and the default scope. Safety and parameter details are low-risk here; only pagination/size behavior is unaddressed.

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% – epoch_id and its 'omit for current' semantics are fully documented in the schema. The description adds no format or behavioral detail beyond that, so the baseline 3 applies.

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

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

The description uses a specific verb ('Get') and resource ('current validator set') and enumerates the payload (stake amounts, status), so the agent knows exactly what this returns. It does not explicitly distinguish itself from siblings, but the resource is unique among 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?

There is no guidance on when to use this versus siblings such as get_staking_info or get_protocol_config, and no mention of prerequisites or exclusions. The word 'current' implies a default scope but the alternative (historical epochs) is only inferable from the schema.

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, and it says nothing about behavior beyond the one-line purpose. It does not state that this is a pure local string-building operation (no network call, no auth, no rate limits), nor whether the resulting URL is mainnet or testnet.

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

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

A single front-loaded sentence with zero filler that names the action, the output artifact, and the three supported inputs.

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 two-parameter, no-output-schema helper this is close to adequate, but a network dimension (mainnet/testnet) is never mentioned and could change the returned URL. With no annotations to fall back on, that omission leaves a real gap.

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

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

Schema description coverage is 100% and the type enum is self-explanatory, so the schema already does the work. The description adds only the mapping of the three enum values to the entity kinds, which is a marginal restatement of the schema.

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

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

States a specific verb (Generate) and resource (NEAR Explorer URL) with the three supported entity types. It is immediately distinguishable from every sibling, all of which fetch chain data rather than build links.

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 prefer this over siblings or any indication of prerequisites. The only routing hint is implicit in the enum-to-id correspondence, which an agent must infer from the schema.

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 does disclose two genuinely useful facts beyond the schema: the call is read-only and requires no gas/deposit. However it says nothing about failure modes (unknown method, panic/revert, non-existent contract), output encoding, or whether the call is free of side effects — meaningful gaps for a zero-annotation 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?

Two short, front-loaded sentences with zero filler. The core purpose leads and the key behavioral attribute (no gas) follows immediately.

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

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

With no output schema and no annotations, the description should at least indicate what a caller gets back (e.g., the deserialized view result) and how errors surface. That return-shape information is absent, though the safety and cost context ('read-only', 'no gas') is covered adequately for a 3-parameter 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%, so contract_id, method_name, and the nested args object are already documented in the schema; the baseline of 3 applies. The description adds no format or type guidance beyond what the schema provides (e.g., how args are serialized for the contract).

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 gives a specific verb+resource combination (call a view/read-only method on a NEAR smart contract) and clearly distinguishes itself from the concrete getter siblings like get_ft_balance or get_account_info. It is not tautological and an agent can tell what class of operation this is. It stops short of explicitly contrasting itself with the fixed-purpose siblings, so a 5 would overstate it.

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 reach for this generic call versus the purpose-built siblings (e.g., use view_contract_method for arbitrary/custom methods vs get_ft_balance for standard FT balances). The 'read-only' framing implies a usage boundary but no when/when-not or alternative routing is stated.

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