tenzro-layerzero

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

No annotations are provided, so the description carries full responsibility. It discloses the core behavior (broadcast via eth_sendRawTransaction, returns tx hash) and the required prior signing step. However, it does not mention failure modes, pending state, or network errors, which are important for a broadcast tool. Slightly below perfect but still strong.

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 paragraph of three sentences, each providing essential information: what it does, when to use it, and the required preconditions. No redundancy or fluff, front-loaded with the core 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?

Given the tool's complexity (LayerZero broadcast) and the presence of an output schema (assumed to document return format), the description covers the full workflow and return value. It lacks some details on error handling, but is complete enough for an agent to use correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining that signed_tx_hex must be RLP-encoded and that calldata comes from specific tools, which aids in constructing correct inputs. This extra context justifies a score above baseline.

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

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

Description clearly states the tool broadcasts a pre-signed transaction via eth_sendRawTransaction on the source chain RPC. It lists specific sibling tools (lz_send_message, etc.) that produce the calldata, effectively distinguishing this broadcast step from other operations like encoding, quoting, or sending messages.

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 instructs when to use this tool ('as the canonical broadcast path for calldata produced by...') and outlines the prerequisite workflow: construct calldata, sign locally with msg.value = nativeFee, then submit the RLP-encoded signed tx hex. This provides clear guidance on when and how to use the 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 provided, the description bears full responsibility. It explains the internal structure (worker ID, option type) and output (hex-encoded bytes). Although it does not explicitly state it is a pure function with no side effects, the behavior is clearly non-destructive and safe.

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 four sentences, each adding critical information: purpose, format standard, internal structure, and output. It is front-loaded with the primary action and avoids redundant or verbose language.

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 (2 optional parameters, no nested objects, clear output), the description covers all necessary context: usage context, parameter roles, output type, and standard version. It is complete for an agent to invoke 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 input schema already describes both parameters (gas_limit, native_drop) with defaults, providing 100% coverage. The description adds context by mentioning 'configurable' gas limit and native drop, reinforcing the schema. No additional parameter details are necessary.

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 encodes LayerZero TYPE_3 options bytes for EndpointV2.quote() and send(), specifying the version, worker ID, and option type. It distinguishes from sibling tools like lz_quote_fee or lz_send_message by focusing on options encoding.

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

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

The description explicitly states the tool is for use with EndpointV2.quote() and EndpointV2.send(), providing clear when-to-use context. It does not explicitly list when not to use or alternatives among siblings, but the specificity is sufficient for an agent to select it appropriately.

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 fully disclose behavioral traits. It states the RPC URL is 'public' and used by the server for eth_call queries, implying read-only access. However, it does not explicitly declare side effects (e.g., no mutations), authentication needs, rate limits, or output format. This is adequate for a simple lookup tool but lacks details that could be critical for an agent (e.g., error handling if chain is unsupported).

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

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

The description is two sentences with zero waste. The first sentence front-loads the core purpose (get RPC URL by chain name), and the second provides relevant context (usage by server). Every word earns its place, and the structure is optimal for quick parsing by an AI agent.

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

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

Given the tool's simplicity (one parameter), complete schema coverage, and the existence of an output schema (per context signals), the description is fully sufficient. It does not need to explain return values as per rules. The description covers the tool's function and one-line behavioral context, making it complete for an agent to select and invoke correctly.

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

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

Schema coverage is 100% for the single parameter chain_name, with a description that matches the tool's description. The tool description adds no new semantic details beyond the schema (e.g., format, allowed values from a list). According to guidelines, baseline is 3 when schema coverage is high, as the schema already provides sufficient meaning. The description does not compensate with additional context like example values beyond what's in the schema.

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

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

The description clearly states the tool's verb ('Get') and resource ('public RPC URL for a supported chain by name'), making the purpose unambiguous. It distinguishes itself from sibling tools like lz_list_chains (which lists chain names) by specifying it retrieves the actual RPC endpoint. The additional context about usage for eth_call queries reinforces the tool's role without causing confusion.

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 (e.g., when a chain is supported, prerequisites like network connection). The description does not mention when-not-to-use or how this tool relates to other tools in the same suite. The context is entirely implicit, leaving the agent to infer usage from the tool name and sibling list.

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

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

Without annotations, the description carries the full burden. It discloses it is a read operation against the LayerZero Metadata API and returns specific address types. Though it does not mention rate limits or idempotency, for a simple GET-like call the transparency is good. No contradictions with annotations (none provided).

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

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

