SAVORDISH

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds behavioral context by specifying the API key is 'the one you're using right now' and enumerates the returned data (call count, rate limit, creation date), adding value beyond 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 concise and well-structured: the main purpose is front-loaded, followed by the trigger list. Every sentence adds value, with no fluff or repetition of schema/annotation 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?

With zero parameters and no output schema, the description fully covers what the tool does and what it returns. The inclusion of trigger phrases makes it self-contained for an agent to invoke correctly.

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

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

The input schema has zero properties, so there are no parameters to explain. Baseline 4 applies since the description doesn't need to compensate for missing 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 tool checks the status of the API key in use, listing specific outputs (call count, rate limit, creation date). It uses a specific verb+resource and is clearly distinct from the cooking/recipe 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 explicitly provides trigger phrases ('check my API key', 'API key status', 'my usage') and states the tool is useful for monitoring MCP usage. This gives clear guidance on when to use it, and no alternatives exist 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the agent knows this is a safe, non-mutating operation. The description adds that it handles various units and includes triggers, but does not mention ingredient-specific density behaviors or output precision. Given the annotations, this level of added context is adequate but not enriching.

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

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

The description is compact: one purpose sentence plus a clear trigger list. Every element earns its place—the triggers are practical and directly aid selection. There is no redundancy or fluff.

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

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

For a straightforward conversion tool with complete schema annotations, the description provides sufficient context—unit examples, trigger phrases, and clear scope. The lack of an output schema is acceptable since the return value is likely simple and predictable. Not quite a 5 because it omits any note about unsupported unit handling or precision.

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% coverage with descriptions for all four parameters, including examples (e.g., fromUnit lists 'cups', 'tbsp', 'oz'). The description's unit list adds minimal new meaning beyond the schema. A baseline of 3 is appropriate since the schema carries the semantic weight.

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

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

The description opens with 'Convert between cooking measurement units', a specific verb+resource, and enumerates unit types (cups, tablespoons, grams, etc.). This clearly distinguishes it from sibling tools like cooking_get_substitutions or nutrition_analyze, which address different tasks.

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 'TRIGGERS' section provides explicit example user queries ('how many grams in a cup', 'convert tablespoons to cups') that signal when to use the tool. This is clear context for selection, though it does not explicitly mention when not to use it or name alternative tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no additional behavioral context, such as output format, error handling, or limitations. It primarily focuses on usage triggers rather than disclosing how the tool 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 front-loaded with a clear main sentence, followed by a labeled TRIGGERS section with four bullet-like examples. It is slightly longer than necessary but each trigger is informative. The structure is logical and aids scanning.

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 lookup tool with two parameters and no output schema, the description adequately covers purpose and usage. It lacks details about return behavior or edge cases, but the annotations and schema fill in safety and parameter information. The tool's low complexity means less is required.

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?

Both parameters have descriptive schema entries with 100% coverage, so the schema already explains meaning. The description's triggers provide real-world examples (e.g., 'dairy-free substitute for X') that map to the dietaryNeed parameter, but this does not add substantial new semantic information beyond the schema.

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

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

The description clearly states it retrieves ingredient substitutions for dietary needs, allergies, or missing ingredients. The verb 'Get' and resource 'ingredient substitutions' are specific, and the trigger examples further clarify what it does. It distinguishes from sibling nutrition tools by focusing on substitutions rather than analysis or planning.

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 TRIGGERS section explicitly lists example queries that should use this tool, such as 'substitute for X' and 'vegan alternative for X'. This provides clear contextual guidance on when to invoke. However, it does not mention alternative tools or when not to use this tool, so it falls short of the highest bar.

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, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, non-mutating operation. The description adds no new behavioral details (e.g., rate limits, auth requirements, output format) beyond confirming it is a knowledge-retrieval tool. It does not contradict 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 structured with a clear opening sentence, followed by TRIGGERS and TOPICS lists that are directly useful for an agent. It is moderately long but every section serves a purpose; it avoids fluff and is front-loaded with the main purpose.

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

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

For a simple tool with one parameter, no output schema, and strong annotations, the description covers purpose, trigger phrases, and topic examples. It is sufficiently complete for an agent to select and invoke correctly, though it could be more explicit about what the response contains (e.g., a list of tips vs. a single tip).

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% coverage with a detailed description of the 'topic' parameter, including examples like 'knife skills' and 'making pho broth'. The description's TOPICS list adds more examples but does not add significant new meaning beyond the schema, which already explains the parameter well.

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 'Get practical cooking tips and expert techniques for any topic,' which clearly identifies the verb (get) and resource (cooking tips). It also lists example topics (knife skills, rice, pho, grilling) that distinguish it from sibling tools like cooking_convert_units or cooking_get_substitutions, though it does not explicitly name these 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 TRIGGERS section provides explicit examples of when to invoke the tool ('how do I X', 'tips for X', 'best way to cook X'), giving an agent clear usage context. However, it does not specify when not to use this tool or direct the agent to alternative tools like cooking_convert_units or recipes_get.

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, idempotentHint=true, and destructiveHint=false, indicating safe read-only behavior. The description adds a benefit statement ('Saves time and reduces food waste') and trigger examples but does not disclose any additional behavioral traits such as output format or processing time, which is acceptable given 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 concise and well-structured with a clear opening sentence followed by a practical trigger list. Every sentence earns its place—the benefit statement and triggers add valuable guidance without redundancy or fluff.

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

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

