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 data but doesn't disclose behavioral traits like whether it's a read-only operation, requires authentication, has rate limits, or what the return format looks like. For a data retrieval 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 a single, efficient sentence with zero waste. It's appropriately sized and front-loaded with the core purpose. Every word earns its place.

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

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

Given the tool's low complexity (2 simple parameters, no output schema, no annotations), the description is minimally adequate but incomplete. It states what data is returned but lacks behavioral context and output details. For a basic list tool, it meets minimum viability but has clear gaps.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (limit and offset). The description doesn't add any parameter-specific information beyond what's in the schema. According to guidelines, baseline is 3 when schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Returns B2B companies with location and contact counts.' It specifies the verb ('Returns'), resource ('B2B companies'), and additional data included ('location and contact counts'). However, it doesn't explicitly differentiate from sibling tools, as none appear to be directly related to B2B companies.

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. There's no mention of prerequisites, context for usage, or comparison to sibling tools. The agent must infer usage based solely on the purpose statement.

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 the tool returns data ('Returns all collections'), implying a read-only operation, but doesn't specify whether it's paginated, what format the results take, if there are rate limits, authentication requirements, or error conditions. For a tool with zero annotation coverage, this leaves significant behavioral 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 a single, efficient sentence that immediately states the tool's core functionality with zero wasted words. It's appropriately sized for a simple lookup tool and front-loads the essential information.

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

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

For a tool with no annotations and no output schema, the description is insufficiently complete. It doesn't describe the return format (e.g., list structure, fields included), pagination behavior, error handling, or performance characteristics. While the input schema is fully documented, the lack of output information and behavioral context leaves significant gaps for an AI agent.

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

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

The description mentions 'specified product' which aligns with the single parameter 'product_id', but adds no semantic details beyond what the schema already provides (100% coverage). The schema fully documents the parameter as 'The product ID (Shopify GID)', so the description doesn't enhance understanding of parameter meaning, format, 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 with a specific verb ('Returns') and resource ('collections that contain the specified product'). It distinguishes from siblings like 'slam_collections_get' and 'slam_collections_list' by focusing on product-to-collection relationships rather than direct collection retrieval. However, it doesn't explicitly contrast with 'slam_products_for_collection' (which does the inverse 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?

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention sibling tools like 'slam_collections_get' (for single collection details) or 'slam_products_for_collection' (for the inverse query). There's no context about prerequisites, performance considerations, 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 of behavioral disclosure. It states the tool returns a collection 'including all member products,' which adds some context about the response content. However, it lacks critical details such as whether this is a read-only operation, error handling for invalid IDs, authentication requirements, or rate limits. For a tool with no annotations, this leaves significant gaps in understanding its 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 a single, efficient sentence that directly states the tool's function and key feature ('including all member products'). It is front-loaded with the core purpose and contains no redundant or unnecessary information, making it highly concise 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, no nested objects) and high schema coverage, the description is somewhat complete but has notable gaps. It lacks output schema details, and with no annotations, it doesn't cover behavioral aspects like safety or performance. The description provides basic purpose and response content, but for a tool in a server with many siblings, more context on usage and limitations would enhance completeness.

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

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

The input schema has 100% description coverage, with the 'id' parameter documented as 'The collection ID (Shopify GID).' The description doesn't add any further meaning beyond this, such as format examples or validation rules. According to the rules, when schema coverage is high (>80%), the baseline score is 3, which is appropriate here as the schema adequately covers parameter semantics without extra value from the description.

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

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

The description clearly states the verb ('Returns') and resource ('a single collection by ID'), making the purpose specific and understandable. It distinguishes from sibling tools like 'slam_collections_list' by specifying retrieval of a single collection rather than a list. However, it doesn't explicitly contrast with 'slam_collections_for_product' or 'slam_products_for_collection', which might involve similar data, so it's not fully differentiated from all siblings.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a collection ID), exclusions, or comparisons to sibling tools like 'slam_collections_list' for listing multiple collections or 'slam_products_get' for product details. Without such context, an agent might struggle to select the appropriate tool in different scenarios.

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

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

No annotations are provided, so the description carries the full burden. It mentions 'paginated list' and 'product counts', which are useful behavioral traits, but fails to disclose critical details such as authentication requirements, rate limits, error handling, or what the output format looks like (e.g., structure of returned collections). For a tool with 5 parameters and no annotations, this leaves significant gaps in understanding its 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 a single, efficient sentence that front-loads the core purpose ('Returns a paginated list of collections with product counts') and adds a key constraint ('Filterable by collection_type'). There is no wasted text, and every word contributes to understanding the tool's function.

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 (5 parameters, no annotations, no output schema), the description is minimally adequate. It covers the basic purpose and a key filter, but lacks details on output structure, error cases, or behavioral nuances like pagination mechanics. With no output schema, the agent must infer return values from the description alone, which is insufficient for full contextual understanding.

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

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

Schema description coverage is 100%, with all parameters well-documented in the schema (e.g., 'collection_type' with enum values, 'limit' with range, defaults for 'limit', 'offset', 'sort_by', 'sort_order'). The description adds minimal value beyond the schema by mentioning filterability by 'collection_type' and 'product counts', but doesn't explain parameter interactions or provide additional context. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the action ('Returns a paginated list') and resource ('collections with product counts'), and specifies the filterable attribute ('collection_type'). It distinguishes from siblings like 'slam_collections_get' by focusing on listing rather than retrieving a single collection. However, it doesn't explicitly contrast with 'slam_collections_for_product' or 'slam_products_for_collection', which might handle related but different queries.

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

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

The description implies usage for listing collections with product counts and filtering by type, but provides no explicit guidance on when to use this tool versus alternatives like 'slam_collections_get' (for single collection details) or 'slam_products_for_collection' (for products in a collection). It mentions filterability by 'collection_type', which hints at context, but lacks clear when-not-to-use scenarios 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. While it states what the tool checks, it doesn't reveal important behavioral aspects: whether this is a read-only analysis or triggers changes, what permissions are required, how results are returned, whether it scans all products or a subset, or any rate limits. For a tool with zero annotation coverage, this represents significant gaps in behavioral 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 perfectly concise - a single sentence that communicates the complete purpose without any wasted words. It's front-loaded with the core action ('Runs content quality checks') followed by specific examples of what it checks. Every element of the description earns its place by contributing essential information.

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

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

Given the tool has no parameters (simplifying the context) but also no annotations and no output schema, the description provides adequate basic purpose but lacks important contextual information. It doesn't explain what format the quality check results take, whether this is a diagnostic tool or triggers actions, or how comprehensive the scanning is. For a tool with zero structured metadata, the description should do more to compensate.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the parameter situation. The description appropriately doesn't waste space discussing parameters that don't exist, earning a baseline score of 4 for not adding unnecessary information while focusing on what the tool actually does.

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 ('Runs content quality checks') and identifies the exact resources being checked ('products with empty descriptions, 'Copy of'/'Untitled' titles, or missing tags'). It distinguishes itself from sibling tools like 'slam_conditions_inventory' or 'slam_conditions_pricing' by focusing specifically on content quality rather than other operational aspects.

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 specifying what content issues it checks (empty descriptions, problematic titles, missing tags), suggesting it should be used when assessing product content quality. However, it doesn't explicitly state when to use this tool versus alternatives or provide any exclusion criteria, leaving some ambiguity about its specific application scenarios.

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

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

No annotations are provided, so the description carries full burden. It states what checks are run but doesn't disclose behavioral traits such as whether this is a read-only operation, if it modifies data, performance characteristics, or output format. For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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 a single, efficient sentence that lists all quality checks without unnecessary words. It's front-loaded with the core purpose and provides specific examples, making it easy to scan 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 has no parameters and no output schema, the description adequately covers what the tool does but lacks details on behavioral aspects and output format. For a quality check tool with zero annotations, more context on results or operational impact would improve completeness.

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

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

The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate, earning a baseline score of 4 for adequately handling the parameter-free context.

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

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

The description clearly states the tool's purpose with specific verbs ('runs customer quality checks') and enumerates the exact checks performed (missing email, duplicate emails, zero order count, customers with orders but zero total spent). It distinguishes itself from sibling tools like slam_customers_list or slam_customers_search by focusing on quality analysis rather than listing or searching customers.

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 customer quality assessment but doesn't explicitly state when to use it versus alternatives like slam_customers_by_tag or slam_customers_top. No guidance on prerequisites or exclusions is provided, leaving usage context inferred rather than clearly 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states what checks are performed but doesn't describe the tool's behavior: whether it's read-only or modifies data, what permissions are required, what the output format looks like, or any rate limits. For a tool that 'runs checks' with zero annotation coverage, this leaves significant gaps in understanding how it operates.

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

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

The description is extremely concise and well-structured in a single sentence. It front-loads the core action ('Runs identifier completeness checks') followed by specific examples. Every word earns its place with zero wasted text, making it easy to understand at a glance.

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 (running multiple checks), lack of annotations, and no output schema, the description is minimally adequate. It tells what checks are performed but doesn't provide behavioral context, output format, or usage guidance. For a tool with no structured metadata, it meets the bare minimum but leaves important questions unanswered about how the tool behaves and what results to expect.

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

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

The tool has 0 parameters with 100% schema description coverage (empty schema). The description appropriately doesn't discuss parameters since none exist. It earns a baseline 4 because it doesn't need to compensate for missing parameter documentation, and the description focuses on what the tool does rather than parameter 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: 'Runs identifier completeness checks' with specific examples of what it checks (empty SKUs, empty barcodes, duplicate product titles). It uses a specific verb ('Runs') and identifies the resource being checked (product identifiers). However, it doesn't explicitly differentiate from sibling tools like 'slam_conditions_inventory' or 'slam_conditions_content' that might also perform checks.

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, timing considerations, or compare it to sibling tools like 'slam_conditions_inventory' or 'slam_conditions_content' that might handle related checks. The user 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 full burden. It states the tool 'runs' checks, implying a read operation, but doesn't disclose behavioral traits like whether it's safe (non-destructive), requires permissions, has rate limits, returns real-time vs cached data, or outputs format. For a tool with zero annotation coverage, this is inadequate.

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

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

