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

With no annotations, the description carries the burden. It discloses the data returned (balance, 12 owned objects, 10 transactions) and that it's a combined read. However, it lacks details on error handling, edge cases (e.g., invalid address), or rate limits. This is adequate but not comprehensive.

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

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

Two sentences: first defines the function concisely, second provides usage guidance. No unnecessary words, each sentence adds value. Front-loaded with key 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?

The description adequately covers output (balance, objects, transactions with limits) and compares to alternatives. Without an output schema, it explains what to expect. Slight room for improvement on output structure but very good overall.

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 50% (only network has description). The tool description mentions 'address' but does not add format or additional constraints beyond the schema. It provides minimal added meaning, so a mid-range 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 tool performs a one-shot relational read for an address, providing balance, owned objects (first 12), and recent transactions (first 10). It explicitly distinguishes from sibling tools by stating it replaces 4-5 separate gRPC calls and is the default 'tell me about this address' tool.

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

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

The description provides clear guidance on when to use: as the default overview tool for an address, and implies it replaces multiple separate calls. It does not exclude deeper dives but gives strong context for its primary use case.

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 provided, so description carries full burden. Mentions 'each may succeed or fail individually', which is important behavioral info. However, lacks details on error handling 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?

Two sentences, front-loaded with key information, 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?

Complexity is low; description covers batch behavior and per-object results but does not explain return value structure beyond that. For a fetch tool with no output schema, 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 67%, and the description adds little beyond schema (e.g., 'up to 50' is already in schema). 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?

Clearly states 'Fetch up to 50 objects in one round-trip' with a specific verb and resource. Distinguishes from sibling sui_get_object by suggesting preference over a loop.

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

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

Explicitly states 'Prefer this over a loop of sui_get_object when you have a known list of ids', giving clear guidance on when to use. Could be more explicit about when not to use, but sufficient.

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 provided, so description carries the full burden. It discloses per-item error tolerance (important) but omits other behaviors like order preservation, missing digest handling, rate limits, or auth requirements. Adequate but not comprehensive.

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

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

Two sentences, front-loaded with purpose. Every word adds value. No redundant 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?

No output schema, so return format is unknown. Description covers batch size and error handling but does not explain what is returned for each digest (e.g., full transaction object vs. subset). Adequate for a simple batch tool but leaves gaps.

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

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

Schema coverage is low (33%, only network has description). The description adds minimal value: only indirectly mentions digests via 'transactions' but fails to explain source or network roles. Insufficient compensation for low 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?

Description clearly states the tool fetches transactions in a batch of up to 50, with a key behavioral differentiator (per-item errors don't fail batch). Clearly distinguishes from single-transaction fetch and other batch 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?

Description implies when to use (multiple transactions at once) but does not explicitly exclude alternatives like repeated single get_transaction calls. Provides clear context but no when-not-to-use 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 provided, so the description carries full burden. It accurately describes a read-only operation and lists the returned fields. It could mention potential error conditions or data freshness, but for a simple read, it is sufficiently 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 concise sentence, front-loaded with key information, and every word adds value. No wasted or redundant text.

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, no output schema), the description provides a complete overview of what the tool returns. Minor improvement could be explicitly listing the fields in a structured way, but it is adequate.

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

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

Schema coverage is 100% with the single parameter 'network' already described in the schema. The description adds no additional meaning beyond the schema, 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 a specific verb and resource: it reads network info (chain identifier, latest checkpoint, current epoch, reference gas price). It is lightweight and distinguishes itself from siblings like sui_get_checkpoint or sui_get_epoch by providing an overview.

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

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

The description implies usage for a quick network overview ('one query'), but does not explicitly state when not to use it or mention alternative tools for detailed data. It is clear in context but lacks exclusionary 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 provided, so description carries full burden. It implicitly indicates a read operation ('Return the catalog') and discloses the mapping to curated tools. However, it does not explicitly state safety or auth requirements, but that is not necessary for this simple 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?

Two sentences, each earning its place: first states purpose, second provides usage guidance. Front-loaded and 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 tool with no parameters and no output schema, the description adequately covers what the tool returns and when to use it. Slightly more detail about the format could improve it, but it's already sufficient.

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

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

