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

With no annotations provided, the description fully discloses behavioral traits: approval is irreversible and starts the refund process. It also notes potential status change to WaitingFraudCheck if fraud control applies. The warning symbol (☢️) emphasizes the destructive nature.

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 paragraph of five sentences, front-loaded with the critical warning. Every sentence adds necessary information without redundancy or fluff.

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

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

The description covers prerequisites, status constraints, and irreversible side effects. However, it lacks any indication of the response format or return values, which would be helpful since there is no output schema. The mention of possible WaitingFraudCheck status partially compensates.

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 value by instructing where to get claimId and claimLineItemIdList from trendyol_get_claims response and how the list maps from items[].claimItems[].id. However, the optional 'params' field is only described as 'Ek parametreler' without further explanation, leaving some ambiguity.

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

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

The description clearly states the tool approves refund items that have reached the warehouse, using the verb 'onaylar' (approves). It specifies the resource (iade kalemleri) and distinguishes from siblings like trendyol_create_claim and trendyol_get_claims by focusing on approval of existing claims in WaitingInAction 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 provides explicit conditions: only claims in WaitingInAction status can be approved. It instructs users to obtain claimId and claimLineItemIdList from trendyol_get_claims response and explains the mapping. It also warns that approval is irreversible and initiates refund, giving clear when-to-use guidance.

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

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

With no annotations, the description fully explains the effect: archived products become invisible but are not deleted, and unarchived ones reactivate. It also mentions the batch result checking method, though it omits potential side effects on pricing or inventory.

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 concise sentences with no redundant information. The key action and constraints are front-loaded, making it efficient for an AI agent to parse.

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

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

For a batch archive/unarchive tool, the description covers the main behavior, limits, and post-action step. It lacks error handling or rate limit details, but overall it is adequately complete for the tool's complexity.

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

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

Schema coverage is 0%, so the description compensates by explaining the items array structure and the meaning of the archived boolean (true=archive, false=unarchive), adding value beyond the raw schema.

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

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

The description explicitly states the action (archive/unarchive) and resource (products), clarifying that archiving makes products invisible but not deleted, distinguishing it from deletion 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 provides a usage limit (max 1000 items) and instructs to check results with a specific sibling tool, offering practical guidance. However, it does not explicitly differentiate when to use this tool over alternatives.

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

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

No annotations are provided, so the description must fully disclose behavior. It explains the basic function but does not mention side effects, persistence, or how credentials are stored/used. This is adequate but lacks depth compared to tools with richer behavioral notes.

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 exceptionally concise—two sentences that first define the purpose and then provide source and alternative. Every sentence adds value, and the key information is front-loaded.

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

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

For a configuration tool with 4 parameters and no output schema, the description covers the essential aspects: purpose, credential source, and alternative. It does not explain return behavior, but that is typical for such tools. Adequate and slightly above average.

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 does not add significant extra meaning beyond what the schema provides for each parameter; it only includes the stageMode behavior note already 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 defines Trendyol Seller API credentials, with a specific verb and resource. It is easily distinguishable from sibling tools which are focused on operations like approvals, creations, and queries.

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

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

The description explicitly tells users where to obtain the credentials (Trendyol Seller Panel) and provides an alternative condition (if environment variables are defined, the tool is not needed), giving clear when-to-use and when-not-to-use guidance.

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

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

No annotations are provided, so the description carries full burden. It thoroughly discloses behavioral traits: only WAITING_FOR_ANSWER status allowed, 10-2000 character limit, forbidden word check (with rejection and state changes), and error conditions (already answered, time limit exceeded, forbidden word limit). This is comprehensive and 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 appropriately sized with 6 sentences, each providing meaningful information. It front-loads the main action and then covers constraints and consequences without redundancy. 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 no output schema, the description explains prerequisites, constraints, and error scenarios well. It could mention the return value or success indicator, but the behavioral details are sufficient for an agent to set expectations. Slight gap in describing the output format.

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

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

Schema coverage is 100%, with both parameters described in the schema. The description adds context about the forbidden word check and error handling, which enriches understanding beyond schema descriptions. However, the schema already provides adequate detail, so the added value is moderate.

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 'Müşteri sorusuna yanıt gönderir' (sends answer to customer question). The verb 'yanıt gönderir' and resource 'müşteri sorusu' are specific. The tool is distinct from sibling tools like trendyol_get_questions and trendyol_get_question_by_id, which are read operations.

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

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

Description specifies that only WAITING_FOR_ANSWER questions can be answered, and directs to trendyol_get_reference_data for status values. It also mentions character limits, forbidden word restrictions, and a 3-day deadline. While it does not explicitly state when not to use the tool, the context and constraints are clear.

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

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

No annotations are provided, so the description carries full burden. It states creation but does not disclose side effects, error behavior (e.g., if brand already exists), authorization requirements, or return values. Adequate but not explicit.

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, concise, and covers purpose and inputs. Could be more structured (e.g., bullet points), but no wasted words. Efficient.

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

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

Given no output schema or annotations, the description is fairly complete for a creation tool. It explains what is created and what inputs are needed. Could mention return value or error conditions, but overall sufficient.

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

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

Schema coverage is 100%, so baseline is 3. The description adds that imagePaths must be file paths on disk ('diskteki dosya yolları'), which is useful but minor. No significant extra meaning 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 the action: creating a brand not in the Trendyol brand list. It specifies required inputs (name and image paths). This distinguishes it from sibling tools like trendyol_get_brands (list) and trendyol_get_brand_by_name (search).

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 versus alternatives (e.g., check if brand exists first). Usage is implied but not stated clearly. Lacks context for decision-making.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It states the claim opens in "Created" status and mentions a stageMode parameter for environment awareness. However, it does not describe side effects, authentication requirements, rate limits, or whether the operation is reversible. Partial transparency but insufficient for a create 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 a single paragraph of five sentences. It is front-loaded with the tool's purpose, then details usage conditions and parameter guidance. It is concise and avoids redundancy, though structuring with bullet points could improve readability.

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

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

Given 6 parameters, no output schema, and no annotations, the description provides decent context: customerId source, stageMode, and links to related tools. However, it omits response format, error handling, and parameter constraints (e.g., valid shipmentCompanyId values). A more complete description would improve agent confidence.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context for customerId (source from orders), indicates optional parameters (excludeListing, forcePackageCreation) are not sent if omitted, and explains the default reasonId (401). These additions are helpful but not extensive, so the score remains at the 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?

The description clearly states the tool creates a claim for packages arriving without a return code. The verb "oluşturur" (creates) and resource "iade talebi" (claim) are specific. It distinguishes from siblings like trendyol_approve_claim_items and trendyol_get_claims.

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 only use for claims you will approve ("yalnızca ONAYLAYACAĞINIZ iadeler için kullanılmalıdır"). It provides guidance on obtaining customerId from trendyol_get_orders and suggests using trendyol_get_claims to view the created package. Does not explicitly mention when not to use or list alternatives, but the guidance is clear.

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

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

