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 this is a mutation tool (changes status from NEEDS_APPROVAL), mentions the workflow dependency, and describes the outcome ('allow delivery'). However, it doesn't cover permissions needed, error conditions, or rate limits.

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

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

The description is efficiently structured with a clear purpose statement, context, and separate Args/Returns sections. Every sentence adds value without redundancy, and the information is front-loaded appropriately.

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 mutation tool with no annotations but an output schema, the description provides good context about the workflow, prerequisites, and expected outcome. The presence of an output schema means the description doesn't need to detail return values, but could better address error cases 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?

With 0% schema description coverage and only one parameter, the description adds essential meaning by explaining what line_item_id represents ('The line item ID to approve'). This compensates well for the lack of schema documentation, though it doesn't provide format or validation details.

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

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

The description clearly states the tool's purpose with a specific verb ('Approve') and resource ('line item'), explicitly mentioning that it's for line items in NEEDS_APPROVAL status. It distinguishes from siblings like pause_line_item or resume_line_item by focusing on approval workflow.

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 about when to use it ('when the approval workflow is enabled' and 'Line items in NEEDS_APPROVAL status'), but doesn't explicitly state when NOT to use it or mention specific alternatives among the many sibling tools.

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

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

With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it describes the effect (hidden from UI, retrievable via API), notes irreversibility ('cannot be undone via API'), and implies a mutation (archive action). It lacks details on permissions or rate limits, but covers essential 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 well-structured and front-loaded with the core action, followed by behavioral details and parameter explanation. Every sentence adds value: the first states the purpose, the next two explain effects and usage, and the Args/Returns sections provide necessary technical details 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 1 parameter with 0% schema coverage and an output schema present, the description is mostly complete. It covers purpose, usage, behavioral traits, and parameter semantics adequately. The output schema handles return values, so the description doesn't need to detail them. It could improve by mentioning prerequisites or error cases, but it's sufficient for this 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 description coverage is 0%, but the description compensates by explaining the single parameter 'line_item_id' in the Args section, adding meaning beyond the schema's type definition. It clarifies this is 'The line item ID to archive', which is helpful context, though it doesn't specify format or constraints like valid ranges.

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 'archive' and resource 'line item', distinguishing it from siblings like 'pause_line_item', 'resume_line_item', or 'update_line_item_name'. It specifies that archived items are hidden from UI but retrievable via API, which adds specificity beyond just the action name.

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 usage ('useful for cleaning up old campaigns') and mentions a key limitation ('cannot be undone via API'), which helps differentiate from reversible actions. However, it does not explicitly name when to use alternatives like 'pause_line_item' or 'delete' operations, though the irreversible nature implies it's for permanent cleanup.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is an association operation but doesn't clarify whether this creates a new association, modifies an existing one, requires specific permissions, has side effects, or what happens with conflicts. The mention of 'Returns the association details' is minimal behavioral information.

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 efficiently structured with a clear purpose statement followed by parameter explanations and a return statement. Each sentence serves a purpose, though the parameter explanations could be more informative. The structure is front-loaded with the core 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 4-parameter mutation tool with no annotations, the description is minimally adequate. The presence of an output schema means it doesn't need to explain return values, but it lacks important context about behavioral implications, error conditions, and relationship to sibling tools. The parameter coverage is basic but 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 description explicitly lists all 4 parameters with brief explanations, which is valuable since schema description coverage is 0%. However, it doesn't explain the significance of creative/line item IDs, what size overrides actually do, or provide format/constraint details. The parameter explanations are basic but cover all 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 action ('Associate') and the resources involved ('a creative with a line item'), making the purpose immediately understandable. However, it doesn't differentiate from the sibling tool 'upload_and_associate_creative', which appears to be a related but distinct operation.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'upload_and_associate_creative' or 'list_creatives_by_line_item'. It doesn't mention prerequisites, dependencies, or contextual constraints for when this association should be performed.

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

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

With no annotations provided, the description carries full burden. It discloses the bulk operation, supported file formats, and that it returns results for all uploads, which adds useful behavioral context. However, it doesn't mention potential side effects (e.g., overwriting existing creatives), authentication needs, rate limits, or error handling for unsupported files.

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 well-structured with a purpose statement, parameter explanations, and additional notes. Every sentence adds value, though the 'Args:' section could be integrated more smoothly. It's appropriately sized for a 5-parameter tool with behavioral details.

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

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

Given no annotations, 0% schema coverage, but an output schema exists, the description provides good context. It covers purpose, parameters, supported formats, and return behavior. The output schema will handle return values, so the description doesn't need to detail them. Some gaps remain in behavioral transparency.

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

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

Schema description coverage is 0%, so the description must compensate. It provides clear semantic meaning for all 5 parameters: folder_path specifies the source, advertiser_id and line_item_id identify targets, click_through_url defines the destination, and name_prefix is optional for naming. This adds significant value beyond the bare schema types.

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 specific action ('Upload all creatives from a folder and associate with a line item'), identifies the resource ('creatives'), and distinguishes from siblings like 'upload_creative' (singular) and 'upload_and_associate_creative' (which might handle single files). The bulk nature and folder-based approach are explicitly stated.

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 you have multiple creatives in a folder to upload and associate with a line item, but doesn't explicitly state when to use this vs. alternatives like 'upload_creative' (for single files) or 'associate_creative_with_line_item' (for existing creatives). No explicit exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It mentions the tool returns 'delivery progress including impressions, clicks, and goal progress,' which adds some behavioral context beyond the input schema. However, it lacks details on permissions, rate limits, error handling, or whether it's read-only (implied but not stated). For a tool with no annotations, this is a significant gap.

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 and front-loaded: the first sentence states the purpose clearly, followed by brief sections for args and returns. Every sentence earns its place with no redundancy or fluff, making it easy to scan.

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

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

Given the tool's moderate complexity (single parameter, delivery-focused), the description is fairly complete. It covers purpose, parameter semantics, and return content. Since an output schema exists, it doesn't need to detail return values. However, with no annotations, it could better address behavioral aspects like safety or constraints.

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

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

The description adds meaning beyond the input schema, which has 0% coverage. It explains that 'line_item_id' is 'The line item ID to check,' clarifying its role. With only one parameter, this is sufficient to compensate for the low schema coverage, though it doesn't specify format constraints (e.g., integer range). Baseline would be 3 if schema coverage were high, but here it's effective.

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

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