Two sentences deliver the full purpose and outcome without any wasted words. The description is front-loaded with the core action and immediately provides specifics. It earns its space.

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

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

Given there are no parameters and an output schema exists, the description covers the main aspects: what it returns and from where. It could mention data freshness or whether it includes all chains always, but overall it is sufficiently complete for a no-input 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?

There are zero parameters, and the input schema defines no properties. The description correctly adds no parameter details since none exist. Baseline for 0 params is 4, which is appropriate here.

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

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

The description uses a specific verb ('Get') and clearly identifies the resource ('LayerZero V2 deployment addresses across all supported chains'). It further lists the specific addresses returned (EndpointV2, SendLib, etc.), making its purpose unambiguous and distinct from sibling tools that handle transactions, quotes, or messages.

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

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

No explicit guidance on when to use or avoid this tool is provided. However, the purpose implies it is the tool to retrieve deployment addresses, and with zero parameters, it is straightforward. Sibling tools like lz_quote_fee or lz_send_message have different purposes, so confusion is unlikely, but explicit usage notes are absent.

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 behavior. It implies a read-only operation by saying 'Get', but does not explicitly confirm no side effects, auth requirements, or rate limits. The GUID format expectation is helpful.

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, front-loading the main purpose. Every sentence adds 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 simple get-by-ID tool with a single parameter, the description is complete. It explains the parameter thoroughly, and since an output schema exists, the return value is covered.

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

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

Schema coverage is 100% and the schema describes the parameter as 'hex, with or without 0x prefix'. The description adds value by explaining the GUID origin (from EndpointV2.send() or Scan API), which helps the agent understand the parameter source.

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 LayerZero message by GUID, specifying the verb 'Get' and the resource. It explains what a GUID is and where to find it, distinguishing it from sibling tools that query by address.

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

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

The description explains where the GUID comes from (EndpointV2.send() or Scan API) but does not explicitly state when to use this tool versus alternatives like lz_get_messages_by_address. There is no guidance on 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?

With no annotations, the description carries full burden. It discloses that it queries the Scan API, returns message details (status, source/destination chains, timestamps), and implies read-only behavior. However, it does not address potential pagination or rate limits, and the phrase 'all messages' slightly conflicts with the limit parameter.

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 front-load the purpose and then provide additional 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 presence of an output schema, the description's mention of return fields (status, chains, timestamps) is adequate. The tool is simple with few parameters, but the lack of usage guidelines and minor inconsistency in 'all messages' vs limit prevent a perfect score.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds no additional meaning beyond the schema; it does not elaborate on the limit parameter or address format beyond what is already provided in the input 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 retrieves LayerZero messages for a specific wallet address, using a specific verb ('Get') and resource ('messages by address'). It distinguishes itself from sibling tools like lz_get_message by focusing on an address-based query rather than retrieving a single message.

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

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

No explicit guidance on when to use this tool versus alternatives. The description implies usage for retrieving all messages for an address, but does not contrast with lz_get_message or other sibling tools. The context suggests it is appropriate for address-based queries, but lacks when-not-to-use instructions.

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, but description explains the tool returns a list of chains with EIDs and mentions usage in quote/send functions, adding transparency beyond the empty schema.

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

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

Two sentences with no unnecessary words. First sentence states purpose, second provides details and use context. Highly efficient.

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

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

Given no parameters and existence of output schema, the description is complete. It covers purpose, content, and relevance to other tools.

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

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

No parameters required. Baseline 4 as per guidelines. Description adds no parameter info, but none is needed.

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

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

Clearly states the tool lists all 16 supported chains with their Endpoint IDs. The verb 'List' and resource 'chains' are specific, and it distinguishes from sibling tools like lz_get_chain_rpc.

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

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

Provides clear context: use when you need the list of supported chains and their EIDs. No explicit exclusions, but context implies when not to use (e.g., for RPC details).

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, but the description transparently states the operation ('List all') and expected output. It does not explicitly note that the tool is read-only or mention any potential side effects, which is acceptable for a simple list operation.

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

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

The description is three sentences: one for purpose, one for context, and one for output. It is clear, concise, and front-loaded with the most important 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?

With no parameters and an output schema present, the description sufficiently covers the tool's purpose and output. It provides enough context for an AI agent to understand what DVNs are and what the tool returns.

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, and the input schema is fully described (100% coverage). The description adds no additional parameter information because none is needed.

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

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

