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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the action and arguments. It does not explain behavior around duplicates, missing recipes, invalid list IDs, or whether existing shopping list contents are affected.

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 the core action, followed by a compact Args block. There is no redundant or wasted text.

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

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

The tool has only two simple parameters and an output schema, so the core invocation details are covered. Missing context about when to use it versus add_shopping_list_item and what side effects may occur leaves notable gaps for a mutation tool.

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

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

The description provides brief definitions for both parameters, which adds meaning beyond the schema's bare string types. However, the explanations are minimal and mostly restate the parameter names, so they provide only basic semantic value.

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

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

The description uses a specific verb and resource: 'Add all ingredients from a recipe to a shopping list.' This clearly communicates the operation and distinguishes it from sibling tools like add_shopping_list_item, which adds an individual item rather than all recipe ingredients.

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

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

No guidance is provided about when to use this tool versus alternatives. There is no mention of add_shopping_list_item for single-item additions or any exclusions, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations, the description carries the full burden for behavioral disclosure, but it only restates the mutation ('Add') without revealing side effects, duplicate behavior, required existing list, or return behavior. An agent knows this writes but not what happens on success, failure, or duplicates.

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 tight and well-structured: a single-purpose opening line followed by a clearly formatted Args list. Every line contributes information, and the format is easy for an agent to parse.

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

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

For a straightforward add-item tool with no nested objects and an output schema, the description adequately covers the purpose, all parameters, and optionality. It is somewhat incomplete due to the absence of usage alternatives and behavioral consequences, but it gives enough to 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?

Schema description coverage is 0%, so the description must compensate for all 5 parameters, and it does: it defines list_id, provides a concrete note example, marks optionality for quantity, unit_id, and food_id, and names provenance tools ('get_units', 'searche_foods'). It adds meaningful operational detail beyond the raw schema, though it leaves the relationship between structured item fields vague.

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

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

The description clearly states the tool's action ('Add an item to a shopping list') and names the key resource. It is specific enough for an agent to understand the tool's core purpose, though it does not explicitly distinguish itself from sibling tools like add_recipe_to_shopping_list.

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

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

The description offers no guidance on when to choose this tool over alternatives such as check_shopping_list_item, remove_shopping_list_item, or add_recipe_to_shopping_list. It implies general usage through the action verb but does not state preconditions, exclusions, or routing 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?

No annotations exist, so the description carries the full burden of explaining behavior. It does state the core state-changing behavior and the default checked=true, but it does not disclose edge cases like idempotency, behavior for a missing item_id, or any side effects beyond setting the flag.

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

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

The description is a single front-loaded sentence followed by a compact Args block. There is no wasted text, and the parameter explanations appear in a predictable, easy-to-scan structure.

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 three-parameter boolean settter with an output schema present, the description provides enough to call the tool correctly. It could be slightly more complete by explicitly stating it modifies an existing item's completion state rather than adding/removing items, but the name and sibling context largely cover that.

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

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

Schema description coverage is 0%, but the Args block fully compensates by explaining each parameter's role: list_id identifies the list, item_id identifies the item, and checked maps True/False to check/uncheck with a default of True. This is exactly the semantic information an agent needs beyond types and required flags.

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 starts with the specific verb pair 'Check or uncheck' and names the resource, 'shopping list item,' making the operation unambiguous. It also clearly differentiates itself from sibling tools that add, remove, or retrieve shopping list 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 operation implies it is for changing the checked state of an existing item, so an agent can infer when to use it. However, it does not explicitly contrast with add_shopping_list_item or remove_shopping_list_item, nor give conditions for choosing this tool over them.

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

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

With no annotations, the description carries the burden of behavioral disclosure, but it only restates the creation action. It does not mention duplicate-name handling, uniqueness constraints, idempotency, or any side effects beyond creating the resource.

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

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

The description is extremely compact, leads with the action, and contains no filler. 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?

