GYOTAK Fish Market

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

With no annotations, the description carries the full burden, and it does well by disclosing that it returns top matching FAQ entries and suggests contact_gyotak on no match. The read-only nature is implied by 'Search' but not made explicit; still, the success and fallback behaviors are clearly stated.

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

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

Three short sentences with no wasted words: the main action is front-loaded, followed by return behavior and the fallback instruction. Every sentence contributes to the agent's 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?

For a one-parameter FAQ lookup with full schema coverage, the description covers the core invocation, return type ('top matching FAQ entries'), and the no-match path. The lack of an output schema is partially mitigated by the return description, though exact formatting or count of matches is left unspecified.

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

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

Schema coverage is 100%, and the schema already describes 'question' as 'Question text (any language)', so the baseline applies. The description's topic list adds context about content areas but not about the parameter's format or constraints beyond what the schema provides.

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

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

The description uses a specific verb and resource ('Search GYOTAK FAQ') and lists concrete topic areas, making the tool's purpose immediately clear. It also explicitly contrasts with contact_gyotak by funneling no-match cases to that sibling, which sharpens differentiation.

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

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

The description gives clear context: use this tool for FAQ lookup on the listed topics. It explicitly names contact_gyotak as the escalation alternative when no match is found. However, it does not distinguish from other search-oriented siblings like search_fish, leaving some when-to-use guidance implicit.

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

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

With no annotations, the description carries the disclosure burden. It usefully lists the return contents (session details, amount, deadline, TX hash if paid, current status) and implies a read-only operation via 'check' and 'returns', but it does not explicitly state that no side effects occur or describe any authorization requirements.

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

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

One concise, front-loaded sentence that directly states the action and expected return values with no filler or redundancy. Every phrase earns its place.

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

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

For a simple one-parameter tool with no output schema, the description sufficiently covers what to pass, what the call returns, and the read-only nature. It could be more complete by explicitly distinguishing itself from create_payment/confirm_payment usage, but the core context is present.

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, order_id, has 100% schema description coverage, so the schema already explains it well. The description adds the 'guest order' context, but provides no additional parameter-level 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?

States a specific verb ('check') acting on a specific resource ('guest order') and the exact kind of result (payment status). This clearly distinguishes it from siblings like create_payment and confirm_payment, which perform actions rather than read status.

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

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

The description implies this is the tool to use when needing current payment status, and the read-oriented wording contrasts with sibling tools. However, it does not explicitly state when not to use it or name alternatives, leaving selection partly to inference.

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

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

No annotations are provided, so the description carries the burden of signaling side effects. The verb 'Check' implies a read-only, non-destructive operation, which is useful. However, it does not disclose the return shape, idempotency, or any authentication/rate-limit implications, leaving some behavioral ambiguity.

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

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

A single, direct sentence with no filler. The action and target are front-loaded, making it immediately scannable for an 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?

With one fully documented parameter and no output schema, the description covers the invocation trigger (previously submitted inquiry) but does not clarify the tool's return value (e.g., boolean vs. reply content). This is the main completeness gap, though the tool is simple enough that an agent can still infer 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?

The input schema already fully documents inquiryId with type and example, so schema coverage is 100%. The description adds only the context that the inquiry was previously submitted; no additional parameter semantics are necessary or 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 uses a specific action ('Check') and a concrete resource ('GYOTAK staff reply to a previously submitted inquiry'). It clearly distinguishes this tool from siblings like ask_gyotak (submission) and check_payment_status (payment), even without naming 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 situates the tool in a clear workflow: after an inquiry has been submitted, check whether staff has replied. It does not explicitly name alternatives or exclusions, but the 'previously submitted inquiry' context is unambiguous and provides enough guidance for an agent to know when to invoke 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 provided, the description must carry the behavioral disclosure burden. It does well by revealing the preprod-only scope, the A→B→A round-trip settlement on Cardano preprod, and the monthly auto-settle allowance. It does not mention irreversibility or failure modes, but the core side effects are disclosed.

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

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