The description clearly states the tool lists all Decentralized Verifier Networks (DVNs) registered in the LayerZero V2 protocol, with a concise explanation of what DVNs do and what the output includes. It distinguishes itself from sibling tools that list other entities (chains, tokens, etc.).

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 that this tool is for listing DVNs, but it does not explicitly mention when to use it versus alternatives or any prerequisites. However, since it is a simple list operation with no parameters, such guidance is less critical.

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 mentions return values but does not disclose behavioral traits like data freshness, authentication requirements, or error handling.

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, 20 words, front-loaded with purpose and outputs; no redundant information.

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

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

Given no parameters and an output schema, the description details the return values sufficiently for a list tool, though lacks pagination or limits info.

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?

Zero parameters with 100% schema coverage; description adds no parameter info but baseline for zero params is 4.

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

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

The description uses specific verb 'List' and resource 'all available OFT deployments', and clearly distinguishes from sibling listing tools by naming the exact resource (OFT tokens vs chains or DVNs).

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 retrieving OFT deployment data but does not explicitly state when to use this tool over siblings or provide conditions/limitations.

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, and description does not disclose side effects, authentication needs, or read-only nature. It only states what it returns, not 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?

Two efficient sentences, front-loaded with purpose, no waste.

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?

Output schema exists, so return values are covered. Description mentions key outputs (fees, rates, details), making it complete for this tool.

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

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

Schema coverage is 100% with adequate descriptions for each parameter. The description adds no extra meaning beyond the schema, meeting baseline.

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

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

Description clearly states the tool quotes OFT transfers, uses specific terminology, and returns fees/exchange rates. It distinguishes from send tools but not explicitly from other quote siblings like lz_transfer_quote.

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?

Implied usage for OFT token transfers, but no explicit guidance on when to use this vs. other quote tools 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?

With no annotations, the description carries full burden. It discloses returns hex-encoded calldata for OFT.send(), explains V2 uses uint64 amountSD, required prior steps, and msg.value requirement. It does not cover error cases but suffices.

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

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

Two sentences with no fluff, front-loaded with core purpose, then details. 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?

Given 7 params (5 required) and no output schema, the description covers main points. Could mention the output is usable with lz_broadcast_signed_tx, but generally 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 100% so baseline is 3. The description adds meaningful clarifications: amount is in shared decimals, recipient left-padded to bytes32, min_amount defaults to 90% of amount, gas_limit defaults to 200000.

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 builds transaction calldata for an OFT send() call, specifying the verb 'build' and resource 'OFT send() call'. It distinguishes from siblings by mentioning OFT specifically and noting version differences (V2).

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 sequence: first call lz_quote_fee or lz_oft_quote to get messaging fee, then sign and broadcast with msg.value = nativeFee. It lacks explicit when-not-to-use but gives sufficient context.

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

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

No annotations are present, so the description carries the full burden. It correctly indicates the tool performs a read-only eth_call, which implies no state mutation. The contract address and selector are disclosed, adding transparency. However, it does not mention potential reverts or gas cost implications, which prevents a perfect score.

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) and begins with the primary purpose. It includes essential details (contract address, selector) without redundancy. Minor improvements could be made by removing redundant phrases like 'eth_call' since the schema implies it, but overall it is well-structured.

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

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

Given that an output schema exists (not shown but indicated), the description does not need to detail return values. It covers the core functionality, target contract, and technical specifics. It lacks discussion of edge cases (e.g., invalid chains, default options), but for a simple fee estimation tool, it is reasonably complete.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds value by mentioning the function selector (0xdb9d28c6) and the contract address, but it does not elaborate on parameter formats or constraints beyond the schema. The schema already explains each parameter adequately.

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 cross-chain messaging fees via a specific on-chain function (LayerZero EndpointV2.quote()). It specifies the return values (native fee and LZ token fee) and provides the contract address and selector. This makes the purpose unambiguous and distinct from sibling tools like lz_oft_quote or lz_stargate_quote.

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

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