The input schema has 0 parameters with 100% coverage. Per guidelines, 0 parameters yields baseline score 4. No parameter info 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 states the tool returns a catalog of gRPC services and methods, with clear verb ('Return') and resource. It distinguishes from siblings like sui_grpc_call by mentioning the mapping to curated 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 description explicitly says 'Use this when deciding whether to call a curated tool or fall back to sui_grpc_call', providing clear guidance on when to use this tool vs the alternative.

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 provided, so description must disclose behavior. Only mentions submission and disabled state; no details on transaction execution, side effects, permissions, or return values.

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

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

Single focused sentence, front-loaded with key info (disabled status and usage condition). No wasted words, though could benefit from slight expansion on purpose.

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

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

Given no parameters, no output schema, and no annotations, description is minimal. Lacks context on what constitutes a pre-signed transaction, expected outcomes, or error handling. Incomplete for an execution 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?

Input schema has no parameters (0), and schema description coverage is 100%. Description adds no value beyond schema, so 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?

Description states it submits a pre-signed transaction but is disabled. The purpose is clear but lacks specificity about what a pre-signed transaction is, and it does not differentiate from siblings like sui_simulate_transaction.

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

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

Explicitly states the tool is disabled and requires setting an environment variable to enable. No guidance on when to use versus alternatives like sui_simulate_transaction.

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 mentions 'aggregated' and the default coin type, implying a read-only query, but does not explicitly state safety, side effects, or permissions. Adequate but not comprehensive.

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, concise sentence containing all essential information: action, resource, optional parameter, and default. No extraneous 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?

While the description covers the core function, it lacks information about the return format (e.g., whether it returns a number or object) and does not clarify optional parameter defaults (network) or required fields (address) beyond the schema. Adequate for a simple tool but could be more 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?

The input schema has 100% description coverage, so baseline is 3. The description adds value by introducing 'aggregated' and specifying the default coin type, which clarifies the purpose of the coin_type parameter beyond the schema's own description.

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 the aggregated coin balance for an address', specifying the resource (address) and the optional coin type with a default. It distinguishes from siblings like sui_list_balances and sui_get_coin_info by focusing on aggregated 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 does not provide explicit guidance on when to use this tool versus alternatives (e.g., sui_list_balances or sui_get_coin_info). It only describes functionality, 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?

With no annotations, the description bears full burden. It discloses routing policy, fallback to archive, and authoritative behavior for latest. It does not mention error conditions or permissions, but the core behavioral traits are covered.

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

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

Two sentences, front-loaded with purpose, then routing details. No redundant information. Every sentence adds value.

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?

No output schema, but description lists return fields (header, summary, digest). Enough for an agent to understand what it gets. Could add pagination or error info, but sufficient for typical use.

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% (all 5 params have descriptions), so baseline is 3. The description adds extra meaning: explains 'auto' routing behavior and latest authoritative details, going beyond schema enums.

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 ('fetch'), resource ('checkpoint'), and identifiers ('sequence number, digest, or latest'). It differentiates from sibling tools like sui_recent_checkpoints and sui_chain_tip by specifying distinct query methods.

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 explains routing behavior ('auto' vs 'live' vs 'archive') and authoritative handling for latest. It implicitly guides when to use each source, but does not explicitly state when_not to use this tool compared to 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?

With no annotations provided, the description carries the full burden. It only discloses cacheability and infrequent changes, but does not state that the tool is read-only, has no side effects, or any authentication requirements. More behavioral details are needed.

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 concise sentences, front-loaded with the main action. No redundant or unnecessary text; every sentence adds value.

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

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

For a simple retrieval tool with fully described parameters, the description adequately conveys the purpose and cacheability. However, without an output schema, it does not fully specify the return structure (e.g., exact field names or types), leaving some ambiguity.

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 both parameters. The tool description adds no additional meaning beyond what the schema already provides, so it meets the baseline for high 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 specifies the verb 'Get' and the resource 'coin metadata', listing specific fields (decimals, symbol, name, icon). It distinguishes from sibling tools by focusing on metadata, not balances or objects.

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 mentions cacheability and that metadata rarely changes, implying when to use (e.g., when caching is beneficial). However, it lacks explicit guidance on when not to use this tool or alternatives among the many sibling 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?