Three sentences, each earning its place: what it does, what is required, and what side effect it triggers. The key action is front-loaded, and there is no filler or repetition of schema fields.

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 payment tool with no output schema and no annotations, the description covers preconditions and settlement behavior but omits what a successful call returns, how the agent should verify success via check_payment_status, and what failure or allowance exhaustion looks like. It is usable but not fully complete.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already documents both order_id and customer_key. The description adds no new parameter semantics and even uses 'customerKey' rather than the schema's customer_key, but this is a minor naming mismatch rather than a substantive gap.

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

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

The description opens with a specific verb and resource: 'Execute payment for a guest order'. It adds scope ('preprod only') and a clear precondition ('pending payment session'), which distinguishes it from sibling tools like create_payment or check_payment_status without ambiguity.

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 states important context: preprod only, requires a customer key, needs a pending payment session, and is subject to a monthly allowance. However, it does not explicitly say when to use this tool instead of create_payment or what to do after execution, such as checking payment status.

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 is the only source of behavioral context. It discloses the asynchronous workflow ('Staff will reply via Discord' and 'Use check_reply to retrieve the response later') but does not mention side effects, whether the submission is stored, or any rate/format constraints. That is partial disclosure, not full.

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, with the action and condition front-loaded and the essential follow-up instruction immediately after. Every word contributes; there is no redundant or filler content.

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

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

For a two-parameter submission tool with no output schema, the description is largely complete: it gives the trigger, the action, and the retrieval path. It does not describe what the call returns or how to distinguish this from ask_gyotak, but these are minor gaps for such a simple tool.

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

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

Input schema coverage is 100% and each parameter already has a description. The tool description only reinforces 'question' implicitly and adds no new semantic detail about either parameter, so the schema carries the burden and the baseline 3 applies.

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

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

The description states a clear action ('Submit a question'), a target ('GYOTAK staff'), and a triggering condition ('when FAQ does not have the answer'). However, it does not differentiate from the sibling ask_gyotak, whose name suggests a similar action, so the agent is left to infer the distinction.

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

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

Explicitly directs when to use the tool ('when FAQ does not have the answer') and points to the follow-up tool ('Use check_reply to retrieve the response later'). It stops short of naming ask_gyotak as an alternative or stating when not to use this tool, so a small guidance gap remains.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It goes beyond 'create' by mentioning THB→tADA conversion, a 30-minute expiry, server-side execution via GYOTAK A→B→A, and that payment details are returned. This is solid coverage of key behavior, though it omits error cases and auth requirements.

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 tight sentences with the main action front-loaded. Every sentence earns its place: the core function, the payment lifecycle details, and the usage trigger all contribute directly to correct tool invocation.

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 single-parameter tool, the description is largely complete: it states when to call it, what it computes, how it executes, and that payment details are returned. The absence of an output schema makes the return format underspecified, but the trigger and input requirements are fully clear for an agent to invoke it correctly.

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

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

Schema coverage is 100%, and the schema already provides an example for order_id. The description adds valuable context by specifying the order must be a 'pending guest order', which clarifies the expected state of the referenced order beyond the raw schema description.

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

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

The description clearly states the primary function: create a Cardano tADA payment session for a pending guest order, with additional specifics about conversion, expiry, and returned details. This differentiates it from siblings like check_payment_status and confirm_payment, which occupy later stages of the payment flow.

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

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