For a one-required-parameter create tool with an output schema, the description plus schema is minimally sufficient to invoke. However, it lacks context about duplicate categories, whether the name is case-sensitive, and how this relates to get_categories.

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 only says name is a required string, while the description adds that the parameter is the category name. This compensates for 0% schema description coverage, though it omits any constraints such as uniqueness or length.

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 a specific action and resource: 'Create a new recipe category.' This clearly differentiates it from sibling create tools like create_recipe and create_tag and from read tools like get_categories.

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

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

The description provides no when-to-use guidance, exclusions, or alternatives. An agent is left to infer that this is for new categories only and cannot tell whether to check get_categories first to avoid duplicates.

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

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

No annotations are provided, so the description carries the full behavioral burden. It conveys that the action is additive and states the recipe_slug OR title/note choice, but it does not disclose preconditions such as whether recipe_slug must exist, duplicate/overwrite behavior, or any side effects beyond creation.

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

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

The description is a single purpose sentence followed by a tight Args list. There is no filler, and every parameter line adds meaningful usage detail.

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?

All five parameters are documented and the behavior of recipe_slug versus title/note is clarified. An output schema exists, so return-value description is unnecessary. Minor gaps such as what happens if both recipe_slug and title/note are supplied prevent a perfect score.

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

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

Schema description coverage is 0%, so the description must compensate. It does so thoroughly: it defines the date format, lists acceptable entry_type values, and explains when to use recipe_slug versus title/note, going well beyond the raw JSON 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 lead sentence states exactly what the tool does: 'Add a meal plan entry for a specific date.' This is a specific verb+resource description that distinguishes it from sibling tools like delete_meal_plan_entry and get_meal_plans.

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 gives clear context for when to use the tool: whenever adding a meal plan entry for a date. It does not explicitly name alternatives or exclusion criteria (e.g., use delete_meal_plan_entry to remove an entry), 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that this creates a new recipe, and it also reveals useful parameter-level behaviors: servings enable scaling, section creates a visual header, summary is a one-line takeaway for cook mode. It does not mention edge behaviors like duplicate-name handling or whether categories/tags must already exist, but the provided details are substantial.

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 long but appropriately structured for a 13-parameter tool with nested objects. It front-loads the purpose, then organizes arguments in a readable list where every line adds semantic information, examples, or expected formats. There is no filler or repetition.

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 high parameter count, dense nested structures, and 0% schema description coverage, the description is exceptionally complete. It documents all fields including optional sub-keys and examples, and since an output schema exists, the description need not explain return values. Only minor usage routing details are absent, and those are already captured in the usage guideline dimension.

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

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

Schema description coverage is 0%, so the description must fully document every parameter. It does exactly that: each parameter has a type, a purpose, and often realistic examples. Nested structures for ingredients, instructions, notes, and extras are explained with optional keys and expected shapes, adding enormous value beyond the bare 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 opens with a specific verb and resource: 'Create a new recipe manually.' The word 'manually' distinguishes it from the sibling create_recipe_from_url, and the parameter list reinforces that this is for full manual entry rather than import or update.

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 phrase 'manually' provides clear context that this tool is for direct entry, implying the correct alternative for URL-based creation is create_recipe_from_url. However, it does not explicitly name siblings like update_recipe for modifying existing recipes or state when not to use this tool, so the guidance is clear but not exhaustive.

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?

It discloses the core behavior: the tool scrapes a URL and automatically extracts recipe data, which is useful context. However, with no annotations, the description carries the full burden and does not mention auth requirements, duplicate handling, or the full side effect profile of importing a recipe.

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 well-structured: two purposeful sentences plus a minimal Args block. The main purpose is front-loaded and there is no fluff or redundant restatement of the schema.

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 one-parameter import tool with an output schema present, the description covers the tool's purpose and its required input well. It does not address usage exclusions or edge cases, but the tool's simplicity limits how much additional context is necessary.

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 only says url is a string, so the description's Args block adds meaningful semantics: 'URL of the recipe page to import.' For a single-parameter tool, this sufficiently compensates for 0% schema coverage, though it could mention format constraints such as public URL requirements.

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 and resource: 'Import a recipe by scraping a URL.' It clearly identifies the URL-based import mechanism, which distinguishes it from the sibling create_recipe tool, though it does not explicitly name that alternative.

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

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