Description indicates a read-only operation ('Get') with no side effects. No annotations exist to provide additional safety info. Explanation of behavior is adequate but lacks details on authentication, rate limits, or error conditions.

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

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

Single sentence that is front-loaded with the action and resource, containing no extraneous words. Every element ('Get', 'Move datatype', 'fields, abilities, type parameters') is necessary and contributes to understanding.

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

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

The description covers the output content (fields, abilities, type parameters) well, given no output schema. However, parameter descriptions are lacking, and the tool's complexity (4 parameters, 3 required) demands more contextual detail for full understanding.

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

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

With only 25% schema description coverage, the description adds no parameter-specific details beyond the tool's purpose. It does not explain the meaning or format of package_id, module_name, or datatype_name, missing an opportunity to compensate for sparse schema documentation.

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

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

Description clearly states the tool retrieves a Move datatype definition, specifying struct or enum, and lists included components (fields, abilities, type parameters). It distinguishes from sibling tools like sui_get_function and sui_get_object by focusing on datatype definitions.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The description implies usage for retrieving datatype information but does not mention alternatives or exclusions, leaving the agent to infer context from 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?

Without annotations, the description carries full burden. It mentions the returned fields (committee, system state, etc.) but does not disclose side effects, rate limits, or authorization needs. The read-only nature is implied but not confirmed.

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

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

Two sentences with no filler. The first sentence defines purpose and key data returned; the second provides a usage tip. Front-loaded and 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?

For a simple fetch tool with no output schema, the description lists several key return fields and explains both parameters well. It lacks only a complete list of all possible fields, but is sufficient for typical use.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context about 'current' usage and network defaults, but this largely repeats the schema. Additional value is minimal.

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

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

The description states a specific verb ('Fetch') and resource ('metadata for an epoch') with clear fields listed (committee, system state, first/last checkpoint, reference gas price). It distinguishes from sibling tools like sui_get_checkpoint by specifying epoch scope.

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

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

Provides explicit guidance on using 'current' for the live epoch, which aids in parameter selection. However, no direct comparison or when-not-to-use advice relative to similar tools (e.g., sui_get_checkpoint) 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?

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It states the tool returns signature details but does not mention whether it is read-only, idempotent, or requires authentication. For a query tool, this is a notable lack of transparency about safety and cost.

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 efficiently conveys the tool's output and a key use case. It contains no filler or redundant information, earning 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?

With four parameters, no output schema, and no annotations, the description is sparse. It does not cover the return format, error handling, or prerequisites. For a tool used in a workflow (before simulation), more completeness is needed to handle edge cases or validation.

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 75% of parameters without descriptions (only 'network' has one). The description does not explain 'package_id,' 'module_name,' or 'function_name,' relying on domain knowledge. With low schema coverage, the description should compensate but fails to add meaning beyond the tool's purpose.

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

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

The description clearly states the tool gets the signature of a Move function, listing specific details (type parameters, argument types, return types, visibility). It distinguishes from siblings like sui_get_package by focusing on function signatures, and provides a concrete use case (before sui_simulate_transaction or PTB construction).

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

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

The description explicitly says 'Use this before calling sui_simulate_transaction or constructing a PTB,' which guides the agent on when to invoke it. It does not include negative examples or alternative tools, but the usage context is clear and sufficient 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?

With no annotations, the description carries full burden. It discloses the 'auto' routing's fallback behavior to Archival Service for expired versions and mentions the trace recording. It is transparent about a non-obvious behavior (version non-monotonicity caveat).

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 with zero waste. The first sentence gives core purpose, the second lists returned fields and use case, the third explains routing and trace. 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?

Despite no output schema, the description thoroughly covers what is returned. Combined with excellent parameter documentation, it provides complete context for a single-object fetch tool. No gaps remain.

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?

All 4 parameters are fully described in the schema (100% coverage). The description adds significant value beyond the schema by explaining the version parameter's non-monotonic nature with a detailed example, and the source parameter's practical routing intent. This aids correct invocation.

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

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

The description begins with a clear action verb 'Fetch' and specifies the resource 'Sui object's current state by object id'. It lists the returned fields (owner, type, version, etc.), distinguishing it from sibling tools like sui_batch_get_objects or sui_get_transaction.

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

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