The description explicitly says to call this 'after placing a guest order to initiate payment', giving clear contextual sequencing relative to place_order. It does not explicitly name when-not-to-use or list alternative tools, but the placement in the workflow is unambiguous enough for correct selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains that retail prices are always included, that customerKey enables wholesale pricing and one-tap checkout, and that delivery is Thailand-only. These are meaningful behavioral details beyond the tool's name and schema, though it stops short of discussing output format or failure modes.

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, front-loads the primary purpose, and then adds only the essential conditional logic and delivery constraint. Every sentence contributes actionable information with 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 annotations and no output schema, the description covers the essential returns, optional parameter behavior, and a critical geographic restriction. It does not explicitly compare against search_fish or other sibling tools, but it is sufficiently complete for a read-only catalog retrieval tool with two optional parameters.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds semantic value by clarifying which type of user should pass each optional parameter and what behavior changes when they do. This goes beyond the schema's per-parameter descriptions by linking them to customer types and checkout 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 identifies a specific verb and resource: 'Get GYOTAK's full fish catalog.' It enumerates the key returned data (real-time availability, retail prices, freshness tiers, traceability records), making the tool's purpose unambiguous. The word 'full' also helps distinguish it from sibling search-oriented tools like search_fish.

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 to pass customerKey vs lineUserId, and it clearly states that international delivery is not accepted. It does not explicitly name alternative sibling tools or state when to prefer search_fish, but the contextual usage instructions are clear enough for an agent to invoke the tool 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 carries the full burden. It usefully discloses the returned fields and the post-sale access via blog URL, but it does not explicitly state that the operation is read-only or describe any side effects, permissions, or error behavior. The planned blockchain integration is future behavior, not current tool behavior, and adds little to invocation 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 first two sentences are crisp and front-loaded, and the consumer-access context is relevant. However, the final planned-integration sentence describes a future state that does not affect current invocation, making the description somewhat padded.

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 key return fields and provides useful business context, but both parameters are optional in the schema and the description does not clarify behavior when neither is supplied or whether date and tier can be combined. There is also no output schema, so the response format is only partially specified.

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

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

Schema description coverage is 100%: both date and tier are already documented with format and meaning. The description only restates that filtering is by date or tier, so it contributes no semantic value beyond the schema, matching the baseline of 3.

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

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

The description opens with a specific verb and resource: 'Get catch records by date or freshness tier.' It further distinguishes this from sibling tools by naming the traceability payload (GPS coordinates, photo timestamp, blog URL), so an agent can separate get_catch_reports from verification and order tools.

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

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

The description implies usage for traceability verification and explains that in-stock products reference these records, but it never states explicit when-to-use or when-not-to-use conditions or names alternatives. An agent must infer when this tool is the right choice among the sibling verification 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?

There are no annotations, so the description carries the full burden, and it succeeds. It discloses that the tool takes no arguments, returns static text, and summarizes the actual content (retail vs. B2B wholesale, LINE contact, tier pricing, application required). This makes the behavior fully transparent for a simple static-info 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 dense but every part earns its place: purpose, key details, call triggers, argument behavior, and sibling routing. It is front-loaded with the core purpose and does not waste words on generic filler.

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

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

For a zero-argument tool returning static text, the description is complete. It covers what the tool returns, when to invoke it, what not to use it for, and which alternatives to choose. No output schema is needed because the description already tells the agent the response is static text with known content.

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, which sets a baseline of 4. The description reinforces this by explicitly saying 'Takes no arguments,' matching the empty input schema. There is no additional parameter meaning to add because 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 states exactly what the tool does: returns the two ways to buy from GYOTAK with contact details. It is specific about both retail and B2B wholesale paths, which differentiates it from the listed siblings such as get_catalog, place_order, and ask_gyotak.

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 call it: when the user asks how to buy, how to open a wholesale account, or how to reach GYOTAK. It also gives clear alternatives: use get_catalog for availability/prices and ask_gyotak for other questions, so an agent knows exactly 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 provided, so the description carries the full burden of behavioral disclosure. It does reveal meaningful context: records represent PUF registrations with minutiae extraction, on-chain commitment, and shielded records do not expose GPS. However, it does not explicitly state that the operation is read-only, describe auth requirements, or clarify response behavior beyond the data model.

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

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

