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

Annotations already declare readOnlyHint=false and idempotentHint=false, indicating this is a non-idempotent write operation. The description adds the behavioral context of 'adding to a log,' which implies persistence and mutation, but doesn't provide additional behavioral details like whether duplicates are allowed, what happens on invalid product_id, or how the system handles conflicts. The description doesn't contradict annotations, but adds minimal value beyond them.

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 purpose without any fluff or redundant information. It's appropriately sized and front-loaded with the core action, 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 mutation tool with 6 parameters and no output schema, the description is minimally adequate. It states what the tool does, but lacks context about prerequisites, error conditions, or what happens after the add operation. With annotations covering safety (non-readOnly) and idempotency, and schema covering parameters, the description fills basic gaps but doesn't provide a complete picture 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?

Schema description coverage is 100%, with all parameters well-documented in the schema itself (e.g., product_id as UUID, date format, daytime enum values, amount in base units). The description adds no parameter-specific information beyond what's already in the schema, so it meets the baseline for high schema coverage without compensating with additional semantic 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 action ('Add') and resource ('food item to user consumption log'), providing a specific verb+resource combination. However, it doesn't explicitly distinguish this tool from its sibling 'remove_user_consumed_item' beyond the obvious add/remove difference, nor does it clarify how it differs from 'add_user_water_intake' in the broader context of consumption logging.

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 (like needing a valid product_id from 'get_product' or 'search_products'), nor does it clarify when to use this versus 'add_user_water_intake' for different consumption types. There's no explicit when/when-not guidance 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?

Annotations indicate this is a non-readOnly, non-idempotent tool (mutation with side effects), which the description aligns with by implying data modification ('Log a water intake entry'). The description adds valuable context beyond annotations by specifying the required cumulative calculation process, though it doesn't detail potential errors, rate limits, or authentication needs. No contradiction exists.

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 essential usage instructions. Both sentences are necessary and efficient, with no redundant information. It's appropriately sized for a tool with two parameters and clear behavioral context.

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 (mutation with a specific calculation process), annotations cover safety hints, and schema fully describes parameters, but there's no output schema. The description compensates well by explaining the cumulative calculation requirement, though it could mention the return value or error handling. It's largely complete 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?

Schema description coverage is 100%, so the schema already fully documents the parameters (date format, water_intake as cumulative ml). The description reiterates the format and cumulative nature but doesn't add significant semantic details beyond the schema, such as validation rules or edge cases. 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 specific action ('Log a water intake entry') with the resource ('water intake') and distinguishes it from sibling tools like 'get_user_water_intake' (which retrieves data) and 'add_user_consumed_item' (which handles different consumables). It precisely defines the tool's function without being vague or tautological.

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 by stating 'Always get the latest water intake first and add the new amount to calculate the cumulative value,' which implies an alternative approach (using 'get_user_water_intake' before this tool) and clarifies the prerequisite step for correct usage. It effectively distinguishes this from read-only 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?

Annotations already declare readOnlyHint=true (safe read), openWorldHint=true (may return null for unknown IDs), and idempotentHint=true (safe to retry). The description adds that it retrieves 'detailed information' (implying comprehensive data), which provides useful context beyond annotations. However, it doesn't describe error behavior, rate limits, or authentication needs.

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 wasted words. It front-loads the core purpose ('Get detailed information') and specifies the key constraint ('by ID'). Every part 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 simplicity (1 parameter, no output schema) and rich annotations (covering safety and idempotency), the description is reasonably complete. It clarifies the scope ('detailed information') and retrieval method. However, without an output schema, it could briefly hint at the return structure (e.g., 'including price, description, etc.') for better 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%, with the parameter 'id' fully documented as a UUID-formatted Product ID. The description adds no additional parameter semantics beyond what the schema provides (e.g., no examples of valid IDs or format details). Baseline 3 is appropriate when schema does all the work.

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 ('Get') and resource ('detailed information about a specific product'), making the purpose unambiguous. It specifies retrieval by ID, which distinguishes it from search_products (which likely searches by criteria). However, it doesn't explicitly differentiate from other get_* tools beyond the resource type.

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

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