No annotations provided, so description carries full burden. It warns that the action is irreversible and directly affects the customer, and explains post-action tracking via rejectedpackageinfo field. This provides critical behavioral context beyond the input 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?

The description is a single paragraph in Turkish, but it is efficient: includes a warning, key conditions, and references to other tools. Could be structured with bullet points for readability, but it is not overly verbose.

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

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

Adequately covers input and behavioral aspects, but lacks information about the response (e.g., what is returned on success, error scenarios). No output schema exists, so description should mention expected output for completeness. Also no mention of rate limits or permissions.

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

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

Schema coverage is 100%, but the description adds significant value by explaining how to obtain each parameter value (e.g., claimId from getClaims, claimIssueReasonId from get_claim_issue_reasons), file attachment exceptions, and the 500-character limit for description. Enhances agent understanding substantially.

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

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

The description clearly states the tool creates a return rejection/issue notification, specifies it applies to items in WaitingInAction status, and distinguishes it from sibling tools like trendyol_approve_claim_items which approves claims.

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

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

Explicit conditions provided: only for WaitingInAction status, file attachment required except for specific reasons, and a note about reason 2101. References to use trendyol_get_claim_issue_reasons for reason IDs. Does not explicitly state when NOT to use, but implied by the status constraint.

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

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

No annotations provided, so description carries full burden. Discloses max 1000 items, variant handling (same productMainId, different attributes), batch request ID requirement, and that products enter an approval process and are not published automatically. Lacks details on rate limits or authentication, but covers key behaviors.

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 paragraph, but efficiently covers preconditions, variant handling, batch ID, and follow-up. Could be slightly more structured (e.g., bullet points) but no redundant sentences. Concisely packed with essential info.

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 tool complexity (nested array with many fields) and no output schema, description adequately covers variant logic, batch result checking, and approval implications. Does not describe error handling or all fields (covered by schema), but overall complete for 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% with field descriptions. Description adds context beyond schema: explains variant usage (same productMainId), that cargoCompanyId must be approved, and that attributes can be either attributeValueId or customAttributeValue. This adds meaningful guidance.

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 uploads single/bulk products to Trendyol with a max of 1000 items per request. It distinguishes from sibling tools like trendyol_update_price_and_inventory or trendyol_update_approved_product_content by focusing on creation and referencing prerequisite tools for IDs.

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

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

Explicit preconditions are given: must first call trendyol_get_brands, trendyol_get_category_tree, etc. to get required IDs. Also specifies follow-up action: call trendyol_get_batch_request_result to check result. Notes that products are not automatically published but go through approval. Does not explicitly state when NOT to use, but 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 full burden. It discloses key behaviors: operates only in stage, no production impact, barcodes must be from stage, address fields use defaults if omitted, and commercial=true triggers mandatory fields. This is substantial, though it omits error handling or return details.

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

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

Three sentences, each serving a distinct purpose: (1) main purpose and environment, (2) barcode source and defaults, (3) commercial invoice conditions. No fluff, front-loaded, concise.

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 environment, barcode source, defaults, and conditional requirements, but lacks any mention of return value or output format. Given the tool's complexity (8 params, nested objects, conditional logic), this gap limits completeness, though it is adequate for basic usage.

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

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

Schema description coverage is 75% (high), but the description adds critical context beyond schema: barcodes must belong to stage products, address/customer fields are optional with defaults, and commercial=true makes specific parameters mandatory. This adds meaning that helps correct invocation.

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

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

The description explicitly states the tool creates a test order in the stage environment and does not affect production. The verb 'oluşturur' (creates) and resource 'test siparişi' (test order) are specific. While no sibling differentiation is explicitly made, the tool's purpose is uniquely clear among sibling tools, none of which create orders.

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

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

The description implies usage when a test order in stage is needed, but does not provide when-not-to-use or alternatives. It gives parameter conditions (barcodes must be from stage, address defaults, commercial invoice requirements) but no broader guidance on when to choose this tool 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?