The description is compact, with the first sentence clearly stating the action and resource and the second adding necessary context. There is no filler, tautology, or redundant repetition. It is appropriately front-loaded and scannable.

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

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

Given the absence of an output schema, the description could do more to explain the return structure, pagination, or whether all records are returned by default. It does cover the core semantics of the records and notes GPS shielding, which is helpful. Missing usage guidance and explicit behavioral expectations keep it below a 4.

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 covers the only parameter ('status') with 100% description coverage and an enum. The tool description does not add parameter-specific meaning beyond the schema, which is acceptable under the baseline when schema coverage is high. It provides helpful background about what a 'record' is, but not about the status filter itself.

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

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

The description names a specific verb ('Get'), a clear resource ('GYOTAK KOMON physical authentication records'), and a source ('the database'). It also adds useful domain context about PUF registration and on-chain commitment, making the tool's purpose understandable. It does not explicitly distinguish itself from sibling tools like get_catch_reports or verify_komon, but the resource is specific enough to avoid major ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it state exclusions or prerequisites. With many sibling tools such as verify_komon and get_catch_reports, the agent is left to infer the appropriate selection without explicit routing.

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

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

With no annotations, the description carries the behavioral disclosure burden. It discloses the result limit ('last 20 orders') and eligibility ('registered VIP customer'), but it does not describe return format, error behavior, or what happens when the user is not found or not eligible.

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 with the core action front-loaded and the eligibility requirement stated immediately after. No unnecessary words.

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

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

For a simple one-parameter read operation with no output schema, the description covers the essential context: what is returned, the limit, and who is eligible. It omits details like return shape or failure modes, but these are less critical given the low complexity.

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

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

The input schema already fully describes lineUserId with 100% coverage, providing a baseline of 3. The description adds extra semantic value by clarifying that the user must be a registered VIP customer and linking the parameter to B2B order history.

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

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

The description states a specific verb and resource: 'Get B2B order history' with a concrete constraint of 'last 20 orders'. This clearly distinguishes it from sibling tools like place_order or create_payment.

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 prerequisite: the caller must have a lineUserId of a registered VIP customer. This provides enough context for when the tool is applicable, though it does not explicitly mention when not to use it or name 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?

The description discloses key behavioral traits beyond annotations: guest orders are tier-linked retail, total is final, inventory is not deducted, orders go to the pick queue, and delivery is Thailand-only. It doesn't mention all side effects (e.g., whether VIP mode also sends confirmation), but it covers the most important ones.

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 dense but well-structured, front-loading the two modes and then covering requirements and consequences in a logical order. Every sentence adds value; no fluff 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 15 parameters, no output schema, and no annotations, the description carries a heavy burden—and it largely succeeds. It covers mode selection, required fields, rejection conditions, pricing, inventory behavior, delivery constraints, and confirmation follow-up. A few minor gaps (e.g., exact response shape) exist, but the core calling context is 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%, but the description adds meaning beyond the schema: it groups parameters by mode (VIP vs guest), explains when to omit customerName/phone/lineUserId (personal token URL), and clarifies required-ness that the schema doesn't enforce (0 required). It doesn't fully define every parameter, but the schema already documents them.

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

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

The description clearly identifies the tool's purpose—placing an order—and distinguishes two modes (VIP wholesale and guest retail) with distinct required parameters. It also differentiates from sibling tools like check_payment_status or confirm_payment by focusing on order creation.

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 when to use each mode, lists required fields for guest mode, notes when a personal token URL resolves the customer, and even excludes international addresses. It also says what happens next (pick queue, confirmation email), giving clear context for 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, the description carries the full burden of behavioral disclosure. It reveals a non-obvious behavior: the tool does not actually recover the key automatically; it only guides toward staff contact. This is meaningful transparency, though the exact output or side effects of using the phone number are not detailed.

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

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

The description is two sentences with no filler. It front-loads the primary purpose and then adds the important security caveat. Every word contributes to understanding the 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?