The description is a single, efficient sentence that front-loads the core action ('Runs inventory status checks') and lists specific checks concisely. Every word earns its place with no redundancy or wasted text.

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

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

Given the complexity (inventory status checks), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what the checks entail, how results are returned, or any behavioral context. For a tool that likely returns structured data, this leaves significant gaps for an AI agent.

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

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

The tool has 0 parameters with 100% schema description coverage. The description doesn't need to explain parameters, and it appropriately doesn't mention any. A baseline of 4 is applied since no parameters exist, and the description doesn't incorrectly suggest otherwise.

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: 'Runs inventory status checks' with specific checks enumerated ('out-of-stock variants, negative inventory, and untracked inventory items'). It uses a specific verb ('Runs') and identifies the resource ('inventory status checks'), but doesn't explicitly differentiate from sibling inventory tools like 'slam_inventory_alerts' or 'slam_inventory_summary'.

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

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

No guidance is provided on when to use this tool versus alternatives. The description lists what checks are performed but doesn't indicate context, prerequisites, or exclusions. With multiple inventory-related sibling tools, this lack of comparative guidance is a significant gap.

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 'Runs order quality checks' but doesn't clarify whether this is a read-only operation, if it modifies data, what permissions are required, or what the output format looks like. For a tool with zero annotation coverage, this is a significant gap in transparency about its behavior and 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 a single, efficient sentence that front-loads the core action ('Runs order quality checks') and follows with specific examples. There is no wasted verbiage, and it effectively communicates the tool's purpose without unnecessary elaboration, making it highly concise and well-structured.

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

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

Given the tool has 0 parameters and no output schema, the description is moderately complete: it explains what the tool does but lacks details on behavioral aspects like safety, permissions, or output format. Without annotations to fill these gaps, the description should ideally provide more context about the tool's operation and results, but it's adequate for a simple check-running 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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing instead on the tool's function. This aligns with the baseline expectation for tools without parameters, where the description should not waste space on non-existent inputs.

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: 'Runs order quality checks' with specific examples of checks performed (orders with no line items, missing customer email, zero total price, and refunded-but-unfulfilled status). It uses a specific verb ('Runs') and identifies the resource ('order quality checks'), though it doesn't explicitly distinguish from sibling tools like 'slam_orders_list' or 'slam_orders_search' which might handle different aspects of orders.

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

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

The description provides no guidance on when to use this tool versus alternatives. It lists the types of checks performed but doesn't indicate scenarios where this tool is appropriate, prerequisites, or how it differs from sibling tools such as 'slam_orders_list' or 'slam_orders_search' that might also involve order data. This lack of context leaves the agent to infer usage.

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

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

No annotations are provided, so the description carries the full burden. It states what the tool checks but doesn't disclose behavioral traits: it doesn't specify whether this is a read-only analysis or if it makes changes, what permissions are required, how results are returned, whether it's resource-intensive, or if there are rate limits. For a 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 a single, efficient sentence that front-loads the core purpose ('Runs pricing anomaly checks') followed by specific examples. Every word earns its place with no redundancy or unnecessary elaboration, making it easy to scan 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 complexity of pricing analysis and the lack of annotations and output schema, the description is incomplete. It explains what checks are performed but doesn't cover critical context: how results are returned, what format they're in, whether this is a batch or real-time operation, or any limitations. For a tool that likely returns detailed anomaly data, this leaves too much unspecified.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description doesn't need to explain parameters, and it appropriately focuses on what the tool does rather than inputs. A baseline of 4 is appropriate for zero-parameter tools when the schema coverage is complete.

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: 'Runs pricing anomaly checks' with specific examples of what it checks (zero-price variants, inverted compare_at_price, and compare_at_price equal to price). It uses a specific verb ('Runs') and identifies the resource ('pricing anomaly checks'), but doesn't explicitly differentiate from sibling tools like 'slam_price_analysis' or 'slam_prices_current'.

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, timing considerations, or compare it to sibling tools like 'slam_price_analysis' or 'slam_prices_current' that might handle related pricing tasks. The user must infer usage from the purpose alone.

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

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

No annotations are provided, so the description carries the full burden. It mentions returning data for 'content audit' and filtering, but lacks critical behavioral details: it doesn't specify if this is a read-only operation, whether it requires authentication, what the return format looks like (e.g., pagination, structure), or any rate limits. For a tool with no annotations, this leaves significant gaps in understanding its 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 extremely concise and front-loaded: two sentences that directly state the purpose and key usage. There's no wasted language, and every sentence earns its place by providing essential information efficiently.

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

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

Given the complexity (a data retrieval tool with 3 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'pages and articles' entail (e.g., fields returned), how results are structured, or any error handling. For a tool without annotations or output schema, more detail is needed to fully guide an agent.

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

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

The description adds minimal parameter semantics: it mentions the 'content_type' filter and its purpose ('to restrict to 'page' or 'article''), which is already covered in the schema (100% coverage). It doesn't provide additional context for 'limit' or 'offset' beyond what the schema describes. With high schema coverage, the baseline is 3, and the description doesn't add significant value beyond that.

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: 'Returns pages and articles for content audit.' It specifies the verb ('Returns') and resource ('pages and articles'), and mentions the context ('content audit'). However, it doesn't explicitly differentiate from sibling tools like 'slam_conditions_content' or other content-related tools, 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 some usage guidance: 'Use content_type filter to restrict to 'page' or 'article'.' This implies when to use the filter, but it doesn't offer explicit when-to-use vs. alternatives (e.g., compared to other content tools in the sibling list) or mention prerequisites. The guidance is helpful but incomplete for optimal agent decision-making.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a read operation ('Returns'), but doesn't mention permissions, rate limits, error handling, or the format of returned data. For a tool with no annotations, this leaves significant gaps in understanding its 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 a single, efficient sentence that directly states the tool's function. It's front-loaded with the core action and resource, with no wasted words, making it appropriately concise for its purpose.

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

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

Given the complexity of a database query tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the return values look like (e.g., address fields, format), error conditions, or how it interacts with sibling tools, leaving the agent under-informed for effective use.

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

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

The schema description coverage is 100%, with clear documentation for all three parameters (customer_id, limit, offset). The description adds no additional meaning beyond the schema, such as examples or edge cases. With high schema coverage, the baseline score of 3 is appropriate as the schema does the heavy lifting.

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

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

The description states the tool 'Returns customer addresses from the customer_addresses table,' which clearly indicates a read operation on a specific database table. However, it doesn't differentiate this tool from potential sibling tools like 'slam_customers_get' or 'slam_customers_list' that might also retrieve customer-related data, making the purpose somewhat vague in 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?

No guidance is provided on when to use this tool versus alternatives. With many sibling tools related to customers (e.g., 'slam_customers_get', 'slam_customers_list', 'slam_customers_search'), the description lacks any indication of specific use cases, prerequisites, or comparisons, leaving the agent without 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool returns distribution data but doesn't cover important aspects like whether it's read-only (implied by 'returns'), pagination behavior (only hinted via limit/offset parameters), performance characteristics, or error conditions. The description adds minimal behavioral context beyond the basic operation.

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

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

The description is efficiently structured in two clear sentences that directly explain what the tool does. The first sentence states the core functionality, and the second elaborates on the output. There's no wasted language, though it could be slightly more front-loaded with key information.

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

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

Given the tool's moderate complexity (analytical query with pagination), no annotations, and no output schema, the description is minimally adequate. It explains what data is returned but lacks details about return format, sorting order, or what constitutes 'most common' tags. The absence of output schema means the description should ideally provide more return value information.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (limit and offset). The description doesn't add any parameter-specific information beyond what's in the schema, such as how these parameters affect the tag distribution analysis. This meets the baseline expectation when schema coverage is complete.

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: 'Returns customer tag distribution from the customer_tags table' specifies the verb (returns), resource (customer tag distribution), and source table. It distinguishes from siblings like 'slam_customers_list' or 'slam_customers_search' by focusing on tag analytics rather than customer records, though it doesn't explicitly name alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'slam_customers_list' for general customer data or 'slam_conditions_customers' for customer conditions, nor does it specify prerequisites or appropriate contexts for tag analysis.

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 the tool returns recent orders (up to 10) and metafields, which adds some behavioral context beyond a simple fetch. However, it lacks details on error handling, permissions, rate limits, or whether it's read-only/destructive—critical for a tool with no annotations.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Returns a single customer by ID') and adds useful details without waste. Every word earns its place, making it highly concise and well-structured.

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

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

Given no annotations and no output schema, the description is adequate for a simple retrieval tool but has gaps. It specifies what's included (orders and metafields), which helps, but doesn't cover response format, error cases, or other behavioral aspects needed for full context without structured fields.

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

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

