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

The description explicitly states it never cancels already signed or submitted chain transactions, providing a clear constraint. No annotations exist, so this is adequate but minimal.

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

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

Two concise sentences with no extraneous information. The first states the action, the second adds a critical behavioral note.

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, no explanation of return values, and no parameter details. Given the lack of annotations and schema descriptions, the description is insufficient 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?

Schema coverage is 0% with no parameter descriptions. The description does not explain what operationId or secret represent, leaving the agent without crucial context for correct invocation.

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

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

The description clearly states it cancels a pending offchain operation handoff. However, it does not differentiate from sibling cancel tools like cancel_xdala_bundle_deploy_handoff, which may cause confusion about which operation to use.

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

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

No guidance on when to use this tool versus alternatives. The description only clarifies what it does not cancel but omits scenarios when this tool is appropriate.

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 partially fills the gap by stating it is offchain and never cancels chain transactions. However, it lacks details about prerequisites, side effects, or whether cancellation always succeeds.

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, no wasted words. Efficiently communicates the core purpose and a key constraint.

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 one parameter and no output schema, the description covers the essential scope but lacks explanation of the 'handle' parameter. It is minimally adequate 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?

Schema coverage is 0%, and the description does not explain the 'handle' parameter. The term 'handle' is vague, and the agent gets no additional meaning from the 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?

Description clearly states the action (cancel), the resource (pending XDaLa bundle deploy handoff), and distinguishes it from chain transactions ('offchain metadata only'). It is specific and unambiguous.

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

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

No guidance on when to use this tool versus siblings like 'cancel_operation_handoff' or 'cancel_xdala_session_start_handoff'. The description does not provide context for selection.

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

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

With no annotations, the description fully bears transparency. It explicitly states what the tool does (cancel metadata) and crucially what it does not do (sign, submit, execute, or cancel on-chain work), providing clear behavioral expectations.

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

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

Two sentences efficiently convey the action and its read-only nature. No extraneous information, front-loads the key 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?

Despite a simple tool with one parameter, the description lacks detail about the 'handle' parameter and does not mention return values or errors. With no output schema, the agent is left without complete context for successful invocation.

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

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

The schema has 0% description coverage and only a required 'handle' string. The description does not explain what 'handle' refers to, leaving the agent to infer from context. No additional meaning beyond the schema is provided.

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 cancels pending xDaLa session start handoff metadata only, using a specific verb and resource. It distinguishes from sibling tools by emphasizing it is a read-only preparation tool that does not sign or execute on-chain work.

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 canceling handoff metadata without on-chain effects, but does not explicitly name alternatives or provide when-not conditions. The read-only nature is highlighted, offering some guidance.

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

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

The description discloses that the MCP never signs or submits transactions and that the user executes locally with a browser wallet. Given no annotations are provided, this adds essential behavioral context. However, it does not mention side effects or persistence details, which would elevate transparency further.

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

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

The description is concise and front-loaded with the primary purpose. It uses multiple sentences without redundancy. However, it could be slightly more structured (e.g., separating the exclusions into a list) to improve 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 tool has 9 parameters, no output schema, and nested objects, the description is insufficient. It only mentions returning a browser URL without explaining the URL format or the nature of the 'offchain human-in-the-loop operation'. The extensive negative guidance is helpful but does not compensate for the lack of positive usage details.

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

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

Schema description coverage is 0%, meaning no parameter descriptions are provided in the input schema. The description does not explain any of the 9 parameters (type, network, chainId, etc.) or their roles, leaving the agent to infer meaning solely from names.

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 creates an offchain human-in-the-loop operation and returns a browser URL. It specifies that the MCP never signs or submits transactions, distinguishing it from related tools. The verb 'create' and resource 'operation handoff' are directly stated, making purpose unambiguous.

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

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

The description provides explicit guidance on when not to use this tool (e.g., for XDaLa sessions, xgr_validateDataTransfer) and directly names the alternative tool 'create_xdala_session_start_handoff'. It also instructs the agent to report unavailability rather than fallback, demonstrating clear usage boundaries.

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 fully convey behavior. It discloses that data is stored offchain, returns a URL, and doesn't execute transactions. However, it doesn't mention resource implications, TTL, or any side effects beyond storage. Adequate but could be richer.

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

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

The description is two sentences, front-loaded with the core action and result. Every sentence adds value, and there is no unnecessary 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 no output schema, complex nested parameters, and a large sibling set, the description is incomplete. It fails to explain input parameter formats, output structure, or when to use this tool over similar ones. The agent lacks sufficient context to correctly invoke the 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 coverage is 0%, and the description provides no explanation for any of the 6 parameters, including the required ones (network, chainId, bundle) and nested objects (bundle, summary, validation). An agent cannot infer valid values or formatting from the description alone.

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 stores a validated xgr-multi-bundle@1 bundle offchain and returns an XDaLa Workbench import URL. It also explicitly notes it does not sign, submit, or execute transactions, which distinguishes it from other tools like submit or execute operations. The verb 'store' and noun 'bundle' are specific.

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 any when-to-use or when-not-to-use guidance. It only states what the tool does, but doesn't indicate when an agent should choose this over sibling tools like create_operation_handoff or validate_xdala_bundle. The explicit negation of signing/execution is helpful but insufficient.

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

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

With no annotations provided, the description carries full burden. It clearly states the tool's read-only nature, that it does not sign/submit/execute, and returns a Workbench xdalaUrl. It also explains limitations and constraints, such as requiring explicit user permission for demo values and correct usage of session ownership terms. This fully discloses behavioral traits.

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

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

The description is lengthy but front-loaded with the main purpose and usage. Each sentence adds value, though some sections (e.g., detailed instructions about owner()/getOwner()) could be condensed. For the complexity of the tool, the verbosity is justified and well-organized.

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 (22 parameters, nested objects, no output schema), the description covers main use cases, return value, and agent actions. It addresses user interaction and data derivation. However, it does not fully explain error scenarios or all parameter combinations, leaving some gaps for edge cases.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by referencing canonical xgr-session-start@1 terminology (sessions[].orchestration, etc.), clarifies that entryStepId is not used, and provides guidance on deriving payload fields. However, it does not detail all 22 parameters (e.g., signing, executorGrants, security), leaving some gaps in semantic clarity for less prominent 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 begins with a specific verb+resource: 'Prepare and store a read-only xgr-session-start@1 handoff for xDaLa Workbench.' It then enumerates multiple use cases (start, run, launch, etc.) and explicitly distinguishes from sibling tools like get_xdala_session_start_handoff and cancel_xdala_session_start_handoff. The purpose is clear and non-overlapping.

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

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

The description provides explicit when-to-use guidance ('Use this tool whenever the user wants to start...') and lists specific scenarios. It also includes exclusions and warnings: 'Do not call this tool with guessed payload values,' 'Do not replace the xdalaUrl with a generic /operations/op_... link,' and advises on when to ask for user input. This clearly helps the agent decide when to invoke this tool over alternatives.

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

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

No annotations are provided. The description explains what the tool returns (validation gas, branch gas, etc.) and that it calls xgr_estimateRuleGas, but does not state whether the operation is read-only or has side effects. Given no annotations, the description provides moderate transparency for a non-mutating estimation tool.

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

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

The description is only two sentences, the first states the purpose and the second lists return values. It is highly concise and front-loaded, with no wasted words.

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

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

Despite a clear purpose and return breakdown, the description omits any explanation of parameters, which is critical given 4 parameters with zero schema descriptions. It also does not address prerequisites or behavior. The tool has no output schema, so the return description is helpful but incomplete 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?