The tool is simple with one parameter, full schema coverage, and strong annotations. The description sufficiently explains the tool's purpose and usage triggers. While no output schema exists, the description implies a text guide, which is adequate for this simple read-only 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 single parameter recipeSlug is fully documented in the input schema with a description and example ('chicken-pho'), providing 100% coverage. The tool description does not add further parameter semantics beyond what the schema already provides, so the 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 tool provides a 'meal prep guide' covering batch cooking, storage, and reheating, which is a specific verb+resource. It distinguishes from siblings like cooking_get_tips or recipes_get by focusing on meal prep specifically, and the additional triggers reinforce the unique scope.

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 includes a detailed TRIGGERS section with explicit example phrases for when to use the tool, providing clear usage context. However, it does not explicitly mention alternatives or when not to use it, but the trigger examples effectively guide the agent on appropriate invocation.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is established. The description adds that the input is a recipe or cuisine, but does not disclose any additional behavioral traits such as return format or number of pairings. Since annotations cover the main safety aspects, a score of 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 concise and well-structured: a single-purpose first sentence followed by a useful TRIGGERS list. Every line adds value, and there is no redundant or filler content.

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

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

For a simple two-parameter tool with annotations and a clear purpose, the description is largely complete. However, with no output schema, it does not describe what the return value looks like (e.g., list of pairing suggestions, whether they include descriptions). A short note on output format would make it 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%; both 'dish' and 'beverageType' already have clear descriptions and an enum for beverageType. The tool description adds no parameter-specific meaning beyond the schema, so it meets the baseline but does not exceed it.

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

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

The description opens with a specific verb and resource: 'Get wine, beer, cocktail, or non-alcoholic drink pairings for a recipe or cuisine.' It clearly differentiates from sibling tools like substitutions and tips by listing the exact beverage types and the pairing focus.

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

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

The TRIGGERS section provides explicit example queries for when to use this tool, such as 'what wine goes with X' and 'non-alcoholic pairing'. This gives clear positive usage context, though it does not mention when not to use it or explicitly name alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, providing the core safety profile. The description adds output context ('with recipe counts') but does not disclose additional behavioral traits beyond what annotations already cover.

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 plus a trigger list. The first sentence is clear and direct, while the second sentence somewhat restates the first. The trigger list is helpful but adds length. Overall, it is reasonably 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?

For a simple list tool with one optional parameter and comprehensive annotations, the description is complete. It explains what data is returned (cuisines with recipe counts) and provides example user queries, giving the agent sufficient context to invoke it correctly.

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

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

The single parameter minRecipes is fully documented in the schema with a description, default, minimum, and maximum. The description adds no additional parameter semantics, and with 100% 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 'List all available cuisines on SAVOR Dish with recipe counts', which is a specific verb+resource combination. It also distinguishes this tool from sibling tools like recipes_list_by_cuisine by focusing on cuisine categories rather than individual recipes.

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 TRIGGERS section provides explicit example queries that indicate when to use this tool, such as 'what cuisines do you have' and 'list all cuisines'. This gives clear context, though it does not explicitly mention alternatives or when not to use the 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering safety. The description adds context that the tool generates suggestions using real recipes and returns meal recommendations, which gives a clearer behavioral picture beyond the annotation hints.

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

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

The description is compact: two purposeful sentences plus a relevant trigger list. The main action is front-loaded, and every sentence earns its place with no redundant content.

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

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