The description is adequate for basic selection and invocation, but it leaves gaps: it doesn't explain what 'guides you to contact staff' actually returns or what next steps look like, and it doesn't clarify how the phone number is used. Still, the tool is simple, and the single-parameter schema limits the impact of these 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 description coverage is 100%, and the phone parameter is already described as the 'Phone number used at registration.' The tool description adds no further meaning beyond that, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies the operation (recovering a lost customerKey) and the resource involved, and it clarifies that automatic recovery is not available. It doesn't explicitly contrast itself with sibling tools, but the intent is unambiguous.

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

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

It gives clear context: use this when a customerKey is lost, and for security reasons automatic recovery is not offered. It explains that the tool guides the user to contact staff, which helps set expectations even if it doesn't explicitly list sibling alternatives.

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

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

With no annotations, the description carries the behavioral disclosure burden. It reveals that the tool returns a customerKey and instructs saving it in AI memory, which is key for future orders. It does not mention potential failure modes or duplicate registration behavior, but covers the essential workflow.

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

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

Three short sentences with no filler. The purpose, prerequisite, and return-value handling are each stated once, efficiently and in logical order.

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 explains what to collect, what will be returned, and how to handle the result, which is sufficient for a registration tool with no output schema. It does not cover edge cases like validation errors or duplicate registrations, but those are not critical 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 coverage is 100%, so the description doesn't need to explain parameter meanings. The description lists the same fields as the schema and adds no new semantics beyond the conversational collection requirement.

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

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

The description states a clear action: 'Register as a GYOTAK customer.' It identifies the resource (customer) and differentiates itself from siblings like place_order and recover_customer_key by focusing on customer creation.

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 collect all required information via conversation BEFORE calling, which gives a clear prerequisite. It does not mention alternatives like recover_customer_key for already-registered customers, so some usage context is missing.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose the conditional behavior that providing lineUserId includes VIP tier pricing, which is useful. However, it says nothing about read-only nature, return format, error handling, or rate limits, so transparency is moderate.

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 covering the core action, then a second sentence addressing the optional parameter. Every word earns its place, with no filler or redundancy.

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

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

For a simple search tool with two parameters and no output schema, the description covers the basics. However, it omits what the search returns, does not differentiate from get_catalog, and does not state whether any authentication or prerequisites apply, leaving moderate 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 100%, so the baseline is 3. The description adds meaningful parameter context by specifying accepted language values for 'query' and explaining that 'lineUserId' modifies pricing to include VIP tiers, going beyond the schema's minimal 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 operation ('Search fish by name') and specifies supported languages (Japanese, Thai, English), making the tool's purpose concrete. However, it does not explicitly differentiate from sibling tools like get_catalog, which may also relate to fish data, so it falls just short of a 5.

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

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

The description gives no guidance on when to choose this tool over alternatives such as get_catalog or other fish-related tools. It implies its use by stating what it does, but lacks exclusions or comparisons, leaving an agent to infer usage context on its own.

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

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

With no annotations provided, the description carries the full behavioral burden and does so thoroughly. It discloses that the tool reads on-chain state (non-mutating), returns raw hex plus decoded fields, cryptographically hides GPS coordinates so only region is provable, and checks comma-separated batch IDs against a single contract fetch. These are meaningful behavioral traits not derivable from the schema.

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

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