The input schema has 100% description coverage, with the 'id' parameter documented as 'The customer ID (Shopify GID).' The description doesn't add further parameter details beyond implying the ID is required. With high schema coverage, the baseline is 3, as the description doesn't compensate with extra semantics.

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 ('Returns a single customer by ID') and distinguishes it from sibling tools like 'slam_customers_list' or 'slam_customers_search' by specifying it fetches a single customer rather than multiple. It also adds valuable detail about what's included ('recent orders up to 10 and metafields'), which goes beyond a basic 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 implies usage by specifying 'by ID,' suggesting this tool is for fetching a known customer. However, it doesn't explicitly state when to use it versus alternatives like 'slam_customers_list' for multiple customers or 'slam_customers_search' for unknown IDs, nor does it 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 full burden. It mentions 'paginated list' and optional tag filtering, which are useful behavioral traits. However, it lacks details on permissions, rate limits, error handling, or what the response structure looks like (e.g., fields beyond orders_count and total_spent). For a tool with no annotations, this leaves significant gaps in understanding its 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 concise and front-loaded: it states the core purpose in the first clause. The second clause adds optional filtering. Both sentences are relevant and earn their place, with no wasted words. However, it could be slightly more structured by explicitly mentioning pagination upfront.

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 (5 parameters, no output schema, no annotations), the description is adequate but incomplete. It covers the basic purpose and one filtering option but misses details on response format, error cases, and differentiation from siblings. Without annotations or output schema, more context on behavior and usage would improve completeness.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds minimal value beyond the schema: it mentions 'Optionally filter by tag,' which aligns with the 'tag' parameter but doesn't provide additional semantics. With high schema coverage, the baseline is 3, and the description doesn't significantly enhance parameter understanding.

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

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

The description clearly states the tool's purpose: 'Returns a paginated list of customers with orders_count and total_spent.' It specifies the verb ('Returns'), resource ('customers'), and key data fields. However, it doesn't explicitly differentiate from sibling tools like 'slam_customers_by_tag' or 'slam_customers_search', which appear to offer similar 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 minimal guidance: 'Optionally filter by tag.' It doesn't explain when to use this tool versus alternatives like 'slam_customers_by_tag' (which might be more specific for tag-based queries) or 'slam_customers_search' (which might support broader search). No explicit when/when-not scenarios 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the search behavior (case-insensitive substring matching) and what fields are searched, which is helpful. However, it doesn't mention important behavioral aspects like whether this is a read-only operation (implied but not stated), performance characteristics, error conditions, or what the return format looks like (especially with no output schema).

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

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

The description is a single, well-structured sentence that efficiently conveys the tool's purpose and key behavior. Every word earns its place - it specifies what the tool does, what parameters it searches, and how the search works, with zero wasted text.

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

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

For a search tool with 3 parameters, 100% schema coverage, but no annotations and no output schema, the description provides adequate basic information about what the tool does and how searches work. However, it lacks details about the return format, error handling, or performance considerations that would be helpful given the absence of both annotations and output schema.

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

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

Schema description coverage is 100%, so the schema already fully documents all three parameters. The description adds some context about how the 'query' parameter works (matched against email, first_name, last_name with case-insensitive substring search), but doesn't provide additional semantic information beyond what's in the schema descriptions. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose with specific verbs ('search customers') and resources ('by email address or name fragment'), and distinguishes it from siblings like 'slam_customers_list' by specifying it's a search operation rather than a simple listing. It explicitly mentions what fields are searched (email, first_name, last_name) and the search behavior (case-insensitive substring).

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

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

The description implies when to use this tool (for searching customers by email/name fragments) but doesn't explicitly state when NOT to use it or name alternatives. Given siblings like 'slam_customers_list' and 'slam_customers_by_tag', the agent must infer this is for flexible text-based searching rather than listing all customers or filtering by tags.

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 filtering for repeat buyers but doesn't cover other critical aspects like whether this is a read-only operation, potential performance impacts, rate limits, or authentication needs. For a tool with no annotations, this leaves significant gaps in understanding its 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 appropriately sized with two sentences that are front-loaded and efficient. The first sentence states the core purpose, and the second adds specific usage guidance, with zero wasted words or redundancy.

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

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

Given the complexity (5 parameters, no output schema, no annotations), the description is adequate but incomplete. It covers the purpose and basic filtering but lacks details on behavioral traits, return format, or error handling. With no output schema, it should ideally hint at what data is returned, but it doesn't, leaving gaps for an AI agent.

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

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

The schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value by mentioning 'min_orders' for filtering repeat buyers, but doesn't provide additional semantics beyond what the schema specifies for other parameters like 'sort_by' or 'limit'. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verbs ('Returns customers ranked by') and resources ('customers'), and distinguishes it from siblings like 'slam_customers_list' or 'slam_customers_search' by specifying ranking criteria (total spend, order count, average order value) and filtering for repeat buyers.

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 ('Use min_orders to filter to repeat buyers only'), which implies it's for analyzing customer loyalty or high-value segments. However, it doesn't explicitly state when not to use it or name alternatives among siblings, such as 'slam_customers_list' for unfiltered lists.

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 reveals the sorting behavior ('Sorted by highest stock first') which is valuable context not in the schema. However, it doesn't mention important behavioral aspects like whether this is a read-only operation (implied but not stated), performance characteristics, or what the return format looks like (no output schema).

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

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

The description is perfectly concise with two sentences that each earn their place. The first sentence states the core functionality, the second provides usage context and sorting behavior. No wasted words, and the most important information (what the tool returns) is front-loaded.

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

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

For a read-only query tool with 3 well-documented parameters and no output schema, the description provides good context about what's being returned and why. It covers the filtering logic and sorting behavior. The main gap is the lack of information about return format/structure, but given the tool's relative simplicity and clear purpose, the description is reasonably complete.

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

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

The schema description coverage is 100%, so all parameters are already documented in the input schema. The description doesn't add any additional parameter semantics beyond what the schema provides. It doesn't explain how parameters interact or provide usage examples. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verb ('Returns') and resource ('variants'), plus the precise filtering condition ('available inventory but no recorded sales (order_count = 0)'). It distinguishes itself from sibling tools like 'slam_variants_list' or 'slam_variants_search' by focusing on dead stock identification rather than general variant listing or searching.

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 ('Useful for identifying stock to clearance or discontinue'), which implicitly suggests it's for inventory management decisions. However, it doesn't explicitly state when NOT to use it or name specific alternative tools from the sibling list for different 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 must fully disclose behavioral traits. It states the tool returns data and specifies the source table, but lacks details on permissions, rate limits, pagination behavior (beyond the limit/offset parameters), or what 'active' and 'live promotions' mean operationally. For a read operation with no annotations, this is insufficient.

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

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

The description is concise and front-loaded, consisting of two clear sentences that directly state the tool's purpose. There is no wasted text, and it efficiently communicates the core functionality. A 5 is reserved for exceptional cases with perfect structure, but this is very good.

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 (a simple read operation with 2 parameters), 100% schema coverage, and no output schema, the description is minimally adequate. It covers what the tool does and the source table, but lacks behavioral context (e.g., permissions, rate limits) and usage guidelines, which are needed for full completeness in the absence of 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?

The schema description coverage is 100%, so the schema already documents both parameters (limit and offset) with their types, constraints, and defaults. The description adds no additional parameter information beyond what the schema provides, such as how they affect the query or result set. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Returns active discount codes from the discounts table (not order_discount_codes). Shows current live promotions.' It specifies the verb ('returns'), resource ('active discount codes'), and source table, distinguishing it from a similar table. However, it doesn't explicitly differentiate from sibling tools like 'slam_discounts_summary', which is why it's not a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions 'not order_discount_codes' to clarify the source table, but offers no explicit context for choosing this over other discount-related tools or general query tools. This lack of usage direction is a significant gap.

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. While it indicates this is a read operation ('Returns'), it doesn't address important behavioral aspects like whether this queries live data or cached data, potential performance considerations, authentication requirements, rate limits, or what format the summary data comes in. The description is minimal beyond stating the basic operation.

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

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

The description is appropriately concise with two sentences that efficiently convey the core functionality. The first sentence states the purpose, and the second elaborates on what data is included. There's no unnecessary verbiage, though it could be slightly more structured for clarity.

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 read-only summary tool with good schema coverage but no output schema, the description provides adequate but minimal context. It explains what data is returned but not the structure or format. Without annotations or output schema, the description should ideally provide more guidance about the return format and typical use cases 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 100%, so the schema already fully documents both parameters (limit and offset). The description adds no additional parameter information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no parameter information in the description.

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

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

The description clearly states the tool's purpose: 'Returns discount code usage summary from order_discount_codes' with specific details about what data is shown ('most-used codes, total discount amounts, and discount types'). It distinguishes from siblings like 'slam_discounts_active' by focusing on historical usage rather than active status. However, it doesn't explicitly contrast with all potential alternatives in the sibling list.

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 this summary tool is appropriate compared to more detailed discount analysis tools or other summary tools in the sibling list. There's no context about prerequisites, timing, 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool returns data (implied read-only) but doesn't cover critical aspects like authentication requirements, rate limits, pagination behavior (beyond schema parameters), error handling, or the structure of returned data. The description is insufficient for a tool with three parameters and no output schema.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Returns draft orders with line item counts') and adds clarifying context ('Draft orders are unpaid/pending orders not yet converted'). There is no wasted verbiage or redundancy.

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

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

Given the tool's complexity (3 parameters, no annotations, no output schema), the description is incomplete. It lacks behavioral details (e.g., data format, pagination, errors), usage guidelines relative to siblings, and sufficient context for an agent to invoke it confidently without trial and error.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters (status, limit, offset). The description adds no additional parameter semantics beyond what's in the schema, such as examples for status values beyond 'open' or context for limit/offset usage. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool 'returns draft orders with line item counts' and defines draft orders as 'unpaid/pending orders not yet converted.' This provides a specific verb ('returns') and resource ('draft orders'), but it doesn't explicitly differentiate from sibling tools like 'slam_orders_list' or 'slam_orders_search' beyond the 'draft' qualifier.

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 sibling tools like 'slam_orders_list' or 'slam_orders_search,' nor does it specify prerequisites, exclusions, or contextual triggers for selecting this tool over others.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'Returns fulfillment records' and filtering, but lacks details on permissions required, rate limits, pagination behavior (beyond schema hints), or what the return format looks like (e.g., JSON structure). For a read operation with no 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 extremely concise and front-loaded: two sentences that directly state the purpose and filtering capability without any fluff. Every word earns its place, making it efficient and easy to parse for an AI agent.

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

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