For a tool with three optional params, good annotations, and no output schema, the description adequately conveys core behavior and the general return type. It could offer more detail on the output structure (e.g., whether it includes recipe IDs or names), but it is sufficient for a simple meal planning 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%, with each parameter fully described in the schema. The description adds a little context (e.g., cuisine/dietary preferences map to the 'preferences' parameter), but it largely paraphrases the schema, so the baseline 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 uses specific verbs ('Create', 'Returns') and clearly identifies the resource ('meal plan suggestion') with scope ('specified number of days', 'cuisine and dietary preferences'). It also states the output ('breakfast, lunch, and dinner recommendations using real SAVOR Dish recipes'), which distinguishes it from generic meal planning tools and from the sibling 'nutrition_daily_plan'.

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 TRIGGERS block provides explicit example phrases indicating when to use the tool, covering a wide range of user intents. However, it does not include when-not-to-use guidance or mention alternatives, so it stops short of full explicit guideline coverage.

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, idempotentHint=true, and destructiveHint=false, so the agent knows the operation is safe and non-mutating. The description adds what the output includes (macros, micros, etc.) but does not disclose additional behavioral traits such as error conditions, response size, or dependency on recipe existence. This is adequate but not rich beyond 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 front-loaded with a clear, informative first sentence. The TRIGGERS list is somewhat verbose but provides actionable query examples, which is valuable for an AI agent. Every line adds use-case context without fluff, though it could be slightly trimmed without losing much.

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 param, no output schema) and the annotations covering safety, the description is fairly complete. It explains what the tool returns (macros, micros, per-serving, ingredient-level calories), which substitutes for a missing output schema. It does not mention error cases or prerequisites, but these are implicitly covered by the parameter description.

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% coverage for the single parameter recipeSlug, with a clear description and examples. The tool description does not add further parameter semantics; it just refers to "recipe" in general. Since the schema already carries the burden, a 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 what the tool does: "Get a deep nutritional analysis for a recipe" with specific details on macros, micros, per-serving breakdown, and ingredient-level calories. It is specific about the resource (recipe) and scope, but it does not explicitly differentiate from siblings like recipes_get_nutrition or nutrition_compare, though the term "deep" and "ingredient-level" imply a distinct, comprehensive 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 explicit triggers such as "nutrition breakdown for X" and "macro breakdown of X", giving clear context for when to use the tool. However, it does not mention when not to use it or point to alternatives (e.g., nutrition_compare for comparing recipes), so it lacks explicit 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful context beyond these by stating the output is a 'comparison table format' and enumerating the specific nutrient fields returned. This gives the agent expectations about the result structure, though it does not cover edge cases like invalid slugs or missing 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 starts with a crisp summary sentence, then offers a helpful trigger list. The trigger examples are somewhat repetitive but serve a purpose in recognizing varied user intents. Overall it is well-structured and each line has a role, though the trigger list could be trimmed without losing meaning.

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 signature and strong annotations, the description is sufficiently complete. It explains the tool's scope (2-5 recipes), the data displayed, and the output format. The absence of an output schema is partially compensated by the table format disclosure. It does not mention error behavior, but that is a minor gap for a read-only comparison tool.

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

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