The description discloses that the tool always calls stageapigw, the question text cannot be empty, and the question enters evaluation before publication. However, it does not mention authentication requirements, rate limits, idempotency, or what the tool returns (no output 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?

The description is concise, consisting of a few focused sentences. It front-loads the core purpose, then adds key usage constraints and parameter hints with no redundant text.

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

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

For a creation tool with no output schema and no annotations, the description adequately covers purpose, environment, constraints, and parameter usage. It is missing output details and authorization info, but is otherwise complete for a test-scenario 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?

With 100% schema coverage, the description adds value by providing concrete examples (userId: 4147346), clarifying that contentId is productContentId, stating defaults for channelId and showUserName, and noting that userFullName is optional. This goes beyond the schema definitions.

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

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

The description clearly states the tool creates a customer question for a product in the STAGE environment, and specifies it's used for trendyol_create_answer test scenarios, distinguishing it from siblings like trendyol_create_claim or trendyol_create_test_order.

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 limits usage to the stage environment and test scenarios, and provides guidance on parameter values (userId example, channelId default). However, it does not mention when not to use it or specify alternative tools.

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

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

Discloses key behaviors: background processing, rate limit (200 req/min), file format/size/duration constraints, single active video rule, approval requirement, auto-removal of old videos. No annotations provided, so description fully carries the burden.

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?

Compact yet comprehensive: 4 sentences efficiently cover purpose, constraints, and behavior. No redundancy. Each sentence adds essential information.

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

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

For a creation tool with 5 parameters and no output schema, the description covers all behavioral aspects: processing, limits, approval workflow, auto-removal, and references sibling tool for status. Complete and actionable.

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

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

Schema coverage is 100%, but description adds significant value: file format/size/duration constraints not in schema, explains default for videoContentType, and clarifies productContentIds limit. Goes well beyond schema descriptions.

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

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

Clearly states it creates video for product content, downloading from URL and processing in background. Distinguishes from sibling tools like trendyol_get_videos which are for retrieval.

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

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

Explicitly mentions tracking status with trendyol_get_videos, and provides constraints (1 active video per productContentId, max 100 linked IDs) that guide appropriate usage. Clear context for when 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?

With no annotations, the description carries the full burden. It discloses the destructive action (deletion) and mentions a constant channelId value (though not in schema), but does not elaborate on irreversibility, permissions, or side effects. The behavior is adequately stated for a simple delete 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 concise (2 sentences plus a note) with no redundant information. It front-loads the action with a caution emoji, and every sentence provides necessary guidance without excess.

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 delete operation with two parameters and no output schema, the description is fairly complete. It explains the purpose, usage scenario, parameter sourcing, and post-deletion step. The note about channelId is helpful, though slightly inconsistent with the schema. Overall, it provides sufficient context for correct invocation.

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

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

The input schema already covers both parameters with descriptions (100% coverage). The description adds value by mapping serviceSourceId to shipmentPackageId and indicating how to retrieve customerId from another tool's response. The mention of channelId (constant 1) provides extra context, though it is not a parameter 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 deletes an incorrectly sent invoice link, using a specific verb ('siler') and resource ('fatura bağlantısı'). It distinguishes from sibling 'trendyol_send_invoice_link' by implying a corrective workflow where deletion precedes resending.

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

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

The description explicitly advises when to use the tool (for incorrectly sent invoice links) and directs to the sibling tool for the next step. It also provides guidance on obtaining parameter values from another tool's response, though it lacks explicit 'when not to use' statements.

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?

Despite no annotations, the description fully discloses irreversibility (geri alınamaz), conditions for deletion, and batch behavior. Instructions on follow-up result checking imply asynchronous processing.

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 paragraph with front-loaded warning, followed by conditions, alternative, and result check instruction. Every sentence adds meaningful information, no redundancy.

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

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

Given complexity (irreversible, conditional, batch, async), the description covers all key aspects: irreversibility, allowed conditions, alternative tool, and result checking. No 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?

Only one parameter (barcodes) with 100% schema description coverage. Description adds no extra meaning beyond the schema, but the schema constraints (maxLength, minLength, maxItems) are sufficient.

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

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

The description clearly states that the tool deletes products from Trendyol system ("ürün silme geri alınamaz... siler") and specifies allowed product types for deletion (onay bekleyen, arşivdeki). It distinguishes from sibling tools like trendyol_archive_products.

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 provides when-not-to-use (for temporary removal, use trendyol_archive_products) and mentions follow-up with trendyol_get_batch_request_result. Conditions for deletion are clearly stated.

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

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

No annotations provided, so the description must reveal behavior. It states the action (delete) but does not mention idempotency, side effects, or error conditions. For a simple delete, this is minimally adequate.

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

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

Two short, front-loaded sentences with no unnecessary words. Every sentence adds value.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers the essential information: what it does and how to get the required ID. It is complete for its complexity.

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

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

Schema coverage is 100% and the parameter description is already clear. The tool description adds no extra meaning beyond what the schema provides, so baseline score 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 clearly states it deletes a registered webhook by ID, using a specific verb and resource. It also references a sibling tool for obtaining the ID, which helps distinguish from other deletion tools.

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

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

Explicitly tells when to use (to delete a webhook) and provides a prerequisite: obtain the ID using trendyol_get_webhooks. This is clear guidance.

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

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

With no annotations, the description should disclose behavioral traits. It mentions pagination limits but omits cost, rate limits, authorization requirements, or any side effects (though likely read-only).

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

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

Two sentences, front-loaded with output fields, followed by essential pagination info. 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 14 optional filter parameters and no output schema, the description lacks details on how filters work, return format, error handling, or pagination continuation beyond nextPageToken.

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

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

The description adds value by explaining the page×size constraint and nextPageToken usage. However, 14 parameters exist with only 36% schema coverage; many filter parameters (status, barcode, brandIds, etc.) remain unexplained.

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 approved products with specific details (price, stock, commission, etc.) and distinguishes it from siblings like trendyol_filter_unapproved_products by specifying 'onaylı ürünler'.

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

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

No guidance on when to use this tool vs alternatives or when not to use it. The pagination hint is useful but does not provide decision-making 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?

The description accurately notes stockLastModifiedDate is non-null only after stock updates and reveals pagination limits. With no annotations provided, it carries the full burden and covers key behavioral traits, though it could explicitly state the tool is read-only.

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 in Turkish, front-loading the purpose and adding two important behavioral notes concisely. 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?

The description covers purpose, key field behavior, and pagination, but does not explain the return format (fields beyond stockLastModifiedDate) or the role of parameters like orderByDirection. For a tool with 9 parameters and no output schema, more detail is needed for full 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 schema has 11% description coverage (only size documented). The description only adds context for page and size via the pagination constraint, leaving 7 parameters entirely unexplained (status, barcode, contentId, etc.). This does not adequately compensate for the low schema coverage.

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

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

The description clearly states the tool lists only stock and price of approved products (without full content details). The name and title reinforce this, distinguishing it from sibling tools like trendyol_filter_approved_products which likely return full details.

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

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

The description provides clear pagination guidance (page × size max 10,000, use nextPageToken beyond) and implies the tool is for retrieving stock/price data. However, it does not explicitly mention when not to use it or suggest alternatives (e.g., for full product details use trendyol_filter_approved_products).

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

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

No annotations exist, so description carries full burden. It explains that rejected products include reasons in rejectReasonDetails, and after corrections the product re-enters approval. It also details pagination limits (max 10,000) and nextPageToken usage. This provides useful behavioral context beyond a simple list.

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 coherent paragraph that front-loads the main purpose. It is concise (three sentences) but could be slightly better structured by separating the pagination note. 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 12 parameters, no output schema, and no annotations, the description covers the output (rejectReasonDetails) and pagination but misses explaining many filtering parameters (like origin, brandIds, dateQueryType). It is adequate for a basic list but incomplete for complex usage.

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

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

Schema description coverage is only 50%, leaving many parameters (e.g., origin, brandIds, dateQueryType) without explanation. The description only mentions output fields (rejectReasonDetails) and pagination, not adding meaning to the input parameters beyond what the schema already 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 clearly states the tool lists unapproved (draft) products, specifically those pending approval (pendingApproval) and rejected after review (rejected). It distinguishes from siblings like trendyol_filter_approved_products by targeting unapproved 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 usage for unapproved product management but does not explicitly state when to use this vs alternatives like trendyol_filter_approved_products or trendyol_get_products. No exclusions or when-not-to-use guidance is provided.

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

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

With no annotations provided, the description carries the full burden. It discloses that results are queryable for up to 4 hours and that stock-price updates do not return batch status. This is valuable behavioral context beyond the minimal read-only assumption. No contradictions exist.

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 plus a note) and includes critical exceptions. It is front-loaded with the purpose. While efficient, there is minor room for improvement in separating general usage from special cases.

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 low complexity (1 parameter, no output schema), the description covers the necessary context: what it does, when to use, key response fields, time limit, and a special case. It provides complete guidance for an agent to select and invoke the tool correctly.

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

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

The single parameter (batchRequestId) is fully described in the schema (100% coverage). The description adds context about the source of the ID but does not provide additional semantic detail beyond what the schema states. Baseline 3 is appropriate.

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

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

The description clearly identifies the tool's purpose: querying the result of batch operations (createProducts, updateProducts, etc.) using a batchRequestId. It specifies the operations and response fields (status, failureReasons), and even notes an exception for stock-price updates, effectively distinguishing it from sibling tools.

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

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

The description explains when to use the tool (after batch operations) and provides guidance on interpreting results, including the exception for stock-price updates. However, it does not explicitly state when not to use it or mention alternative tools, though the context of sibling tools makes alternatives 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 adds a critical behavioral detail (case sensitivity). However, it does not disclose other traits such as what happens when the brand is not found (e.g., error vs empty result) or any 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 extremely concise: one sentence stating purpose immediately followed by a critical warning. 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?

The description covers the basic usage but omits details on return values, error handling, or how results are structured. Given the tool's simplicity, it is minimally adequate but not 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 already provides 100% coverage with a description matching the tool's. The description adds an example ('TRENDYOLMİLLA') but does not substantially enhance meaning beyond the schema.

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

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