The description implies the tool is used to estimate fees before sending a message, but it does not explicitly state when to use it versus alternatives like lz_oft_quote or lz_stargate_quote. No usage conditions, exclusions, or recommendations are provided, leaving the agent to infer context from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns hex-encoded calldata, the required follow-up action (sign and broadcast), and the selector. It does not cover error conditions or prerequisites, but the core behavior is 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 three sentences, each adding unique information: purpose, usage instruction, and selector. No redundant or fluff content. 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 presence of an output schema (not shown but mentioned), the description does not need to explain return values. It covers the tool's action, how to use the output, and a default option. It could mention validation of inputs (e.g., invalid src_chain), but overall it is reasonably complete for a calldata-building tool.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds value by stating the default behavior for options_hex (lzReceive with 200000 gas) and the selector. This provides context 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 builds transaction calldata for EndpointV2.send() to dispatch a cross-chain message via LayerZero V2. It specifies the verb (build), resource (EndpointV2.send() calldata), and context (cross-chain message). This distinguishes it from siblings like lz_broadcast_signed_tx and lz_quote_fee.

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

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

The description explains that the output calldata must be signed and broadcast with msg.value set to the nativeFee from lz_quote_fee. It provides the function selector. While it doesn't explicitly state when not to use the tool or suggest alternatives, the instructions for subsequent steps are 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 explains the tool calls quoteSend on specific contracts and returns fees in wei and minimum amount. This implies a read-only operation, though it does not explicitly state that no state change occurs or what permissions are needed.

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

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

The description is concise (4 sentences) and front-loaded with the main purpose. Every sentence adds useful 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?

Given the presence of an output schema and 100% schema coverage, the description adequately covers key details including contract function, supported tokens/chains, and return values. No gaps identified for a quoting 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 100% and the description adds value beyond schema by listing supported tokens (ETH, USDC, USDT) and chains (e.g., Ethereum, Optimism, Arbitrum, Base for ETH; 6 chains for USDC/USDT), plus clarifying what the return values are.

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 quotes a Stargate V2 native bridge transfer fee, specifying the contract (StargatePoolNative) and the function (quoteSend). It distinguishes from sibling tools that target different protocols (e.g., lz_oft_quote for OFT).

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

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

The description implies use for Stargate V2 native bridge quotes but does not explicitly state when to prefer this tool over siblings like lz_oft_quote or lz_transfer_quote. No when-not-to-use or alternative tool names 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?

The description discloses return values (calldata, contract, msg.value) and key behavioral details like msg.value computation and ERC-20 approval requirement. It does not mention error handling or limitations, but covers essential behavior without annotations.

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

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

The description is concise with 5 sentences, front-loaded with the main purpose, and well-structured. Every sentence adds 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?

Given the complexity of Stargate bridging, the description covers key prerequisites, return values, and token/chain support. It is complete for most use cases, though some edge cases (e.g., unsupported chains) are omitted.

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

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

Schema coverage is 100%, so parameters are described. The description adds significant value by explaining how to compute msg.value based on token type and the relationship between amount and nativeFee, which is not in the schema.

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

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

The description clearly states the tool builds transaction calldata for Stargate V2 sendToken() bridge transfer. It distinguishes itself from sibling tools like lz_broadcast_signed_tx and lz_stargate_quote by specifying it returns calldata, requiring separate broadcast.

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

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

The description explicitly states the caller must sign and broadcast the transaction, and provides specific rules for native ETH vs ERC-20 tokens. However, it does not directly compare to sibling tools or state when to prefer this over others.

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

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

Describes that it queries LayerZero Scan API, lists possible message statuses, and specifies return details (chains, GUID, status). No annotations provided, so description carries the burden and does it well, though missing potential error conditions.

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

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

Three purposeful sentences, no wasted words, front-loaded with primary 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?

Given output schema exists and schema coverage is 100%, description sufficiently covers functionality and return values without 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?

Single parameter tx_hash is fully described in schema with 100% coverage. Tool description adds context about 0x prefix flexibility, exceeding schema info.

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

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

Clearly states the tool tracks a cross-chain LayerZero message by source transaction hash, with specific verb and resource. Implicitly differentiates from siblings like lz_get_message which may use GUID.

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 usage when transaction hash is available, but no explicit guidance on when not to use or alternatives like lz_get_message.

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 effectively discloses key behaviors: it returns pre-built calldata for signing, and automatically handles approval and bridge steps. No contradictions.

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

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

Two concise sentences, front-loaded with purpose, followed by details. 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?

Given the tool's complexity and the presence of an output schema, the description covers the flow, automatic steps, and return format. Could mention prerequisites like valid quote, but overall 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 100%, and description adds value by clarifying that quote_id originates from lz_transfer_quote, providing useful context beyond the schema's 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?

Clearly states it builds signable transaction steps from a quote, specifying input (quoteId) and output (calldata). Distinguishes from sibling lz_transfer_quote and lz_broadcast_signed_tx by indicating its role in the pipeline.

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?