The description clearly states the tool's purpose: 'Check detailed delivery status for a line item.' It specifies the verb ('check') and resource ('line item'), and distinguishes it from siblings like 'get_line_item' (which likely retrieves basic metadata) by focusing on delivery metrics. However, it doesn't explicitly contrast with 'run_delivery_report' (which might be broader), so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention siblings like 'get_line_item' (for general info) or 'run_delivery_report' (for broader reporting), nor does it specify prerequisites (e.g., only for active line items). Usage is implied by the purpose but not explicitly 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Create a new advertiser' which implies a write operation, but lacks details on permissions needed, whether the operation is idempotent, error handling, or rate limits. The mention of returning 'created advertiser details' is minimal and doesn't fully describe output 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?

The description is well-structured with a clear purpose statement followed by 'Args:' and 'Returns:' sections. It's appropriately sized with no redundant information, though the 'Args:' section could be slightly more detailed without sacrificing conciseness.

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

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

Given that there's an output schema (which handles return values) but no annotations and low schema coverage, the description is moderately complete. It covers the basic purpose and parameters but lacks behavioral context and usage guidelines, making it adequate but with clear gaps for a creation tool in a complex sibling environment.

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

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

Schema description coverage is 0%, so the description must compensate. It lists the three parameters (name, email, address) and indicates that email and address are optional, which adds some meaning beyond the schema. However, it doesn't provide format details (e.g., email validation, address structure) or constraints, leaving gaps in 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 action ('Create a new advertiser') and resource ('advertiser'), which is specific and unambiguous. However, it doesn't differentiate from sibling tools like 'find_or_create_advertiser' or 'get_advertiser', which would require explicit comparison to achieve a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'find_or_create_advertiser' or 'list_advertisers'. It also doesn't mention prerequisites, such as whether the advertiser must be unique or if there are any constraints on creation.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does well by describing the multi-step workflow behavior and what gets created/modified. However, it lacks important behavioral details like whether this requires special permissions, whether operations are atomic/rollback on failure, rate limits, or what happens when entities already exist (beyond 'finds or creates').

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 well-structured with a clear purpose statement upfront, followed by parameter explanations, then workflow steps, and finally return information. While comprehensive, some sentences could be more concise (e.g., the creative_sizes example could be simplified). Overall, most content earns its place given the tool's complexity.

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 complex 12-parameter workflow tool with no annotations, the description provides substantial context about the multi-step process, parameter meanings, and expected outcomes. The presence of an output schema reduces the need to describe return values. However, given the tool's complexity and mutation nature, it could benefit from more behavioral warnings or prerequisites.

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?

Given 0% schema description coverage and 12 parameters, the description provides excellent parameter semantics. It clearly explains each parameter's purpose with specific examples (e.g., creative_sizes JSON format, end_month range 1-12, target_ad_unit_id source). This fully compensates for the schema's lack of descriptions and adds crucial context beyond basic type 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 specific action ('Create a complete campaign') and enumerates the exact sequence of operations performed (find/create advertiser, order, line item, upload creatives). It explicitly distinguishes this comprehensive workflow from sibling tools that handle individual components like create_advertiser, create_order, or upload_creative.

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 by stating it's a 'complete workflow' that handles multiple steps. It implicitly suggests using this instead of individual sibling tools when creating an entire campaign from scratch. However, it doesn't explicitly state when NOT to use it or mention specific alternatives for partial updates.

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

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

With no annotations provided, the description carries full burden. It states this is a creation operation but doesn't disclose behavioral aspects like required permissions, whether this is a mutating operation with side effects, rate limits, or what happens if validation fails. The description mentions default values but doesn't explain creation consequences 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?