It explicitly states 'Use for any "what is object 0x..." question — bypass GraphQL for single-object reads', giving clear when-to-use guidance. It also explains routing policies and when to force specific sources. It lacks explicit when-not-to-use, but the sibling list implies batch for multiple objects.

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 what the tool returns (modules, ABI, dependencies, bytecode), implying a read-only operation. However, it does not explicitly state that it is non-destructive, nor does it cover rate limits, permissions, or other behavioral traits. The description is adequate but lacks depth.

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. The first sentence efficiently states the core functionality and return components, while the second sentence adds valuable usage context. No unnecessary words or redundancy.

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

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

Given no output schema, the description explains the return value (modules, ABI, dependencies, bytecode pointer). It covers the tool's purpose and typical use case. It does not mention error handling or prerequisites, but for a simple read tool, it is sufficiently 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?

The input schema has 100% description coverage for both parameters. The description does not add additional meaning beyond what the schema provides. According to guidelines, baseline 3 is appropriate when schema coverage is high.

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

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

The description clearly states the verb ('Get'), the resource ('Move package by id'), and specifies the returned components (modules, ABI, dependencies, bytecode pointer). It also provides a use-case context ('starting point for any 'what does this contract expose?' question'), distinguishing it from sibling tools that focus on objects or functions.

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

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

The description provides clear context for when to use the tool ('starting point for contract exposure questions'), but does not explicitly state when not to use it or suggest alternatives. Given the sibling tools list includes related tools like sui_get_function and sui_get_object, explicit exclusions would improve the score.

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

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

No annotations exist, so the description must fully disclose behavior. It describes what data is returned but does not explicitly state read-only status, error behavior, or prerequisites like endpoint accessibility. This leaves some ambiguity.

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

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

The description is two sentences, front-loaded with the action, and every word adds value. No repetition or superfluous text.

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?

Considering the tool has two optional parameters, no required ones, and no output schema, the description adequately explains the tool's purpose and the data it returns. A minor gap is not mentioning that the operation is read-only or safe.

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 50% (only 'network' has a description). The tool description does not add parameter semantics beyond what the schema provides, e.g., it doesn't explain what 'live' vs 'archive' means for the 'source' parameter. 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 specifies the verb 'Probe', the resource 'gRPC endpoint', and the exact data items retrieved: chain identifier, latest checkpoint, and lowest checkpoint. It also states the utility for distinguishing between live and archive endpoints, clearly differentiating it from sibling tools like sui_get_checkpoint.

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

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

The description explicitly states it is 'useful for picking between live and archive when you don't know which side has the data you need.' This provides clear context, though it does not explicitly mention when not to use it or name alternative tools.

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

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

No annotations provided, so description carries full burden. Discloses routing policy and fallback, but does not explicitly state that the tool is read-only or safe. The behavior is implied, but lacks explicit safety or error handling details.

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, no wasted words. Purpose, usage, and routing are front-loaded. Efficient 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?

With 3 parameters and no output schema, the description adequately covers purpose, returns, and routing. Missing details on error handling or validation, but sufficient for agent decision-making.

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

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

Schema coverage is 100%, so baseline is 3. Description adds minor context about routing defaults ('auto' tries live then archive) but does not significantly enhance understanding beyond schema descriptions.

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

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

Description clearly states 'Fetch a transaction by its base58 digest' and lists return contents (body, effects, events, signatures). Explicitly distinguishes itself as 'The right tool for what happened in tx <digest>'.

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

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

Provides clear usage context: 'The right tool for what happened in tx <digest>'. Explains routing defaults and fallback behavior. Does not explicitly compare to siblings like sui_batch_get_transactions, but the use case is clear.

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 states that the tool returns the type system, which implies a read-only operation. However, it does not explicitly disclose any behavioral traits such as no side effects, required permissions, or rate limits. The description is adequate but not thorough.

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 consists of two concise sentences. The first sentence clearly states the action and result, and the second sentence adds the purpose. No unnecessary words 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 the tool has only two optional parameters and no output schema, the description adequately covers the purpose and parameter usage. It explains how to narrow the introspection and the network context. The missing information about the output format is somewhat compensated by the clear purpose of enabling queries.

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

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