The input schema has 4 parameters with 0% description coverage. The description does not mention any parameters or their meanings, failing to add value beyond the bare schema. This leaves agents with no guidance on how to use 'json', 'encrypted', 'validSpawns', or 'invalidSpawns'.

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 estimates XDaLa/XRC-137 rule gas and lists specific return metrics (validation gas, branch gas, grant fees, worst-case totals). It distinguishes from sibling estimation tools by specifying 'rule gas' as the resource.

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 instructs 'Use this to estimate XDaLa/XRC-137 rule gas', implying the tool is for rule gas estimation tasks. However, it does not provide explicit guidance on when not to use or mention alternatives, leaving the agent to infer from context.

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

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

No annotations provided, so description bears full burden. It states 'read-only' and describes data source, which is good. But lacks details on rate limits, auth, or behavior when no session found.

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 use case. But includes an erroneous reference to 'sessionId' which could cause confusion. Could be more concise and accurate.

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 annotation coverage, the description should cover return structure, error scenarios, and all parameters. It provides minimal context beyond basic purpose, leaving significant gaps.

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

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

Schema coverage is 0%, so description must explain parameters. However, it incorrectly refers to a non-existent 'sessionId' parameter and does not explain 'owner' or 'windowHours'. Only 'includePayload' is hinted via 'optionally include final receipt payload data'. This is insufficient and partially misleading.

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 resolves the latest XDaLa session from the Explorer database, read-only, with optional payload inclusion. However, it does not explicitly differentiate from sibling tools like 'get_xdala_session_detail' or 'list_xdala_sessions', so a slight deduction.

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 tells when to use: when user asks for latest session without providing owner and sessionId. But does not mention when not to use or alternative tools, missing some guidance.

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

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

The description mentions 'read-only' which informs about non-destructiveness, but provides no details on authentication, rate limits, or behavior under various input conditions. With no annotations provided, the description carries full burden but falls short.

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 that front-loads the purpose with no filler words. Every word 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?

Given the tool's complexity (8 parameters, nested objects, no output schema), the description is too sparse. It omits parameter meanings, return format, pagination, and error handling, leaving agents underinformed.

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%, and the description does not explain any of the 8 parameters (owner, draftRule, ruleHash, etc.). It only hints at 'metadata-assisted search' but leaves agents guessing about required inputs beyond 'owner'.

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 is for searching existing owner XRC-137 contracts that could be reused, with a read-only metadata-assisted approach. It specifies the resource (XRC-137 contracts) and action (search for reusable ones), but does not explicitly differentiate from similar sibling like 'get_unused_xrc137_rules'.

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 when searching for reusable contracts to avoid redeployment, but lacks explicit when-not-to-use guidance or comparisons with alternatives like 'get_unused_xrc137_rules' or 'read_xrc137_rule_json'.

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

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

The description declares the operation as 'read-only' and states it does not create handoffs, setting safety expectations. However, with no annotations, more details about authentication, rate limits, or error handling would improve transparency. It covers basic behavioral traits adequately.

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 core purpose with a usage hint. It is concise and direct, though it could be slightly more structured (e.g., bullet points) for scanning.

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 9 parameters and no output schema, the description leaves out critical details: parameter meanings, output format, and error conditions. It is insufficient for an agent to use the tool correctly without additional information.

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

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

The input schema has 9 parameters with 0% description coverage, and the description does not explain individual parameters (e.g., owner, includeOwner, limit). It only mentions address and roles in general. The description fails to compensate for the lack of 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 clearly states the tool performs 'read-only discovery of deployed XRC-729 workflows' that an address can start, specifying the resource and action. It also mentions the roles (owner, executor, wildcard executor) and contrasts with creating handoffs.

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 advises when to use the tool ('whenever the user provides an address and asks which sessions/workflows they can start') and clarifies what it does not do (no session-start handoffs). It provides clear context but doesn't mention explicit alternatives or 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?

No annotations provided, so description carries full burden. It states the tool is 'live' and returns specific fields, implying real-time read-only behavior. However, it does not mention rate limits, prerequisites, or potential errors.

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, front-loaded with purpose, no wasted words. Perfectly concise for the tool's simplicity.

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 one parameter and no output schema, the description covers the key inputs and outputs. It could mention the return format more explicitly, but it's adequate for the agent to understand the tool's function.

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 only parameter 'address' is described merely as 'for an address' in the description. Schema coverage is 0%, so description should add more meaning, but it only minimally restates the parameter's purpose beyond the pattern in the schema.

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

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

The description clearly states it returns live EVM account state with balance, nonce, and contract code for an address. This is specific and distinct from sibling tools like get_account_transactions or get_block_transactions.

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 'Use this for live EVM account state,' providing clear context. No explicit alternatives or when-not-to-use, but the purpose is narrow enough that it's clear when to apply.

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 full burden. It states 'Read-only' indicating non-mutation, but fails to disclose behaviors like pagination, sorting, rate limits, or how parameters like windowHours and page affect results.

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

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

The description is concise: two sentences that efficiently convey purpose, read-only nature, and usage guidance without any 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?

Given 6 parameters with no schema descriptions, no output schema, and no annotations, the description is incomplete. It lacks details on pagination, filtering, result format, and edge cases, which are essential for proper tool invocation.

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

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

With schema description coverage at 0%, the description adds no meaning beyond the schema. Parameters like address, direction, valueOnly, windowHours, page, and limit are unexplained, leaving the agent to infer from names alone.

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 does a read-only chain-wide Explorer DB transaction lookup for one account, specifying it can be sender, recipient, or both. This distinguishes it from sibling tools like get_block_transactions or get_session_transactions.

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 advises using this tool instead of XDaLa session tools for account-wide transaction history, providing clear guidance on when to use it. It lacks explicit exclusions for other scenarios but effectively directs the agent.

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

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

The description explicitly states the tool is 'read-only', which implies no side effects. It also describes the three distinct modes of retrieving block transactions. However, it does not disclose pagination behavior, result structure, or any rate limits, though the core behavior is well-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?

The description is a single, concise sentence that front-loads the key information. Every word is meaningful, and there is no fluff.

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

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

Given the tool has 4 parameters, no annotations, and no output schema, the description covers the core functionality but lacks details on pagination and the structure of returned transactions. It is adequate for basic use but not fully complete.

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

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

The schema provides no parameter descriptions (0% coverage), so the description must compensate. It explains the semantics of blockNumber and latestOffset well, describing how they work in the three modes. However, the page and limit parameters are not mentioned, leaving some gaps.

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

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

The description clearly states the tool's purpose: listing transactions in a specific indexed block, the latest indexed block, or the latest block minus an offset. It uses a specific verb (list) and resource (transactions), and distinguishes the three modes of operation.

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

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

The description provides no guidance on when to use this tool versus sibling tools like get_account_transactions or get_session_transactions. There is no mention of prerequisites, alternatives, or when not to use it.

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?

Discloses return values (chain id, latest block number, gas price) and source (JSON-RPC), but no annotations provided; description adequately covers behavioral traits for a read-only 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?

Single sentence efficiently conveys purpose and output, with no extraneous information.

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

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

Given zero parameters and no output schema, the description fully explains the tool's return values and source, making it complete for a simple status query.

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?

No parameters exist, and schema coverage is 100%; description adds value by specifying the returned data fields beyond the empty 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 live XGRChain status including chain id, latest block number, and gas price, distinguishing it from sibling tools that focus on transactions, sessions, or contracts.

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 'Use this for live XGRChain status,' providing clear context for when to invoke this tool, though it does not explicitly exclude scenarios.

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

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