The description clearly states the tool's action ('searches by brand name') and resource ('brand'). While it doesn't explicitly differentiate from sibling 'trendyol_get_brands', the name and context imply a specific lookup by name, making purpose sufficiently clear.

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

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

The description warns about case sensitivity but provides no guidance on when to use this tool versus alternatives like 'trendyol_get_brands'. No usage context or exclusions are given.

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

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

No annotations provided, but the description covers key behavioral aspects: paginated results via page/size parameters, indication that it returns a list of brands, and mention of typical page size. It does not describe any destructive effects, which is appropriate for a read-only tool.

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

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

The description is two concise sentences, front-loaded with the primary purpose, followed by a usage tip. No extraneous words.

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

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

Given the tool's simplicity (2 parameters, no output schema, no nested objects), the description provides all necessary information: what it does, how pagination works, typical page size, and a sibling alternative. It is 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 coverage is 50% (only size has description). The description adds meaning by explaining that parameters control pagination, with defaults (page=0, size=1000) and that a page can contain at least 1000 brands. This enriches understanding beyond the schema.

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

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

The description clearly states it returns a paginated list of brands (Trendyol marka listesini sayfalı olarak döndürür) and explains the purpose of brandId. It also distinguishes itself from the sibling trendyol_get_brand_by_name, making the purpose crystal clear.

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

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

The description explicitly advises when to use this tool (for paginated brand listing) and when not to (for a specific brand, use trendyol_get_brand_by_name). It also mentions that a page can return at least 1000 brands, providing practical guidance.

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

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

No annotations are provided, so the description carries full burden. It discloses limits and return fields, adding context beyond the schema. Could mention idempotency but covers key behaviors adequately.

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

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

Single, concise sentence that front-loads the main purpose and includes key details without redundancy. Every element 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?

No output schema, but description lists return fields, which compensates. It explains limits and functionality. Could briefly mention error handling but overall complete for a simple getter 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 the barcodes parameter already described. The description reinforces the max 10 limit but doesn't add new semantic meaning 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 clearly states the tool returns buybox information for products, listing specific fields like buyboxOrder and prices. It distinguishes from siblings as the only buybox-related tool among many.

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

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

The description specifies usage limits (max 10 barcodes per request, rate limit 1000 req/min) but does not explicitly state when to use vs alternatives. However, the unique function of returning buybox info makes 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 are provided, so the description carries the full burden. It implies a read-only operation ('getirir') but does not disclose any behavioral traits such as permissions, rate limits, or safety profile. The lack of explicit safety disclosure reduces the score to 3.

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

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

The description consists of two concise sentences. The first states the purpose, and the second explains the parameter. It is front-loaded and contains 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 tool with one parameter and no output schema, the description is fairly complete. It explains the purpose and how to get the input. However, it does not describe the response format, which would be helpful for an agent.

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%, but the description adds value beyond the schema by explaining how to obtain the invoiceSerialNumber from another tool and the specific filtering condition. This provides context not present in the schema alone.

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

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

The description clearly states it gets items of the cargo invoice issued by Trendyol to the seller. It is specific and distinguishes from sibling tools like trendyol_get_other_financials by focusing on cargo invoice items.

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 instructions on when to use this tool: after obtaining the invoiceSerialNumber from trendyol_get_other_financials filtering for transactionType='Kargo Faturası' or 'Kargo Fatura'. This is excellent prerequisite guidance.

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

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

With no annotations, the description carries the full burden. It explains the meaning of boolean response fields (required, allowCustom, etc.), which adds transparency. However, it does not disclose whether the operation is read-only, mention auth requirements, or discuss rate limits. For a getter, this is adequate but not thorough.

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

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

The description is a single, efficient paragraph that is front-loaded with the main purpose. All sentences add value, explaining response fields. It is not overly verbose, though it could be slightly more structured.

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

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

For a simple attribute retrieval tool with two parameters and no output schema, the description provides detailed field meanings that are crucial for using the output. It covers the main use case well, but lacks mention of pagination or read-only nature, which would be nice extras.

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 applies. The description does not add significant meaning to the input parameters beyond what the schema already provides; the schema describes both parameters adequately. The description's value lies in explaining output fields, not parameters.

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

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

The description clearly states the tool returns category attributes and specifies that attributeId values are used when creating products. It is distinct from sibling tools like get_category_tree or get_category_attribute_values.

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

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

The description explains the primary use case (getting attribute IDs for product creation) and defines the meaning of response fields. It does not explicitly mention when not to use the tool or contrast with alternatives, but the usage 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 burden. It discloses that results are paginated and that values can change (weekly refresh recommended). However, it does not mention authentication, rate limits, or response structure, which is a gap for a read tool with no output 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 short sentences, front-loaded with purpose and key behavior (paginated, recommend refresh). 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 4 params (2 undocumented), no output schema, and a paginated response, the description is too brief. It lacks explanation of attributeValueId, response structure, or default pagination behavior beyond what is in the schema.

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

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

Schema description coverage is 50% (only page and size described). The description adds no parameter-specific meaning beyond implying categoryId and attributeId are required. It does not compensate for the missing parameter 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 returns paginated values for a category attribute (specific verb 'returns', resource 'values for a category attribute'). It distinguishes from siblings like 'get_category_attributes' which returns attributes, not values.

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 vs alternatives (e.g., get_category_attributes). The description implies usage when needing attribute values but does not mention exclusions or prerequisites.

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

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

Discloses that the tree updates regularly and advises weekly refreshes to avoid errors. While it doesn't explicitly state read-only behavior, the description is sufficient for understanding expected behavior given no annotations are 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?

Concise and front-loaded: first sentence states purpose, followed by essential usage rules and parameter behavior. Every sentence adds value without redundancy.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description covers purpose, usage constraints, and parameter behavior completely. No additional information is necessary for correct invocation.

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

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

Adds significant meaning beyond the input schema by explaining that the 'name' parameter filters categories where the keyword appears at any level, which isn't fully conveyed in the 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 it returns the Trendyol category tree and specifies critical usage constraints (only leaf categories for product creation). It distinguishes itself from sibling tools by providing unique functionality not covered by other getters.

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 provides when to use (get category tree) and when not to (cannot use non-leaf categories for product creation). Recommends weekly refresh to maintain data accuracy, offering clear contextual guidance.

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

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

Since no annotations are provided, the description carries full behavioral burden. It discloses the returned fields and the meaning of executorApp, indicating a read operation. However, it omits potential edge cases like empty results or error scenarios.

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 purpose, and includes necessary details without extraneous text.

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

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

Given no output schema, the description adequately lists returned fields (status history, date, operator) and explains the executorApp distinction. It could mention response structure or pagination, but it's sufficiently complete for a simple audit query.

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

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

The parameter claimItemId has 100% schema coverage. The description adds valuable context: 'İade kalemi ID (getClaims: items[].claimItems[].id)', explaining where to find the value, which goes beyond the schema's minimal label.

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

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

The description clearly states the tool retrieves the status history of a claim item, including previous/new status, update date, and operator. It explains the executorApp field and distinguishes this from siblings like trendyol_get_claims.

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 (e.g., when to call after getting claims or before approving). The description only explains how to interpret results, not usage context.

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

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