Schema coverage is 100%, with both parameters having descriptions in the schema. The description adds examples for 'type_name' (e.g., 'Address', 'TransactionBlock') and clarifies the default behavior for 'network'. While this adds some value, the schema already provides the core meaning, so a 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 'introspect', the resource 'Sui GraphQL schema', and the purpose 'so an agent can construct a valid sui_graphql_query'. It distinguishes from the sibling tool 'sui_graphql_query' by explaining that this tool provides the schema for constructing queries.

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 that this tool should be used before constructing a GraphQL query, but does not explicitly state when not to use it or provide alternative tools. The relationship with 'sui_graphql_query' is clear, but more explicit guidance would be beneficial.

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 description carries full burden. It discloses that GraphQL is indexer-backed, explains the meaning of empty/null results, and describes the escalation path. This provides excellent transparency beyond basic functionality.

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?

Well-structured with purpose first, then usage guidelines. While slightly lengthy, every sentence adds value. Could be trimmed slightly but still 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 no output schema and no annotations, the description fully covers behavior, error interpretation, and alternatives. It is complete for a query tool with 3 parameters.

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

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

Schema coverage is 100%, so baseline 3. The description adds minimal extra meaning beyond the schema: it confirms optional variables and network default. No significant additional context for 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 clearly states the tool's purpose: 'Run an arbitrary GraphQL query against the Sui GraphQL endpoint.' It distinguishes itself as the escape hatch when no curated tool fits, making its role 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?

Provides explicit guidance: use sui_graphql_introspect first if schema unknown, and explains when to drop to other tools (e.g., sui_get_object) when GraphQL returns null. This covers both when to use and when not to use.

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?

Given no annotations, the description fully discloses that only READ methods are allowed, that ExecuteTransaction and SubscribeCheckpoints are blocked, that read_mask_paths affects response detail, and details the source routing behavior including fallback and limitations.

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

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

The description is a single dense paragraph that front-loads the main purpose. It is concise but could be better structured (e.g., with bullet points) for 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?

Given the complexity of 6 parameters, nested objects, and no output schema, the description covers all essential aspects: allowed services, blocked methods, recommended discovery, parameter nuances, routing policies, and network defaults.

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 significant value: explains that read_mask_paths is needed for full fields (otherwise digests), that numeric fields should be passed as decimal strings for BigInt coercion, and the interaction between source and service.

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 it is an 'escape hatch' for calling READ methods on specific services (LedgerService, StateService, MovePackageService), explicitly blocking ExecuteTransaction and SubscribeCheckpoints, which distinguishes it from sibling 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?

Explicitly recommends using sui_describe_grpc_services first to discover available methods, clarifies which methods are blocked and why, and explains the source routing policy for different services.

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 provided, so description carries full burden. It only states 'List all coin-type balances' and 'Paginated', omitting details like response structure, required permissions, or data freshness.

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?

Extremely concise with two sentences, front-loading the purpose and immediately noting pagination. 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?

Without output schema or annotations, the description fails to explain response format or pagination mechanics. Insufficient for a tool with 4 parameters and no return guidance.

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 75%, covering most parameters. The description adds no additional semantic value beyond the schema, so 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 clearly states the action ('List'), the resource ('all coin-type balances held by an address'), and includes pagination info, distinguishing it from siblings like sui_get_balance.

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

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

The description implies use for listing all balances, but does not explicitly mention when to use vs. alternatives (e.g., sui_get_balance for a single coin) or provide context on prerequisites.

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 bears full responsibility for behavioral disclosure. It merely states the tool lists fields, without mentioning safety (read-only vs. mutation), rate limits, or pagination behavior details beyond parameter names. This leaves significant gaps for an AI agent.

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

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

The description is two sentences, front-loaded with key information. It avoids fluff but could be more informative within the same length, e.g., explaining return format.

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, the description should explain what the tool returns (e.g., list of dynamic field names/types). It does not. Coupled with partial schema coverage and missing pagination behavior, the description feels incomplete for a list 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 50%, but the tool description does not clarify the uncovered parameters (page_size, page_token) beyond the schema. Even the covered parameters lack additional context. The description adds no value over the schema, failing to compensate for missing param descriptions.

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

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