No annotations provided, so the description carries the full burden. It indicates a read operation but does not disclose caching, rate limits, or behavior if no block exists. Adequate but minimal.

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

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

Single sentence of 15 words, direct and front-loaded. No unnecessary 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 no-parameter tool, the description sufficiently identifies the use case. Lacks output format details but not required given sibling context and no 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?

No parameters exist, schema coverage is 100%. Baseline for zero parameters is 4, and the description adds no parameter info since none are needed.

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

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

The description clearly states the tool retrieves the latest EVM block details from XGRChain, using specific verb and resource. It directly addresses the user's intent.

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 says to use when the user asks for latest EVM block details, which is a clear trigger. However, it does not mention when not to use it or suggest alternatives among many sibling tools like get_block_transactions.

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?

Discloses read-only nature, autonomy in resolving latest session without owner+sessionId, and return fields. Lacks details on error handling or rate limits but sufficient for a read-only tool with no annotations.

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

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

Two concise sentences, front-loaded with usage guidance, 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?

Adequately describes return fields and purpose, but entirely omits parameter semantics, which is critical for agent usage given no 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?

Description provides zero information about the two parameters (owner, windowHours), and schema coverage is 0%. Agent cannot infer their meaning or constraints from description alone.

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 resolves the latest indexed session and returns specific data fields, distinguishing it from sibling tools that require explicit session identification.

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 when to use (when user asks for the payload of the latest XDaLa session), but does not mention when not to use or suggest alternatives like get_xdala_session_detail.

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 only says 'return the current status,' implying a read operation, but does not disclose any behavioral traits like side effects, permissions, or response structure. Minimal transparency.

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

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

The description is two short sentences (11 and 10 words) with no filler. It front-loads the purpose and then gives usage guidance. Every sentence serves a clear role.

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 lacks details on return values. Parameter semantics are missing. For a simple tool with 2 params, the description is incomplete and does not provide enough context for correct invocation.

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

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

Schema coverage is 0% and the description does not describe any parameters. It fails to explain what operationId or secret mean, forcing the agent to guess their roles. No additional semantics provided beyond the schema's type constraints.

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 'Return the current status of an operation handoff,' using a specific verb and resource. It differentiates from siblings like cancel_operation_handoff by focusing on status retrieval.

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

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

The description provides explicit usage context: 'Use this after the user opens the operation page and signs or cancels local wallet transactions.' It does not exclude alternatives or discuss when not to use, but the guidance is clear and actionable.

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

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

With no annotations, the description carries full burden. It states read-only, excludes gas fees, and sources from the Explorer transaction index. However, it does not disclose pagination behavior, rate limits, ordering, or behavior with zero results.

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

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

The description is two concise sentences, front-loading the core concept without extraneous words. 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?

Despite low complexity, the tool has 6 parameters and no output schema. The description fails to explain pagination, filtering, or output format, making it insufficient for effective use without further inference.

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

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

Schema description coverage is 0%, and the description only explains minValueWei in context. It does not describe windowHours, from, to, page, or limit, leaving critical parameters undocumented.

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 a 'read-only shortcut for recent native XGR value transfers' and defines 'native value transfer' as transactions with value > minValueWei excluding gas fees. It distinguishes itself from sibling tools like 'search_transactions' by being a quick, focused query.

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

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

The description implies usage for quickly retrieving recent value transfers but does not explicitly state when to use this tool versus alternatives like 'search_transactions' or 'get_account_transactions'. No exclusions or when-not guidance is provided.

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 disclose behavior. It states the tool accesses a 'read-only Explorer database', implying safety. It adds context about payload enrichment and optional filtering, but does not detail return structure or pagination beyond listing.

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 sentence that packs in the core purpose, use case, and parameter options without any filler. Every part 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 tool's purpose and parameters well, but lacks details on return structure (no output schema) and ordering (implied recent but not stated). With 4 optional parameters, it is adequate but could be more complete regarding output format.

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

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

Despite 0% schema description coverage, the description enumerates the four parameters ('owner filtering, time windows, result limits and payload enrichment'), directly mapping to owner, windowHours, limit, and includePayload. The schema itself only provides constraints, so the description adds meaningful 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 lists recent indexed XDaLa sessions, specifying it is for when the user does not know owner or sessionId. It distinguishes from siblings like list_xdala_sessions by mentioning the read-only Explorer database and enumerating supported filtering options.

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

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

The description provides a clear use case ('especially when the user does not know owner and sessionId') and lists supported filters. It does not explicitly mention when not to use or compare to alternatives, but the context is clear enough for an agent to decide.

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

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

The description discloses the tool returns decoded engine receipt data and lists included fields. While it doesn't explicitly state read-only, the return semantics imply no side effects. Without annotations, it adequately informs behavior, though a read-only hint would be beneficial.

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 purpose, with no unnecessary words. Every sentence contributes to understanding the tool's function and usage boundaries.

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 (8 parameters, no output schema, no annotations), the description provides adequate high-level context about what the tool returns and when to use it. However, it lacks detail on parameters and output structure, leaving significant gaps for an agent to fully understand invocation and interpretation.

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%, and the description does not explain any of the 8 parameters. It only describes the return data, leaving parameter semantics entirely undocumented. No value is added beyond the raw schema.

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

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

The description clearly states the tool's purpose: 'inspect what an XDaLa session actually did' and lists specific return fields. It distinguishes from sibling get_session_transactions by advising against using it for a simple transaction timeline, making the purpose specific and 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?

Explicit usage guidance is provided: when to use ('inspect what a session did') and when not to ('do not use for a simple transaction timeline') with a named alternative tool (get_session_transactions). This gives clear direction for 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 bears full responsibility for behavioral disclosure. It only says 'high-level indexed analytics' but does not explain what the tool returns (e.g., aggregated counts, trends), whether it is read-only, or any other behavioral traits like rate limits or authentication needs.

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 12-word sentence, making it concise and front-loaded with the verb 'Use'. However, it sacrifices informativeness for brevity; it could be restructured to include more details without losing conciseness.

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

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

Given the tool has one optional parameter, no output schema, and many sibling tools, the description is incomplete. It does not explain the return value, the effect of the window parameter, or how to decide when to use this tool vs. siblings. More context is needed for effective agent usage.

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

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

The description does not mention the sole parameter 'window' (enum: 24h, 7d, 30d, 1y, all). With 0% schema description coverage, the description should explain what the parameter does, but it provides no semantics. The agent cannot infer that window controls the time range for the overview.

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 'high-level indexed XDaLa session analytics' from the 'Explorer API', identifying the resource (sessions) and the generic action (get overview). It distinguishes from siblings like get_session_detail, but the phrase 'high-level indexed' could be more specific to differentiate from similar aggregate tools like get_session_stats.

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 usage context ('high-level analytics') but fails to give explicit when-to-use, when-not-to-use, or alternatives. With many sibling tools (e.g., get_session_stats, get_session_timeseries), no guidance is given to help the agent choose between them.

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 disclose behavioral traits. It mentions that the tool uses XGR RPC and returns a live status, implying a read-only operation. However, it does not describe authentication needs, rate limits, or potential side effects, which would be valuable for an 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 consists of two concise sentences that convey the tool's purpose and basic behavior with no wasted words. It is front-loaded with the key action.

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 status-check tool with two required parameters and no output schema, the description sufficiently covers the return field (xgr_sessionAlive) and the source (XGR RPC). It is complete enough given the absence of complex output.

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

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