Given the tool's moderate complexity (4 parameters, no output schema, no annotations), the description is adequate but incomplete. It covers the basic purpose and filtering, but lacks details on behavioral aspects like permissions or return format, which are crucial for a read operation. This makes it minimally viable but with clear gaps 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 description adds minimal value beyond the input schema, which has 100% coverage with clear parameter descriptions. It mentions filtering by 'order or status,' which aligns with the 'order_id' and 'status' parameters in the schema but doesn't provide additional context like valid status examples beyond what's in the schema. With high schema coverage, the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Returns fulfillment records from the fulfillments table.' This specifies the verb ('Returns'), resource ('fulfillment records'), and source ('fulfillments table'). However, it doesn't explicitly differentiate from sibling tools like 'slam_orders_list' or 'slam_orders_search' that might also involve fulfillment data, 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 implied usage guidance by stating 'Filter by order or status,' suggesting this tool is for retrieving filtered fulfillment data. However, it doesn't explicitly state when to use this tool versus alternatives (e.g., compared to 'slam_orders_list' or 'slam_run_query'), nor does it mention prerequisites or exclusions, leaving room for ambiguity.

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 summary, implying a read-only operation, but does not specify if it requires authentication, has rate limits, returns paginated results, or includes timestamps. For a tool with no annotations, this leaves significant gaps in understanding its behavior and constraints.

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

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

The description is a single, clear sentence with no wasted words. It is front-loaded with the core action and result, making it easy to understand at a glance. Every part of the sentence contributes directly to explaining the tool's purpose.

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

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

Given the tool has 0 parameters, no annotations, and no output schema, the description is minimally adequate. It explains what the tool does but lacks details on behavioral traits, usage context, or output format. For a simple read operation, this might suffice, but it could benefit from additional context like data freshness or access requirements.

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 parameters are documented. The description does not need to add parameter details, as there are none to explain. It efficiently focuses on the tool's output semantics (balance summary grouped by currency), which is appropriate given the lack of inputs.

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: 'Returns outstanding gift card balance summary grouped by currency.' It specifies the verb ('Returns'), resource ('gift card balance summary'), and grouping criterion ('by currency'). However, it does not explicitly differentiate from sibling tools like 'slam_discounts_summary' or 'slam_sales_summary', which might also return summaries, so it lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or specific contexts for usage. For example, it does not clarify if this is for reporting, auditing, or real-time data, nor does it reference sibling tools like 'slam_customers_list' that might relate to gift card holders.

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 describing what information is returned (protocol versions, database details, metadata). It doesn't mention rate limits, authentication needs, or error behavior, but provides useful operational context about connection 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 two sentences: the first lists what information is returned, the second provides usage guidance. Every element serves a purpose with zero wasted words.

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

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

For a diagnostic tool with one parameter and no output schema, the description provides good context about what information is returned and when to use it. It could benefit from mentioning return format or error conditions, but covers the essential purpose and usage well.

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

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

Schema description coverage is 100% with one parameter well-documented in the schema. The description doesn't add parameter-specific information, but since the schema fully covers the single parameter and there's no output schema, the description's focus on what the tool returns provides adequate context.

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

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

The description clearly states the tool's purpose with specific verbs ('introspect', 'verify', 'detect') and resources ('SLAM MCP server'), listing detailed information returned. It distinctly differentiates from sibling tools by focusing on server introspection rather than data querying.

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

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

The description provides explicit guidance on when to use this tool ('as the first call to verify the connection and detect version drift'), giving clear context for its application. It implicitly distinguishes from siblings by not being for data retrieval operations.

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 key behavioral traits: it returns a sorted list ('Sorted by lowest stock first'), uses aggregation logic ('multi-location inventory_levels aggregation'), and references a specific data source ('variant_stock_health view'). However, it doesn't mention permissions needed, rate limits, response format, or whether this is a read-only operation (though 'Returns' implies read).

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 with three information-dense sentences that each earn their place: purpose statement, implementation detail, and sorting behavior. It's front-loaded with the core functionality and contains zero wasted words.

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

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

For a read operation with 4 parameters (all optional) and 100% schema coverage but no output schema, the description is reasonably complete. It explains what the tool does, how it works (aggregation via specific view), and sorting behavior. The main gap is lack of output format details, but given the tool's relative simplicity and good parameter documentation, this is acceptable.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the overall purpose ('Returns variants at or below a stock threshold — your reorder list') which provides context for how parameters work together, though it doesn't add specific parameter details beyond what the schema already documents. The description's framing elevates it above baseline.

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

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

The description clearly states the tool's purpose with specific verb ('Returns') and resource ('variants at or below a stock threshold'), and distinguishes it from siblings by specifying it's 'your reorder list' using 'multi-location inventory_levels aggregation via the variant_stock_health view'. This differentiates it from other inventory tools like slam_inventory_by_location or slam_inventory_levels.

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 ('your reorder list') and mentions the underlying view, but doesn't explicitly state when to use this tool versus alternatives like slam_inventory_by_location or slam_dead_stock. It provides some guidance through the purpose statement but lacks explicit when/when-not instructions or named alternatives.

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

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

No annotations are provided, so the description carries the full burden. It states this is a read operation ('Returns'), which implies non-destructive behavior, but doesn't disclose other traits like authentication needs, rate limits, error conditions, or response format. For a tool with zero annotation coverage, this leaves significant behavioral 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 a single, efficient sentence that front-loads the core purpose and includes key details (aggregation by location, specific metrics). There is no wasted text, and it's appropriately sized for a simple read tool.

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

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

Given the tool's low complexity (one optional parameter, no output schema, no annotations), the description is minimally adequate. It covers what the tool does but lacks context on usage, behavioral traits, or output structure. For a read tool with no annotations, it should provide more guidance 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 100%, so the schema fully documents the single optional parameter 'location_id'. The description adds no parameter-specific information beyond implying location-based aggregation. With high schema coverage, the baseline is 3, as the description doesn't enhance parameter understanding but doesn't need to compensate.

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

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

The description clearly states the tool's purpose: 'Returns inventory stock totals aggregated by location' with specific metrics (available, on_hand, reserved, committed units). It distinguishes from inventory-related siblings like 'slam_inventory_levels' or 'slam_inventory_summary' by focusing on location aggregation, though it doesn't explicitly name alternatives. The verb 'returns' and resource 'inventory stock totals' are specific.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'slam_inventory_summary' or 'slam_inventory_levels'. It mentions aggregation by location but doesn't specify use cases, prerequisites, or exclusions. The agent must infer usage from the purpose alone, which is insufficient for optimal 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 full burden. It mentions the tool 'returns' data (implying read-only) and describes the join operation, but doesn't disclose important behavioral traits like pagination behavior (implied by limit/offset but not explained), rate limits, authentication requirements, error conditions, or response format details. The description is minimal beyond stating the basic operation.

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

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

The description is a single, efficient sentence that front-loads the core functionality (returns inventory levels with joins) followed by filter options. There's no wasted text, though it could be slightly more structured for clarity. Every word earns its place.

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

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

For a read operation with 5 parameters and no output schema, the description is insufficiently complete. It doesn't explain the response structure (what fields beyond those mentioned), pagination behavior (how limit/offset work together), sorting, error handling, or performance characteristics. With no annotations and no output schema, users lack critical context for proper tool invocation.

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

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

Schema description coverage is 100%, so the schema already fully documents all 5 parameters with their types, constraints, and descriptions. The description adds marginal value by listing three filterable parameters (product_id, SKU, location_id) but doesn't provide additional semantic context beyond what's in the schema. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool returns inventory levels joined with variant and location information, specifying the data fields included (SKU, title, location name). It distinguishes from some siblings like 'slam_inventory_summary' or 'slam_inventory_by_location' by mentioning the join operation, but doesn't explicitly differentiate from all inventory-related siblings.

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

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