The description implies the use case—providing a recipe page URL and having Mealie extract the data—but it does not explicitly state when to prefer this over create_recipe or when not to use it. No exclusions or alternative routing are present.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that a new empty list is created but does not mention return behavior, duplicate/name-collision handling, permissions, or side effects. This is a significant gap for a mutation tool with zero 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 appropriately compact: one sentence states the purpose and one documents the argument. There is no fluff, and the main action is front-loaded.

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

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

For a one-parameter create tool, the description covers the core invocation, especially with an output schema available for return values. However, with no annotations and no usage guidance, it omits behavioral context such as duplicate handling and whether any other setup is required. It is adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain that the single required parameter is the name for the new list, but it adds no constraints, formatting, uniqueness rules, or other meaning beyond what the parameter name already implies.

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 ('Create') and a precise resource ('new empty shopping list'), making it clear what the tool does and distinguishing it from siblings like add_shopping_list_item or get_shopping_lists. The word 'empty' adds useful precision about the resulting state.

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?

There is no guidance on when to use this tool versus alternatives such as add_shopping_list_item or create_recipe. Usage must be inferred from the tool name and the generic 'Create a new empty shopping list' statement; no exclusions, prerequisites, or alternative conditions are mentioned.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. 'Create a new recipe tag' clearly indicates a mutation that creates an entity, though it does not mention duplicate handling, authorization, or whether the operation is idempotent. For a simple one-parameter creation tool with an output schema, 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 extremely concise and front-loaded with the core purpose. The 'Args' line is minimal and directly useful, 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 one-parameter creation tool with an output schema, the description covers the essential input and purpose. It would be slightly more complete with a note about duplicate tag names or relationship to get_tags, but those gaps are not critical for initial invocation.

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

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

The JSON Schema only defines 'name' as a required string with no description. The description compensates by explaining that name is the tag name, which is meaningful and sufficient for the single parameter.

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 a specific action ('Create') and a specific resource ('new recipe tag'), making the tool's purpose unambiguous. It clearly distinguishes itself from read tools like get_tags and from other creation tools like create_category or create_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 verb 'Create' implies the tool is for adding a new recipe tag, but there is no explicit guidance about when to use it versus alternatives or when not to use it. The context is inferred rather than stated.

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

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

With no annotations provided, the description must disclose behavioral traits itself. It states the action but does not mention permanence, side effects, permission requirements, or behavior on invalid IDs, leaving the irreversibility of the operation ambiguous.

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

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

The description is extremely concise and front-loaded, with the action stated in the first sentence. The additional Args line provides necessary parameter context without any redundant words.

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

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

For a single-parameter delete operation with an output schema present, the description covers the core identification requirement. However, given the absence of annotations, it lacks information about the destructive nature and post-conditions, making it barely adequate.

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

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

The schema has zero description coverage, so the description is the only source of parameter meaning. It explains that entry_id is a meal plan entry ID and reveals its origin from get_meal_plans, which adds significant clarity beyond the raw string type.

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 the specific verb 'Remove' with the resource 'meal plan entry', clearly indicating the operation. It distinguishes from sibling tools by explicitly naming the target resource type, which is unique among the delete-type tools.

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

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

The description provides a practical pointer that entry_id comes from get_meal_plans, implying the intended workflow. However, it does not explicitly state when to prefer this tool over alternatives like delete_recipe or delete_shopping_list, leaving selection to inference.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'Permanently' usefully signals that deletion is irreversible and destructive, but it does not mention side effects on related data, permissions, or error behavior for nonexistent slugs.

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

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

The description is extremely concise and front-loaded: one clear action sentence followed by a minimal Args section. There is no filler or redundant content beyond the necessary parameter annotation.

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?