The schema covers 100% of the single parameter recipeSlugs with a clear description including range and examples. The tool description reinforces the 2-5 recipe range and implies slugs as input, but adds no new parameter-level details beyond what the schema already provides. Per rubric, 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 opens with a specific verb and resource: 'Compare nutrition facts across 2-5 recipes side-by-side.' It then lists exact nutrients shown (calories, protein, carbs, fat, fiber) and a comparison table format, making it clear this is a multi-recipe nutrition comparison. This distinctly separates it from sibling tools like nutrition_analyze (single recipe) or recipes_compare (general recipe 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?

A dedicated TRIGGERS section provides concrete example phrasings for when to use this tool, such as 'compare nutrition of X and Y' and 'which is healthier X or Y'. This is clear context for invocation, but it does not explicitly mention when not to use it or alternative tool names, so it stops short of the full 5.

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, and the description is consistent, describing plan generation rather than data mutation. It adds context about optional snacks and combined nutrition totals, but does not describe edge cases like conflicting targets or precision limitations, providing only partial additional transparency beyond 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 well-structured with the core purpose first, then output details, and a TRIGGERS list. The trigger examples are somewhat redundant but useful for usage guidance; overall the text is front-loaded and each section serves a purpose, though it is slightly long.

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

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

For a tool with no output schema and four optional parameters, the description covers the essential output composition (meals and totals) and usage triggers. It could be more explicit about the return format or how to handle competing constraints, but the annotations and schema fill safety and parameter gaps, making it 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 input schema has 100% description coverage for all four parameters, so the schema fully defines their semantics. The description only generically references 'calorie and macro goals' without adding interaction details, format specifics, or additional parameter context, warranting 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 builds a single-day meal plan with specific calorie and macro goals, and specifies the output structure (breakfast, lunch, dinner, optional snack, and combined nutrition totals). This distinguishes it from sibling tools like 'meals_plan' by emphasizing optimization for nutritional targets.

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 TRIGGERS section provides explicit example phrases for when to use this tool, such as 'meal plan for 2000 calories' and 'high protein meal plan'. However, it does not state when not to use it or mention alternative tools, so it lacks explicit 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safe read nature is known. The description adds no further behavioral context such as return format, pagination, or no-match behavior, so it stays at baseline.

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 a clear purpose statement, followed by a well-structured TRIGGERS list. It is appropriately sized, though the trigger examples are somewhat repetitive, each line adds value for intent matching.

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 search tool with 7 optional parameters and no output schema, the description adequately covers purpose and usage triggers. It could explicitly state that it returns a list of recipes, but this is implied by the tool name and purpose sentence.

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

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

Schema coverage is 100%, with every parameter having a description and example. The description merely mentions a subset of filters (calories, protein, carbs, fat) without adding meaning beyond the schema.

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

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

The description clearly states the tool finds recipes by specific nutritional targets, listing filters like max calories, minimum protein, max carbs, and max fat. This distinguishes it from sibling recipe finders like recipes_find_by_ingredient or recipes_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 TRIGGERS section provides explicit example user intents (e.g., 'high protein recipes', 'recipes under 400 calories') that should route to this tool. It gives clear context for when to use it, though it does not name alternatives 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds context that the tool is 'AI-powered' and provides 'estimated calorie savings', which are useful behavioral traits, but it doesn't disclose additional traits like response format or accuracy limitations. This is adequate but not rich.

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

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

The description is well-structured: a concise main sentence followed by a useful TRIGGERS list. Every line earns its place with practical examples. It is somewhat longer than minimal but appropriately so for the added trigger guidance.

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 2-parameter tool with no output schema and good annotations, the description covers the core purpose, output nature (suggestions with calorie savings), and usage via triggers. It could mention what the response looks like, but this is not essential given the simplicity and annotation coverage.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-specific information beyond the schema, which already well-documents recipeSlug and the goal enum with descriptions. Thus no extra value is provided, but the schema is sufficient.

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

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

The description clearly states the tool's function: 'Get AI-powered suggestions to make a recipe healthier' and enumerates specific outputs (ingredient swaps, cooking technique changes, portion adjustments, calorie savings). This distinguishes it from siblings like cooking_get_substitutions by covering broader health improvement, not just substitutions.

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 TRIGGERS with example user phrasings such as 'make X healthier' and 'reduce calories in X', giving clear context for when to use the tool. However, it doesn't mention alternatives or when not to use it, so it lacks explicit exclusions/alternatives for a perfect score.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds that it covers 'common cooking ingredients' and returns health benefits and culinary uses, but doesn't disclose behavior for unknown ingredients or return format. With annotations covering safety, this adds modest context 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 front-loaded with a clear opening sentence. The TRIGGERS block is somewhat lengthy but provides concrete examples that aid selection. Overall acceptable structure with minimal filler.

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

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

For a single-parameter lookup tool with strong annotations and full schema coverage, the description adequately covers scope ('any cooking ingredient', 'common cooking ingredients'), return content (nutrition facts, health benefits, culinary uses), and example usage. It lacks explicit return format details, but this is not critical given the simple nature of the tool.

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

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

The schema already provides a full description of the single 'ingredient' parameter (100% coverage). The trigger examples reinforce usage but add little new semantic meaning beyond the schema's 'Ingredient name to look up.'

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

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

The description uses a specific verb 'Get' and clearly specifies the resource: 'nutrition facts, health benefits, and culinary uses for any cooking ingredient.' This distinguishes it from sibling tools like nutrition_compare or recipes_get_nutrition by focusing on single-ingredient lookups.

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 TRIGGERS section provides explicit example queries, indicating the tool is intended for natural-language ingredient nutrition questions. This gives clear context for when to use it, though it does not explicitly mention alternatives or 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 declare readOnlyHint=true and idempotentHint=true, so the safety profile is clear. The description adds behavioral context by specifying the output is a 0-100 score and that it evaluates balance of protein, fiber, calorie density, and variety, which goes beyond 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 concise, with a clear first sentence stating the function, followed by the evaluation criteria and a structured list of trigger phrases. It contains no redundant text and is well-organized for quick parsing.

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 a single parameter and no output schema, the description adequately explains the purpose, the computation basis, the output scale, and when to use it. The trigger list covers the key invocation scenarios, making it contextually complete.

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

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

The input schema covers 100% of parameters with a clear description and example for recipeSlugs. The description does not add additional parameter-level detail beyond what the schema already provides, so 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 tool 'Rate the nutritional quality of a meal plan or set of recipes on a 0-100 health score' and lists evaluation criteria. It distinguishes from siblings like nutrition_analyze by focusing on whole meal plans/recipes rather than individual items.

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

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

The TRIGGERS section explicitly lists example user phrases that should invoke this tool, such as 'rate my meal plan' and 'health check my recipes'. It provides clear when-to-use context but does not explicitly mention alternatives or exclusions, so it stops short of the top score.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds that it returns features, pricing, platforms, and integration details, but does not disclose additional behavioral aspects such as data source or response format. Given the annotation coverage, this is adequate but not rich.

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, with two sentences plus a compact trigger list. The trigger list adds actionable context without repetition, though it could be considered slightly redundant with the purpose statement.

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

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

For a read-only info retrieval tool with one optional parameter and no output schema, the description is mostly complete: it states what is returned and provides example triggers. It does not exhaustively describe the return structure, but the listed categories (features, pricing, platforms, integrations) give sufficient context.

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

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

The input schema fully documents the single 'section' parameter with an enum and description, achieving 100% schema coverage. The tool description does not add parameter-specific guidance, so the baseline of 3 applies.

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

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

The description clearly states 'Get comprehensive information about the SAVOR Dish platform' and enumerates specific content areas (features, pricing, platforms, Instacart integration). This distinguishes it from sibling tools focused on recipes, nutrition, and shopping.

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 includes explicit TRIGGERS listing user query examples like 'what is SAVOR Dish' and 'pricing plans', providing clear context for when to invoke this tool. It does not mention when not to use it or name alternatives, but the triggers are specific enough for an agent to match user intent.

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, idempotentHint, and destructiveHint, so the description doesn't need to restate safety. The description adds the 'curated' aspect, which is a behavioral trait (pre-selected vs. exhaustive results), but doesn't disclose return format or other behaviors like pagination. With the annotation coverage, this is adequate but not rich.

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

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

The description is compact and front-loaded with the purpose in the first sentence. The trigger list is clearly structured and directly useful for usage decisions. Every sentence earns its place — no filler or redundant 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?

With two parameters, one enum, full schema coverage, and helpful annotations, the description is largely complete for a simple browse operation. It doesn't describe return values, which could be a gap without an output schema, but the tool's simplicity and direct language make it clear enough for an agent to use correctly.

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

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

The schema provides complete parameter descriptions (100% coverage), but the description adds value by mapping natural language trigger phrases to the theme enum values (e.g., 'date night' → 'date-night'). This helps the agent select the correct parameter value beyond what the schema alone offers, even though the limit parameter isn't elaborated further.

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 function with a specific verb ('Browse') and resource ('curated recipe collections by theme'). It distinguishes this from sibling recipe tools by emphasizing curated collections rather than search or individual retrieval, and the trigger examples make the scope immediately understandable.

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

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

Provides explicit trigger phrases that indicate when to use this tool, such as 'date night recipes' and 'comfort food ideas'. While it doesn't name specific alternatives or exclusions, these triggers effectively guide an agent on when this tool is appropriate, especially compared to broader search tools like recipes_search.

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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds what fields are shown ('Shows prep time, cook time, servings, difficulty, and ingredients'), but it does not disclose behaviors like error handling for missing recipes, response format, or any side effects. This is adequate but not rich, hence a 3.

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

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

The description is concise: one clear sentence stating the core function, followed by a structured TRIGGERS block with six example utterances. Every sentence earns its place, and the front-loaded main sentence ensures immediate comprehension. No fluff or redundant restatement.

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

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

The tool has only one parameter, no output schema, and annotations that cover safety and idempotency. The description explains what the tool shows (the recipe attributes), and the trigger list provides sufficient context for when to use it. Nothing critical is missing for an agent to select and invoke the tool correctly.

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

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

The schema description for recipeSlugs is fully explicit ('Array of 2-5 recipe slugs to compare (e.g. ['chicken-pho', 'beef-pho'])'), so schema coverage is 100%. The description only repeats the notion of comparing two or more recipes, which adds no new semantic information beyond the schema. 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 uses a specific verb ('Compare') and resource ('recipes') and explicitly lists the comparison dimensions (prep time, cook time, servings, difficulty, ingredients), making the tool's purpose unambiguous. This distinguishes it from the sibling tool nutrition_compare, which focuses on nutritional values rather than side-by-side recipe attributes.

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 TRIGGERS section provides concrete natural-language examples that indicate when to invoke this tool ('compare X and Y recipes', 'X vs Y recipe', 'which recipe is faster'). While it doesn't explicitly mention when not to use it or name alternatives, the trigger list gives clear usage context, so this is above the minimum but not a full 5.

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, idempotentHint=true, and destructiveHint=false, establishing the safety profile. The description adds no specific behavioral details beyond this (e.g., no mention of default matching behavior or result limits), though these are covered in the schema. It does not 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 front-loaded with a clear purpose sentence, followed by a compact trigger list. Every element earns its place—the first sentence defines the operation, and the triggers make the invocation contexts immediately actionable.

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 search tool with full schema coverage, the description adequately conveys the use case and scope. There is no output schema to describe return values, but the tool's behavior is straightforward and the trigger list provides enough context for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, with each parameter fully documented (ingredients, limit, matchAll). The description adds no parameter-level meaning beyond what the schema provides, but no compensation is needed because the schema already covers it thoroughly.

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 function: 'Find recipes that use specific ingredients you have on hand.' It also distinguishes from siblings like recipes_search and recipes_get by focusing on ingredient-driven discovery and provides sample trigger phrases that clarify the exact use case.

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 trigger list gives explicit contexts for when to use this tool ('what can I make with X and Y', 'I have X, what can I cook', 'fridge clean out recipes'). It does not explicitly contrast with alternatives like recipes_search, but the use cases are clear enough to guide 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is established. The description adds the scope of the response (ingredients, instructions, etc.) but says nothing about error behavior, invalid IDs, or response formatting. This adds moderate value beyond annotations, but not enough for a 4.

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 a clear purpose sentence, followed by a structured list of trigger phrases. While the trigger list is longer than necessary, it is organized and useful for an AI agent, making it efficient rather than bloated.

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

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

For a single-parameter, read-only tool with strong annotations, the description provides sufficient context for selection and invocation. It could benefit from mentioning what happens if the slug/ID is invalid, but overall it is complete enough for an agent to use it correctly.

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

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

Schema coverage is 100%, with the slugOrId parameter fully documented as a URL slug or UUID. The description does not add any additional meaning or context for the parameter, so the baseline 3 applies.

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

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

The description clearly states a specific verb ('Get full details') and resource ('specific recipe'), and enumerates the included components (ingredients, instructions, nutrition, tips, photo), distinguishing it from more specialized sibling tools like recipes_get_nutrition or recipes_get_dietary.

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 TRIGGERS section explicitly lists user phrasings that should invoke this tool, providing clear when-to-use context. It does not, however, explicitly mention alternatives or exclusions relative to sibling tools like recipes_get_nutrition, which would make it a 5.

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 convey that this is a read-only, idempotent, non-destructive operation, so the description doesn't need to repeat safety traits. It adds context about filtering by tags/categories/metadata, but does not disclose return format, pagination, or potential empty results. Given the annotation coverage, this is adequate but not rich.

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

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

The description is well-structured with a concise summary sentence followed by labeled TRIGGERS and DIETARY OPTIONS sections. Every section serves a purpose; the trigger examples and option list are directly useful. It could be slightly shorter, but the structure aids readability and scanning.

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 filtered lookup tool, the description covers the core behavior and available filters, and the schema handles parameter details. There is no output schema, but the return type (recipes) is implicit from the name and tool family. A sentence about combining with cuisine or describing the output structure would improve completeness, but it's not critical.

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 for all three parameters, so baseline is 3. The description adds value by enumerating all supported dietary options (vegan, gluten-free, keto, etc.) which are not defined as enums in the schema. This full list helps agents construct valid inputs beyond the schema's examples.

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

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

The description clearly states the tool's function: 'Find recipes matching specific dietary requirements.' It specifies the resource (recipes) and the filtering mechanism (tags, categories, metadata), which distinguishes it from sibling tools like recipes_get or recipes_search. The verb 'find' and scoping to dietary needs are unambiguous.

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

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

The description provides concrete trigger examples ('vegan recipes', 'gluten-free meals') and lists available dietary options, giving agents clear context on when to use this tool. It does not explicitly state exclusions or alternatives, but the specialized purpose is evident from the name and sibling 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, idempotentHint, and destructiveHint. The description adds useful return-value context ('calories, macros, dietary labels') but does not disclose potential edge cases like invalid recipe slugs or error behavior. Thus it adds some value beyond annotations but not extensive behavioral detail.

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 a clear purpose sentence, followed by a useful trigger list. The trigger list is somewhat repetitive but serves a functional role in guiding the agent. It is not overly verbose, and every section earns its place.

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

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

For a simple, read-only tool with one parameter and no output schema, the description provides sufficient context: it states the input (recipeSlug via schema), the output (calories, macros, dietary labels), and clear usage triggers. No critical information is missing for an agent to select and invoke the tool correctly.

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

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

The input schema fully describes the single parameter 'recipeSlug' with type, maxLength, and examples. The description reinforces that it targets a 'specific recipe' but does not add additional semantic meaning beyond what the schema provides, so the baseline 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 function: 'Get detailed nutrition information for a specific recipe' and lists specific return types (calories, macros, dietary labels). This distinguishes it from sibling tools like recipes_get_dietary or nutrition_analyze by being specifically tied to a recipe.

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 'TRIGGERS' section provides clear examples of when to use the tool ('nutrition for X', 'calories in X', 'is X healthy'). However, it does not explicitly mention when not to use it or name alternative tools, so it lacks the exclusion/alternative guidance needed for a 5.

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, idempotentHint, and destructiveHint, covering the safety profile. The description adds useful context about the time-limit parameter and the quick-meal focus, which goes beyond the annotations without contradicting 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 concise and front-loaded, with a clear purpose statement followed by a structured trigger list. The trigger list is slightly long but serves as a practical reference for intent matching, earning its place.

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

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

The tool is simple with well-documented parameters and annotations. The description explains the core behavior and usage context, which is sufficient for the tool's complexity. The absence of an output schema is mitigated by the clear 'Find quick recipes' statement.

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% coverage with full descriptions for all three parameters (limit, mealType, maxMinutes). The description only reiterates the time-limit concept already present in the schema, providing no additional semantic value beyond the structured data.

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 function: finding quick recipes within a time limit. It distinguishes the tool from siblings like recipes_get and recipes_search by emphasizing the time constraint and quick-meal context.

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

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

The trigger phrases provide concrete examples of when to use this tool, such as 'quick recipes', 'fast meals', and 'recipes under 30 minutes'. It also mentions the busy weeknight use case. However, it does not explicitly name alternative tools or state when NOT to use it, so it falls short of a 5.

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, destructiveHint=false, and idempotentHint=true. The description adds no behavioral details beyond stating randomness, which is already implied by the name. It does not contradict annotations, but also provides no extra transparency (e.g., whether results can repeat, how many results are returned).

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 brief and front-loaded with the main function. The trigger list adds some redundancy but is useful for an agent to recognize user intent. It is not overly verbose.

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

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

For a simple read-only tool with good annotations and 100% schema coverage, the description adequately conveys purpose. It does not explain the return format, but 'a random recipe' implies a single result. This is sufficient for the tool's 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 schema covers 100% of parameters with descriptions for cuisine and mealType. The description only repeats 'Optionally filter by cuisine or meal type' without adding new meaning, so it meets the baseline for schema-covered 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 verb and resource: 'Get a random recipe suggestion.' It also mentions optional filters, which distinguishes it from sibling tools like recipes_search or recipes_get that are not random. The purpose is immediately obvious.

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 it ('when you can't decide what to cook') and includes trigger phrases like 'surprise me' and 'random recipe.' However, it does not explicitly contrast with alternatives such as recipes_search or recipes_get, which would earn a 5.

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 a safe read operation (readOnlyHint, idempotentHint, destructiveHint). The description adds meaningful behavioral context: results include photos and are ordered by newest first, which is valuable beyond 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?

Two concise parts: a clear first sentence followed by a compact trigger list. No wasted words or redundancy. Information is front-loaded and easy to scan.

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

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

Given the tool's low complexity (one optional parameter, no output schema, safe annotation), the description covers everything an agent needs: purpose, result format, ordering, and example user queries. No significant gaps.

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

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

The only parameter (limit) is fully described in the schema (coverage 100%), so the description doesn't need to repeat it. The description adds no extra parameter-level detail, but per the calibration baseline, a score of 3 is appropriate when the schema covers everything.

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

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

The description clearly states it gets 'the most popular and recently published recipes' with specific output details (photos, newest first). This distinguishes it from siblings like recipes_get_random or recipes_search, which have different selection criteria.

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

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

Provides a list of trigger phrases ('what's trending', 'popular recipes', 'top recipes') that clearly indicate when to use this tool. However, it does not explicitly mention when not to use it or name alternative tools, so it falls short of a 5.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context by stating 'Returns public recipes,' clarifying that only public, not user-specific, recipes are returned. However, it does not disclose details about pagination, error behavior, or other operational aspects, keeping it at a baseline of 3.

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

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

The description is moderately sized and well-structured with clear sections for TRIGGERS and SUPPORTED CUISINES. While it is longer than a minimal two-sentence description, all content is relevant and directly aids tool selection and invocation, so it earns a 4.

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

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

For a simple read-only list tool with good annotations and full schema coverage, the description provides sufficient context: what it returns (public recipes), how to filter (cuisine), and examples of user queries. It does not explain return format, but no output schema exists and the tool is straightforward, so a 4 is appropriate.

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

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

Schema coverage is 100% with both parameters having descriptions, so the baseline is 3. The description adds value by listing SUPPORTED CUISINES and providing trigger examples that show how the cuisine parameter maps to natural language, which goes beyond the schema's examples. This justifies a 4.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Browse recipes filtered by world cuisine type' and 'Returns public recipes from a specific culinary tradition.' This distinguishes it from sibling tools like recipes_search or recipes_find_by_ingredient, which focus on other criteria.

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 with specific TRIGGERS examples like 'show me Vietnamese recipes' and 'Italian food,' which help an agent recognize when to invoke this tool. However, it does not explicitly state when not to use it or mention alternatives, so it falls short of a 5.

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, idempotentHint=true, and destructiveHint=false, establishing the safety profile. The description adds value by describing the return behavior: it returns original ingredients with a multiplier, which is a meaningful behavioral detail beyond the annotations. No contradictions.

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

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

The description is succinct and well-structured: a one-sentence purpose statement followed by a relevant trigger list. Every sentence serves a purpose, and the triggers are practical without being redundant. The format is easy to scan 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?

For a simple, two-parameter, read-only scaling tool, the description is complete. It covers the core function, return value shape, and typical user phrasings. No output schema exists, but the description gives a sufficient hint of the result without needing further detail. The combination of schema annotations and description fully equips an agent.

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

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

Schema coverage is 100% with descriptions for both parameters: recipeSlug includes an example ('chicken-pho') and targetServings has a range (1-100). The description provides trigger examples but no additional parameter semantics beyond what the schema already documents, so a baseline 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 states the tool's purpose with a specific verb and resource: 'Scale a recipe for different serving sizes.' It also clarifies the output ('Returns the original ingredients with a scaling multiplier to adjust quantities'), which distinguishes it from sibling tools like recipes_get or recipes_search that fetch or search rather than scale.

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 TRIGGERS section provides concrete example phrases for when to use the tool, such as 'scale recipe X for 8 people' and 'halve the recipe'. This gives clear usage context without explicitly naming alternatives, but the scope is well-defined and distinct from sibling tools like cooking_convert_units or recipes_compare.

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, idempotentHint=true, and destructiveHint=false. The description does not contradict these and adds some useful context (e.g., handling multiple filter types in one call), but it does not disclose additional behavioral traits like pagination, result ordering, or response format.

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 opens with a clear one-line summary and then uses a structured TRIGGERS list. It is somewhat redundant with the opening sentence, but the trigger examples add practical value. Overall it is appropriately sized 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 rich schema, strong annotations, and relatively simple search operation, the description covers the main dimensions (what, when, how to phrase queries). It lacks an explicit note about return format, but this is not essential for a search tool and the trigger coverage is comprehensive.

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

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

Schema description coverage is 100% and the parameter descriptions are already rich—query includes examples like 'chicken pho' and 'vegan tacos', limit has min/max/default, mealType lists valid values. The description's trigger phrases add conversational mapping but do not significantly enhance schema 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 identifies a specific verb+resource ('Search and filter recipes') and lists the multiple filter dimensions (keyword, ingredient, cuisine, meal type, dietary). It also differentiates from sibling tools by highlighting 'in ONE call', which distinguishes it from specialized endpoints like recipes_find_by_ingredient or recipes_get_dietary.

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 TRIGGERS section provides explicit user-phrase examples for when to invoke this tool, such as 'find recipes with X' and 'what can I make with X'. However, it does not name alternative tools or state when NOT to use it, so it misses the explicit exclusion/alternative guidance required for a 5.

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 description doesn't need to restate safety. It adds little about actual behavior, such as that only four seasons are accepted, and confuses with the 'month' promise, which is a behavioral limitation not disclosed.

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

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

The description is concise, front-loading the core purpose in the first sentence. The trigger list is helpful but somewhat redundant and includes a misleading 'March' example, which wastes a bit of space.

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

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

For a simple tool with strong annotations and schema, the description is mostly sufficient. However, it fails to mention that only the four seasons are valid and does not clarify what the response looks like. The 'month' contradiction is a notable gap that could lead to incorrect usage.

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

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

Schema has 100% coverage for both parameters, so baseline is 3. The description does not add useful parameter semantics and actively misleads by implying 'month' is a valid input when the only parameter is an enum of four seasons.

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

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

The description clearly states it finds recipes for a specific season, with a verb and resource ('Find recipes perfect for a specific season or month'). However, the mention of 'month' is misleading because the schema only supports a season enum, which introduces 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 TRIGGERS provide explicit example queries like 'fall recipes' and 'Thanksgiving ideas', giving clear context on when to use the tool. However, there is no mention of alternative tools or when not to use it, and one trigger ('seasonal dishes for March') implies month support not present in the schema.

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, idempotentHint=true, and destructiveHint=false, indicating a safe, non-mutating operation. The description adds valuable behavioral context: it mentions the output includes an Instacart delivery link and lists categories such as produce, dairy, etc., which sets expectations for the response format beyond what annotations provide.

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

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

The description is well-structured with clear sections for triggers and categories. It is reasonably concise, though the trigger and category lists add length. Every section serves a purpose: triggers guide usage, categories set output expectations. It's informative without being overly verbose.

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

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

For a simple read-only tool with two well-documented parameters and no output schema, the description covers the essential context: purpose, usage triggers, and expected output (Instacart link, categories). It doesn't dive into error handling or edge cases, but it is sufficient for an agent to invoke the tool correctly. The sibling context (shopping_instacart) is not explicitly differentiated, but the description's focus on recipe aggregation makes it clear.

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 recipeSlugs and servingsMultiplier having clear descriptions in the schema. The tool description does not add additional parameter-level semantics, but this is acceptable since the schema carries the full burden. Baseline 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 function with specific verbs: 'Generate a grocery shopping list from recipe ingredients' and 'Collects ingredients across multiple recipes'. It distinguishes itself from sibling tools like shopping_instacart by explicitly mentioning the aggregation of ingredients and the Instacart delivery link, making its unique value clear.

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

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

The TRIGGERS section provides explicit example phrases for when to use this tool, such as 'make a grocery list for X' and 'generate shopping list'. This gives concrete guidance on input phrasing and usage scenarios, effectively matching user intents to the tool. It clearly communicates the tool's context, though it doesn't explicitly exclude 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 already declare readOnlyHint=true and idempotentHint=true, so the safety profile is known. The description adds that it returns a direct link for same-day delivery, which is informative but not deeply behavioral. It does not mention auth, rate limits, or any side effects beyond what annotations imply, so it adds only moderate 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 compact and front-loaded, stating the core function in the first sentence. The bulleted trigger list is concise and organized, adding practical usage examples without unnecessary fluff. Every sentence earns its place.

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

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

Given the simple tool (2 params, full schema coverage, good annotations), the description sufficiently covers what the tool does and its trigger conditions. It states the return type (direct link) and the delivery context. It could mention response structure, but that is not necessary given the simplicity and annotation coverage.

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

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

Schema description coverage is 100%, and both parameters (recipeSlug and postalCode) are already well-documented with examples in the schema. The description does not add any additional parameter semantics beyond restating that it deals with recipe ingredients and delivery, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Get') and resource ('Instacart delivery information for recipe ingredients'), clearly stating it returns a direct link to order groceries. It distinguishes itself from sibling tools like shopping_generate_grocery_list by focusing on Instacart-specific delivery. The trigger examples further reinforce the purpose.

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 trigger list explicitly gives example phrases for when to use the tool, such as 'order ingredients for X' and 'Instacart delivery for X'. This provides clear context. However, it does not explicitly mention alternatives or when-not-to-use cases, so it falls short of a 5.

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