The description implies usage when you have a specific product ID and need detailed information. It doesn't provide explicit when-not-to-use guidance or name alternatives (like search_products for when you don't have an ID). The context is clear but lacks explicit exclusion criteria.

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?

Annotations already indicate readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds no behavioral context beyond this, such as authentication needs, rate limits, or what specific profile information is returned, but it doesn't contradict the 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 with no wasted words, clearly front-loading the purpose. It's appropriately sized for a simple tool with no parameters, 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 simplicity (0 parameters, no output schema) and annotations covering safety, the description is adequate but minimal. It lacks details on what 'profile information' includes or how it differs from sibling tools, leaving some contextual gaps for the 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?

With 0 parameters and 100% schema description coverage, the schema fully documents the lack of inputs. The description implies no parameters are needed, which aligns with the schema, so it adds minimal but sufficient value, earning a baseline score for this scenario.

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 ('Get') and resource ('Yazio user profile information'), making the purpose specific and understandable. However, it doesn't differentiate from sibling tools like 'get_user_settings' or 'get_user_goals', which also retrieve user-related data, so it falls short of a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'get_user_daily_summary' or 'get_user_weight', there's no indication of whether this tool is for general profile info or how it relates to other user-specific tools, leaving usage 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds minimal behavioral context beyond this, stating it retrieves data for a specific date but not detailing return format, pagination, or error handling. With annotations covering core safety, a 3 is appropriate for limited added value.

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 ('Get food entries') with the key constraint ('for a specific date'). There is zero wasted verbiage, 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 (1 parameter, 100% schema coverage, read-only/idempotent annotations) but lack of an output schema, the description is minimally adequate. It covers the basic operation but doesn't explain return values or potential edge cases, leaving gaps in 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%, with the 'date' parameter fully documented in the schema as a YYYY-MM-DD format string. The description implies date-based filtering but adds no syntax or format details beyond what the schema provides. Baseline 3 is correct 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 verb 'Get' and the resource 'food entries' with the scope 'for a specific date', making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'get_user_daily_summary' or 'get_user_consumed_item' (which appears to be a write operation), missing full 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 doesn't mention sibling tools like 'get_user_daily_summary' for aggregated data or 'search_products' for broader queries, nor does it specify prerequisites or exclusions for 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?

Annotations already indicate read-only and idempotent behavior, so the description doesn't need to repeat safety aspects. However, it adds no additional behavioral context such as rate limits, authentication requirements, or what the summary includes (e.g., calories, nutrients), resulting in a baseline score with minimal added value.

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 purpose without unnecessary words. It's front-loaded with the core action and resource, 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?

Given the simple single parameter with full schema coverage and annotations covering safety, the description is adequate for a basic read operation. However, without an output schema, it doesn't explain what the summary contains (e.g., format, data fields), leaving a gap in completeness 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?