The description implies usage through filterable parameters (product_id, SKU, location_id), suggesting when to use it for filtered inventory queries. However, it doesn't provide explicit guidance on when to choose this tool over alternatives like 'slam_inventory_summary' or 'slam_inventory_by_location', nor does it 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the core behavior (returning oversold variants sorted by most negative first) and clarifies the meaning of 'overselling'. However, it lacks details on permissions, rate limits, or response format, which are important for a tool that likely involves sensitive inventory 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 front-loaded with the core purpose in the first sentence, followed by clarification and sorting details. Every sentence adds value without redundancy, making it efficient and well-structured for quick comprehension.

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 (identifying oversold variants), no annotations, and no output schema, the description does a good job explaining what the tool does and its output characteristics (sorted list). However, it could be more complete by specifying the return format or data structure, which would help an agent understand how to process the results.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description does not add any parameter-specific information beyond what the schema provides (e.g., it doesn't explain how 'limit' or 'offset' affect the sorting or filtering of oversold variants).

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 ('Returns variants') and resource ('where total available stock is negative'), and explicitly distinguishes it from sibling tools by contrasting 'overselling' with 'out-of-stock (zero stock)'. This precise differentiation from related inventory tools like 'slam_inventory_alerts' or 'slam_inventory_levels' is evident.

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 on when to use this tool by defining its scope ('variants where total available stock is negative') and distinguishing it from alternatives ('Distinct from out-of-stock'). However, it does not explicitly state when not to use it or name specific alternative tools, such as 'slam_inventory_levels' for general inventory checks.

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 ('Returns'), which implies non-destructive behavior, but doesn't disclose any behavioral traits like authentication requirements, rate limits, data freshness, or whether it performs real-time calculations versus cached data. For a statistics tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.

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

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

The description is a single, efficient sentence that immediately states the action ('Returns') and enumerates the specific statistics provided. Every element earns its place—no redundant words or unnecessary elaboration. It's front-loaded with the core purpose and follows with clarifying 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 the tool has no parameters, no annotations, and no output schema, the description does an adequate job explaining what the tool returns. However, for a statistical aggregation tool, additional context about calculation methods, data sources, or format of the returned 'units by location' would be helpful. The description is complete enough to understand the tool's basic function but lacks depth for optimal agent usage.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, maintaining focus on what the tool returns rather than what it accepts. This meets the baseline expectation for a parameterless tool.

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: 'Returns aggregated inventory statistics' with specific metrics listed (total SKUs, total units, units by location, out-of-stock count, low stock count). It distinguishes from sibling tools like 'slam_inventory_by_location' or 'slam_inventory_levels' by focusing on aggregated summary statistics rather than detailed listings. However, it doesn't explicitly contrast with these siblings in the text.

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 'slam_inventory_by_location', 'slam_inventory_levels', and 'slam_inventory_alerts', there's no indication whether this tool provides a higher-level overview, combines multiple metrics, or serves a different use case. 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 states the tool returns data (implying read-only) and mentions the data source view, but lacks details on permissions, rate limits, pagination, or response format. For a tool with zero annotation coverage, this is insufficient to ensure safe and effective 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 extremely concise and front-loaded: the first sentence states the core functionality, and the second adds useful technical context about the data source. Every sentence earns its place with no wasted words, making it easy for an agent to parse 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 complexity (simple read operation) but lack of annotations and output schema, the description is incomplete. It doesn't explain the return format, data structure, or any behavioral constraints, which are critical for a tool that returns 'all' data. Without annotations or output schema, more detail is needed 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?

The tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, but it correctly implies no inputs are required. A baseline score of 4 is appropriate since the schema fully covers the absence of parameters.

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

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

The description clearly states the tool's purpose: 'Returns all fulfilment locations with stock totals.' It specifies the verb ('returns'), resource ('fulfilment locations'), and data included ('stock totals'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'slam_inventory_by_location' or 'slam_inventory_summary', 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. It mentions 'Uses the inventory_by_location view,' which hints at the data source but doesn't clarify use cases, prerequisites, or exclusions compared to sibling inventory-related tools. This leaves the agent without clear 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's read-only nature ('browse and filter') and output format ('returns owner label alongside each metafield'), but lacks details on permissions, rate limits, pagination behavior beyond limit/offset parameters, or error handling. It adds value but not 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 appropriately sized and front-loaded, with two sentences that efficiently convey the tool's purpose, filtering capabilities, and return format. Every sentence earns its place without redundancy or unnecessary elaboration.

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 (7 parameters, no output schema, no annotations), the description is largely complete. It covers the tool's purpose, filtering scope, and return format. However, it could benefit from more behavioral context (e.g., pagination details, error scenarios) to fully compensate for the lack of annotations and output schema.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters thoroughly. The description adds marginal value by summarizing the filter options ('filter by owner type, namespace, key, a specific entity ID, or a substring of the value'), but does not provide additional syntax, format details, or usage examples beyond what the schema specifies. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verbs ('browse and filter') and resources ('metafields across products, variants, customers, orders, and collections'). It distinguishes itself from sibling tools by focusing specifically on metafields, unlike other tools that handle collections, customers, orders, or products directly.

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 ('browse and filter metafields') and implies usage through the listed filter criteria. However, it does not explicitly state when not to use it or name specific alternative tools for related tasks, such as when searching for the entities themselves rather than their metafields.

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

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

No annotations are provided, so the description carries the full burden. It describes what the tool returns (schema, relationships, documentation, SQL patterns) but lacks details on behavioral traits like performance, data freshness, or potential errors. It adds some context but doesn't fully compensate for the lack of annotations.

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

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

The description is front-loaded with the tool's purpose in the first sentence and includes a clear usage guideline in the second. Every sentence adds essential information without waste, making it efficient and well-structured.

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

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

Given the tool's complexity (returning schema and SQL patterns) and lack of annotations and output schema, the description is fairly complete. It explains what the tool returns and when to use it, but could benefit from more behavioral details like response format or limitations. It's adequate but has minor gaps.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't mention any parameters, which is appropriate, and adds value by explaining the tool's purpose and usage, earning a baseline score above 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 returns the full database schema with tables, columns, relationships, TEMP view documentation, semantic descriptions, column type notes, and SQL patterns. It distinguishes from sibling tools by specifying this is for understanding the data model before using slam_run_query, making the purpose specific and differentiated.

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

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

The description explicitly states when to use this tool: 'Call this before writing slam_run_query to understand the data model.' It provides clear context and an alternative (slam_run_query), guiding the agent on usage timing and purpose.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states what data is returned (sync metadata and row counts) but doesn't describe format, structure, or any behavioral traits like performance characteristics, data freshness, or potential limitations. The description provides basic functional information but lacks 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 a single, efficient sentence that front-loads the core functionality ('Returns sync metadata...') with specific details about what metadata is included. Every word contributes value with zero waste or redundancy.

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

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

For a zero-parameter tool with no output schema, the description provides adequate functional context about what data is returned. However, without annotations or output schema, it lacks details about return format, structure, or any behavioral considerations that would help an agent understand how to interpret and use the results effectively.

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

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

The tool has zero parameters with 100% schema description coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, earning a baseline score of 4 for this zero-parameter tool.

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 ('Returns') and resources ('sync metadata and row counts for every entity table in the SLAM database'). It distinguishes itself from siblings by focusing on database metadata rather than specific business entities like customers, orders, or products.

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

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

The description implies usage for checking database sync status and table statistics, but provides no explicit guidance on when to use this versus alternatives. No sibling tools appear to offer similar metadata functionality, so the lack of comparison is understandable but still leaves usage context implicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a read operation ('Returns'), implying it's likely safe and non-destructive, but doesn't specify any behavioral traits such as authentication requirements, rate limits, error conditions, or what 'other store-level settings' might include. For a tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.

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

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

The description is a single, well-structured sentence that efficiently conveys the tool's purpose and output. It's front-loaded with the core action ('Returns store information') and provides specific examples without unnecessary elaboration. Every word earns its place, making it highly concise.

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

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

Given the tool has 0 parameters, no annotations, and no output schema, the description is adequate but has clear gaps. It explains what information is returned, which is helpful, but doesn't cover behavioral aspects like error handling or response format. For a simple read tool with no structured metadata, it meets minimum viability but could be more complete by addressing missing 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 tool has 0 parameters with 100% schema description coverage (since there are no parameters to describe). The description doesn't need to add parameter semantics, so it appropriately focuses on what the tool returns. A baseline of 4 is justified as the description compensates for the lack of parameters by explaining the output content.

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: 'Returns store information from the SLAM metadata table' with specific examples of what information is returned (shop domain, currency, timezone, and other store-level settings). It uses a specific verb ('Returns') and identifies the resource ('store information'), though it doesn't explicitly distinguish from sibling tools like 'slam_store_snapshot' which might have overlapping functionality.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, context for usage, or comparison with sibling tools like 'slam_meta_schema' or 'slam_meta_status' that might relate to metadata. The agent must infer usage from the tool 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. It implies a read-only operation ('List') and hints at filtering capabilities, but does not disclose behavioral traits like pagination (though the schema covers limit/offset), rate limits, authentication needs, or error handling. The description adds some context with use cases but lacks depth on operational 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 front-loaded with the core purpose, followed by filtering details and practical examples. Every sentence earns its place by clarifying usage without redundancy. It is appropriately sized at two sentences, 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 the tool's moderate complexity (5 parameters, no output schema, no annotations), the description is fairly complete. It covers the purpose, filtering options, and use cases. However, it lacks details on return format or error scenarios, which would be helpful since there is no output schema. The schema handles parameters well, but the description could enhance behavioral context.

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

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

Schema description coverage is 100%, so the schema fully documents all 5 parameters. The description mentions filtering by product, variant, or order, which aligns with the schema but does not add meaning beyond it. No parameters are explained in the description, so it meets the baseline of 3 without compensating for 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 verb ('List') and resource ('individual order line items'), making the purpose specific. It distinguishes from siblings like 'slam_orders_list' by focusing on line items rather than full orders, and from 'slam_products_list' by targeting order-associated items. The examples reinforce 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 clear context for when to use this tool: for 'cross-order product queries' and filtering by product, variant, or order. It gives concrete examples like 'show all orders containing variant X' and 'which orders had this product?'. However, it does not explicitly state when not to use it or name specific 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?

No annotations are provided, so the description carries the full burden. It states the tool returns data, which implies a read-only operation, but does not disclose behavioral traits like error handling (e.g., what happens if the ID is invalid), rate limits, authentication needs, or whether it's idempotent. The description is minimal and misses key operational details.

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

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

The description is a single, efficient sentence that front-loads the key information ('Returns a single order by ID') and adds necessary details ('including line items, discount codes, and customer info') without any waste. It is appropriately sized for a simple tool with one parameter.

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 output schema, no annotations), the description is somewhat complete but lacks depth. It covers the basic purpose and what data is returned, but does not address behavioral aspects like error cases or performance, which are important for a read operation. It's adequate but has clear gaps in 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?

The schema description coverage is 100%, with the parameter 'id' fully documented in the schema as 'The order ID (Shopify GID)'. The description does not add any additional meaning beyond this, such as format examples or constraints. Since the schema does the heavy lifting, the baseline score of 3 is appropriate.

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

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