Without annotations, the description provides valuable behavioral context by noting that reason 1651 cannot be selected within the first 24 hours after WaitingInAction. This is a key constraint that helps the agent avoid errors.

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

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

The description is two sentences with no wasted words. The main purpose is front-loaded, and the note adds essential information efficiently.

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

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

Given no output schema, the description could hint at the return format (e.g., includes claimIssueReasonId), but it is sufficient for the agent to understand the tool's output is a list of reasons. The behavioral note adds depth.

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 schema coverage is 100%. The description does not need to add more, so baseline 4 is appropriate.

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

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

The description clearly states the tool lists valid rejection reasons (red nedenleri) for trendyol_create_claim_issue, using specific verb 'listeler' and resource, distinguishing it from sibling claim tools.

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

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

The description explicitly ties the tool to trendyol_create_claim_issue, implying it is a prerequisite. It does not explicitly state when not to use or mention 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?

No annotations, so description carries full burden. Discloses sorting, filtering override, date format, and status values. Does not mention pagination behavior or rate limits, but adequate for list endpoint.

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 paragraph, front-loaded with main purpose. Every sentence adds critical information. No redundancy.

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

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

With 7 parameters and no output schema, description covers date format, statuses, filter behavior. Lacks response field explanations but output schema not provided.

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 86% is high, but description adds value: explains claimItemStatus usage, orderShipmentPackageId meaning, and date interpretation. Adds beyond schema.

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

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

Clearly states it lists claim packages paginated, sorted by lastModifiedDate. Distinguishes from sibling tool trendyol_update_test_claim_to_waiting_in_action by mentioning the expected 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?

Provides explicit guidance: use claimItemStatus=Created for new claims, claimIds filter overrides others, date format for panel matching. Lacks explicit when-not-to-use but 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?

The description indicates the tool 'lists' orders, implying a read operation, but does not explicitly state it is non-destructive or require authentication. With no annotations, this leaves some behavioral ambiguity, though the status filters give some operational context.

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

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

The description is extremely concise with two sentences, front-loading the main purpose, then listing filter values. Every sentence is essential, no redundancy.

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

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

Given the tool has 8 parameters and no output schema, the description adequately covers core functionality (pagination, status filter, orderNumber), but omits details on date range, sorting, and return structure. It is sufficient for a simple listing tool but not comprehensive for complex queries.

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

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

The description adds value by enumerating the valid status values and emphasizing the use of orderNumber for specific order retrieval. It also mentions pagination. Since the schema already covers 75% of parameters with descriptions, the description's additions are meaningful but not extensive.

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 explicitly states the tool lists the seller's orders (packages) with pagination, and mentions filtering by orderNumber and status. This clearly distinguishes it from other trendyol tools like getting claims or products.

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

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

It provides clear context on when to use the tool (list orders) and how to filter (by orderNumber, status). However, it lacks explicit when-not-to-use or alternative tool mentions, so it does not reach the highest score.

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

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

With no annotations, the description carries the full burden. It discloses automatic interval splitting and the priority of transactionTypes over transactionType. It also explains the interaction between DeductionInvoices and transactionSubType, and links to another tool for cargo invoices.

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 paragraph but well-structured with clear, informative sentences. Each sentence adds value without redundancy. It could be slightly more organized (e.g., bullet points), but it remains concise and 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?

The description provides good usage context and interactions between parameters. However, with no output schema, it lacks explanation of the response structure (e.g., pagination, fields returned). The tool has 8 parameters and no output schema, so a brief note on what to expect in the response would improve completeness.

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

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

Despite 100% schema coverage, the description adds significant value: it explains the purpose of paymentDate, the exclusive use of transactionSubType with DeductionInvoices, and the behavior when both transactionType and transactionTypes are provided. The reference to trendyol_get_reference_data for type descriptions further enriches understanding.

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 fetches non-order financial records, listing specific types like satıcı finansmanı, virmanlar, ödemeler, etc. It distinguishes itself from sibling tools by focusing on financial data outside of orders.

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 when to use transactionType vs transactionTypes, the automatic 15-day interval splitting, and the specific use of transactionSubType with DeductionInvoices. It also provides a cross-tool reference for cargo invoice serial numbers. However, it does not explicitly state 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 provided; description only mentions pagination and filters. Lacks disclosure on rate limits, authentication, error handling, or return structure. Adequate but minimal.

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

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

Two concise sentences, front-loaded with main action and filter summary. 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?

With 11 parameters, no output schema, and no annotations, the description is brief. Does not explain pagination defaults, return format, or data types beyond schema. Slightly incomplete for a complex 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 91%, and description adds value by summarizing filter types (barcode, stock code, status, dates). One parameter (page) lacks description but is self-explanatory.

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 tool lists seller's Trendyol products with pagination and filter options (barcode, stock code, status, dates). Distinguishes from siblings focused on claims, orders, brands, 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?

Description implies usage for general product listing with filters, but does not explicitly mention when to avoid or suggest alternatives like specific filter tools (trendyol_filter_approved_products).

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

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

No annotations are provided, so the description must carry the full burden. It only describes the return value and does not explicitly state that this is a read-only operation with no side effects, nor does it mention idempotency, rate limits, or other behavioral traits. The name suggests read-only but the description lacks explicit transparency.

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

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

The description is a single concise sentence with no wasteful words. It front-loads the action and immediately specifies the returned 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?

Given the tool's simplicity (one parameter, no output schema), the description adequately previews the output by listing the fields. It compensates for the lack of output schema. However, it could improve by explaining the meaning of each field or their data types.

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

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

The schema already describes the single parameter 'barcode' with 100% coverage. The description merely references the barcode without adding new meaning such as expected formats, validation rules, or examples. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description uses a specific verb 'döndürür' and clearly specifies the resource 'tek bir barkod' and the exact fields returned (approved, archived, listingId, contentId, approvedDate). This distinctly differentiates it from sibling tools like trendyol_get_products which return full product details or trendyol_filter_approved_products which filter lists.

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 a single barcode status check but provides no explicit guidance on when to use this tool versus alternatives like trendyol_get_products or trendyol_filter_approved_products. No usage context, prerequisites, or exclusion criteria are mentioned.

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

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

No annotations provided, so the description carries the full burden. It discloses the tool returns statuses, reject reasons, and changed/current values, and lists update types. It does not explicitly state the tool is read-only, but the read nature is implied. Overall, it provides sufficient behavioral context without 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 compact sentences that front-load the main purpose and then detail the return structure. No extraneous information; every sentence is informative and 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 tool with one parameter and no output schema, the description explains the return structure in sufficient detail. It lacks mention of limitations like time range or permissions, but is still complete enough for a typical query.

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

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

Schema coverage is 100% with a single parameter 'contentId' described as 'Ürün içerik ID'. The description mentions 'contentId bazında', adding little beyond the schema. Baseline 3 is appropriate as the description does not significantly enhance parameter understanding.

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

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