The input schema has no descriptions for its two parameters, and the description only mentions 'session owner and session id' without explaining formats or constraints. The pattern for owner (Ethereum address) is in the schema but not in the description. The description adds minimal 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 the tool checks live session status from XGR RPC and returns a specific field (xgr_sessionAlive). It specifies the action (check status) and resource (XDaLa session), distinguishing it from sibling tools like get_xdala_session_detail which likely return more comprehensive data.

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 to check live session status', but does not provide guidance on when not to use or mention alternatives. There are sibling tools like get_xdala_session_detail that might also provide session information, but no exclusion criteria are given.

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

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

With no annotations, the description carries the burden. It correctly indicates it is a read operation (list, returns) and does not mention destructive actions or special permissions. However, it lacks details on rate limits, authentication needs, or response size constraints. Basic transparency is achieved 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 the main purpose, and includes a negative statement to clarify scope. Every sentence contributes meaning; no filler or repetition.

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

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

Given no output schema, the description covers what is returned (timeline of hashes, blocks, fees, steps). It omits how pagination works (page/limit params exist) and ordering. The context is fairly complete for a list operation, but the pagination behavior would help the agent 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 coverage is 0%, so the description should explain parameters. It does not mention sessionId, owner, page, or limit at all. The parameter names are somewhat self-explanatory (e.g., sessionId, owner), but page and limit lack context such as default values or pagination behavior. The description adds no value over the raw 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 verb 'list' and the resource 'blockchain transactions belonging to an XDaLa session'. It specifies the returned data (timeline of transaction hashes, blocks, fees, iteration steps) and explicitly differentiates from tools that return full engine payloads or contract read results, thus distinguishing from siblings.

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 when one needs the transaction timeline of a session and excludes returns like full payloads, which hints at alternatives but does not explicitly name them or state when not to use this tool. Guidance is adequate but not robust.

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 must disclose behavioral traits. It states that the tool combines indexed data, receipt data, and falls back to live RPC if available. This provides useful behavior context. However, it does not mention any potential side effects, authentication needs, 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?

The description is concise at two sentences, front-loading the usage context. Every sentence adds value without redundancy.

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

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

Given the tool has one parameter, no output schema, and no annotations, the description sufficiently explains what the tool does. However, it does not describe the return format or typical fields, which could leave the agent uncertain about what to expect.

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

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

The schema has 0% description coverage for the single parameter 'txHash'. The description does not add parameter-level details beyond the schema. The parameter name and pattern make it self-explanatory, but the description could clarify expected format or examples.

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: to retrieve what happened in a specific transaction. It mentions combining multiple data sources (indexed Explorer data, receipt data, live RPC fallback), distinguishing it from sibling tools like 'get_transaction_receipt' which only fetch receipt data.

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 the user asks what happened in a specific transaction,' providing clear context. It mentions data sources but does not explicitly exclude cases where simpler tools would suffice, though the context implies this is the comprehensive option.

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 only mentions a preference for Explorer decoded receipt data, which is a minor behavioral hint. It does not disclose potential limitations, authentication needs, or other important traits.

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

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

The description is extremely concise with two short sentences that convey the essential information. There is no wasted text or redundancy.

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

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

Given the tool has a single parameter and no output schema, the description is reasonably complete. It covers the purpose and a behavioral preference. However, mentioning the return format or an example would make it slightly more robust.

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% description coverage for the txHash parameter, and the description adds no explanation of what txHash represents (though it is implicit). For agents, explicitly stating 'the transaction hash' would be helpful.

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 retrieves receipt logs, status, and gas usage, and mentions a preference for decoded data. It effectively communicates the tool's purpose, but does not explicitly differentiate from sibling tools like get_transaction_evidence or get_session_receipt_logs.

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

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

The description implies when to use the tool ('use this for receipt logs...'), but lacks explicit guidance on when not to use it or alternatives. Given the many sibling tools, more detailed usage context would improve 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?

Explicitly states 'read-only' and specifies the data source (Explorer transaction index), which is helpful given no annotations. However, does not detail what 'compact statistics' includes or any other behavioral traits like pagination 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?

Single sentence of ~45 words efficiently conveys purpose, read-only nature, source, and filter options without redundancy.

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

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

Adequately covers the tool's purpose and filtering capability for a simple stats retrieval tool, though it omits details about the shape of the returned statistics (e.g., counts, averages).

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

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

With 0% schema description coverage, the description compensates by explaining the three parameters as 'optional block or block-timestamp window filters', adding meaningful context beyond parameter names.

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?

Describes a read-only tool for retrieving compact chain transaction statistics from the Explorer index, with optional block or time-window filters. Clearly differentiates from siblings like get_block_transactions or get_account_transactions by specifying the source and aggregated nature.

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

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

Mentions optional filters (windowHours, fromBlock, toBlock) implying when to use, but lacks explicit guidance on when not to use or alternatives among siblings.

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

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

The description declares it is read-only and lists rules with no observed usage, which are key behavioral traits. However, it fails to disclose ordering, exhaustiveness, error handling, or any performance implications. With no annotations, the description carries the burden but provides only basic 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 a single, front-loaded sentence with no unnecessary words. It is maximally concise and well-structured for a simple tool.

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

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

Given no output schema, annotations, or parameter descriptions, the description should provide more context about return format, pagination, and behavior for missing or invalid owners. It completely lacks details on the 'limit' parameter and output structure, leaving significant gaps for proper 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 description coverage is 0%, so the description must explain parameters. It only implicitly references 'owner' in the phrase 'owner XRC-137 rules', and completely ignores the 'limit' parameter. No additional meaning is added beyond the schema's type and pattern.

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 a read-only list of owner XRC-137 rules with no observed usage. It uses specific verb 'list' and resource 'unused rules', and while it implicitly distinguishes from related siblings like 'find_reusable_xrc137_rules', it does not explicitly differentiate.

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

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

No guidance is provided on when to use this tool versus alternatives like 'find_reusable_xrc137_rules' or 'read_xrc137_rule_json'. There is no mention of prerequisites or context for usage.

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

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

With no annotations, the description carries full burden. It does not disclose behavioral traits like return format, aggregation, or time range defaults, leaving the agent uninformed about what to expect.

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, efficiently stating when to use it. It could include more detail without becoming verbose, but currently it is clean and focused.

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 lack of output schema, parameter description, and annotations, the description is incomplete. It does not cover return values, default window, or behavior when parameter is omitted, leaving significant gaps.

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

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

The input schema has 0% description coverage; the description adds no meaning to the 'windowHours' parameter, failing to explain its role (e.g., how it affects the timeseries or default behavior).

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: retrieving active/concurrent XDaLa sessions over time. It uses specific verbs and distinguishes from sibling tools like get_xdala_session_timeseries.

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 when to use ('when the user asks for active/concurrent XDaLa sessions over time'), providing clear context. No exclusions or alternatives mentioned, but it's sufficient for this simple tool.

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

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

With no annotations, the description fully discloses its read-only, informational nature ('explains'). It clearly indicates the tool does not perform mutations or destructive actions. The description could be slightly more explicit about the output format, but the core behavioral traits are 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 sentence, concise and front-loaded with the use context. It contains no extraneous words and effectively communicates the tool's value. Minor improvement could be adding structure, but it is already efficient.

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

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

Given the tool has no parameters and no output schema, the description provides sufficient context for an agent to understand its purpose and when to invoke it. It covers the relevant payload types and the nature of the information returned. It is complete enough for a zero-parameter knowledge retrieval 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 has zero parameters, so the description does not need to explain param semantics. The baseline for 0-param tools is 4, and the description adds no additional parameter information, which is acceptable.

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's purpose: to explain payload schema rules, placeholder syntax, apiCalls, rules, and validation requirements for XRC-137, XRC-729, and XDaLa payloads. It uses specific verbs ('explains') and resources (payload types), and distinguishes from sibling tools like validate_xrc137_authoring by focusing on information retrieval rather than validation.

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

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