Description clearly states specific verb 'List' and resource 'dynamic fields attached to a parent object', with context hinting at crawling tables/bags. This distinguishes it from sibling tools like sui_get_object or sui_batch_get_objects, which serve different purposes.

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?

Description says 'Useful when crawling tables/bags/dynamic object fields', providing clear context for when to use. However, it does not explicitly mention when not to use or provide alternative tools, missing some completeness for a top score.

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

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

No annotations are provided, so the description must carry the burden. It mentions 'env-override resolution,' which hints at configuration behavior, but it does not explicitly state read-only nature, required permissions, or potential side effects. The description is adequate for a simple listing but lacks full 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, front-loading the action and context. Every word is purposeful, with no redundancy 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 tool has a single optional parameter, no output schema, and no annotations. The description adequately explains what the tool returns and one key use case. It lacks details on output structure (e.g., format of URLs) but is sufficiently complete for a simple list operation.

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

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

Schema description coverage is 0%, meaning the description must compensate. While the parameter 'network' has an enum in the schema, the description only says 'for a given network' without explaining it is optional or listing the accepted values. This adds minimal value 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 returns gRPC, GraphQL, and Archival URLs for a network after env-override resolution. It uses a specific verb ('Return') and resource ('URLs') and distinguishes itself from sibling tools by addressing network endpoint listing rather than data queries.

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 context with 'Useful when deploying behind a self-hosted full node,' indicating when to use the tool. However, it does not explicitly state when not to use it or mention alternative tools, which would improve clarity.

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 provided. Description discloses pagination and content of items but does not mention read-only nature, authentication, rate limits, or ordering. Adequate for a simple list tool but lacks some 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?

Single sentence that packs purpose, pagination, item fields, and guidance to siblings. No fluff, 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?

For a list tool with pagination, the description covers what's returned and next steps. Lacks mention of sorting or ordering but is sufficient given tool complexity and absence of 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 only 25% (only network has description). Description adds pagination context for page_size/page_token but does not explain address or page_size range. Provides marginal value beyond 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?

Clearly states it lists objects owned by an address with pagination. Mentions item fields (id, version, type) and directs to sibling tools for full bodies, differentiating it from sui_get_object and sui_batch_get_objects.

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 advises using sui_get_object or sui_batch_get_objects for full object bodies, implying this tool is for lightweight listing. Pagination mention sets expectations for large result sets.

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 only states 'list historical versions' but does not explain critical aspects such as pagination behavior, error handling, authentication requirements, or the structure of the returned data. This is insufficient for an agent to understand the tool's behavior 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 consists of two short, front-loaded sentences with no extraneous information. Every phrase ('historical versions', 'upgrade chain', 'useful when...') adds value, making it highly efficient for an agent 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?

Given the tool's complexity (4 parameters, no output schema, no annotations), the description is inadequate. It does not specify the return format, pagination limits, or how to interpret the 'upgrade chain' data. Agents would likely need to infer or experiment to use 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 only 25% (only the 'network' parameter has a description). The tool description adds no parameter-level information, nor does it clarify the meaning or expected format of required parameters like 'package_id' or optional ones like 'page_size' and 'page_token'. The description fails to compensate for the low 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 specifies the action ('List historical versions') and the resource ('a Move package'), with additional context ('the upgrade chain') that distinguishes it from sibling tools like sui_get_package which retrieves the current package. The purpose is unambiguous and directly actionable.

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

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

The description provides a concrete use case ('Useful when an address points at an older snapshot of a contract'), helping agents decide when to invoke this tool. However, it does not explicitly exclude scenarios or name alternative tools for when the current version is needed, leaving some ambiguity.

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 description carries the full burden. It discloses non-monotonic versioning and the internal logic, but does not specify permissions or side effects, which are minimal for a read-only history walk.

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

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