The description clearly states the tool returns QC results for product update requests by contentId, specifying the return structure (status per update type, reject reasons, changed values). This distinguishes it from sibling tools like trendyol_get_product_status, which returns product status rather than audit results.

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 when needing QC results for product updates, but does not explicitly state when to use this tool versus alternatives or any exclusion criteria. Given no sibling confusion, the context is clear enough for an AI agent to infer usage.

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

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

No annotations provided, but description details the response fields (question text, status, customer info, product info, active answer, rejected answer). Does not mention error handling or permissions, but for a read operation it is fairly 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?

Two sentences: first states purpose, second details response structure. No extra words, 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?

Tool is simple with one parameter. Description provides sufficient context: response structure and ID source. No output schema, but description compensates by listing response fields.

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 schema description already explains the parameter. The tool description reiterates the same info, adding no extra 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?

Description clearly states the tool retrieves a single customer question by ID, specifies source of ID, and distinguishes from sibling 'trendyol_get_questions' which lists questions.

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?

Tells when to use (when you have a specific question ID) and where to get the ID. No explicit when-not or alternatives, but usage is implied given sibling list.

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

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

With no annotations, the description carries full responsibility. It discloses that Trendyol silently adjusts dates beyond 2 weeks and that this tool rejects such ranges to prevent data loss. It also mentions that userName is only filled if showUserName=true and that dates are epoch milliseconds. However, it references a parameter (showUserName) that does not exist in the input schema, which is a minor contradiction.

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 paragraph but is information-dense and front-loaded with the main purpose. Each sentence contributes unique value. It could benefit from bullet points for easier scanning, but it is not overly verbose.

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

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

For a listing tool with 8 parameters and no output schema, the description provides comprehensive context: it explains the response format (id, userName, dates), links to reference data for status descriptions, and gives cross-tool usage guidance for trendyol_create_answer and trendyol_get_question_by_id. It covers pagination, date filtering, and sorting options adequately.

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

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

All 8 parameters have descriptions in the schema (100% coverage), so the baseline is 3. The description adds significant value by explaining the date range constraint in detail, recommending status usage, and linking response fields to other tools. However, it mentions a non-existent parameter showUserName, which reduces reliability.

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

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

The description clearly states that the tool lists customer questions with pagination. It distinguishes itself from related tools like trendyol_get_question_by_id by explaining how the id from this tool can be used. The verb 'listele' (list) and resource 'sorular' (questions) are specific and unambiguous.

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

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

The description provides explicit guidance on when to use this tool (listing questions with pagination) and how to narrow down to answerable questions (status=WAITING_FOR_ANSWER). It also explains the date range limitation and recommends breaking long ranges into 2-week chunks. However, it does not explicitly state when to use alternative tools like trendyol_get_question_by_id for a single question.

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 discloses that the tool returns fixed lists and describes contents (e.g., settlement fields). Does not mention destructive actions or auth needs, acceptable for read-only tool.

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

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

Two sentences covering main content. Front-loaded with list of returned types. Could be more structured (e.g., bullet points) but overall efficient.

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

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

Given no output schema, description provides good overview of each reference data type and links to alternative tool. Sufficient for agent to decide 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 has 1 enum parameter with 0% description coverage. Description compensates by explaining what each kind of reference data contains (e.g., 'settlement_islem_turleri gives description, effect, signs').

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 'Returns fixed lists' and enumerates specific reference data types (return reasons, statuses, cargo companies, etc.), contrasting with sibling trendyol_get_claim_issue_reasons for rejection reasons.

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

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

Explicitly tells when to use the tool (to get reference data) and when to use an alternative (trendyol_get_claim_issue_reasons for full rejection reasons). Could be improved with more general when-not-to-use guidance.

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

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

No annotations provided, so the description carries full burden. It discloses key behaviors: settlements appear only after delivery, date range auto-batching, paymentOrderId creation timing, correction entry pairing, and store* field nullability. This is comprehensive beyond 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?

The description is lengthy but efficiently packed with essential details. It is structured logically: purpose, parameter interactions, date handling, payment info, correction notes, and field behavior. For a tool with 7 parameters and complex rules, this length is justified, though slightly verbose.

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

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

The tool has no output schema, so the description should explain return structure. It mentions store* fields and affiliate values but does not fully describe the response format or pagination. However, it covers most behavioral aspects and references other tools for detailed transaction type explanations, leaving minor 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%, but the description adds significant meaning: priority of transactionTypes over transactionType, automatic 15-day slicing, paymentDate expected as string, and correction entry relationships. These details go beyond basic parameter descriptions, helping the agent use parameters correctly.

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 what the tool does: 'Satış, iade, indirim, kupon ve provizyon işlemlerinin detaylarını getirir.' It specifies the resource (settlements) and verb (get details). Among siblings like trendyol_get_other_financials, it distinguishes as the settlement-specific financial tool.

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

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

The description provides detailed guidance on when to use the tool: after delivery, with date range limitations (max 15 days, auto-batched), single vs multiple transaction type selection, paymentOrderId usage, and cross-references to other tools for transaction type definitions. It also explains field behavior for different seller types, giving clear context for proper invocation.

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 output structure with fields like shipmentAddress, returningAddress, addressType, and defaultAddresses. Warns about prerequisite. No annotations exist, so the description carries full burden and does it well, though no mention of auth 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?

Multiple sentences but each adds value: primary purpose, usage details, and a crucial warning. No redundant words. Front-loaded with main 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 zero parameters and no output schema, the description fully covers the tool: what it returns, how to use the output, and a prerequisite condition. No 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?

Zero parameters with 100% schema coverage; description adds value by explaining how to interpret the response and map fields to product creation parameters. No omissions.

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 verb 'döndürür' (returns) and resource 'kayıtlı adresler' (registered addresses). Distinguishes from siblings by explicitly linking to product creation tool and explaining how address IDs are used.

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

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

Provides explicit context: used to obtain addresses for shipmentAddressId and returningAddressId in product creation. Includes a clear warning not to use before the application process is completed. No explicit alternatives, but the unique purpose makes usage 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 transparency burden. It discloses rate limit (1000 req/min), status lifecycle, and conditions for video publication and field population, which are key behavioral traits.

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

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

The description is two sentences, front-loaded with purpose, and every piece of information (rate limit, status meanings, conditions) 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?

The description covers essential context: rate limit, status explanations, and field conditions. However, no output schema exists and return structure is not described, leaving some gaps for a 4-parameter tool.

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

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

Schema coverage is low (25%). The description adds meaning for sellerIntegrationStatus by explaining status values and implications, but page and size parameters remain unexplained. Partial compensation.

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 the seller's integration videos, uses a specific verb (listeler), and the sibling tools include create_video and other operations, so it distinguishes itself as a read-only list operation.

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

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

The description provides status meanings and rate limit but does not specify when to use this tool over alternatives or give exclusion criteria. No explicit 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?

No annotations provided, so description carries full burden. It does not disclose behavioral traits such as whether it is read-only, pagination, filtering capabilities, or rate limits. Merely states it lists webhooks.

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

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

Single sentence that is clear, direct, and contains no unnecessary words. Efficiently conveys the purpose.

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

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