This is a simple one-parameter tool with an output schema available, so the description is mostly adequate. Still, it omits context about destructive consequences beyond the word 'permanently' and provides no guidance on what happens if the slug is invalid or the recipe is in use.

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

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

Schema description coverage is 0%, so the description must compensate. It does add some meaning by defining slug as 'Recipe slug to delete', but it doesn't explain what a slug is, how to obtain it, or any format constraints, leaving only a minimum-viable parameter explanation.

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 a specific verb and resource: 'Delete a recipe permanently.' This clearly distinguishes it from sibling tools like create_recipe, update_recipe, and get_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?

Usage is implied by the verb 'Delete' and the qualifier 'permanently'—an agent can infer it should call this when a recipe must be removed for good. However, there is no explicit when-to-use guidance, prerequisites, or mention of alternatives like soft-delete or update.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, yet it only says 'Delete a shopping list.' It does not disclose that deletion is permanent/irreversible, whether deleting the list cascades to its contained items, or what happens when the ID does not exist. The cascade question is a meaningful gap given the existence of add_shopping_list_item.

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 action verb is front-loaded and both sentences earn their place with no fluff. It is brief but not absurdly under-specified like a bare verb; the brevity is proportionate to a one-parameter tool, though it contributes to missing content penalized in other dimensions.

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 destructive tool with zero annotations, the description is incomplete: it omits irreversibility, cascade behavior on contained items, and scope boundaries versus remove_shopping_list_item. The presence of an output schema covers return values, which mitigates but does not offset the missing behavioral context.

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

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

Schema description coverage is 0%, so the description must compensate, but 'list_id: Shopping list ID to delete' merely restates the parameter name. It adds no meaning about how to obtain the ID, its format, or whether it must reference an existing list.

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 a specific verb and resource: 'Delete a shopping list.' This clearly identifies the operation and differentiates from list-retrieval and creation siblings by name. However, it does not explicitly distinguish scope from the sibling remove_shopping_list_item, which could plausibly be confused with deleting part of a list.

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

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

No guidance is given about when to use this tool versus alternatives. The description offers no mention of remove_shopping_list_item for item-level removal, no cautionary context for a destructive operation, and no prerequisite such as first fetching the list via get_shopping_lists.

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

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

No annotations are present, so the description is the only source of behavioral information. It does not disclose whether the operation creates or replaces entries, whether existing entries are preserved, whether duplicate recipes are possible, or any side effects. 'Auto-fill' implies mutation, but important behavioral details are absent.

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 one concise sentence followed by a clean parameter list with no filler. Every element contributes, and important details are front-loaded.

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

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

For a low-complexity tool with three documented parameters and an output schema available, the description is nearly sufficient. It misses only a side-effect clarification (e.g., whether auto-filling overwrites existing plan entries), which is relevant for safe invocation.

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

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

The schema only provides types and a default, with zero description coverage, so the Args section is essential. It gives exact date format (YYYY-MM-DD), allowed meal-type values, and the dinner default, adding substantial meaning beyond the raw schema.

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

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

The description uses a specific verb ('auto-fill') and resource ('date range with random recipes from your collection'), clearly distinguishing itself from the manual create_meal_plan_entry and other meal-plan tools. The notion of auto-generating random meals is immediately understandable and unique among 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 use case (filling a date range with generated meals) is implied by the verb and object, but there is no explicit when-to-use guidance, exclusion criteria, or comparison to alternatives such as create_meal_plan_entry for manual entries. This leaves some routing inference to the agent.

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

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

With no annotations, the description carries the burden of indicating safety and side effects; 'List' clearly signals a non-mutating operation and 'all' defines scope. It does not discuss pagination or ordering, but with an output schema present and no parameters, the behavioral surface is minimal.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes meaning, and the core operation and resource are immediately clear.

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

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

For a zero-parameter list operation with an output schema available, 'List all recipe categories' is sufficient for an agent to call the tool correctly. No additional context is necessary.

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 contains zero parameters, so there is no parameter burden for the description to carry. Baseline 4 applies because nothing additional is needed.

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 ('List') and resource ('all recipe categories'), clearly indicating a read-only retrieval operation. This distinguishes it from sibling tools like create_category, get_tags, and get_cookbooks, whose resources or actions differ.

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

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