Explicitly states when to use ('before creating, modifying or reviewing'), providing clear context. Although it doesn't mention alternatives or when not to use, the guidance is sufficient given the tool's nature as a reference resource. The sibling set includes other get_ tools, but none duplicate this specific purpose.

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

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

The description implies a read operation but does not explicitly state safety or side effects. With no annotations, it lacks full transparency, though for a get tool it is minimally adequate.

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 with no wasted words. Front-loaded with the verb and key results.

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 low complexity (1 param, no output schema), the description covers the main return items. It lacks detail on return structure or errors but is sufficient for a simple retrieval.

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% and the description only repeats 'handoff handle' without adding details about format, source, or constraints on the single parameter.

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 stored metadata, bundle JSON, and deployed result/artifact for a specific handle, using a specific verb and resource. It distinguishes the 'handoff' retrieval from siblings like get_xdala_bundle_deploy_result.

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 vs alternatives (e.g., get_xdala_bundle_deploy_result). No mention of prerequisites or 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?

Description explicitly states read-only nature and lack of side effects, which is positive given no annotations. However, does not disclose other potential behaviors like authentication requirements, 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 concise sentences with front-loaded action and no superfluous information. Every word serves a 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?

For a simple 1-parameter retrieval tool with no output schema, the description adequately covers purpose, read-only nature, and required input. Lacks detail on error responses or output format, but sufficient for basic usage.

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%, and the description only mentions 'handoff handle' without adding meaning beyond the parameter name. No elaboration on format, constraints, or examples.

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 returns stored XDaLa bundle deploy result, canonical deployed artifact, and audit events for a handoff handle. Verb 'return' and specific resource distinguish it from sibling tools like get_xdala_bundle_deploy_handoff.

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?

States it is read-only and does not sign/submit/execute transactions, implying safe usage. Mentions usage context 'for a handoff handle' but does not explicitly exclude alternatives or provide 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, and the description does not disclose behavioral traits such as read-only nature, rate limits, or potential side effects. The name implies a read operation, but this is not explicitly stated.

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

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

The description is a single sentence plus examples, concise and front-loaded. It wastes no words but could be slightly more 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 6 parameters, no output schema, and no annotations, the description only covers the field parameter and overall purpose. It omits details on optional filters, limit, and expected output, making it incomplete 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?

With 0% schema description coverage, the description must compensate but only addresses the 'field' parameter through examples. It does not explain other parameters (owner, windowHours, outcome, source, limit), leaving their semantics unclear.

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: answering which values occurred for a specific payload field, with concrete examples. However, it does not explicitly differentiate from similar sibling tools like get_xdala_payload_key_stats.

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

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

The description explicitly tells when to use the tool ('when the user asks which values occurred...'), providing clear usage context. It does not mention when not to use 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 provided, so description carries full burden. It implies read-only behavior but does not explicitly state it. No mention of return format, pagination, or side effects. 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?

Two sentences, directly front-loaded with purpose and usage scenarios. 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?

Has 5 parameters, no output schema, no annotations. Description is very short; lacks explanation of output structure, parameter meanings beyond windowHours, and behavioral details like pagination or rate limits. Incomplete for a statistical 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 has no descriptions (0% coverage). Description only explains windowHours with an example. Other parameters (owner, outcome, source, limit) are not explained, leaving significant gaps for an agent.

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 statistics about payload fields/keys: occurrence, frequency, and empty/non-empty status. It distinguishes from siblings like get_xdala_payload_field_value_stats and get_xdala_payload_term_stats by focusing on keys.

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 lists when to use: when user asks about payload fields/keys occurrence, frequency, or empty/non-empty. Provides a concrete example for windowHours. However, does not explicitly mention alternative tools or when not to use this tool.

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

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

No annotations are present, so the description carries full behavioral burden. It only states 'Do not sample sessions', implying the tool processes all sessions, but does not disclose side effects, permission requirements, rate limits, or whether it is read-only. The 'get' prefix suggests idempotence, but that is implicit.

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

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

The description is three focused sentences, front-loading the usage trigger and providing a key example. Every sentence adds value with no redundancy or verbosity.

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 (7 parameters, no output schema, no annotations), the description is incomplete. It explains the intended use case but lacks details on return format, parameter interactions (e.g., mode: keys vs values vs keys_and_values), and behavior over large time ranges. The agent is left guessing about important constraints.

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%, yet the description only adds meaning for windowHours (example value 336 for 14 days). The other six parameters (owner, outcome, source, mode, minTermLength, limit) are not explained. Their names and enum values provide some hints, but the description does not clarify how they filter or affect results.

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 retrieves payload term statistics and specifies user queries that trigger it (e.g., 'payload words', 'payload Begriff statistics'). It implicitly distinguishes from siblings like get_xdala_payload_key_stats by focusing on 'terms' rather than keys or values, but does not explicitly contrast.

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

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

The description provides explicit use cases ('when the user asks for payload terms...') and an anti-pattern ('Do not sample sessions'). It gives a concrete hint for the common 'last 14 days' request. However, it does not mention alternative tools for sampling or for key/value statistics, leaving the agent to infer from sibling names.

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 explicitly states the tool is read-only, does not sign/submit/execute transactions. This is a key behavioral trait, though it omits details like error handling or authorization.

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

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

The description is a single, well-structured sentence that front-loads the core purpose and adds the read-only qualifier efficiently, with no wasted words.

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

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

Despite high complexity (11 parameters, nested objects, no output schema), the description only covers the outcome and side effects, ignoring parameter semantics and output format details. The agent would struggle to invoke the tool correctly without additional context.

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

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

Schema description coverage is 0%, and the description provides no explanation for any of the 11 parameters. Parameters like 'source', 'bundle', and 'handle' are not clarified, leaving the agent without guidance on their meaning or usage.

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 renders an XDaLa XRC-729 process graph as Mermaid flowchart text, with a specific verb ('Render') and resource. It also distinguishes from sibling tools by noting it is read-only and does not sign or execute transactions.

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 implicitly indicates when to use it (for visualization) and explicitly confirms read-only nature, but does not mention alternatives or specific scenarios where other tools are preferred.

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 does not mention side effects, permissions, rate limits, or error behavior. The description only hints at read-only access by describing retrieval of details, but the agent lacks explicit confirmation of safety.

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 communicates the tool's purpose and usage context. No unnecessary words or repetition, and it front-loads the critical information.

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

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

Given the 5 parameters, lack of output schema, and many sibling tools, the description is incomplete. It does not describe the return format, pagination behavior, or effects of optional parameters. The agent lacks enough detail to confidently invoke the tool with appropriate 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 description coverage is 0%, so the description should explain parameters. It mentions owner and sessionId but does not explain the optional parameters (includePayloads, includeFinalPayload, limitSteps). Their purposes are only weakly implied by the description's mention of 'payloads' and 'steps', leaving ambiguity.

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 retrieves details, timeline, steps, payloads, or evidence for a specific XDaLa session, using owner and sessionId. This distinguishes it from sibling tools that list sessions or provide overviews, though it does not explicitly name alternatives.

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

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