Two sentences, front-loaded with purpose and output, followed by essential context. No superfluous 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 tool with 2 parameters, no output schema, and no annotations, the description adequately covers purpose, output, and a key nuance. Lacks parameter-level guidance but schema partially covers that.

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 50% (only 'network' has a description). The tool-level description adds no per-parameter details, failing to compensate for the missing schema descriptions.

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 ('walk') and resource ('object's history'), clearly distinguishes from siblings like sui_get_object, and explains the non-obvious version behavior.

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 explains the canonical walk it encapsulates, implying its use case, but does not explicitly state when not to use it or list 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 are provided. The description mentions the output includes digests, timestamps, and transaction counts, but does not disclose ordering, default recency, or pagination behavior. Some behavioral context is given but incomplete.

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

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

Single sentence of 10 words, front-loaded with the core purpose. No unnecessary words or repetitions.

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 tool with two optional parameters and no output schema, the description covers the main output fields and purpose. Lacks details on default behavior (e.g., how many checkpoints by default) but is generally sufficient.

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

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

Schema description coverage is 50% (only 'network' has a description). The description does not explain the 'last' parameter, which controls the number of checkpoints returned. It adds minimal semantic value 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 provides a feed of recent checkpoints with digests, timestamps, and transaction counts. It distinguishes from siblings like sui_get_checkpoint (single checkpoint) and sui_stream_checkpoints (streaming).

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

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

No guidance on when to use this tool versus alternatives (e.g., sui_get_checkpoint for a single checkpoint, sui_stream_checkpoints for streaming). The description does not mention 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?

Describes safety (no state changes, no fees) and outputs (effects, command outputs, gas price). Without annotations, this provides necessary behavioral context. Could specify more about input validation.

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 well-structured sentences that front-load the purpose and safety, then detail output and usage. No unnecessary words.

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

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

Given no output schema, it lists key return values. For a 2-parameter tool, it covers input format and usage context adequately. Could elaborate on output structure but sufficient.

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

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

Schema coverage is 100% and both parameters are described in the schema. The description restates the base64 encoding but adds no new meaning 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 it dry-runs a transaction, is safe, and has no state changes or fees. It distinguishes itself from real execution tools like sui_execute_transaction by being a simulation.

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 to use before real execution to check success and size gas. Implicitly contrasts with sui_execute_transaction, but doesn't explicitly name the sibling.

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 provided, so description fully discloses behavior: windowing (max_frames, max_seconds), each frame carries cursor + summary, resumption with after_cursor, and server caps. Transparent about all key 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?

Three sentences: first conveys core behavior, second explains windowing, third usage pattern. No wasted words, front-loaded with essential 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?

Covers all parameters and usage pattern well despite no annotations or output schema. Could elaborate on output format details (e.g., what fields are in the checkpoint summary), but sufficient for an AI agent to use correctly.

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

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

Schema coverage is 100%, but description adds meaning: explains max_frames/seconds caps, after_cursor for resumption, default fields for read_mask_paths, and network default. Adds useful context beyond 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?

Description clearly states it subscribes to new checkpoints and returns a window of up to 10 frames (or 30s). It distinguishes from siblings like sui_recent_checkpoints by explicitly stating the streaming pattern and resumable reads.

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

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

Provides clear instructions to call repeatedly and pass the last cursor back as 'after_cursor' for resumable reads. Implicitly differentiates from one-shot checkpoints but lacks explicit when-not 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 exist, so description carries full burden. It reveals the tool is a GraphQL round-trip fetching multiple data types, implying read-only. However, it lacks details on authentication, rate limits, or potential errors, leaving some behavioral gaps.

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

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

A single sentence front-loads the action and key outputs. It is efficient, though the phrase 'relational reads gRPC isn't shaped for' is slightly jargon-heavy. Overall 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?

Given 2 parameters, no output schema, and no annotations, the description provides a reasonable overview but omits details on return format, error handling, and usage constraints. It is minimally complete for a tool of this complexity.

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

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

Schema coverage is 50% (only 'network' has a description). The description adds no parameter-level meaning—'digest' is mentioned but not explained (e.g., format). The description fails to compensate for the missing schema documentation.

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

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

The description clearly states that the tool pulls transaction effects, gas summary, balance changes, and checkpoint pointer via GraphQL, distinguishing it from gRPC. The verb 'pull' and specific data types make the purpose unambiguous.

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

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

The description implies use for relational reads that gRPC isn't suited for, but does not explicitly contrast with sibling tools like sui_get_transaction or provide when-not-to-use guidance. It offers decent context but no exclusions.

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