For a simple tool with no parameters and no output schema, the description is adequate. It tells what the tool does. However, adding context about output format or that it lists all webhooks without filters would improve completeness.

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

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

No parameters exist in the input schema, so description needs to add no parameter info. Baseline for 0 params is 4; description is sufficient given no parameters to document.

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

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

Description clearly states the action (list) and resource (registered webhooks) with specific scope (belonging to the seller). It distinguishes from sibling tools like register and delete webhooks.

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

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

No guidance on when to use this tool versus alternatives (e.g., register_webhook, delete_webhook). The description only states what it does, not when it's appropriate.

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

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

With no annotations provided, the description carries the full burden. It discloses the authentication mechanism (BASIC_AUTHENTICATION with fallback to API key/secret) and lists all subscribable statuses. However, it does not mention side effects, idempotency, or error scenarios.

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

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

The description is two sentences long. The first sentence states the core purpose, and the second sentence adds essential details (status list, authentication). No redundant or unnecessary information. Every sentence earns its place.

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

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

The description covers the main purpose and auth but lacks information about the return value (e.g., webhook ID or confirmation), error handling, or prerequisites (e.g., valid API credentials). Given no output schema, the description should explain what happens after registration, which is missing.

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 all 4 parameters. The description adds value beyond the schema by explaining the authentication fallback behavior and listing all valid statuses, which is not in the schema. This helps the agent understand parameter meaning and defaults.

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

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

The description clearly states the verb (kaydeder - registers), resource (webhook for sipariş durum değişiklikleri - order status changes), and lists the specific statuses. This distinguishes it from sibling tools like trendyol_delete_webhook and trendyol_get_webhooks.

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 when registering a webhook for order status changes, but it does not provide explicit guidance on when to use this tool versus alternatives (e.g., when to delete or get webhooks) or mention any prerequisites or exclusions.

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

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

With no annotations, the description adds substantial behavioral context: file type/size restrictions, future date prohibition, conditional mandatory fields, and specific error messages. Missing details on response format or rate limits, but covers key operational constraints.

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?

Four sentences; efficiently conveys action, constraints, and common errors. Front-loaded with primary purpose. Could trim some redundancy but overall well-structured.

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

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

For a file upload tool with no output schema, the description covers core functionality, constraints, conditional requirements, and frequent errors. Lacks response details but sufficient 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?

Schema coverage is 100% with good descriptions. Description adds context about when invoiceNumber/invoiceDateTime are required (micro export) and error conditions. Extra value is moderate; baseline 3 is appropriate.

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

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

Clearly states the tool uploads an invoice file (pdf, jpeg, png) for an order. Specifies file types and size limit. Does not explicitly differentiate from sibling tool trendyol_send_invoice_link, but the action of uploading vs sending a link is implied.

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 constraints (file size, future date not allowed) and mandatory fields for micro export/cross-border orders. Lists common errors but does not explicitly state when to use this tool versus sending an invoice link or other 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, description fully covers behavioral traits: how the link is used by Trendyol, legal requirement for 8-year accessibility, conditional parameter mandatory status, error causes, and recovery via delete tool. 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?

Description is detailed but every sentence adds unique context. Front-loaded with core purpose, then conditions, legal, errors, recovery. Could be slightly more concise, but no redundancy.

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

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

Covers all critical aspects: purpose, usage conditions, legal requirements, parameter dependencies, error handling, and recovery in case of mistakes. No output schema but error info compensates. Complete for a mutation tool with 4 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?

Despite 100% schema coverage, description adds significant value: explains which parameters are mandatory for which package types, legal context for invoiceLink, and pattern backgrounds. Goes beyond schema descriptions.

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

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

Describes specific verb (transmits) and resource (e-archive invoice link) and explains the flow: sends link to Trendyol, they email customer. Clearly distinguishes from sibling tools like trendyol_send_invoice_file and trendyol_delete_invoice_link.

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

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

Explicitly states when to use (when PDF cannot be sent to encrypted email) and provides alternatives (trendyol_delete_invoice_link). Also includes legal obligation, parameter conditions for specific package types, and error scenarios (HTTP 409) with corrective action.

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

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

No annotations are provided, so the description bears full responsibility. It correctly notes that the secret is masked, conveying read-only behavior. However, it omits details like authentication requirements or rate limits, which are not critical for such a simple 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 a single concise sentence with no wasted words. It is front-loaded with the essential purpose and a key detail (secret masking).

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

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

For a tool with no parameters and no output schema, the description fully covers its function. The detail about secret masking adds transparency. There are no gaps in 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 and 100% schema coverage. The description does not need to add parameter meaning. Per the rubric, no parameters warrant a baseline of 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 clearly states the tool shows the status of Trendyol API credentials with secret masking. It uses a specific verb ('gösterir' - shows) and resource ('API kimlik bilgileri'), and is distinct from siblings that perform actions on orders, products, 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 implies this tool is for checking credential status before other operations, but lacks explicit guidance on when to use it versus alternatives or exclusions. No context on prerequisites is provided.

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

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

No annotations are provided, so the description bears full responsibility. It discloses the action (unlocking) and its triggers, but omits details on side effects, permissions, 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?

The description is concise (three short sentences) and front-loaded with the core action. Every sentence adds value, though the mix of Turkish may slightly reduce clarity for non-Turkish agents.

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, no output schema), the description sufficiently covers purpose, precondition, and post-action check. No major gaps identified.

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 describes the single parameter 'barcodes' adequately, and the description adds no further nuance beyond 'barcodes to unlock.' With 100% schema coverage, baseline score 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 clearly states the tool unlocks products locked due to pricing or supply issues. It distinguishes itself from sibling tools like trendyol_filter_approved_products (which shows lock status) and trendyol_get_batch_request_result (for checking outcomes).

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

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

Provides explicit context: lock reasons are visible in trendyol_filter_approved_products response, and result should be checked with trendyol_get_batch_request_result. However, does not specify when not to use or 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?

Despite no annotations, the description discloses key behavioral traits: what fields are not updated, partial update behavior, and the requirement to send all attributes when updating any attribute. It mentions max items per request and references follow-up tools. It doesn't cover auth or rate limits but provides good transparency for a mutation 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 concise, front-loading the action and key constraints. It's a single paragraph but well-organized with clear conditions. Could be slightly more structured with bullets, but overall efficient and readable.

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 (1 parameter, no output schema, no annotations), the description covers usage, constraints, and post-action steps. It references related tools for result checking, which adds completeness. Minor omissions like error handling don't significantly detract.

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

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

Schema coverage is 0%, but the description adds meaning: it explains the contentId purpose, image URL requirements, and the critical rule that attribute updates require the full attributes array. This goes 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 verb (günceller/updates) and the resource (onaylı ürün içeriği/approved product content) with specific fields (başlık, açıklama, görsel, özellik). It distinguishes from siblings by focusing on approved products and content updates, not approvals or variant updates.

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

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

The description provides clear usage context: works with contentId, max 1000 items, partial update support with a crucial exception for attributes. It also directs users to related tools for batch results and QC audits. While it doesn't explicitly state when to use alternatives, the context is sufficient.

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

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