The description implies when to use the tool (when a full list of recipe categories is needed) but does not explicitly state alternatives or exclusions. For a zero-parameter getter this is adequate but leaves the guidance implicit.

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

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

No annotations are provided, so the description carries the full burden. It does disclose that results are paginated via page and per_page, which is useful, but it does not mention return format, ordering, error behavior, authentication, or response shape. It does not contradict any 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 appropriately terse: one core sentence followed by a compact Args block. There is no filler, and the most important information is front-loaded.

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

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

With no output schema and a large set of sibling tools, the description should clarify whether the response contains full recipe objects or summaries, and when to use this tool instead of search_recipes or get_recipe. It enables a basic call but leaves important selection and expectation gaps.

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

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

The input schema has 0% description coverage, so the Args block is essential and does compensate: it clarifies 'cookbook_slug' as a slug identifier, 'page' as a page number, and 'per_page' as results per page, including defaults. This is sufficient for the three parameters, though the explanations are minimal.

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 a clear resource ('recipes in a cookbook'), making the operation easy to identify. It indirectly distinguishes itself from siblings like get_recipe, get_cookbooks, and search_recipes, though it does not explicitly contrast them.

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?

There is no guidance on when to use this tool versus search_recipes, get_recipe, or get_cookbooks. The description is limited to an imperative statement plus parameter definitions, leaving selection entirely to inference.

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

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

No annotations are provided, so the description carries the full burden. 'List' implies a read-only operation, but the description does not mention pagination, ordering, authentication, or error behavior. The output schema may cover return structure, but broader behavioral context is absent.

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

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

The description is a single concise sentence with no filler. It front-loads the verb and resource and avoids unnecessary detail.

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

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

For a zero-parameter list operation with an output schema present, 'List all cookbooks' is largely sufficient. It lacks usage differentiation and behavioral details, but the low complexity means nothing essential for invocation is missing.

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

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

The tool has zero parameters and the schema coverage is 100%, so there is no parameter information that the description needs to add. The baseline for a zero-parameter tool is 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 uses a specific verb ('List') and resource ('cookbooks') with an explicit scope ('all'). It is clearly distinguishable from sibling tools like get_cookbook_recipes, which concern recipes within cookbooks.

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?

There is no guidance on when to use this tool versus alternatives such as get_cookbook_recipes or get_categories. The description states only what it does, not when it should be preferred.

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

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

With no annotations, the description carries the full burden of behavioral transparency. It communicates a read-only retrieval operation over a date range, which is the core behavior, but it does not mention ordering, date inclusivity, timezone handling, or any request limits. The output schema likely covers return shape, so 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: a one-sentence purpose statement followed by a terse Args block. Every line serves a purpose, and the main action is front-loaded. No filler or redundant explanation.

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 getter with an output schema, the description covers the essentials needed to invoke it. However, it lacks usage guidance and any caveats about date range boundaries or result limits, and the sibling context is large enough that a small amount of tool-selection guidance would have made it more complete.

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

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

Schema description coverage is 0%, so the parameter documentation in the description provides needed meaning. It identifies both required parameters and specifies the expected date format (YYYY-MM-DD), which goes beyond the raw string type in the schema. It could have added more constraints such as whether the range is inclusive, but for two simple parameters this is solid.

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 a clear action ('Get') and resource ('meal plan entries') with a date range qualifier. It is unambiguous enough to distinguish from related tools like get_shopping_lists, but it does not explicitly differentiate itself from sibling tools that might also retrieve date-scoped data.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any exclusions or preferred use cases. The only contextual hint is the date range, which describes the input requirement rather than the decision to choose this tool.

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

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

No annotations are provided, so the description carries the full burden of disclosure. It adds useful context about what the response contains (ingredients, instructions, nutrition) and the provenance of the slug, but it does not disclose error behavior for invalid/not-found slugs, authentication needs, or rate limits. For a simple read operation, the safety profile is reasonably inferable.

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

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