The description clearly states the specific action ('Returns a single order by ID') and resource ('order'), and distinguishes it from sibling tools like 'slam_orders_list' (which returns multiple orders) and 'slam_orders_search' (which searches orders). It also specifies the included details: 'line items, discount codes, and customer info', making the purpose explicit and differentiated.

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

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

The description implies usage when you need a specific order by its ID, but does not explicitly state when to use this tool versus alternatives like 'slam_orders_list' or 'slam_orders_search'. It provides some context (e.g., 'by ID'), but lacks explicit guidance on exclusions or prerequisites, such as whether the ID must be valid or if authentication is required.

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 pagination and filtering capabilities, which is helpful, but doesn't disclose important behavioral traits like rate limits, authentication requirements, error conditions, or what happens with invalid filter values. For a read operation with 6 parameters, 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 perfectly concise - a single sentence that efficiently communicates the core functionality (returns paginated order lists), key fields included (customer name, line item count), and primary filtering capabilities. Every word earns its place with zero 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?

For a read-only list tool with excellent schema coverage (100%) but no output schema, the description is adequate but minimal. It covers the basic purpose and filtering but doesn't address the return format, pagination behavior details, or how it differs from similar order-related tools. Given the complexity (6 parameters, no annotations), it should provide more contextual guidance.

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

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

Schema description coverage is 100%, so the schema already fully documents all 6 parameters. The description adds minimal value beyond the schema - it mentions filtering by financial_status and fulfillment_status (which the schema already describes) but doesn't provide additional context about parameter interactions or usage 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 returns a paginated list of orders with specific fields (customer name and line item count) and is filterable by statuses. It uses specific verbs ('returns', 'filterable') and identifies the resource ('orders'), but doesn't explicitly differentiate from sibling tools like 'slam_orders_get' or 'slam_orders_search'.

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

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

The description implies usage for retrieving filtered order lists with pagination, but doesn't explicitly state when to use this tool versus alternatives like 'slam_orders_get' (for single orders) or 'slam_orders_search' (which might offer different filtering capabilities). No 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions search functionality and support workflows but lacks details about permissions needed, rate limits, pagination behavior (beyond what's in schema), or what happens with no results. It adds some context but doesn't fully compensate for the absence of annotations.

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

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

The description is perfectly concise with two sentences that are front-loaded and zero waste. Every word contributes to understanding the tool's purpose and usage, with no redundant information.

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

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

For a search tool with 7 parameters, 100% schema coverage, but no annotations and no output schema, the description provides good purpose and usage guidance but lacks behavioral details (like authentication requirements, error handling, or result format) that would be helpful given the tool's complexity.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters thoroughly. The description mentions searchable fields (customer email/name, date range, status) but doesn't add syntax, format, or behavioral details beyond what the schema provides. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verbs ('Search orders') and resources ('orders'), and distinguishes it from siblings by specifying search capabilities (by customer email/name, date range, or status) that differentiate it from generic list tools like 'slam_orders_list'.

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 provides usage context with concrete examples ('find all orders from jane@example.com', 'show unfulfilled orders from last week') and specifies the intended workflow ('Use for support workflows'), giving clear guidance on when to use this tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior: it returns data from a specific view ('price_comparison view'), applies filtering logic ('only items on sale'), and specifies sorting ('biggest discount first'). However, it lacks details on permissions needed, rate limits, error conditions, or what the return format looks like (e.g., JSON structure, fields included).

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 front-loaded, with two sentences that efficiently convey the tool's purpose and key behavior. Every word earns its place, avoiding redundancy or fluff while clearly stating what the tool does and how it operates by default.

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

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

Given the tool's moderate complexity (4 parameters, no annotations, no output schema), the description is adequate but has gaps. It explains the core functionality and default behavior well, but lacks details on the return format, error handling, or authentication requirements. Without an output schema, the description should ideally hint at what fields are returned (e.g., 'variants with discount_percentage, price, compare_at_price'), but it doesn't.

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

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

Schema description coverage is 100%, so the schema fully documents all 4 parameters. The description adds minimal value beyond the schema—it mentions the default filtering behavior ('only items on sale') which aligns with the 'on_sale_only' parameter's default, but doesn't provide additional context about parameter interactions or usage examples. This meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('Returns variants with discount analysis') and resource ('from the price_comparison view'), with precise scope details ('only items on sale', 'sorted by biggest discount first'). It effectively distinguishes this tool from sibling tools like 'slam_prices_current' or 'slam_variants_list' by focusing on discount analysis rather than general pricing or variant listing.

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 ('discount analysis', 'items on sale'), but does not explicitly mention when not to use it or name specific alternatives. For example, it doesn't contrast with 'slam_prices_current' (which might show current prices without discount analysis) or 'slam_variants_list' (which lists all variants regardless of sale status).

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the filtering behavior for 'below_compare' but doesn't describe the return format (e.g., structure of price data), pagination behavior (implied by limit/offset but not explained), rate limits, authentication requirements, or error handling. For a read operation with 4 parameters and no annotations, 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 concise with two sentences that directly address purpose and key parameters. It's front-loaded with the main function and avoids unnecessary elaboration. However, the second sentence could be slightly more structured by separating the two parameter mentions more clearly.

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

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

Given the tool's moderate complexity (4 parameters, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose and hints at parameter usage but lacks details on return values, error conditions, and broader behavioral context. For a tool that returns pricing data, users would benefit from more information about the output structure and typical use 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 100%, so the schema already documents all 4 parameters thoroughly. The description adds marginal value by emphasizing the 'below_compare' parameter's purpose ('on sale') and mentioning product_id filtering, but doesn't provide additional syntax, format details, or examples beyond what the schema provides. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Returns current variant prices' (verb+resource). It distinguishes from siblings like slam_price_analysis or slam_variants_list by focusing specifically on pricing data rather than analysis or broader variant information. However, it doesn't explicitly contrast with all pricing-related siblings, keeping it at 4 rather than 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 some usage context: 'Use below_compare to show only variants where price < compare_at_price (on sale)' and 'Filterable by product_id.' This implies when to use certain parameters but doesn't explicitly state when to choose this tool over alternatives like slam_price_analysis or slam_variants_list, nor does it 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. While it indicates this is a read operation ('Returns'), it lacks critical behavioral details: it doesn't mention whether this is a safe read-only operation, what authentication might be required, potential rate limits, pagination behavior beyond limit/offset parameters, or what the return format looks like (e.g., array of image objects with URLs). For a tool with no annotation coverage, this leaves significant gaps in understanding how it behaves.

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 concise with two clear sentences that directly address the tool's function and primary filtering capability. It's front-loaded with the main purpose and avoids unnecessary elaboration. However, it could be slightly more structured by explicitly separating purpose from capabilities, but this is a minor issue.

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 (3 parameters, no output schema, no annotations), the description is minimally adequate but incomplete. It covers the basic purpose and mentions one filtering capability, but lacks information about return format, error conditions, authentication requirements, and how it differs from related product tools. For a read operation with no output schema, the description should ideally provide more context about what 'product images' actually returns.

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

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

Schema description coverage is 100%, with all three parameters (product_id, limit, offset) well-documented in the schema. The description adds minimal value beyond this, only mentioning that it 'Supports filtering by product_id' - which is already clear from the schema. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't provide additional semantic context about parameter interactions or usage 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: 'Returns product images from the product_media table' specifies both the verb (returns) and resource (product images from product_media table). It distinguishes itself from siblings like slam_products_get or slam_variants_get by focusing specifically on images. However, it doesn't explicitly contrast with potential similar tools like media-specific queries that might exist elsewhere.

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 some implied usage context by mentioning 'Supports filtering by product_id,' suggesting this is the primary filtering mechanism. However, it doesn't explicitly state when to use this tool versus alternatives like slam_products_get (which might include images) or other image-related tools. No guidance is given about prerequisites, when-not-to-use scenarios, or named alternatives among the 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 the full burden of behavioral disclosure. It describes the core functionality (returning ranked product pairs based on co-purchase frequency) but lacks details about performance characteristics, error conditions, data freshness, or authentication requirements. The description is adequate but doesn't provide rich behavioral context beyond the basic operation.

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

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

The description is perfectly structured with two sentences that each earn their place. The first sentence states the purpose and core functionality, while the second provides usage guidance. There's zero waste or redundancy, making it highly efficient and front-loaded.

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

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

Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description provides good coverage of what the tool does and when to use it. However, without an output schema, the description doesn't explain what the return values look like (e.g., format of product pairs, ranking metrics). For a tool that returns ranked data, this is a minor gap in completeness.

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

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

The schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description mentions the product_id parameter's purpose ('anchor product ID') and the effect of omitting it, but doesn't add significant semantic value beyond what's already in the schema descriptions. This meets the baseline expectation when schema coverage is complete.

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 ('Returns product pairs ranked by co-purchase frequency') and resources ('product pairs', 'orders'). It distinguishes itself from siblings by focusing on co-purchase analysis rather than product listings, collections, or other e-commerce functions.

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

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

The description provides explicit guidance on when to use the tool: 'Use to discover bundle opportunities.' It also specifies usage scenarios: 'Supply product_id to anchor on a specific product, or omit to see the top pairs across all orders.' This clearly differentiates it from alternative approaches.

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 it 'Returns the total count' but doesn't cover aspects like whether this is a read-only operation, performance implications, rate limits, or authentication requirements. For a tool with no annotations, this leaves significant behavioral 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 a single, efficient sentence that front-loads the core purpose ('Returns the total count of products') and succinctly adds filtering details. There is no wasted language, making it highly concise and well-structured.

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

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