With no annotations, the description carries full burden. It discloses batch limit, non-updateable barcode, and partial update support. But it does not detail whether the operation is synchronous or asynchronous, nor error behavior. Adequate but not comprehensive.

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

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

Two sentences, front-loaded with purpose, then key details. No wasted words; efficient and well-structured.

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

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

The description mentions checking batch result but does not describe output schema or expected response format. For a mutation tool, it provides basic flow but lacks 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?

Schema description coverage is 0% (based on context), and the description only adds value for the barcode parameter (non-updateable). It does not explain other nested fields, leaving significant ambiguity for the agent.

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

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

The description clearly states it updates variant information of approved products with a batch limit of 1000 items. It uses a specific verb ('günceller') and resource ('onaylı ürün varyantları'), distinguishing it from sibling tools like trendyol_filter_approved_products or trendyol_update_approved_product_content.

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 explains that all fields except barcode can be updated and that partial updates are supported, guiding when to use. It also directs checking the batch request result for status. However, it does not explicitly compare to alternative tools or state 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?

No annotations provided, so description fully bears the burden. It reveals the tool is mutating, warns about a specific deduplication error, and explains that batch status field is not returned for stock-price updates, requiring item-level status checks. This is highly 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?

Description is a single paragraph of 4 sentences, front-loaded with purpose, then limit, clarification, warning, and follow-up. Clear and efficient, though could be slightly more concise.

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?

Tool has simple structure (one parameter with array of objects, no output schema). Description covers purpose, quantity meaning, duplication risk, and follow-up tool. Implies asynchronous behavior via reference to batch result. Lacks explicit mention of output format but sufficient given 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?

Schema description coverage is 0%, but description adds meaning for 'quantity' (satılabilir stok) and warns not to send unchanged data. It does not elaborate on barcode or prices beyond the schema's minimal descriptions. Repeats maxItems limit already in schema. Adds some value but not comprehensive.

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 verb 'günceller' and resource 'onaylı ürünlerin stok ve fiyatı'. It also specifies a per-request limit of 1000 SKU, distinguishing it from sibling tools like trendyol_filter_approved_products_inventory_and_price.

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 important guidance: clarifies quantity meaning, warns against resending unchanged data (15-minute deduplication error), and directs to use trendyol_get_batch_request_result for result checking with a note about batch status. Does not explicitly state when not to use, but the warning implies avoidance of duplicate identical requests.

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 barcode is immutable, the fastDeliveryType constraint, and the need to check batch result via another tool, implying async behavior. This is valuable behavioral context beyond basic 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 a short three-sentence paragraph that front-loads the main action and includes essential constraints and follow-up. Every sentence contributes useful information, but it could be slightly more structured for readability.

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

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

Given no output schema and complex nested parameters, the description provides key missing context: barcode immutability, batch size limit, and async result checking. It lacks explanation of error handling or input structure description, but is fairly complete for a batch update 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 0% except for deliveryDuration minimally. The description adds that all fields except barcode are updatable and the fastDeliveryType condition. However, it does not explain what deliveryDuration means (duration unit) or the meaning of fastDeliveryType enum values, leaving gaps.

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

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

The description clearly states the tool updates delivery information for approved products, with constraints like max 1000 items and barcode immutability. However, it does not explicitly distinguish it from sibling update tools for other product aspects (content, variants, price/inventory).

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 usage context (approved products, batch limit) and a specific condition for fastDeliveryType. It also mentions checking batch request result for async follow-up. But it lacks when-not-to-use guidance or explicit alternatives among siblings.

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

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

No annotations provided, so description carries full burden. It discloses the state change and that it's for STAGE environment (non-production). However, it does not mention prerequisites (e.g., initial status), side effects, or permissions needed. Adequate but could be more 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?

Two sentences: first states purpose and usage context, second provides parameter sourcing guidance. No redundancy, every sentence earns its place.

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

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

Given simple schema (single integer param) and no output schema, description adequately covers purpose, usage, and param source. Missing details like expected response or error conditions, but overall sufficient for a straightforward mutation.

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 a description for the parameter. The tool description adds value by explicitly stating the parameter can be obtained from trendyol_get_claims response field orderShipmentPackageId, which helps the agent source the correct value.

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 specific action: moving a claim to WaitingInAction status, and mentions it is for STAGE environment test scenarios. Differentiates from siblings like trendyol_approve_claim_items or trendyol_create_claim by targeting a specific status transition.

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

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

Explicitly says used for claim approval/rejection test scenarios, implying when to use. Provides guidance to get shipmentPackageId from trendyol_get_claims. Does not explicitly state when not to use or list alternatives, but 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?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It reveals the status progression order and environment scope but omits important details such as required permissions, side effects (e.g., whether it triggers real-world events), error handling, or rate limits. For a mutation tool that likely has real effects, this is insufficient.

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

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

The description is extremely concise with two sentences. The first sentence states the primary purpose, and the second provides vital context on status progression and ID sourcing. 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?

Given the tool's complexity (4 parameters, nested objects, no output schema), the description covers core aspects: environment, status sequence, and ID source. However, it does not describe the expected return value, error conditions, or what happens if the status transition is invalid. With no output schema, more explanation on response behavior would improve completeness.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds value by explaining where to get packageId and lineId (from trendyol_get_orders) and clarifying the status progression. However, it does not elaborate on the structure of the 'lines' array or the 'params' object beyond what the schema already provides. The added context is moderate.

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 updates the status of a test order package in the STAGE environment, specifies the status progression sequence, and explains how to obtain required IDs from another tool. This specificity differentiates it from sibling tools like trendyol_create_test_order or trendyol_get_orders.

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

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

The description provides clear context for when to use this tool: updating test order statuses in the STAGE environment. It explains the status flow and references trendyol_get_orders for ID retrieval. However, it does not explicitly state when not to use it or mention alternative tools for similar updates (e.g., for production orders).

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

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

No annotations provided, so description carries full burden. It discloses that only product info is updated (not stock/price), per-request limit of 1000 items, and asynchronous nature (batchRequestId). This adds value beyond schema and clarifies behavior.

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 in Turkish, front-loaded with purpose. Efficient but could benefit from bullet points or grouping of constraints (e.g., limits, async monitoring).

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 many parameters and no output schema or annotations, description omits prerequisites (e.g., product must be draft), response format, and detailed field explanations. Only mentions batch monitoring and category verification, leaving significant gaps.

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

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

Schema coverage is 0% (no property descriptions in schema). Description does not elaborate on the items array or individual parameters like barcode, title, images, etc. Agent receives no guidance on what fields are updatable, severely limiting usability.

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

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

Description clearly states it updates information of pending approval (draft) products, specifying verb (günceller) and resource (onay bekleyen ürünler). It differentiates from sibling update tools by targeting unapproved products.

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

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

Description advises verifying category/attribute info before update and suggests checking result with trendyol_get_batch_request_result. However, it does not explicitly state when not to use this tool versus alternatives (e.g., for approved products), relying on implicit differentiation from tool name.

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