Two sentences, both earning their place: the first front-loads the tool's purpose, the second documents the parameter in a standard Args format. There is zero wasted text or redundancy.

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

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

For a low-complexity tool with one required parameter and an output schema present, the description covers purpose, parameter semantics, and the search-to-detail workflow. The only meaningful gap is the absence of not-found/error behavior expectations, which is a minor omission for a read-only getter.

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

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

Schema description coverage is 0%, so the description must compensate for the bare 'string' type. It does so by explaining that slug is a 'Recipe slug identifier' and that it comes 'from search results', which gives the agent meaningful guidance on what value to pass and where to obtain 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 states a specific verb ('Get'), resource ('recipe'), and scope ('full recipe details including ingredients, instructions, and nutrition'). This clearly differentiates it from siblings like get_recipe_ingredients, which covers only a subset of the content.

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

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

The phrase 'slug: Recipe slug identifier (from search results)' implies a workflow of searching first then retrieving details, but there is no explicit when-to-use or when-not-to-use guidance against alternatives like get_recipe_ingredients. The usage context is implied rather than stated.

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

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

No annotations are provided, so the description carries the burden for behavioral disclosure. It clearly indicates a read-only operation that returns an ingredient list, but it does not disclose error behavior, authentication needs, or any side effects. 'Get' implies safety, but the description is minimal.

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

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

The description is two short lines with no filler. The main behavior is front-loaded, and the parameter note is separated clearly. 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?

For a one-parameter read tool with an output schema, the description covers the core invocation details: what the tool returns and what input is required. It does not go into depth about alternatives or edge cases, but the low complexity and presence of an output schema make this mostly complete.

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

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

Schema description coverage is 0%, so the description must document the parameter. It adds 'slug: Recipe slug identifier', which clarifies that the parameter is the recipe's slug. However, this mostly restates the field name and does not explain how to obtain the slug or what 'slug' means technically.

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 a specific verb ('Get') and a specific resource ('just the ingredient list for a recipe'). The word 'just' clearly distinguishes this from the sibling get_recipe tool, which presumably returns the full recipe. The purpose is unambiguous and immediately actionable.

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 only implies usage: use this when you need only the ingredient list, not the full recipe. It does not explicitly say when not to use it or mention alternatives like get_recipe or search_recipes. The guidance is present but only by implication.

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

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

With no annotations, the description carries the full burden, and 'Get' strongly implies a read-only operation returning the list and its items. It does not disclose what happens for a missing or invalid list or explicitly confirm that no modifications occur, but for a simple getter the verb and scope provide reasonable transparency.

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

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

The description is two lines: a clear front-loaded purpose sentence followed by a minimal Args entry. Every word contributes, with 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?

The output schema covers return values, the single required parameter is explained with its source, and the scope is stated. For a low-complexity one-parameter read tool, nothing essential is missing.

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

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

The schema only declares list_id as a string, but the description adds meaningful provenance: it is a shopping list ID obtained from get_shopping_lists. This compensates for the 0% schema description coverage by telling the agent where the value comes from.

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 ('a shopping list') and explicitly scopes the result to include 'all its items', which distinguishes this from the sibling get_shopping_lists (which lists shopping lists). The operation is immediately 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 Args note 'list_id: Shopping list ID (from get_shopping_lists)' implies a prerequisite: call get_shopping_lists first to obtain the ID. However, it does not explicitly state when to prefer this tool over related siblings or mention any exclusions, so the usage guidance is only implied.

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

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

With no annotations, the description carries the full burden. 'List' and 'all' convey a read-only, unfiltered retrieval, which is transparent for a zero-parameter tool, but it does not mention permissions, errors, or any response-side behavior beyond the output schema.

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

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

The description is a single sentence with no filler: every word adds meaning, and the scope ('all') is front-loaded. This is appropriately sized for a zero-parameter tool.

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

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