Well-structured with clear sections (purpose, Args with detailed parameter explanations, Returns). While comprehensive due to many parameters, each sentence adds value. The line_item_type enumeration is necessary but makes it somewhat dense. Front-loaded with the core purpose first.

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 (11 parameters, creation operation, no annotations) and the presence of an output schema (so return values don't need description), the description is mostly complete. It thoroughly documents parameters but lacks behavioral context about permissions, side effects, or error handling that would be important for a creation 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 0% schema description coverage for 11 parameters, the description provides extensive parameter documentation beyond the schema. It explains each parameter's purpose, provides examples (e.g., end_year format, creative_sizes JSON format), lists valid line_item_type values with explanations, and specifies defaults where applicable, fully compensating for the schema's lack of 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 creates a new line item for an order with the verb 'Create' and resource 'line item'. It distinguishes from siblings like 'update_line_item_name' or 'duplicate_line_item' by specifying it's for creation, but doesn't explicitly contrast with all alternatives like 'create_order' or 'create_campaign'.

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 like 'create_order' or 'duplicate_line_item'. The description mentions prerequisites (order_id, target_ad_unit_id) but doesn't provide context about appropriate scenarios or exclusions for this specific creation operation.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a creation operation, implying it's a write/mutation tool, but doesn't cover critical aspects like required permissions, whether it's idempotent, error handling, or rate limits. The mention of returning 'created order details' hints at output but lacks detail on format or structure.

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 well-structured and appropriately sized. It front-loads the purpose in the first sentence, then lists parameters with brief explanations, and ends with return information. There's no wasted text, though the 'Args:' and 'Returns' formatting could be slightly more integrated for flow.

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 an output schema (which handles return values) and only 2 parameters with 0% schema coverage, the description does a decent job. It covers the purpose and parameter semantics adequately. However, as a mutation tool with no annotations, it lacks behavioral details like error cases or side effects, making it incomplete for safe agent use.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful context for both parameters: 'order_name: Name for the new order' and 'advertiser_id: ID of the advertiser company'. This clarifies what each parameter represents beyond just their types, though it doesn't specify constraints like name length or advertiser ID format.

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

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

The description clearly states the tool's purpose: 'Create a new order for an advertiser.' This specifies the verb ('Create'), resource ('order'), and context ('for an advertiser'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'find_or_create_order' or 'get_order', which would be needed for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether the advertiser must exist first), compare it to similar tools like 'find_or_create_order', or specify scenarios where it's appropriate. This leaves the agent without context for tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly indicates this is a creation/mutation operation ('Create', 'Returns the created creative details'), which is helpful. However, it doesn't mention important behavioral aspects like required permissions, whether this operation is idempotent, rate limits, or error conditions. The SafeFrame compatibility note is useful context but doesn't fully compensate for the missing behavioral information.

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 perfectly structured and concise. It begins with a clear purpose statement, provides usage context, then systematically documents parameters with helpful explanations, and ends with return information. Every sentence earns its place, with no redundant or unnecessary information. The information is well-organized and easy to parse.

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

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

Given the complexity of a 7-parameter creation tool with no annotations, the description does an excellent job covering the essentials. The parameter explanations are thorough, and the presence of an output schema means the description doesn't need to detail return values. However, for a mutation tool with no annotations, it could benefit from more behavioral context about permissions, side effects, or error handling to be 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?

With 0% schema description coverage, the description provides excellent parameter semantics through the 'Args:' section that clearly explains each of the 7 parameters. It adds meaningful context beyond the bare schema - explaining what 'advertiser_id' represents, clarifying that width/height are in pixels, describing what 'snippet' contains, explaining the purpose of 'expanded_snippet', and providing the default for 'is_safe_frame_compatible'. This fully compensates for the lack of schema descriptions.

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

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

The description clearly states the specific action ('Create a third-party creative') and resource type ('HTML/JavaScript ad tag'), with explicit examples of what it's used for (DCM/Campaign Manager tags, custom HTML ads, third-party ad server tags). It distinguishes itself from sibling tools like 'upload_creative' or 'bulk_upload_creatives' by specifying it's for third-party creatives with HTML/JavaScript code snippets.

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 about when to use this tool ('Use this for DCM/Campaign Manager tags, custom HTML ads, or any third-party ad server tags'), which helps differentiate it from other creative-related tools. However, it doesn't explicitly state when NOT to use it or mention specific alternatives among the sibling tools for different creative types.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool duplicates a line item and returns details of both items, but doesn't cover critical aspects like permissions required, whether this is a read-only or mutation operation, potential side effects (e.g., impact on associated campaigns or orders), or error handling. For a tool that likely modifies data, this is a significant gap in 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 well-structured and concise, with a clear purpose statement followed by parameter explanations and return information. Each sentence adds value without redundancy. It could be slightly more front-loaded by integrating parameter hints into the main sentence, but overall it's efficient and easy to parse.

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

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

Given that there's an output schema (which handles return values), no annotations, and 3 parameters with good semantic coverage in the description, the description is moderately complete. It explains what the tool does and what parameters mean, but lacks behavioral details (e.g., mutation effects, error cases) and usage guidelines relative to siblings, which are important for a tool in a crowded namespace.

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 meaningful context for all three parameters beyond the input schema, which has 0% description coverage. It explains that 'source_line_item_id' identifies the item to duplicate, 'new_name' is for the new item, and 'rename_source' is optional for renaming the original. This clarifies the purpose and relationships of each parameter, compensating well for the schema's lack of 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's purpose: 'Duplicate an existing line item.' It specifies the verb ('duplicate') and resource ('line item'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'create_line_item' or 'update_line_item_name', which would require more specific context about when duplication is preferred over creation or modification.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention scenarios where duplication is appropriate (e.g., copying configurations) or when other tools like 'create_line_item' might be better. With many sibling tools available, this lack of context leaves the agent without clear usage direction.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns a list of matching advertisers, which is useful, but lacks details on permissions, rate limits, pagination, or error handling. For a search tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves in practice.

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 and front-loaded: the first sentence states the core purpose, followed by structured 'Args' and 'Returns' sections. Each sentence earns its place by providing essential information without redundancy. Minor improvements could include integrating the sections more fluidly, but it's efficient overall.

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 low complexity (one parameter, no nested objects) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the purpose, parameter meaning, and return type. However, it lacks behavioral details like error cases or performance expectations, which would enhance completeness for a search operation.

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

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

The schema has 0% description coverage, but the description compensates by explaining the 'name' parameter as 'Advertiser name to search for' and noting it's a 'partial match.' This adds crucial context beyond the bare schema, clarifying the search behavior. With only one parameter, the description effectively covers its semantics, though it could mention case sensitivity or formatting.

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

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

The description clearly states the tool's purpose: 'Find an advertiser by name (partial match).' It specifies the verb ('find'), resource ('advertiser'), and search method ('partial match'), which is specific and actionable. However, it doesn't explicitly differentiate from siblings like 'get_advertiser' or 'list_advertisers', which likely have different scopes or matching behaviors.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention siblings such as 'get_advertiser' (likely for exact matches or IDs), 'list_advertisers' (likely for unfiltered lists), or 'find_or_create_advertiser' (which combines search and creation). Without this context, users must infer usage from tool names alone.

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

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

No annotations are provided, so the description carries full burden. It discloses the tool's conditional behavior (find or create based on existence) and that email is used only for creation. However, it lacks details on permissions needed, rate limits, error handling, or what 'exact name' entails (case-sensitivity, whitespace). The description adds some behavioral context but not comprehensive coverage 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 front-loaded with the core purpose in the first sentence, followed by clear sections for Args and Returns. Every sentence earns its place by providing essential information without redundancy, and the structure is logical and easy to parse.

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

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

Given no annotations, 0% schema coverage, but an output schema exists, the description is reasonably complete. It covers purpose, parameters, and return value adequately. However, as a mutation tool with conditional behavior, it could benefit from more behavioral details (e.g., idempotency, error cases) to be fully comprehensive.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that 'name' is for exact advertiser name matching and 'email' is optional and used only if creating. This adds crucial semantic meaning beyond the schema's basic types, though it doesn't detail format constraints (e.g., email validation).

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

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

The description clearly states the tool's purpose with specific verbs ('find' and 'create') and resource ('advertiser'), and distinguishes it from siblings like 'find_advertiser' (find only) and 'create_advertiser' (create only) by combining both operations. The first sentence explicitly defines the dual functionality.

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

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

The description provides explicit usage guidance: use this tool to find an advertiser by exact name or create one if not found. It implicitly distinguishes from alternatives like 'find_advertiser' (for lookup only) and 'create_advertiser' (for creation only), and specifies the condition ('if not found') for when creation occurs.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool can find or create an order, which implies mutation capabilities, but doesn't describe any behavioral traits such as permissions needed, whether creation is idempotent, error handling, or rate limits. This leaves significant gaps for an agent to understand how to use it safely and effectively.

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 and front-loaded: the first sentence states the core purpose clearly, followed by a structured 'Args' and 'Returns' section. Every sentence earns its place without redundancy, making it efficient and easy to parse.

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

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

Given that there is an output schema (which handles return values), no annotations, and low schema coverage, the description provides a basic but incomplete picture. It covers the purpose and parameters superficially but lacks behavioral context and detailed usage guidelines. For a mutation tool with no annotations, this is minimally adequate but has clear gaps in helping an agent use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It lists the parameters ('order_name' and 'advertiser_id') and provides basic semantics ('Name of the order' and 'ID of the advertiser company'), adding value beyond the bare schema. However, it doesn't explain format constraints, relationships between parameters, or what happens if an order with the same name exists under a different advertiser, leaving room for improvement.

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

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

The description clearly states the tool's purpose: 'Find an existing order by name or create a new one.' It specifies the verb (find or create) and resource (order), making the intent unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'create_order' or 'get_order', which would be needed for a perfect score.

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 context through the phrase 'Find an existing order by name or create a new one,' suggesting it should be used when you want to ensure an order exists without checking separately. However, it lacks explicit guidance on when to use this versus alternatives like 'create_order' or 'get_order', and doesn't mention any 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'Returns advertiser details,' which implies a read-only operation, but does not clarify aspects like authentication needs, rate limits, error handling, or what specific details are included in the return. For a tool with no annotation coverage, this is insufficient to inform the agent fully.

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 and front-loaded, with the core purpose stated first ('Get advertiser details by ID.') followed by parameter and return details. It avoids unnecessary elaboration, though the 'Args:' and 'Returns advertiser details.' sections could be more integrated for better flow. Overall, it is efficient with minimal waste.

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

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

Given the tool's low complexity (one parameter) and the presence of an output schema (which handles return values), the description is moderately complete. It covers the basic purpose and parameter semantics but lacks behavioral details and usage guidelines. With no annotations, it should provide more context on how the tool behaves, but the output schema reduces the need for return value explanation.

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 meaningful context for the single parameter: 'advertiser_id: The advertiser/company ID.' This clarifies that the ID refers to an advertiser or company, which is not evident from the schema alone (which only specifies 'type: integer'). With 0% schema description coverage and only one parameter, the description effectively compensates by providing essential semantic information.

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

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

The description clearly states the tool's purpose: 'Get advertiser details by ID.' This specifies the verb ('Get'), resource ('advertiser details'), and key input ('by ID'). However, it does not explicitly differentiate from sibling tools like 'find_advertiser' or 'list_advertisers,' which likely serve similar but distinct purposes, preventing a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions the required 'advertiser_id' but does not specify prerequisites, context, or exclusions, such as when to prefer 'find_advertiser' or 'list_advertisers' from the sibling list. This lack of usage context leaves the agent with minimal direction.

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 this is a read operation ('Get'), but doesn't disclose behavioral traits like authentication requirements, rate limits, error handling, or what happens if the ID doesn't exist. The mention of return details is minimal and doesn't cover format or structure beyond mentioning 'size and destination URL'.

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 and front-loaded: the first sentence states the core purpose, followed by a clear 'Args' and 'Returns' section. Every sentence earns its place with no redundant information, making it efficient and well-structured for quick understanding.

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

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

Given the tool's low complexity (single parameter, simple retrieval) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the basic purpose and parameter, though it could benefit from more behavioral context. The output schema reduces the need for detailed return explanations.

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

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

Schema description coverage is 0%, so the description must compensate. It adds that 'creative_id' is 'The creative ID', which provides basic semantics but lacks details like format constraints, valid ranges, or examples. Since there's only one parameter, the baseline is 4, but the minimal added value reduces this to 3.

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

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

The description clearly states the tool's purpose: 'Get creative details by ID' specifies the verb (get) and resource (creative details). It distinguishes from siblings like 'list_creatives_by_advertiser' by focusing on retrieval by ID rather than listing. However, it doesn't explicitly differentiate from 'get_creative_preview_url' which also retrieves creative-related data.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose 'get_creative' over 'list_creatives_by_advertiser' or 'get_creative_preview_url', nor does it specify prerequisites or context for usage. The only implied usage is when you have a creative ID, but this is obvious from the parameter.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains what the tool generates (a preview URL that loads the site with creative displayed) and that the URL can be opened in a browser, which is useful context. However, it doesn't mention important behavioral aspects like whether this requires specific permissions, if the URL is time-limited, rate limits, or whether it triggers any side effects in the system.

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 perfectly structured and concise: a clear purpose statement, elaboration of what the preview does, organized parameter explanations with an example, and a clear returns statement. Every sentence earns its place with no wasted words, and the most important information (what the tool does) is front-loaded.

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

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

Given the tool has an output schema (which handles return value documentation) and the description provides excellent parameter semantics despite 0% schema coverage, this is quite complete. The only gap is the lack of behavioral context about permissions, URL expiration, or side effects, which would be valuable for a preview generation tool.

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

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

The schema description coverage is 0%, so the description must fully compensate. It provides excellent parameter semantics: clearly explaining what each parameter represents (line_item_id, creative_id, site_url) and giving a concrete example for site_url ('e.g., "https://abc.com"'). This adds substantial meaning beyond the bare schema types.

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 specific action ('Get a preview URL') and the target resource ('for a creative associated with a line item'), distinguishing it from sibling tools like get_creative or get_line_item which retrieve metadata rather than generate previews. The verb 'generates' further clarifies this is a creation/rendering operation rather than a simple retrieval.

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

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

The description provides clear context about when to use this tool: when you need to see how a creative will appear on a specific site. However, it doesn't explicitly state when NOT to use it or mention alternatives like get_creative (which returns creative metadata without preview) or verify_line_item_setup (which might check creative compatibility).

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a read operation ('Get') and mentions what information is returned, but doesn't cover important aspects like authentication requirements, rate limits, error handling, or whether this is a safe/idempotent operation. The description adds minimal behavioral context beyond the basic purpose.

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 perfectly concise and well-structured: a clear purpose statement followed by parameter and return value documentation in separate sections. Every sentence adds value with zero waste, making it easy to parse and understand quickly.

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 simple nature (single parameter read operation) and the presence of an output schema (which handles return value documentation), the description is reasonably complete. It covers the purpose, parameter meaning, and return content at a high level. The main gap is lack of behavioral context that would be important for a production API tool.

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

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

The description explicitly documents the single parameter ('line_item_id') and its purpose, though the schema already shows it's a required integer. With 0% schema description coverage, the description compensates adequately by explaining what the parameter represents, but doesn't add format details or constraints beyond what's inferable from 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 purpose with a specific verb ('Get') and resource ('line item details by ID'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_order' or 'get_advertiser' beyond the resource name, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'list_line_items_by_order' or 'check_line_item_delivery_status'. It mentions the required parameter but offers no context about prerequisites, error conditions, or typical use cases.

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

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

No annotations are provided, so the description carries the full burden. It states the tool returns 'order details including all line items', which gives some behavioral insight into the output. However, it doesn't disclose critical traits like whether this is a read-only operation (implied by 'Get' but not explicit), error handling (e.g., what happens if no order matches), authentication needs, rate limits, or side effects. For a retrieval tool with zero annotation coverage, this leaves significant gaps.

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

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

The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by a structured 'Args' section and a 'Returns' statement. Each sentence earns its place by adding value (parameter guidance and output scope). It could be slightly more concise by integrating the parameter notes into a single flow, but it's efficient overall.

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 low complexity (2 optional parameters), no annotations, but with an output schema present, the description is reasonably complete. It covers the purpose, parameter semantics, and output scope ('including all line items'), and the output schema will handle return value details. For a simple retrieval tool, this provides adequate context, though it could benefit from more behavioral transparency.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics: it explains that 'order_id' and 'order_name' are alternative identifiers (one optional if the other is provided), which clarifies their mutual exclusivity and purpose beyond the schema's basic types. This addresses the coverage gap effectively, though it doesn't detail format constraints (e.g., ID integer ranges or name string patterns).

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

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

The description clearly states the tool's purpose: 'Get order details by ID or name' with a specific verb ('Get') and resource ('order details'). It distinguishes itself from siblings like 'list_delivering_orders' or 'find_or_create_order' by focusing on retrieving details for a specific order. However, it doesn't explicitly differentiate from 'get_line_item' or other retrieval tools beyond the resource type.

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

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

The description implies usage through the parameter documentation ('optional if order_name provided' and vice versa), suggesting this tool is for retrieving a specific order when you have an identifier. It doesn't explicitly state when to use this vs. alternatives like 'find_or_create_order' or 'list_delivering_orders', nor does it mention prerequisites or exclusions. The guidance is functional but lacks strategic context.

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

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

No annotations are provided, so the description carries full burden. It mentions returning a list and a default limit, but lacks critical behavioral details: pagination behavior, sorting order, authentication requirements, rate limits, or whether it's a read-only operation. For a list tool with zero annotation coverage, this leaves significant gaps.

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

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

The description is appropriately sized with three brief sentences that are front-loaded (purpose first, then args, then returns). No wasted words, though the structure could be slightly more polished (e.g., combining the last two sentences).

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 low complexity (single optional parameter) and presence of an output schema (which handles return values), the description is minimally adequate. However, with no annotations and incomplete behavioral disclosure, it doesn't fully prepare an agent for reliable usage in a real system context.

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

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

With 0% schema description coverage and only one parameter, the description adds meaningful context by explaining 'limit' controls maximum number returned and providing the default value (100). This compensates well for the schema gap, though it doesn't specify minimum/maximum bounds or what happens when limit is exceeded.

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

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

The description clearly states the verb ('List') and resource ('advertisers'), making the purpose immediately understandable. It distinguishes from siblings like 'get_advertiser' (singular retrieval) and 'find_advertiser' (search-based). However, it doesn't specify if this lists all advertisers globally or within a specific scope, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'find_advertiser' (search-based) and 'get_advertiser' (single retrieval), there's no indication of when bulk listing is preferred over targeted lookups, nor any prerequisites or exclusions 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it 'Returns list of creatives', implying a read-only operation, but lacks details on permissions, rate limits, pagination (beyond the limit parameter), or error handling. For a list tool with zero annotation coverage, this is a significant gap in 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 appropriately sized and front-loaded with the core purpose in the first sentence. The Args and Returns sections are structured clearly, though 'Returns list of creatives' could be more specific (e.g., 'Returns a list of creative objects'). Overall, it's efficient with minimal waste.

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

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

Given the tool's low complexity (2 parameters, list operation) and the presence of an output schema (which handles return value documentation), the description is mostly adequate. However, with no annotations and 0% schema coverage, it should provide more behavioral context (e.g., pagination, errors) to be fully complete for agent use.

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

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

Schema description coverage is 0%, so the schema provides no parameter descriptions. The description adds basic semantics for both parameters: 'advertiser_id: The advertiser ID' and 'limit: Maximum number of creatives to return (default: 100)'. This compensates partially, but it doesn't explain format constraints (e.g., integer ranges) or usage context, 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's purpose with 'List creatives for an advertiser', specifying the verb ('List') and resource ('creatives'), and it distinguishes from siblings like 'list_creatives_by_line_item' by specifying the advertiser scope. However, it doesn't explicitly contrast with 'get_creative' (which fetches a single creative), slightly reducing specificity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose it over 'list_creatives_by_line_item' (for line-item-specific listing) or 'get_creative' (for single creative details), nor does it indicate prerequisites like needing an advertiser ID from tools like 'get_advertiser'.

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 mentions the tool returns a list with 'association status,' which adds some behavioral context beyond a basic list operation. However, it lacks details on permissions, rate limits, pagination, or error handling, which are critical for a tool with potential data access implications.

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

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

The description is well-structured and front-loaded with the core purpose, followed by a concise breakdown of args and returns. Every sentence earns its place, with no redundant or verbose language. It efficiently communicates essential information in a compact format.

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

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

Given the tool's moderate complexity (2 parameters, no annotations, but with an output schema), the description is reasonably complete. It covers the purpose, parameters, and return type. Since an output schema exists, it doesn't need to detail return values. However, it could improve by addressing usage context or behavioral traits like error cases.

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

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

Schema description coverage is 0%, so the description must compensate. It explains both parameters: 'line_item_id' as the identifier for the line item and 'limit' as the maximum number of creatives to return with a default. This adds clear meaning beyond the schema's type definitions, though it doesn't cover validation rules or examples.

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

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

The description clearly states the tool's purpose: 'List creatives associated with a line item.' It specifies the verb ('list') and resource ('creatives'), and distinguishes it from siblings like 'list_creatives_by_advertiser' by focusing on line items. However, it doesn't explicitly differentiate from other list tools in terms of scope or filtering capabilities.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, compare it to siblings like 'get_creative' or 'list_creatives_by_advertiser', or specify scenarios where it's appropriate. The agent must infer usage from the name and description alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that the tool returns 'a list of orders with their delivering line items, including impression and click statistics,' which adds some context about output content. However, it fails to address critical behavioral aspects such as whether this is a read-only operation, potential rate limits, authentication requirements, or any side effects, which are significant gaps for a tool with no annotation coverage.

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

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

The description is highly concise and well-structured, consisting of two sentences that efficiently convey the tool's purpose and output. Every sentence earns its place without any wasted words, making it easy to parse and understand quickly.

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

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

Given that there is an output schema (which should detail the return values), the description does not need to explain return values, and it adequately covers the tool's purpose. However, with no annotations and multiple sibling tools, the description lacks completeness in terms of usage guidelines and behavioral transparency, leaving gaps that could hinder an agent's ability to use the tool effectively in context.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description does not add any parameter information, which is appropriate in this case. Since there are no parameters, the baseline score is 4, as the description does not need to compensate for any gaps in 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's purpose: 'List all orders with line items currently delivering ads.' It specifies the verb ('List') and resource ('orders with line items currently delivering ads'), which is precise. However, it does not explicitly differentiate from sibling tools like 'list_line_items_by_order' or 'run_delivery_report', which might offer overlapping functionality, so it misses the top score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It lacks any mention of prerequisites, exclusions, or comparisons to sibling tools such as 'list_line_items_by_order' or 'run_delivery_report', leaving the agent to infer usage context without explicit direction.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the return format ('list of line items with their status and statistics'), which adds some context beyond the input schema. However, it lacks critical details: whether this is a read-only operation, if it requires specific permissions, pagination behavior, or error handling. For a list tool with zero annotation coverage, this is a significant gap.

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 and front-loaded: the first sentence states the purpose clearly, followed by structured 'Args' and 'Returns' sections. Every sentence earns its place by providing essential information. However, the 'Args' section is redundant with the input schema (though helpful given 0% coverage), and it could be more concise by integrating the return info into the main description.

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 low complexity (one parameter, list operation) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the purpose, parameter meaning, and return content. However, it lacks behavioral context (e.g., safety, permissions) and usage guidelines, which are notable gaps for a tool with no annotations.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for the single parameter 'order_id' by explaining it's 'The order ID' and that the tool lists line items for that order. This clarifies the parameter's role beyond the schema's type (integer). With only one parameter, the description adequately covers its semantics, though it doesn't specify format constraints (e.g., valid ID range).

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

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

The description clearly states the tool's purpose: 'List all line items for an order.' It specifies the verb ('List') and resource ('line items'), and distinguishes it from siblings like 'get_line_item' (singular) or 'list_creatives_by_line_item' (different resource). However, it doesn't explicitly differentiate from 'list_delivering_orders' (orders vs. line items), though the distinction is implied by the resource focus.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention siblings like 'get_line_item' (for a single line item) or 'list_creatives_by_line_item' (for related resources), nor does it specify prerequisites (e.g., requires an existing order). Usage is implied by the name and description but not explicitly 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the operational effect ('stops the line item from delivering ads') and mentions the action is reversible ('can be resumed later'), which is valuable context. However, it doesn't address potential side effects, permissions required, or error conditions that might occur when pausing.

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 efficiently structured with a clear purpose statement first, followed by behavioral explanation, usage context with alternative tool, and parameter documentation. Every sentence adds value without redundancy, and the information is appropriately 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 single-parameter mutation tool with no annotations but an output schema, the description provides good coverage: clear purpose, behavioral effect, reversibility context, and parameter semantics. The presence of an output schema means the description doesn't need to detail return values. The main gap is lack of information about permissions or potential side effects.

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 provides the parameter name ('line_item_id') and clarifies its purpose ('The line item ID to pause'), adding meaningful context beyond the schema's basic type information. With 0% schema description coverage and only 1 parameter, this adequately compensates for the schema's lack of semantic documentation.

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

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

The description clearly states the specific action ('pause a delivering line item') and the resource affected ('line item'), distinguishing it from siblings like resume_line_item (which reverses the action) and archive_line_item (which is a different state change). The phrase 'stops the line item from delivering ads' provides concrete operational context.

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

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

The description explicitly states when to use this tool ('pause a delivering line item') and when not to use it (implied: only for line items currently delivering). It names the alternative tool ('resume_line_item') for reversing the action, providing clear sibling differentiation and 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?

No annotations are provided, so the description carries the full burden. It mentions that resuming allows ad delivery based on schedule and targeting, which adds some behavioral context, but lacks details on permissions, rate limits, or side effects like whether it affects billing or requires approval.

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

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

The description is front-loaded with the core purpose, followed by brief context and structured sections for args and returns. Every sentence adds value without redundancy, making it efficient and well-organized.

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

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

Given the tool's moderate complexity (a mutation action), no annotations, and an output schema present, the description covers purpose and parameters adequately. However, it could benefit from more behavioral details, such as prerequisites or error conditions, to be fully complete.

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

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

Schema description coverage is 0%, but the description compensates by explaining that 'line_item_id' is 'The line item ID to resume,' adding meaning beyond the schema's type definition. With only one parameter, this is sufficient for clarity.

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 ('resume') and resource ('paused line item'), specifying that it restarts ad delivery based on schedule and targeting. It distinguishes from sibling tools like 'pause_line_item' by describing the opposite action.

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 context by stating 'previously paused line item,' indicating when to use this tool. However, it doesn't explicitly mention when not to use it or name alternatives, such as whether to use 'update_line_item_name' for other modifications.

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 mentions 'Returns report data' and includes a timeout parameter, which adds some behavioral context about asynchronous processing. However, it doesn't disclose important traits like whether this is a read-only operation, what permissions are required, rate limits, error conditions, or the format/structure of the returned data.

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 well-structured with a clear purpose statement followed by detailed parameter documentation. While comprehensive, some information could be more efficiently presented (e.g., the long lists of valid dimensions/metrics). Every sentence serves a purpose, but there's minor room for optimization in the parameter explanations.

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 (11 parameters, no annotations, but has output schema), the description provides strong parameter documentation but lacks behavioral context. The existence of an output schema means the description doesn't need to explain return values, but it should still cover operational aspects like permissions, rate limits, and error handling for a reporting tool of this complexity.

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

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

With 0% schema description coverage and 11 parameters, the description compensates excellently. It provides detailed explanations for all parameters including valid values for dimensions, metrics, and date_range_type, examples of JSON array formatting, and clarifies the relationship between date_range_type and the individual date parameters. This adds substantial meaning beyond what the bare 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's purpose: 'Run a custom report with specified dimensions and metrics.' This is a specific verb+resource combination. However, it doesn't explicitly distinguish this custom report tool from sibling reporting tools like 'run_delivery_report' and 'run_inventory_report', which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'run_delivery_report' and 'run_inventory_report' available, there's no indication of when a custom report is preferable to these specialized reports or what distinguishes this tool's use case.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions a timeout parameter (120 seconds default) which hints at potential long-running operations, but doesn't address other important behavioral aspects like whether this is a read-only operation, if it requires specific permissions, rate limits, or what happens when the timeout is exceeded. The description is functional but lacks comprehensive behavioral 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 well-structured with clear sections: purpose statement, return metrics, parameter documentation, and return summary. While comprehensive, it's appropriately sized for an 11-parameter tool. The front-loaded purpose statement is clear, though the parameter section is lengthy but necessary given the complexity.

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 (11 parameters, 0% schema coverage) and the presence of an output schema, the description is reasonably complete. It thoroughly documents all parameters and their semantics, explains the return metrics, and provides operational context. The main gap is lack of behavioral transparency around permissions, rate limits, and error conditions, but the parameter documentation is excellent.

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 provides extensive parameter documentation that fully compensates for the 0% schema description coverage. It explains each parameter's purpose, valid values for date_range_type, conditional requirements (CUSTOM_DATE requires start/end parameters), defaults, and optional filtering capabilities. This adds significant meaning beyond what the bare 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's purpose: 'Run a delivery report for orders and line items' with specific metrics (impressions, clicks, CTR, revenue). It distinguishes itself from other reporting tools like 'run_custom_report' and 'run_inventory_report' by focusing specifically on delivery metrics. However, it doesn't explicitly contrast with sibling tools beyond the naming difference.

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

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

The description implies usage through parameter documentation (e.g., date_range_type options, when CUSTOM_DATE requires additional parameters), but doesn't explicitly state when to use this tool versus alternatives like 'run_custom_report' or 'run_inventory_report'. It provides context about what the report returns but lacks explicit guidance on use cases 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions a timeout parameter but does not address critical aspects like whether this is a read-only operation, potential side effects, authentication needs, rate limits, or error handling, leaving significant gaps for a tool with 10 parameters.

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 well-structured and appropriately sized, with a clear purpose statement, detailed parameter explanations, and a returns section. While slightly verbose due to listing all parameters, each sentence adds value, and it is front-loaded with the core functionality.

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 (10 parameters, no annotations, but with an output schema), the description is mostly complete. It covers parameter semantics thoroughly and mentions return data, though it could better address behavioral aspects like safety or performance, which are not fully compensated by the output schema alone.

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 substantial meaning beyond the input schema, which has 0% description coverage. It explains the purpose of all 10 parameters, including date_range_type options, conditional usage for CUSTOM_DATE fields, defaults for include_date_breakdown and timeout_seconds, and the optional nature of ad_unit_id, effectively compensating for the schema's lack of documentation.

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

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

The description clearly states the specific action ('Run an inventory report') and resource ('for ad units'), distinguishing it from sibling tools like 'run_custom_report' or 'run_delivery_report' by specifying the report type and breakdown metrics (ad requests, impressions, fill rate).

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 generating inventory reports with date ranges and optional filtering, but lacks explicit guidance on when to use this versus alternatives like 'run_custom_report' or 'run_delivery_report', and does not mention prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool updates properties and returns updated details, but lacks critical information such as required permissions, whether changes are reversible, rate limits, or error conditions. For a mutation tool with zero annotation coverage, this is a significant gap in 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 appropriately sized and front-loaded, starting with the core purpose followed by parameter details and a constraint. Every sentence adds value, with no redundant information. However, the structure could be slightly improved by integrating the constraint more seamlessly rather than as a separate statement.

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 (a mutation with 3 parameters) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the purpose, parameters, and a key constraint. However, it lacks behavioral details like permissions or side effects, which are important for a mutation tool without annotations, preventing a perfect score.

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

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

The description adds substantial meaning beyond the input schema, which has 0% description coverage. It explains each parameter's purpose: 'creative_id: The creative ID to update,' 'destination_url: New destination/click-through URL for the creative,' and 'name: New name for the creative.' Additionally, it provides the constraint 'At least one of destination_url or name must be provided,' which is not evident from the schema alone. This fully compensates for the schema's lack of 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's purpose: 'Update an existing creative's properties.' It specifies the verb ('update') and resource ('creative'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'update_line_item_name' or 'upload_and_associate_creative', which also modify creative-related entities.

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 implied usage guidance by stating 'At least one of destination_url or name must be provided,' which indicates when the tool should be used (when updating those specific properties). However, it doesn't explicitly mention when to use this tool versus alternatives like 'upload_creative' for new creatives or 'get_creative' for read-only access, nor does it specify 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is an update operation, implying mutation, but doesn't cover critical aspects like required permissions, whether changes are reversible, error handling (e.g., invalid IDs), or rate limits. The mention of returning 'updated line item details' hints at output but lacks specifics on format or side effects.

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 well-structured and appropriately sized: a clear purpose statement followed by parameter explanations and return information. It uses minimal sentences without redundancy. However, the 'Args:' and 'Returns' sections could be integrated more seamlessly, and some wording is slightly verbose (e.g., 'Returns the updated line item details' could be tighter).

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

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

Given 2 parameters with 0% schema coverage and an output schema present, the description partially compensates by explaining parameters and hinting at returns. However, as a mutation tool with no annotations, it lacks details on behavioral traits (e.g., safety, errors) and doesn't leverage sibling context. The output schema reduces the need to describe returns, but overall completeness is moderate due to missing usage and transparency elements.

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

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

Schema description coverage is 0%, so the schema provides no parameter descriptions. The description adds basic semantics: 'line_item_id: The line item ID' and 'new_name: New name for the line item', clarifying what each parameter represents. However, it doesn't provide format details (e.g., ID constraints, name length limits) or examples, leaving gaps in 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's purpose: 'Update a line item's name.' It specifies the verb ('Update') and resource ('line item's name'), making the action unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'update_creative' or 'duplicate_line_item', which could also involve modifications to line items or related entities.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing line item ID), exclusions, or comparisons to siblings like 'get_line_item' (for viewing) or 'archive_line_item' (for deletion). Usage is implied but not explicitly defined.

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 mentions the tool performs an upload and association, implying a write/mutation operation, but lacks details on permissions, error handling, rate limits, or side effects. The description adds basic context but doesn't fully disclose behavioral traits needed for safe use.

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 well-structured and front-loaded: the first sentence states the purpose clearly, followed by a bullet-like Args section and a Returns statement. Every sentence adds value without redundancy, making it efficient and easy to parse.

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

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

Given 5 parameters with 0% schema coverage and no annotations, the description does a good job explaining parameters and stating the return value ('Returns the creative and association details'). However, as an output schema exists, the description doesn't need to detail return values, but it could benefit from more behavioral context for this mutation 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%, so the description must compensate. It lists all 5 parameters in the Args section with brief explanations (e.g., 'Path to the image file', 'ID of the advertiser'), adding meaningful semantics beyond the bare schema. However, it doesn't specify formats (e.g., file types for 'file_path', URL validation for 'click_through_url') or constraints, leaving some gaps.

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

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

The description clearly states the specific action: 'Upload a creative and associate it with a line item in one step.' It uses precise verbs ('upload', 'associate') and identifies the resource ('creative', 'line item'), distinguishing it from sibling tools like 'upload_creative' (which only uploads) and 'associate_creative_with_line_item' (which only associates).

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 'in one step,' indicating this tool should be used when both uploading and associating are needed together, rather than using separate tools like 'upload_creative' and 'associate_creative_with_line_item'. This provides clear guidance on when to choose this tool over alternatives among the 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?

With no annotations provided, the description carries full burden and does well: it discloses that this creates a new creative (mutation), explains how creative size is extracted from filename, describes the override_size use case for different placements, and mentions the return value. It doesn't cover permissions, rate limits, or error conditions, but provides solid 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?

Well-structured with clear sections: purpose statement, parameter list with explanations, and return value. Every sentence adds value, though the parameter explanations could be slightly more concise. The information is front-loaded with the core purpose first.

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

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

Given 6 parameters with no schema descriptions, no annotations, but with output schema present, the description provides excellent parameter semantics and behavioral context. It covers the creation process, filename parsing, and override use cases. The output schema handles return values, so the description appropriately focuses on input behavior and operational context.

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

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

With 0% schema description coverage, the description fully compensates by explaining all 6 parameters in detail: required vs. optional status, purpose of each parameter, and specific usage examples for override_size parameters. It adds crucial semantic context beyond the bare schema, including filename parsing behavior and parameter interdependencies.

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 specific action ('Upload an image creative') and resource ('to Ad Manager'), distinguishing it from sibling tools like 'bulk_upload_creatives' (single vs. bulk) and 'create_third_party_creative' (image vs. third-party). It specifies the exact type of creative being uploaded.

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

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

The description implies usage through parameter explanations (e.g., when to use override_size parameters), but doesn't explicitly state when to choose this tool over alternatives like 'bulk_upload_creatives' or 'upload_and_associate_creative'. It provides contextual guidance for parameter usage but not tool selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes the verification checks performed (creative placeholders, associations, size mismatches) and mentions it returns results with issues, which adds some behavioral context. However, it lacks details on permissions, side effects, error handling, or rate limits, leaving gaps for a mutation-like verification tool. This partial disclosure earns a baseline score of 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 is well-structured and appropriately sized, with a clear purpose statement, an Args section, a Checks list, and a Returns note. Each sentence adds value without redundancy. However, the 'Args' and 'Checks' sections could be integrated more seamlessly, slightly reducing conciseness to a score of 4.

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

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

Given the tool's moderate complexity (verification with checks), no annotations, and an output schema present (which handles return values), the description is reasonably complete. It covers the purpose, parameter, checks, and output intent. But it lacks details on error cases or integration with siblings, preventing a perfect score. With output schema reducing burden, a score of 4 is appropriate.

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 1 parameter with 0% description coverage, and the description adds minimal semantics: it states 'line_item_id: The line item ID to verify,' which clarifies the parameter's purpose but doesn't provide format, constraints, or examples. Since schema coverage is low, the description compensates somewhat but not fully, resulting in a score of 3.

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

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

The description clearly states the tool's purpose: 'Verify line item setup including creative placeholders and associations.' It specifies the verb 'verify' and the resource 'line item setup,' with details on what aspects are checked. However, it doesn't explicitly differentiate from sibling tools like 'verify_order_setup' or 'check_line_item_delivery_status,' which limits the score to 4.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions what the tool checks but doesn't specify prerequisites, timing (e.g., before approval or after creation), or comparisons to siblings like 'check_line_item_delivery_status' or 'verify_order_setup.' This lack of explicit usage context results in a score of 2.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It mentions 'comprehensive verification' but doesn't specify what that entails (e.g., validation checks, error reporting, or audit trails). It doesn't address permissions, side effects, or response format beyond the generic 'Returns comprehensive verification'.

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 efficiently structured with a purpose statement followed by parameter and return value sections. Both sentences earn their place by defining scope and output, though the return statement is somewhat vague ('comprehensive verification').

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

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

Given the tool's moderate complexity (verification operation), no annotations, and an output schema present, the description is minimally adequate. It covers the basic purpose and parameter but lacks details on verification criteria, error handling, or how results are structured, relying on the output schema for return value specifics.

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 meaningful context for the single parameter 'order_id' by specifying it's 'The order ID to verify', which clarifies its role beyond the schema's type definition (integer). With 0% schema description coverage and only one parameter, this adequately compensates, though it could provide format examples or constraints.

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

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

The description clearly states the tool's purpose as verifying order setup including all line items, using specific verbs ('verify') and resources ('order setup', 'line items'). It distinguishes from siblings like 'verify_line_item_setup' by focusing on the complete order rather than individual line items, though it doesn't explicitly name this distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when verification is needed, prerequisites, or how it differs from related tools like 'get_order' or 'verify_line_item_setup', leaving the agent to infer usage context.

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