Given the tool's low complexity (simple counting with optional filters), no output schema, and no annotations, the description is adequate but incomplete. It covers the basic purpose and parameters but lacks behavioral context and usage guidance, which are important for effective tool selection by an AI agent.

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

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

The description mentions optional filtering by status, vendor, or product_type, which aligns with the three parameters in the schema. Since schema description coverage is 100%, the schema already documents these parameters well, so the description adds minimal value beyond restating what's in the schema, meeting the baseline score.

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 ('Returns') and resource ('total count of products'), making it easy to understand what it does. However, it doesn't explicitly differentiate from sibling tools like 'slam_products_list' or 'slam_products_search', which likely return detailed product data rather than just counts.

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 optional filtering but doesn't specify scenarios where counting products is preferred over listing them, nor does it reference sibling tools for comparison, leaving usage context unclear.

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

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

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: it returns enriched data (variant count, sales metrics), handles products with no sales (shows zeros), and sources sales data from 'product_sales view'. However, it lacks details on permissions, rate limits, or error handling.

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

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

The description is a single, well-structured sentence that efficiently conveys the tool's purpose, enrichment details, and edge case handling ('Products with no sales show zeros'). Every part adds value with no wasted words.

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

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

For a read-only tool with 5 parameters and no output schema, the description is reasonably complete. It explains what data is returned and enrichment sources, but could benefit from mentioning pagination behavior (implied by limit/offset) or response format to fully compensate for the lack of output schema.

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

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

Schema description coverage is 100%, so the schema fully documents all 5 parameters. The description does not add any parameter-specific information beyond what the schema provides, such as explaining how 'collection_id' relates to Shopify or clarifying metric calculations. Baseline 3 is appropriate.

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

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

The description clearly states the specific action ('Returns all products in a collection') and resource ('products'), enriched with specific metrics ('variant count and sales metrics'). It distinguishes from siblings like 'slam_products_list' by focusing on products within a specific collection with sales enrichment.

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

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

The description implies usage for retrieving products in a collection with sales data, but does not explicitly state when to use this tool versus alternatives like 'slam_products_list' or 'slam_collections_for_product'. No 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 discloses the return content (variants, collection memberships, metafields), which adds useful behavioral context beyond the basic 'get' operation. However, it lacks details on error handling, permissions, or rate limits, which are important for a read operation in a Shopify context.

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

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

The description is a single, well-structured sentence that front-loads the core purpose ('Returns a single product by ID') and efficiently adds details on included data. There is no wasted verbiage, making it highly concise 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 and no output schema, the description provides adequate context for a simple read operation by specifying the return content. However, it lacks details on output structure, error cases, or dependencies, which could be helpful for an AI agent to handle this tool robustly in a complex environment like Shopify.

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

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

Schema description coverage is 100%, with the schema clearly documenting the 'id' parameter as 'The product ID (Shopify GID)'. The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline of 3 for high schema coverage without extra value.

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

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

The description clearly states the specific action ('Returns a single product by ID') and resource ('product'), and distinguishes it from siblings by specifying the inclusion of 'variants, collection memberships, and metafields', which is more detailed than generic list/search tools like slam_products_list or slam_products_search.

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

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

The description implies usage context by specifying 'by ID' and the included data, suggesting it's for retrieving detailed information about a known product. However, it doesn't explicitly state when to use this versus alternatives like slam_products_list (for listing) or slam_variants_get (for variant-specific details), leaving some ambiguity.

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's a read operation (implied by 'Returns'), it's paginated, it includes variant counts, and it supports specific filtering parameters. It also explains the 'data_quality' parameter's effect in detail. However, it doesn't mention rate limits, authentication needs, or error conditions.

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

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