For a simple zero-parameter read-only list operation with an output schema available, 'List all shopping lists' is nearly complete. The only notable gap is the lack of explicit guidance about the singular get_shopping_list alternative.

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?

There are zero parameters, so there is nothing for the schema to document or for the description to clarify. The baseline of 4 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 ('List') and resource ('shopping lists'), and the word 'all' signals the plural/collection scope, which distinguishes it from the singular sibling get_shopping_list. An agent can tell exactly what this tool returns.

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

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

The description implies the tool is for when the agent needs the complete set of shopping lists, but it gives no explicit when-to-use/when-not-to-use guidance or alternatives. It relies on the sibling names to carry the comparison.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. The verb 'List' implies a non-destructive read operation, but the description does not mention ordering, pagination, or whether all tags include hidden/system tags. This is adequate for a simple list tool but leaves some behavioral aspects unspecified.

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

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

The description is a single concise sentence with no filler. The verb and resource are front-loaded, making the purpose immediately clear. Every word earns its place.

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

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

For a simple parameterless list tool with an output schema provided, the description is nearly complete. It could optionally mention ordering or pagination, but these are minor omissions given the tool's trivial complexity. The output schema covers return structure.

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

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

The tool has zero parameters, and schema description coverage is 100% (empty schema fully describes parameter set). Baseline for 0 params is 4; the description adds no parameter information because none is needed.

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 a specific verb ('List') and resource ('all recipe tags'), clearly identifying the operation. It distinguishes from siblings like create_tag (different action) and get_categories (different resource). No ambiguity about what the tool does.

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?

Although no explicit when-to-use guidance or alternatives are named, the tool has a singular, obvious purpose: retrieve all recipe tags. There is no competing sibling tool for this task, so the context is clear without needing 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?

With no annotations, the description carries the burden of behavioral disclosure. 'List all' conveys that this is a read-only retrieval operation with no inputs. It doesn't add details about response shape or potential edge cases, but for a simple list tool this is adequate.

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

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

A single sentence that is entirely informative, with no filler. It states the action, the resource, and the scope ('in Mealie') without any redundancy.

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

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

For a parameterless list operation with an output schema available, the description fully covers the tool's purpose. There are no parameters to document and no complex behaviors that the description must explain.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly implies that no arguments are needed to call the tool, and there is nothing further it needs to explain about parameter 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 uses a specific verb ('List') and identifies a precise resource ('measurement units available in Mealie'). It clearly distinguishes this tool from siblings that list categories, tags, or cookbooks.

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

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

The description implies usage: if an agent needs the list of measurement units in Mealie, this is the tool. However, it does not explicitly state when to prefer it over alternatives or when not to use it, though no direct sibling covers measurement units.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states 'Remove an item,' implying a destructive action, but does not disclose permanence, side effects, permissions required, or behavior when the item does not exist. This is a significant gap for a mutation tool.

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

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

The description is compact and front-loaded with the core purpose. The Args block efficiently documents both parameters without unnecessary prose. Every sentence earns its place.

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

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

The tool is simple and has an output schema, so return values need no explanation. However, with no annotations, the description lacks critical behavioral context such as irreversibility or prerequisites. It is adequate for a straightforward removal but leaves gaps an agent might need to infer.

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

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

Schema description coverage is 0%, but the description compensates by explaining each parameter: list_id is 'for context' and item_id is the target, sourced from get_shopping_list. This adds meaningful semantics beyond the bare string type definitions, though 'for context' is somewhat vague.

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 a specific verb and resource: 'Remove an item from a shopping list.' This clearly identifies the operation and distinguishes it from sibling tools like delete_shopping_list (removing a whole list) and add_shopping_list_item (adding an item), though it does not explicitly name those alternatives.

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

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