The description specifies exactly when to use the tool: 'when the user asks for details, timeline, steps, payloads, or evidence for a concrete XDaLa session with owner and sessionId.' It implies that for listing or summary queries, other tools are appropriate, but it does not explicitly state when not to use it or name specific 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, so the description carries the full burden. It states 'Read-only; does not sign, submit, or execute,' which is clear about side effects. However, it does not mention error handling, authentication needs, or what happens if the handle does not exist. More detail could be expected given no annotations.

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

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

The description is three sentences and front-loaded with purpose. The first sentence lists the retrieved components, the second clarifies read-only behavior, and the third gives usage guidance. It is efficient but could be slightly more streamlined. Overall, it conveys essential information without redundancy.

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

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

For a tool with one parameter and no output schema, the description lists the data fields returned, which is helpful. However, it does not explain the parameter or error conditions. Given the complexity of the domain and many sibling tools, a more complete description including return format or typical usage would improve completeness.

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

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

The input schema has one required parameter 'handle' with 0% schema coverage (no description). The description does not explain what 'handle' represents (e.g., session ID or handoff identifier). The tool name and title provide indirect context, but the description adds no explicit meaning to the parameter 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 reads stored handoff metadata and lists specific components (canonical request, authority, etc.). It explicitly says 'Read-only; does not sign, submit, or execute,' distinguishing it from mutation tools. Among sibling get_xdala_session_* tools, this one is uniquely about session start handoff, and the description highlights that.

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 specific usage guidance: 'Use sessionOwnership to avoid confusing the XRC-729 contract owner with the actual session owner/starter before Workbench completion.' This tells when to leverage the sessionOwnership field. However, it does not explicitly compare to alternative tools like get_xdala_session_detail or get_xdala_session_start_result, so it lacks explicit exclusions.

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

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

With no annotations, the description properly discloses read-only nature and that no signing/submitting/executing occurs. It adds a detail about preferring certain fields. Could be more complete about return format but adequate for a simple lookup.

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, no waste. Front-loaded with purpose, followed by usage and a specific preference note. Highly concise and well-structured.

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

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

Given the simple tool with one parameter and no output schema, the description covers purpose, usage, and a behavioral note. Missing parameter explanation but overall sufficient for context.

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

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

Schema coverage is 0% and description does not explain the 'handle' parameter. It adds no meaning beyond the schema, which is insufficient for a single required parameter.

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 terminal session start result, lean result summary, and audit events, specifying the verb 'return' and resource. It distinguishes from siblings like get_xdala_session_start_handoff by emphasizing read-only lookup.

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 indicates read-only usage and that the MCP does not sign/submit/execute, guiding when to use. It also provides a preference note for owner identification. However, it does not explicitly exclude alternatives or mention 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention whether the operation is read-only, what side effects exist, how it handles large windows, or any rate limits. The description is insufficient for an agent to understand the tool's runtime implications.

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

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

The description is concise, with two sentences that front-load the purpose and immediately provide a useful example. No unnecessary words are included, and the structure 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?

The description adequately conveys the tool's purpose and provides a usage example, but it does not outline the output format, the type of aggregation (e.g., counts vs. averages), or how the optional owner parameter affects results. Given the abundance of sibling tools, more detail would aid correct selection.

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

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

The schema has 0% description coverage for parameters. The description partially compensates by explaining windowHours with a concrete example (336 hours for two weeks). However, the owner parameter is entirely unexplained, leaving its purpose ambiguous.

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 aggregates XDaLa session statistics with concrete examples like success/failure counts and average duration. However, it does not explicitly distinguish itself from sibling tools such as get_xdala_session_timeseries or get_xdala_step_stats, which may also provide aggregated data.

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 the tool (when the user asks for aggregate statistics) and includes a concrete parameter example for 'last 2 weeks'. It does not, however, mention when not to use it or list alternative sibling tools for specific queries.

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, and the description does not disclose behavioral traits such as idempotency, side effects, rate limits, or response format. The only behavioral hint is the type of data returned (timeseries), which is minimal.

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

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

The description is extremely concise with two sentences, no redundant information, and front-loads the purpose. Every word serves a 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 output schema and missing parameter descriptions, the description covers the basic usage adequately but leaves out details like return value structure or error handling.

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

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

The input schema has no descriptions (0% coverage), but the description adds value by explaining how to combine windowHours and bucket for common use cases. However, it does not explain the 'owner' parameter.

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 retrieves XDaLa session timeseries data and provides concrete query examples like 'sessions per day'. However, it does not explicitly differentiate from similar tools like get_xdala_active_sessions_timeseries or get_sessions_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 gives clear guidance on when to use (e.g., 'when user asks for XDaLa sessions over time') and includes example parameter values. However, it omits when not to use and does not mention alternative tools for different scenarios.

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

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

No annotations are provided, and the description fails to disclose any behavioral traits such as read-only nature, required permissions, or side effects. The agent has no information about whether this tool modifies state or has 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?

The description is a single, front-loaded sentence that efficiently conveys the tool's purpose. However, it lacks structural elements like bullet points or sections that could improve 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?

With 4 parameters and no output schema, the description omits critical details such as what the tool returns, how parameters affect results, and behavior when parameters are omitted. The agent lacks sufficient information for correct invocation.

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

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

Schema description coverage is 0% and the description does not explain any of the 4 parameters (owner, sessionId, windowHours, bucket). The agent must guess their meaning from names and schema constraints alone.

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 returns step-level XDaLa statistics and gives concrete examples like 'how many steps were valid', distinguishing it from sibling tool get_xdala_session_stats.

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

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

It provides a clear usage context ('use when the user asks for step-level XDaLa statistics') but does not specify when not to use it or mention alternatives like get_xdala_session_stats.

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

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

No annotations are provided, so the description must carry the full burden. It only states it retrieves information from an underlying API call. It does not confirm that it is a safe read operation, mention rate limits, or describe any side effects. For a parameterless read, this is marginal but not misleading.

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

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

The description is a single, short sentence that is immediately clear and front-loaded. There is no wasted text; 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?

The tool has no output schema, so the description should hint at the return format. It only says 'circulating supply information' without specifying whether it returns a number, string, or object. For such a simple tool, this is a noticeable 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?

There are zero parameters, and the schema coverage is 100% by default. The description adds no extra parameter information, but since there are none, the baseline of 4 is appropriate as the description does not need to compensate.

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 'retrieve' and the resource 'circulating supply information'. The name and title reinforce this, and the sibling tools contain no alternative for the same data, so it is well-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?

The description explicitly tells the agent to use it for retrieving circulating supply. While it doesn't mention when not to use or list alternatives, given the sibling list, there is no competing tool for this specific data, so the guidance is 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 are provided, so the description must fully convey behavioral traits. It only states the tool retrieves data via an RPC method, without disclosing side effects, error conditions, required permissions, or rate limits. For a simple read operation, the minimal description is insufficient for 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 a single sentence that is front-loaded and to the point. Every word serves a purpose, making it highly concise and effective.

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

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

For a parameterless tool with no output schema, the description should explain what 'core protocol addresses' are and what the return structure looks like. It currently only states the action, leaving potential ambiguity about the output format. This is adequate but not fully complete.

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

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

The tool has zero parameters and schema description coverage is 100% (the schema is empty). According to rules, baseline is 4. The description adds no parameter details, but none are needed as there are no 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 retrieves XGR core protocol addresses and names the specific RPC method (xgr_getCoreAddrs). It is distinct from sibling tools, which mainly deal with transactions, sessions, or other specific data.

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 to retrieve...', providing clear context for when to invoke the tool. However, it does not discuss when not to use it or mention alternatives, though the tool is unique enough that exclusion guidance might not be necessary.

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 should disclose behavioral traits. It only says 'explains', implying a read-only operation, but does not explicitly state it does not modify state or require authentication. The output format is also not described.

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

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