The description is perfectly concise with two sentences that each earn their place. The first sentence establishes core functionality, the second provides crucial detail about the 'data_quality' parameter. No wasted words, and 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 read-only list tool with 100% schema coverage but no output schema, the description provides good context about what's returned (products with variant counts) and filtering behavior. It could be more complete by mentioning response format or pagination details, but given the tool's relative simplicity and good schema documentation, it's mostly adequate.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some value by explaining the 'data_quality' parameter's semantics with concrete examples ('no_description' returns only products with empty body_html'), but doesn't significantly enhance understanding beyond what's already documented in the schema for other parameters.

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

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

The description clearly states the tool's purpose with specific verbs ('Returns a paginated list of products with variant counts') and distinguishes it from siblings like 'slam_products_get' (single product) and 'slam_products_search' (likely keyword-based). It explicitly mentions filtering capabilities and variant counts, which are unique aspects.

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 its filtering examples (e.g., 'Supports filtering by status, vendor, and product_type'), but doesn't explicitly state when to use this tool versus alternatives like 'slam_products_search' or 'slam_products_get'. No explicit when-not-to-use guidance or prerequisite information is provided.

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

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

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: LIKE matching (fuzzy search), pagination support, and that results include variant counts. However, it doesn't mention performance characteristics, rate limits, authentication requirements, or error conditions that would be important for a search tool.

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

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

Two sentences with zero waste. The first sentence covers the core functionality and search fields, the second covers pagination and result structure. Every word earns its place 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 search tool with no annotations and no output schema, the description provides adequate but minimal context. It covers what the tool does and basic behavior, but doesn't explain the structure of returned results beyond 'paginated results with variant counts', nor does it address error cases or performance considerations.

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

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

Schema description coverage is 100%, so the schema already fully documents all three parameters. The description adds minimal value beyond the schema - it mentions LIKE matching which relates to the query parameter, but doesn't provide additional semantic context about parameter interactions or usage 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 action ('Searches products') and specifies the searchable fields (title, vendor, product_type, tags) with LIKE matching. It distinguishes itself from sibling tools like slam_products_list, slam_products_get, and slam_products_top by focusing on multi-field search 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 implies usage for searching across multiple product attributes, but doesn't explicitly state when to use this versus alternatives like slam_products_list (which likely lists without search) or slam_products_get (which likely retrieves a specific product). No guidance on when NOT to use this tool is provided.

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

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

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: pagination support, filtering capabilities, and the data source constraint ('only products with at least one order appear'). However, it doesn't mention rate limits, authentication requirements, error conditions, or response format details.

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

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

The description is efficiently structured in two sentences: the first states the core purpose and key features, the second provides important data source context. Every sentence adds value with zero wasted words, making it easy to parse 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?

For a read-only tool with 6 well-documented parameters but no output schema, the description provides adequate context about what the tool does and its data constraints. However, it lacks details about the return format, error handling, or performance characteristics that would be helpful for an agent invoking this tool.

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

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

Schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly. The description adds minimal value beyond the schema, mentioning 'pagination, sort direction, and optional vendor/product_type filters' but not providing additional context about parameter interactions or usage 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 verb ('Returns') and resource ('products ranked by sales performance'), specifying the ranking metrics (revenue, units sold, or order count). It distinguishes from sibling tools like 'slam_products_list' or 'slam_products_search' by focusing on performance ranking rather than general listing or search.

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

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

The description implies usage for sales performance analysis but doesn't explicitly state when to use this tool versus alternatives like 'slam_products_list' or 'slam_products_search'. It mentions the underlying view ('product_sales') which helps understand scope, but lacks explicit guidance on use cases 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 the tool returns data (a read operation) but doesn't cover critical aspects like whether it's paginated (implied by limit/offset but not stated), rate limits, authentication needs, error conditions, or data freshness. For a read 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 a single, efficient sentence that front-loads the core purpose ('Returns refund records joined with refund line items') and adds clarifying detail. There's no wasted verbiage, though it could be slightly more structured (e.g., separating purpose from data 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 the tool's moderate complexity (a read operation with joined data), lack of annotations, and no output schema, the description is minimally adequate. It covers what data is returned but omits behavioral context (e.g., pagination, performance) and output format details. For a tool with 100% schema coverage but no other structured support, it meets the baseline.

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

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

The input schema has 100% description coverage, with clear documentation for 'limit' and 'offset' parameters. The description adds no parameter-specific information beyond what the schema provides, such as how these parameters affect the joined data or typical usage patterns. With high schema coverage, the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Returns refund records joined with refund line items' specifies the verb and resource, and 'Shows refund amounts, reasons, and order context' adds detail about the data returned. It distinguishes from siblings like 'slam_returns_summary' by focusing on refunds rather than general returns, but doesn't explicitly contrast with other refund-related tools (none are listed).

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, context for selecting it over other tools (e.g., 'slam_orders_list' or 'slam_returns_summary'), or any exclusions. The agent must infer usage from the tool 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. While it indicates a read operation ('returns'), it lacks details on permissions, rate limits, pagination behavior (beyond the 'limit' and 'offset' parameters), or error handling. The description does not add meaningful context beyond the basic operation, leaving gaps in understanding how the tool 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 a single, efficient sentence that clearly states the tool's purpose without unnecessary words. It is front-loaded with the core functionality, making it easy to grasp quickly. However, it could be slightly improved by adding a brief note on usage context, but as is, it avoids redundancy and 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 complexity (a read operation with filtering and pagination), no annotations, and no output schema, the description is minimally adequate. It covers what data is returned but lacks details on output format, error cases, or integration with sibling tools. While it meets a basic threshold, it does not fully compensate for the missing structured information, leaving room for improvement in completeness.

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

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

The input schema has 100% description coverage, with clear documentation for 'status', 'limit', and 'offset' parameters. The description does not add any semantic details beyond what the schema provides, such as explaining the join operation's impact on results or default behaviors. Given the high schema coverage, a baseline score of 3 is appropriate, as the schema adequately covers parameter meanings without extra description.

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

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

The description clearly states the tool's purpose: 'Returns return records from the returns table, joined with return line item counts.' It specifies the verb ('returns'), resource ('return records'), and scope ('joined with return line item counts'), making it easy to understand what data is retrieved. However, it does not explicitly differentiate from sibling tools like 'slam_refunds_summary', which might handle related but different data, leaving some ambiguity about when to choose this specific tool.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, context for usage, or comparisons to sibling tools such as 'slam_refunds_summary' or 'slam_orders_list', which might handle overlapping data. This lack of explicit usage instructions could lead to confusion in selecting the appropriate tool for a given task.

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 an excellent job disclosing key behavioral traits: read-only nature, validation, pagination support, money column warnings, fuzzy error suggestions, and allowed statement types. The only minor gap is lack of explicit mention about authentication requirements 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 perfectly concise - a single sentence that packs essential information about the tool's purpose, constraints, and key features. Every word earns its place, and the information 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?

For a 4-parameter tool with no annotations and no output schema, the description provides excellent context about behavioral constraints and safety. The main gap is lack of information about return format or result structure, which would be helpful given the absence of an output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description doesn't add any parameter-specific information beyond what's already in the schema descriptions (e.g., it doesn't explain the relationship between sql/params or how limit/offset interact with existing LIMIT clauses).

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 ('Executes a read-only SQL query') and the target resource ('against the SLAM database'), with explicit mention of allowed statement types (SELECT, PRAGMA, EXPLAIN, WITH). It distinguishes itself from sibling tools by being a general query executor rather than a specific data retrieval function.

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 ('read-only SQL query') and implicitly suggests when not to use it (no DML/DDL statements allowed). However, it doesn't explicitly name alternatives or specify when to choose this over other sibling tools that might provide pre-built queries.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it returns aggregated data (not raw orders), includes specific metrics (order_count, total revenue, average order value), sorts results (most recent periods first), and implies read-only operation through 'returns.' However, it doesn't mention potential limitations like data freshness, permissions required, or error conditions.

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

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

The description is efficiently structured in two sentences: the first states the core purpose and output format, and the second adds crucial behavioral context (sorting order). Every phrase adds value with zero redundancy, 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?

For a read-only aggregation tool with full schema coverage but no output schema, the description is reasonably complete. It explains what the tool does, key metrics, and sorting behavior. However, without annotations or output schema, it could benefit from clarifying the return format (e.g., JSON structure) or any data constraints, slightly limiting completeness for agent invocation.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters. The description adds no additional parameter semantics beyond what's in the schema—it doesn't explain parameter interactions, default reasoning, or usage examples. The baseline score of 3 reflects adequate coverage through the schema alone.

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

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

The description clearly states the tool's purpose with specific verbs ('returns orders grouped by day, week, or month') and resources ('sales performance'), distinguishing it from siblings like slam_sales_summary or slam_orders_list by focusing on time-series aggregation rather than summary statistics or raw order listings.

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 time-series analysis of sales performance but provides no explicit guidance on when to use this tool versus alternatives like slam_sales_summary or slam_orders_list. It mentions 'most recent periods first' as a behavioral detail but doesn't define appropriate contexts or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the output content well but fails to mention critical behavioral traits such as whether this is a read-only operation, potential rate limits, authentication requirements, or data freshness. For a dashboard tool with no 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 efficiently structured in a single sentence that front-loads the core purpose and lists all output components without unnecessary words. Every element (verb, resource, output details, filter note) earns its place with zero 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 moderate complexity (dashboard with multiple metrics), no annotations, and no output schema, the description adequately covers what the tool returns but lacks completeness regarding behavioral aspects (safety, performance, constraints) and detailed output structure. It's minimally viable but has clear gaps.

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

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

Schema description coverage is 100%, so the schema already fully documents the single optional parameter. The description adds minimal value by mentioning the optional filter in natural language but provides no additional semantics beyond what's in the schema (e.g., example values beyond those listed). Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the specific action ('Returns') and resource ('store sales dashboard') with detailed output components (total orders, revenue, average order value, breakdowns, top products). It distinguishes from sibling tools like 'slam_sales_by_period' by focusing on a comprehensive dashboard rather than period-based analysis.

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 by specifying the optional filter parameter ('Optionally filter by financial_status'), but does not explicitly mention when to use this tool versus alternatives like 'slam_sales_by_period' or 'slam_store_snapshot'. The guidance is helpful but lacks sibling differentiation.

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 it 'Returns subscription selling plan groups with plan and product counts,' which implies a read-only operation, but doesn't disclose behavioral traits like pagination behavior (implied by limit/offset but not explained), rate limits, authentication needs, or error conditions. The description is minimal and lacks critical 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 a single, efficient sentence that directly states the tool's function without unnecessary words. It's front-loaded with the core action ('Returns') and resource, making it easy to parse quickly. Every word earns its place, achieving optimal conciseness.

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

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

Given the complexity of a list operation with pagination parameters and no output schema, the description is incomplete. It doesn't explain the return format (e.g., structure of 'selling plan groups' or what 'plan and product counts' entail), pagination behavior, or any error handling. With no annotations and missing output details, it leaves significant gaps for an agent to use the tool effectively.

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

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

Schema description coverage is 100%, with both parameters ('limit' and 'offset') well-documented in the schema. The description adds no additional parameter semantics beyond what the schema provides (e.g., it doesn't explain how 'plan and product counts' relate to the parameters). Given the high schema coverage, a baseline score of 3 is appropriate.

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

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

The description clearly states the verb ('Returns') and resource ('subscription selling plan groups'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'slam_products_list' or 'slam_collections_list' that might also return lists of different entities, leaving room for minor ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are no mentions of prerequisites, context, or comparisons to sibling tools (e.g., 'slam_products_list' for products or 'slam_collections_list' for collections), leaving the agent to infer usage based on the name alone.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns a snapshot with specific data types (sales, inventory, issues, freshness) and is a one-call operation, which is useful behavioral context. However, it lacks details on permissions, rate limits, or response format, leaving 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 two sentences, front-loaded with the core purpose and followed by a clarifying benefit. Every sentence earns its place by specifying what the tool does and why it's useful, with zero waste or redundancy.

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

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

Given the tool's complexity (providing a multi-faceted health snapshot) and lack of annotations and output schema, the description is somewhat complete but has gaps. It explains the data included and the one-call advantage, but doesn't cover behavioral aspects like error handling or output structure, which could be critical for an agent.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately adds no parameter details, maintaining focus on the tool's purpose and usage. Baseline is 4 for 0 parameters, as it avoids unnecessary repetition.

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 ('returns') and resources ('store health snapshot'), detailing exactly what it provides: sales totals, inventory counts, data condition issue counts, and sync freshness. It distinguishes itself from siblings by emphasizing it answers 'what is the state of my store right now?' without requiring multiple tool calls, unlike other tools that focus on specific aspects like inventory or orders.

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

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

The description explicitly states when to use this tool: to get a comprehensive store health snapshot in one call, answering 'what is the state of my store right now?' It implies when not to use it by noting it avoids 'requiring multiple tool calls,' suggesting alternatives like using sibling tools for more detailed or specific queries (e.g., slam_inventory_summary for inventory-only data).

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' data, implying a read-only operation, but doesn't clarify aspects like error handling (e.g., what happens with an invalid product_id), performance (e.g., response time or data size), or the JSON structure of option_values. For a tool with no annotations, this leaves significant gaps in understanding its behavior and limitations.

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

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

The description is concise and front-loaded, consisting of a single sentence that directly states the tool's purpose. There is no wasted language or redundancy. However, it could be slightly more structured by explicitly mentioning the parameter or usage context, but overall, it efficiently conveys the core functionality without unnecessary 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 the tool's low complexity (one parameter, no output schema, no annotations), the description is minimally complete. It covers the basic purpose and data source but lacks details on behavioral traits, error handling, and differentiation from siblings. For a simple read operation, this might suffice, but the absence of annotations and output schema means the description should ideally provide more context to fully guide usage, resulting in an adequate but not comprehensive 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 input schema has 100% description coverage, with the 'product_id' parameter clearly documented as 'The product ID to fetch options for.' The description adds minimal value beyond this, only implying that product_id is used to fetch from the product_options table. Since the schema already provides adequate parameter semantics, the baseline score of 3 is appropriate, as the description doesn't significantly enhance or detract from the schema's 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: 'Returns product option names and values from the product_options table.' It specifies the verb ('returns'), resource ('product option names and values'), and data source ('product_options table'), which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'slam_variants_get' or 'slam_products_get', which might also retrieve product-related data, leaving some ambiguity about when this specific tool is uniquely appropriate.

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, such as needing a valid product ID, or compare it to sibling tools like 'slam_variants_get' or 'slam_products_get' that might handle similar product data. Without this context, users must infer usage from the tool name and parameters alone, which is insufficient for optimal selection.

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

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

No annotations are provided, so the description carries the full burden. It states this is a read operation ('Returns'), which is helpful, but doesn't disclose behavioral traits such as error handling (e.g., what happens if the ID is invalid), performance characteristics, or any limitations (e.g., rate limits, authentication needs). The description is minimal and misses key operational details.

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

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

The description is a single, efficient sentence that front-loads the core action ('Returns a single variant by ID') and includes relevant details. There's no wasted language, making it appropriately concise for a simple retrieval tool. However, it could be slightly more structured by separating usage context from return 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 the tool's low complexity (single parameter, read-only operation) and no output schema, the description is adequate but incomplete. It specifies what data is returned but doesn't cover the return format, error cases, or behavioral context. With no annotations, it should provide more operational guidance to be fully helpful for an AI agent.

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

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

The schema description coverage is 100%, with the single parameter 'id' fully documented in the schema as 'The variant ID (Shopify GID).' The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints. Given the high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't need to heavily.

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