The description provides indirect usage guidance by noting item_id comes 'from get_shopping_list' and that list_id is 'for context,' implying the tool is used after fetching a shopping list. However, it does not explicitly state when to use this tool over alternatives or provide any exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It conveys only that this is a paginated search; it omits search matching semantics, result ordering, limits, and any authentication or read-only expectations.

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 short and front-loaded with the core action, with a compact parameter list following. There is no fluff, though the Args section largely duplicates the input schema.

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 three-parameter search with an output schema, the description is minimally sufficient, but it lacks context on search behavior such as partial vs exact matching, case sensitivity, or maximum per_page. It also provides no rationale for when this tool is preferred over others.

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

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

Schema description coverage is 0%, and the Args section is the sole source of parameter meaning. It gives brief descriptions for query, page, and per_page, but these are generic and lack format constraints or value ranges.

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

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

The description states a specific verb and resource: 'Search the foods database.' This clearly differentiates it from sibling CRUD tools such as create_recipe and delete_shopping_list. However, it is terse and doesn't clarify what a food entry is or how results are scoped.

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?

There is no guidance on when to use this tool, no mention of alternatives, and no exclusions. The description only states the action and lists parameters, leaving the agent to infer selection 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?

With no annotations, the description carries the behavioral transparency burden. It discloses that query matches against name, description, and ingredients, that categories and tags filter by slugs, and that pagination uses page and per_page defaults. This gives an agent a clear model of the tool's matching and filtering behavior without hiding important operational details.

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

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

The description is compact and front-loaded with the primary purpose, followed by a concise parameter list. There is no fluff or redundant restating of the tool name. Each line earns its place and an agent can scan the description quickly.

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

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

For a read-only search tool with five optional parameters and an output schema, the description covers all invocation-relevant semantics: search scope, filter behavior, pagination defaults, and parameter roles. Since an output schema exists, not detailing the return shape is acceptable. No critical operational detail needed to call the tool correctly is missing.

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

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

Schema description coverage is 0%, so the description must compensate. It does so thoroughly: query is described as search text over name, description, and ingredients; categories and tags are explained as filters by slug; page and per_page are given their pagination roles. Every parameter gains meaning beyond the bare schema fields and defaults.

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

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

The description opens with 'Search recipes by keyword with optional category/tag filters', which states a specific verb, resource, and scope. It clearly distinguishes itself from sibling retrieval tools like get_recipe by emphasizing keyword search rather than direct lookup. The filter behavior is stated up front, making the tool's purpose 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 implies when to use it: when you need to search recipes by keyword and optionally filter by categories or tags. However, it does not explicitly contrast it with get_recipe, search_foods, or other sibling tools, nor does it specify when not to use it. The usage context is present but relies on inference.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It explicitly discloses the critical partial-update behavior ('Only provided fields are changed') and uses 'Replace' to warn that array fields like ingredients, instructions, categories, tags, and notes overwrite existing content. This is valuable behavioral transparency beyond the schema, though it does not cover permissions, errors, or side effects.

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

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

The description is long but every line earns its place, given 14 parameters with nested objects and zero schema descriptions. It front-loads the key update semantics and then organizes each parameter with clear, consistent formatting and examples. No filler or redundancy.

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

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

The description is highly complete for a complex mutation tool with 14 parameters and no parameter descriptions in the schema. It covers parameter semantics and the critical replace-vs-update behavior, and an output schema exists so return values are already specified. It could be slightly more complete by stating when to prefer this over create_recipe or delete_recipe, but that is a minor gap.

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

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

Schema description coverage is 0%, so the description must provide all parameter meaning, and it does. Every parameter is explained with concrete examples and nested structures are fully documented, including optional keys for ingredient dicts, instruction dicts, and note blocks. This is exceptional compensation for a schema with no descriptions.

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

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

The description clearly states the tool updates fields on an existing recipe, with a specific verb and resource. It also clarifies partial-update semantics ('Only provided fields are changed'), distinguishing it from create/delete operations. This makes the tool's purpose unmistakable even among many sibling tools.

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

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

The description clearly communicates that this tool is for updating an existing recipe, which implies it should not be used for creation or deletion. However, it does not explicitly name alternatives like create_recipe or delete_recipe or state when not to use it. This is clear context without explicit exclusions.

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