Every sentence adds distinct information: the core on-chain verification, the contrast with the alternative, the GPS privacy limitation, network support, and batchId batch semantics. It is dense but not padded, and the most important purpose is front-loaded in the first sentence.

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 verification tool with no output schema and no annotations, the description gives enough to call it correctly: what it reads, what it returns, the key cryptographic limitation, and multi-ID behavior. The schema covers parameter syntax, and the description fills the functional gaps without leaving critical unknowns.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining that batchId can contain comma-separated IDs checked against a single contract fetch, and by reinforcing the return behavior per ID. This exceeds baseline but the schema already covers the basic meaning of all three 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 opens with a specific verb and resource ('Verify a GYOTAK catch record DIRECTLY from the Midnight blockchain') and immediately distinguishes this from the sibling get_catch_reports. It clearly identifies what makes this tool unique: on-chain, trustless verification rather than reading GYOTAK's own database.

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 names the alternative (get_catch_reports) and states the decision criterion: use this tool when you need to verify without trusting GYOTAK. It also clarifies supported networks and batchId multi-ID behavior, so an agent knows when and how to invoke 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 carries the full behavioral burden and does well by disclosing that it reads on-chain state, returns raw hex and decoded fields, and preserves GPS privacy via shielded records. However, the statement 'Currently preprod only' conflicts with the network parameter enum that includes mainnet, creating ambiguity about whether mainnet is usable.

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

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

The description is compact and front-loaded with the core action and resource. Every sentence adds useful context: what it does, what it returns, how it differs from the sibling, its privacy property, and its current environment.

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

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

For a tool with no output schema and no annotations, the description adequately explains return content, source of truth, and usage distinction. The main gap is the unresolved contradiction between 'preprod only' and the network enum exposing mainnet, which prevents it from being fully unambiguous.

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% parameter description coverage, so the baseline is 3. The description adds no additional parameter-level detail beyond what the schema already provides, and the 'preprod only' note slightly muddies the network parameter's documented mainnet option.

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

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

The description names a specific verb (Verify), a specific resource (GYOTAK KOMON record), and a specific source (Midnight blockchain). It also distinguishes itself from get_komon_records by clarifying that it reads on-chain state rather than GYOTAK's database, and it states the output (raw hex plus decoded fields).

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

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

It explicitly contrasts with get_komon_records, telling the agent that this tool is for independent verification directly from the chain. It also adds a clear environmental constraint, 'Currently preprod only,' which helps the agent decide 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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It clearly states this is a read-only operation ('Reads on-chain state'), explains what the data represents (hourly averages committed on-chain), and explicitly discloses the limitation that it does not prove temperatures stayed within limits at every moment. It also notes network support (preprod and mainnet). It doesn't specify output format or error behavior, but the key behavioral caveat about hourly averages is well disclosed.

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 front-loaded with the core function ('Verify ... DIRECTLY from the Midnight blockchain'), followed by the key trust differentiator, the critical limitation, and network support. Every sentence earns its place: the first sentence states the purpose, the second explains why this tool exists (vs the dashboard), the third warns about what the data doesn't prove, and the fourth notes supported networks. 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 the tool's moderate complexity (4 optional parameters, no required parameters, no output schema), the description covers the essential context: what it verifies, why it's different from the dashboard, the hourly-average limitation, and supported networks. It doesn't describe the return format or error cases, but for a read-only verification tool with heavily documented parameters, the described context is largely sufficient. The trust/verification framing is particularly valuable for agent decision-making.

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

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

Schema description coverage is 100%, so all four parameters are already described in the input schema. The tool description adds context about what the parameters filter (network, freezerId, hourStartUtc, contractAddress) by explaining the purpose of verification, but it doesn't add new parameter-level semantics beyond the schema. The baseline of 3 is appropriate because the schema does the heavy lifting and the description reinforces the verification context.

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

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

The description states a specific verb ('Verify'), a specific resource (GYOTAK cold-chain storage temperatures from the Midnight blockchain), and immediately distinguishes itself from the dashboard reading from GYOTAK's D1 database. It clearly explains the independent verification purpose and the hourly-average limitation, which differentiates it from sibling tools like verify_catch or verify_komon. The scope is precise: reads on-chain state and returns decoded hourly temperature records per freezer.

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 explicit guidance: use this when you need independent verification without trusting GYOTAK, unlike the dashboard. It also clarifies the limitation that hourly averages do not prove continuous compliance, which is a key usage consideration. It names the alternative context (the dashboard) and explains the trust difference, giving clear when-to-use reasoning.

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