The description is extremely concise with two sentences, no redundant text, and front-loads the usage context. Every sentence provides 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?

Despite being a simple tool, the description fails to specify the return value or output format, which is critical since there is no output schema. The agent cannot fully anticipate what the tool will provide.

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

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

The tool has no parameters, so the input schema is trivial. The description adds value by explaining the tool's purpose and usage, exceeding the minimal baseline of 3 for high schema coverage.

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

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

The description clearly states the tool explains the canonical xgr-multi-bundle@1 format and is to be used before generating a bundle. The verb 'explains' and specific resource 'xgr-multi-bundle@1 format' provide good purpose clarity, though it could be more precise about output.

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

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

The description gives a clear usage context ('Use this before generating...'), implying it's a preparatory step. However, it does not explicitly mention when not to use it or compare with alternative tools like get_xgr_multibundle_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 full burden for behavioral disclosure. It only states the purpose but does not mention any side effects, read-only nature, authentication requirements, or return format. For a retrieval tool, it is implied to be read-only, but lack of explicit detail reduces 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 a single concise sentence front-loading the purpose. It is efficient, though could provide a bit more context (e.g., what the schema contains) without becoming verbose.

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

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

Given zero parameters, no output schema, and no annotations, the description covers the essential purpose. However, it does not specify the return format or data type, which would be helpful given the completeness burden on the description.

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

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

The input schema has zero parameters, so the baseline is 4. The description adds no param info because none exist, which 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 retrieves the canonical XGR MultiBundle schema for a specific version ('xgr-multi-bundle@1'), using a specific verb and resource. It distinguishes from siblings like get_xgr_session_start_schema which retrieve different schemas.

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 through the phrase 'Use this to retrieve...' but does not explicitly state when to use this tool over alternatives, nor provides conditions or prerequisites. The sibling context provides implicit differentiation via tool names, but no explicit guidance is given.

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

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

No annotations are provided, so the description carries the burden. It explicitly states that the tool retrieves a schema and enumerates the fields returned (stepId, payload, maxTotalGas). This sufficiently discloses the output structure, though it does not mention any side effects or limitations, which are minimal for a read-only schema retrieval.

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

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

The description is extremely concise: two sentences that efficiently convey the purpose and a usage caveat. Every sentence adds value, and the key information is front-loaded.

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

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

Given the tool has no input parameters and no output schema, the description fully covers the essential context. It specifies the exact schema name and fields returned, making the agent fully informed about the output without needing additional documentation.

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

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

The input schema has zero parameters, so there is no need for parameter explanation. The description does not add parameter info, but the baseline for 0 parameters is 4, and no further value is required.

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

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

The description clearly states the tool retrieves the canonical Workbench Session Start Handoff schema 'xgr-session-start@1' with specific field details (type, stepId, payload, maxTotalGas). It distinctly identifies the resource and differentiates from sibling tools that might deal with other schemas or handoffs.

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 when-to-use: for retrieving the Workbench Session Start schema. It also gives a negative instruction ('Do not use entryStepId'), which helps avoid misuse. However, it does not explicitly compare or contrast with similar sibling tools like get_xdala_session_start_handoff.

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 convey behavioral traits. It only states 'retrieve', implying a read operation, but lacks details on permissions, data freshness, or side effects. This is insufficient given the absence of annotations.

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

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

The description is two sentences, front-loading the purpose and adding a brief usage note. Every sentence adds value with no redundancy.

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

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

For a simple two-parameter tool without output schema, the description covers the return type (JSON example) and intent, but omits parameter explanations and does not fully address the selection of standards. It is adequate but has clear gaps.

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

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

The schema has two required parameters (standard with enum, name as string) with no descriptions (0% coverage). The description does not explain what 'name' represents or how to use the parameters, leaving the agent without crucial information.

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 retrieves a JSON example for XRC-137 or XRC-729. However, the schema includes additional standards (xdala-authoring, xgr-multibundle) not mentioned, causing slight ambiguity. It does not differentiate from sibling tools like get_xgr_standard_reference or get_xgr_standard_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?

The description advises that examples are for drafting and need validation, but provides no explicit guidance on when to use this tool vs alternatives like get_xgr_standard_reference. Usage context is implied but not detailed.

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, and the description does not disclose behavioral traits (e.g., read-only, no side effects) beyond the purpose. It relies on inference from the name and context.

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

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

Two concise, front-loaded sentences with no wasted words. Each sentence serves a clear 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 the simple single-parameter tool with no output schema, the description adequately covers primary usage scenarios and distinguishes from a key sibling. Minor gaps remain in explaining all enum values and output expectations.

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

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

Schema coverage is 0%, and the description only partially explains the 'standard' parameter by mentioning two of four enum values. The other values (e.g., xgr-multibundle) are unaddressed.

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 retrieves a standard reference for drafting XRC-137 or XRC-729 artifacts, distinguishing it from siblings like get_xdala_authoring_rules.

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 when to use (before drafting XRC-137/729) and when to use an alternative (for authoring guardrails, use get_xdala_authoring_rules).

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 must reveal behaviors. It notes that xdala-authoring returns empty schema, but lacks details like output format, required permissions, or effects on system state. 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?

The description is two sentences, front-loaded with purpose, and contains no redundant information. 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?

Given the tool has one parameter and no output schema, the description covers the core purpose and one behavioral nuance. It is mostly sufficient for correct invocation, though it could explicitly state that the output is a JSON 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 coverage is 0%, so the description must explain parameters. It mentions three enum values (xrc-137, xrc-729, xdala-authoring) and explains the xdala-authoring case, but does not clarify 'xgr-multibundle' or provide full details for all options.

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 retrieves JSON schemas for XRC-137 and XRC-729 drafts, with specific mention of xdala-authoring returning empty. This differentiates it from sibling tools like get_xgr_standard_example or get_xgr_standard_reference.

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 indicates when to use it (for XRC-137/729 drafts) and notes a special case (xdala-authoring returns empty), but does not explicitly mention when not to use it or provide 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?

With no annotations, the description carries the full burden and clearly discloses read-only behavior, listing specific functions read and explicitly stating it never signs, submits, executes, or creates a handoff. It also mentions detecting zero-address executor wildcard. It lacks details on edge cases like contract call failure, but overall provides solid 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?

Two sentences, no extra words. Front-loaded with the key purpose 'Read-only authority lookup'. Every sentence adds value without repetition.

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

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

Given the simple input schema and no output schema, the description adequately covers intent and behavior. It mentions what is read, which gives agents an idea of the return value. However, it doesn't specify output structure, which may be needed for complex data, but remains sufficient for this tool's apparent simplicity.

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

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

The only parameter, orchestration, is described as 'for one XRC-729 orchestration contract', providing context beyond the schema's pattern. Schema coverage is 0%, so the description compensates by clarifying the parameter's role, though it could more explicitly state it is a contract address.

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 a read-only authority lookup for one XRC-729 orchestration contract, specifying the exact functions read (owner()/getOwner() and getExecutorList()) and detecting zero-address executor wildcard. It distinguishes from sibling tools by explicitly stating it never signs, submits, executes, or creates a handoff.

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 read-only authority queries and explicitly states it does not perform write operations, helping agents avoid action-based tools. However, it does not provide explicit alternatives or conditions for when not to use this tool compared to other authority-related siblings like get_xrc_owner_summary.

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

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