Schema description coverage is 100%, with the parameter 'date' fully documented in the schema. The description mentions 'for a specific date' but adds no semantic details beyond what the schema provides, such as date range constraints or default behaviors, aligning with 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 action ('Get') and resource ('daily nutrition summary') with a specific constraint ('for a specific date'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_user_consumed_items' or 'get_user_exercises' that might also provide daily 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 no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_user_consumed_items' for detailed item lists or 'get_user_goals' for goal-related summaries, leaving the agent with no explicit 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds no behavioral context beyond what annotations provide - no information about authentication needs, rate limits, or what specific data is returned. With annotations covering the safety profile, a baseline 3 is appropriate.

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 states exactly what the tool does without any wasted words. It's appropriately sized for a simple retrieval 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 simple read-only tool with good annotations (readOnlyHint, idempotentHint) and no parameters, the description is minimally adequate. However, without an output schema, the description doesn't explain what data is returned (e.g., format, structure, or specific dietary fields). Given the complexity is low but output is undocumented, a score of 3 reflects this gap.

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 the schema fully documents the absence of inputs. The description doesn't need to compensate for any parameter gaps. A baseline of 4 is appropriate for parameterless tools where the schema already provides complete documentation.

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

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

The description clearly states the verb 'Get' and the resource 'user dietary preferences and restrictions', making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'get_user' or 'get_user_settings', but the specificity of 'dietary preferences and restrictions' provides reasonable distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_user' (which might include dietary data) or 'get_user_settings'. There's no mention of prerequisites, context, or exclusions that would help an agent choose between similar retrieval 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds minimal behavioral context by specifying the date/date range scope, but doesn't disclose other traits like rate limits, authentication needs, or what specific exercise data is returned. With annotations covering safety, a 3 is appropriate as the description adds some value but not rich behavioral 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 purpose without unnecessary words. Every part of the sentence earns its place by specifying the action, resource, and scope, making it appropriately sized for a simple 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 (1 parameter, no output schema, simple annotations), the description is adequate but has gaps. It covers the basic purpose and scope, but lacks usage guidelines, detailed behavioral context beyond annotations, and clarification on date range handling. For a read-only tool with good annotations, it meets minimum viability but could be more 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%, with the parameter 'date' fully documented in the schema as a date in YYYY-MM-DD format. The description mentions 'date or date range' but doesn't clarify how to specify a range (e.g., if multiple dates or a start/end are supported), adding only marginal semantic value beyond the schema. Baseline 3 is correct when the schema handles most parameter documentation.

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

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

The description clearly states the action ('Get') and resource ('user exercise data') with scope ('for a date or date range'), making the purpose immediately understandable. However, it doesn't explicitly distinguish this tool from sibling tools like 'get_user_daily_summary' or 'get_user_goals' that might also involve user data retrieval, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_user_daily_summary' or 'get_user_goals', nor does it mention prerequisites or exclusions. It only states what the tool does, leaving the agent to infer usage context from the tool name alone.

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

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

Annotations indicate readOnlyHint=true and idempotentHint=true, which already inform the agent that this is a safe, non-destructive read operation with idempotent behavior. The description adds no additional behavioral context beyond this, such as rate limits, authentication needs, or response format details. Since annotations cover the core safety profile, the description meets the lower bar but doesn't enrich behavioral understanding.

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: 'Get user nutrition and fitness goals.' It is front-loaded with the core purpose, has no unnecessary words, and efficiently communicates the tool's function without any fluff. This makes it easy for an agent to parse and understand quickly.

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

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

Given the tool's simplicity (0 parameters, no output schema) and the presence of annotations that cover safety and idempotency, the description is minimally adequate. It states what the tool does but lacks details on return values or usage context. For a read-only tool with no parameters, this is acceptable but leaves room for improvement in guiding the agent on when and how to use it 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 input schema has 0 parameters with 100% coverage, meaning no parameters are documented in the schema. The description doesn't mention any parameters, which is appropriate here as there are none to explain. This aligns with the baseline score of 4 for zero parameters, as the description doesn't need to compensate for missing schema information.

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

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

The description clearly states the tool's purpose: 'Get user nutrition and fitness goals.' It specifies the verb ('Get') and the resource ('user nutrition and fitness goals'), making it easy to understand what the tool does. However, it doesn't explicitly distinguish this tool from sibling tools like 'get_user' or 'get_user_daily_summary,' which might also retrieve user-related data, so it misses full 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 doesn't mention any specific context, prerequisites, or exclusions, nor does it refer to sibling tools. This lack of usage instructions leaves the agent to infer when this tool is appropriate, which could lead to incorrect selections in a server with multiple user-data retrieval 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds no behavioral context beyond this, such as rate limits, authentication needs, or what specific settings are returned. Since annotations cover key safety aspects, a baseline score of 3 is appropriate, but the description doesn't enhance transparency further.

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 purpose without any wasted words. It's appropriately sized and front-loaded, 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?

Given the tool's simplicity (0 parameters, read-only/idempotent annotations) and lack of an output schema, the description is minimally adequate. However, it doesn't explain what 'settings and preferences' entail or the return format, which could be helpful for an agent. With annotations providing safety info, it meets a basic threshold but lacks depth 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?

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't mention parameters, which is acceptable here. A baseline of 4 is given because the schema fully handles the parameter semantics, and the description doesn't need to compensate for any 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 ('Get') and resource ('user settings and preferences'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_user' or 'get_user_dietary_preferences', which might retrieve overlapping or related user data, so it doesn't reach the highest 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, such as distinguishing it from 'get_user' (which might return general user info) or 'get_user_dietary_preferences' (which might be a subset of settings). There's no mention of prerequisites, context, or exclusions, leaving usage ambiguous.

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?

Annotations provide readOnlyHint=true, openWorldHint=true, and idempotentHint=true, indicating a safe, non-destructive operation with open-ended data and repeatable results. The description adds no behavioral details beyond this, such as rate limits, authentication needs, or what 'suggestions' entail (e.g., algorithm, freshness). It doesn't contradict annotations, but offers minimal extra context, meeting the lower bar with annotations present.

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: 'Get product suggestions for the user'. It's front-loaded with the core action and resource, with zero wasted words. Every part earns its place by stating the tool's purpose directly, 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 (2 optional parameters, no output schema) and rich annotations (covering safety and behavior), the description is minimally adequate. It states what the tool does but lacks details on output format, personalization aspects, or differentiation from siblings. With annotations handling key behavioral traits, it's complete enough for basic use but leaves gaps in 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 clear descriptions for 'query' (optional search) and 'limit' (maximum results). The description adds no parameter semantics beyond the schema, such as how 'query' influences suggestions or default behaviors. With high schema coverage, the baseline is 3, as the description doesn't compensate but doesn't detract either.

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's purpose as 'Get product suggestions for the user', which is clear but vague. It specifies the verb 'Get' and resource 'product suggestions', but doesn't distinguish it from sibling tools like 'get_product' or 'search_products', nor does it clarify what makes these suggestions 'for the user' (e.g., personalized vs. general). This is a basic, functional statement without specificity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools such as 'get_product' or 'search_products', nor does it specify contexts like personalization, recommendation scenarios, or prerequisites. Usage is implied only by the name, with no explicit when/when-not instructions.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds the date-specific constraint, which is useful context beyond annotations. However, it doesn't describe return format, error conditions, or data freshness - leaving behavioral gaps despite 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 a single, efficient sentence with zero wasted words. It's appropriately sized for a simple retrieval tool and front-loads the essential information without 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?

For a simple read operation with good annotation coverage (readOnly, idempotent) and full schema documentation, the description is minimally adequate. However, without an output schema, the description should ideally mention what data structure or units are returned (e.g., milliliters, ounces, timestamped entries). The current description leaves return values 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?

With 100% schema description coverage, the schema fully documents the single 'date' parameter with format and pattern details. The description mentions 'specific date' but adds no additional semantic context 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 action ('Get') and resource ('water intake data') with a specific scope ('for a specific date'), which distinguishes it from general data retrieval tools. However, it doesn't explicitly differentiate from sibling tools like 'get_user_daily_summary' which might also contain water intake information.

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 'get_user_daily_summary' or 'get_user_consumed_items' (which might include water intake). There's no mention of prerequisites, constraints, or comparative use cases with 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?

Annotations indicate readOnlyHint=true and idempotentHint=true, which already inform the agent this is a safe, non-destructive read operation. The description adds no behavioral context beyond this, such as rate limits, authentication needs, or what 'weight data' entails (e.g., format, timestamps). Since annotations cover key safety aspects, the description meets a baseline but lacks added value like performance or error 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 'Get user weight data' is a single, clear sentence with no wasted words. It is front-loaded and efficiently conveys the core action, making it easy to parse. Given the simplicity of the tool, this conciseness is appropriate and effective.

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

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

With no output schema, the description should ideally explain return values, but it does not. Annotations provide safety info, and the zero-parameter schema is fully covered. However, for a data retrieval tool, the description lacks details on what 'weight data' includes (e.g., numeric values, dates, units), making it incomplete for guiding the agent on expected outputs. It is minimally adequate given the low complexity.

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

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

The input schema has 0 parameters with 100% coverage, meaning no parameters are documented in the schema. The description does not mention any parameters, which is appropriate here. It implies the tool might fetch weight data without inputs (e.g., for a default user), but does not clarify if this is user-specific or global. Baseline is 4 due to zero parameters, though it could hint at implicit context like user authentication.

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 'Get user weight data' restates the tool name 'get_user_weight' with minimal elaboration, making it tautological. It specifies the verb 'get' and resource 'user weight data' but lacks detail about what weight data includes (e.g., current weight, historical trends, units) or how it differs from siblings like 'get_user' or 'get_user_daily_summary'. This is vague and fails to distinguish from related tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention context, prerequisites, or exclusions, such as whether it retrieves only the latest weight or a history, or if it should be used over 'get_user_daily_summary' for weight-specific data. This absence of usage instructions leaves 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?

Annotations already indicate this is a destructive, non-read-only, idempotent operation. The description adds minimal behavioral context beyond this, such as specifying it removes from a 'consumption log,' but doesn't detail effects like whether removal is permanent or affects related data. No contradiction with annotations exists.

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, direct sentence with no wasted words, clearly front-loading the core action. It's appropriately sized for a simple tool, 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?

Given the tool's destructive nature (per annotations) and lack of output schema, the description is minimally adequate but could better address risks or confirmations. It covers the basic action but doesn't enhance understanding of outcomes or error cases, leaving some 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?

With 100% schema description coverage, the input schema fully documents the 'itemId' parameter as a UUID for the consumed item. The description adds no extra semantic details beyond implying the item is in a 'consumption log,' which is redundant with the schema's description, meeting the baseline for high 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 ('Remove') and resource ('food item from user consumption log'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'add_user_consumed_item' beyond the obvious verb difference, missing nuance about scope or constraints.

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. It doesn't mention prerequisites (e.g., needing an existing item ID), exclusions, or how it relates to siblings like 'get_user_consumed_items' for verification, 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?

The annotations already indicate this is a read-only, open-world, and idempotent operation, which the description doesn't contradict. The description adds value by specifying the database source ('Yazio database') and the types of optional filters (sex, country, locale), providing context beyond the annotations. However, it doesn't mention potential limitations like result count, pagination, 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 a single, well-structured sentence that front-loads the core purpose ('Search for food products in Yazio database') and efficiently lists optional parameters. There is no wasted language, and every word contributes to understanding the tool's functionality.

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

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

Given the tool's moderate complexity (4 parameters, 1 required), rich annotations (readOnlyHint, openWorldHint, idempotentHint), and no output schema, the description is adequate but has gaps. It covers what the tool does and optional parameters but lacks details on return values, error handling, or usage examples. With annotations covering safety and idempotency, the description is minimally complete but could be more informative.

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

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

Schema description coverage is 75%, with three parameters having descriptions and one ('sex') lacking a description. The description mentions the optional parameters (sex, country, locale) but doesn't add significant meaning beyond what's in the schema (e.g., it doesn't explain why sex matters or how locales affect results). Since schema coverage is high, the baseline is 3, and the description provides minimal additional semantic 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 verb ('search for') and resource ('food products in Yazio database'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'get_product' or 'get_user_suggested_products', which might also retrieve product information. The description is specific about what it searches for but lacks sibling comparison.

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 context by mentioning optional parameters (sex, country, locale), which implies when to use them, but it doesn't give explicit guidance on when to choose this tool over alternatives like 'get_product' or 'get_user_suggested_products'. There's no mention of prerequisites, limitations, or scenarios where this tool is preferred versus others.

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