Implicitly tells when to use: after obtaining a quote from lz_transfer_quote. No explicit when-not-to-use or alternatives, but the context is clear.

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

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

With no annotations, the description carries the full burden. It states the tool lists all chains (read-only, no side effects) and returns 130+ chains and keys. This is adequate for a simple query tool, though it omits details like potential caching or rate limits.

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

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

The description is two sentences, front-loaded with the main action ('List all chains'), and every word adds value. No fluff 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 zero parameters and an output schema (which explains return values), the description is complete. It specifies the scope (130+ chains, specific examples) and the primary use case. Minor improvement could be differentiating from lz_list_chains, but not necessary for 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 tool has zero parameters, so the baseline is 4. The description adds no parameter info, which is appropriate. No additional meaning is needed beyond what the schema already conveys (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 lists chains supported by the LayerZero Value Transfer API, naming specific examples (Solana, EVM L1s/L2s) and the output's purpose (chain keys). This distinguishes it from sibling tools like lz_list_chains, which may serve different purposes.

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

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

The description explicitly says the chain keys are for use in lz_transfer_quote, providing clear downstream context. It does not discuss when not to use this tool or compare to all siblings, but the guidance is sufficient for an AI agent to select it correctly.

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 discloses that the tool returns quotes with fees, estimated times, and a quote ID for building transaction steps. It also provides a special token address constant. It does not mention potential errors, rate limits, or authentication, but for a read-only quote tool, the transparency is 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?

The description is concise with about 4 sentences, front-loading the purpose and then adding details. There is minimal redundancy, though it could combine some information (e.g., merging the first two sentences). Overall, it is well-structured and efficient.

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

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

Given the presence of an output schema (not shown but hinted), the description sufficiently covers return values (fees, times, quote ID). With 7 required parameters and no nested objects, the description provides all necessary context for using the tool effectively, including replacing the deprecated API.

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

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

Schema coverage is 100%, so baseline 3. The description adds significant value by explaining the native ETH address constant and specifying that amounts are in base units (wei). It also gives examples of chain keys like 'optimism' and 'solana', which are not in the 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 gets a cross-chain transfer quote from the LayerZero API, noting it replaces the deprecated Stargate API and supports 130+ chains. It distinguishes itself from siblings like lz_stargate_quote (deprecated) and lz_transfer_build (builds transaction steps) by mentioning the returned elements (fees, estimated times, quote ID).

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

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

The description implies this is the updated tool to use instead of the deprecated Stargate API, but it does not explicitly state when to use this versus other quote tools like lz_oft_quote or lz_quote_fee. It lacks exclusion criteria or specific 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?

No annotations are provided, so the description carries the full burden. It describes the return values but does not disclose that it is read-only, nor mentions prerequisites (e.g., quote_id must exist) or potential errors. The transparency is adequate for a simple status check but could be improved.

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 that are front-loaded with the main purpose and list key return values 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?

Given the output schema exists, the description sufficiently explains the tool's action and expected output. It lacks details about error cases or polling behavior, but for a simple status check, it is complete enough.

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

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

Schema coverage is 100%, and the parameter description in the schema already explains the quote_id. The description adds marginal value by reiterating its use, but does not provide new information beyond the schema.

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

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

The description clearly states the tool checks the status of a transfer using a quote ID, specifying the verb ('check'), resource, and identifier. It also lists the return values, differentiating it from sibling tools that handle building, quoting, or sending transfers.

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 after initiating a transfer to check its progress, but lacks explicit guidance on when not to use or comparisons to alternatives. However, the narrow purpose and clear identifier make the usage context clear.

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

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

No annotations, but description details return fields (addresses, symbols, decimals, chains) and optional filtering. Could mention if it's cached or requires API key, but still 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?

Two sentences with zero waste: first specifies action, second clarifies filtering and output. Perfectly 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 one parameter, 100% schema coverage, and output schema, description is almost complete. Could mention pagination but not critical.

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

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

Only one parameter with full schema coverage. Description adds meaning by stating filtering effect and return values beyond schema.

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

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

Description clearly states verb 'List', resource 'tokens', and context 'cross-chain transfer via LayerZero'. Distinguishes from sibling tools like lz_transfer_build by being a listing tool.

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

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

Explicitly mentions optional chain filtering and what is returned, providing clear context. But no guidance on when not to use or alternatives among sibling listing tools.

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