The description states 'Read-only', which implies non-destructive behavior. However, with no annotations, the description should disclose more behavioral traits, such as pagination behavior, whether it returns all entries at once or supports filtering, and any rate limits. The term 'indexed' is ambiguous.

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, which is short but not well-structured. It lacks front-loading of key information. While concise in word count, it sacrifices clarity and completeness for brevity.

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 the tool (4 parameters, no output schema, no annotations), the description is completely inadequate. It does not explain the return format, pagination details, or the meaning of 'indexed'. A minimally viable description should cover these aspects.

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 4 parameters with 0% description coverage, and the tool description does not explain any parameter. For example, it does not mention that 'address' is required, or what 'includeDeleted', 'page', and 'limit' do. The description adds no 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 a 'read-only list of indexed OSTC state entries for an XRC-729 contract', indicating a list operation on a specific resource. However, it does not explicitly differentiate from the sibling tool 'read_xrc729_ostc_json', which may have overlapping functionality.

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

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

No guidance is provided on when to use this tool versus alternatives, such as 'read_xrc729_ostc_json'. There is no mention of prerequisites, context, or scenarios where this tool is appropriate.

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 description must disclose behavior. It claims 'Read-only lookup' indicating safe operation, but lacks details on behavior when address not found, error handling, or any permissions needed. More transparency is expected given zero annotation coverage.

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

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

One sentence with no extraneous words. Front-loaded with the key trait 'Read-only lookup.' Every word 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?

Given the tool's simplicity (1 parameter, no output schema), the description is minimally adequate but fails to describe return value or common error cases. Output schema absence means description should compensate; it does not mention what data is returned, leaving the agent with incomplete context.

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

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

Schema description coverage is 0%, so description should add parameter meaning. However, description does not elaborate on the 'address' parameter beyond what schema provides (type, pattern). It adds no context on format examples or expected input, leaving the agent underinformed.

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 'Read-only lookup of one indexed XRC contract by address,' specifying verb (lookup), resource (XRC contract), and scope (by address). Distinguishes from sibling tools like list_xrc_contracts (listing multiple) and get_xrc_contract_events (different resource).

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 usage for single contract lookup but does not explicitly state when to use this over siblings, nor provides exclusions or prerequisites. Usage context is implied but not spelled out.

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 only says 'read-only list' but does not disclose pagination behavior, result ordering, or any other behavioral details. The tool is marked as read-only but lacks further context.

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

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

The description is a single sentence, which is concise but lacks necessary detail. It does not include structure like parameter descriptions or 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?

Given 3 parameters and no output schema or annotations, the description is incomplete. It omits explanation of pagination (page, limit) and does not describe what events are returned.

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 adds no information about parameters. The schema provides basic constraints but the description does not explain how to use address, page, or limit.

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 lists all indexed XRC events for one contract, using specific verb 'list' and resource 'XRC events'. It distinguishes from siblings like list_xrc_events by specifying 'for one contract'.

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. Does not mention conditions like requiring a contract address or when not to use it.

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

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

The description notes 'read-only,' but with no annotations, it fails to disclose additional behavioral traits such as data aggregation scope, authentication needs, or rate limits. The burden of transparency is not met.

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, very concise and front-loaded. However, it sacrifices necessary detail for brevity, making it only adequate in structure.

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 7 optional parameters and no output schema or annotations, the description is incomplete. It does not explain usage patterns or parameter dependencies for different XRC types.

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 7 parameters with 0% description coverage, and the description adds no meaning to any parameter. The agent cannot infer the role or format of address, type, ostcId, etc.

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 returns 'read-only invalid/failure statistics' for XRC-137 rules or XRC-729 OSTC/process filters, specifying the resource and verb. However, it does not differentiate from sibling tools like get_xrc_usage or get_xrc729_ostc_state, which may also return statistics.

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

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

No guidance is provided on when to use this tool versus alternatives. The description lacks any mention of context, prerequisites, or exclusions, leaving the agent without direction on tool selection.

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

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

The description states it is 'read-only,' which implies non-destructive behavior, but with no annotations, it does not disclose any other behavioral traits like caching, latency, 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?

The description is a single, compact sentence that front-loads key information. Every word is functional, with no redundancy.

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

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

Given the lack of output schema and low parameter details, the description provides a minimal but adequate overview. It could be improved by specifying what the summary includes (e.g., balances, counts).

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

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

The single parameter 'owner' has no schema description, and the tool description merely restates 'for an owner' without adding format or usage details beyond the regex pattern.

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 (get compact summary), resource (XRC-137/XRC-729 assets and recent XRC events), and scope (for an owner). It effectively distinguishes from sibling tools like get_xrc_contract_events or get_xrc_usage.

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

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

No guidance is provided on when to use this tool versus alternatives, such as when an owner needs a high-level overview versus detailed event logs or statistics.

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

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

States 'read-only', indicating no mutation. Mentions source and scope, but does not disclose performance, error conditions, or other behavioral traits beyond basic safety. No annotations to supplement.

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 17 words, concise and front-loaded with 'Read-only usage statistics'. However, lacks any parameter explanation, which would be valuable given schema coverage is zero.

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 6 parameters with no schema descriptions, no output schema, and no behavioral details, the description is inadequate. It does not explain return format, filter combination logic, or how to use the parameters effectively.

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?

0% schema description coverage and description adds no meaning to any of the 6 parameters. Agent must rely solely on schema property names and constraints (e.g., address pattern, type enum), which is insufficient.

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 verb 'get', resource 'usage statistics', source 'Explorer PGRO tx_receipts', and scope 'XRC-137 rules or XRC-729 OSTC/process filters'. It distinguishes from sibling tools like get_xrc_contract or get_xrc_failure_stats.

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?

Implies use when needing usage stats for XRC-137 or XRC-729, but no explicit when-to-use or when-not-to-use compared to many similar sibling tools. Lacks exclusion criteria.

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

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

With no annotations, the description carries the full burden. It only discloses that secrets and browser execution tokens are never returned, which is helpful. However, it fails to mention other important behaviors like read-only nature, authentication needs, or pagination.

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 are efficient and front-loaded with purpose. The second sentence adds valuable behavioral context. However, it could be improved by mentioning the limit parameter without adding length.

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 one parameter, no output schema, and no annotations, the description should cover how to use the tool and what 'recent' means. It does not define 'offchain operation handoff' or clarify the limit parameter, making it incomplete for effective agent 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?

The schema has one parameter (limit) with 0% description coverage, and the tool's description does not mention the parameter at all. The description adds no meaning beyond the schema, leaving the agent to infer its 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 lists 'recent offchain operation handoffs' and adds a critical note about secrets not being returned, distinguishing it from other tools. However, it could benefit from defining 'offchain operation handoff' for new users.

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

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

No guidance is given on when to use this tool versus the many sibling tools (e.g., get_operation_status, list_xdala_sessions). The description only implies it's for recent operations, but no explicit when-to-use or alternatives are mentioned.

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

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

No annotations are provided, so the description must fully disclose behavior. It mentions the grouping by owner, which is useful, but lacks information on idempotency, side effects, error handling, or return format. Given the absence of annotations, this is insufficient.

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

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

The description is two concise sentences that directly state the purpose and key behavior (grouping by owner). No unnecessary words, and the important information is front-loaded.

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

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

Despite having five optional parameters and no output schema or annotations, the description does not explain the return format, parameter usage, or error conditions. It only covers the grouping behavior, leaving significant gaps for an agent 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?

The schema has 0% description coverage, and the description does not explain any of the five parameters (owner, windowHours, outcome, limitOwners, maxSessionIdsPerOwner). The description adds no meaning beyond the schema, failing to compensate for the coverage gap.

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