Wellness Nourish

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 read operation. The description adds minimal behavioral context beyond 'review' and 'explain', which is consistent but not additional.

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 wasted words. However, it could be slightly longer to improve clarity without losing conciseness.

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

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

Given 9 parameters with low schema coverage and no output schema, the description is insufficient. It fails to specify what the output format is, how parameters affect behavior, or what 'next correction or action' entails.

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 only 11%, and the tool description does not explain any of the 9 parameters. Parameters like date, focus, meal_type, wearable_context, etc., are left unexplained, forcing the agent to infer from names alone.

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

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

The description states the tool reviews the day after a meal log and explains changes plus next action, but it is ambiguous whether it reviews the day following a log entry or reviews the day after logging. It does not clearly differentiate from sibling tools like nourish_daily_coach or nourish_suggest_next_meal.

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

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

The description provides no guidance on when to use this tool versus alternatives such as nourish_daily_coach or nourish_suggest_next_meal. No exclusions or prerequisites are mentioned.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds context by specifying the type of guidance returned (install, safety, resource, first-call). It does not contradict annotations and provides meaningful behavioral insight beyond the structured fields.

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 that is concise and front-loaded with the purpose. Every word is necessary, and there is no redundancy or 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?

Given the tool's simplicity (no output schema, two optional parameters), the description covers the return content adequately but fails to explain the parameters. Without parameter descriptions, an agent might not know how to effectively use the client or response_format options. The description is mostly complete for a simple manifest tool but has a clear 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 compensate for parameter meanings. However, the tool description does not mention or explain the two parameters (client and response_format). The enums and defaults in the schema provide some implicit meaning, but the description adds no value, leaving the agent to guess the significance of different client options or format choices.

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 'Return' and identifies a clear resource: 'agent-facing install, safety, resource, and first-call guidance'. It clearly distinguishes this tool from the many sibling tools that deal with food, hydration, goals, etc., by being a meta-tool for agent setup.

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

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

The description implies usage when the agent needs manifest guidance, but does not explicitly state when to use or when not to use. No alternatives or exclusions are mentioned. Given the unique nature of the tool among siblings, the usage context is clear but not formally guided.

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

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

Annotations already indicate read-only and non-destructive. The description adds that it does not log data, which is a specific privacy behavior not covered by annotations. It also reveals the internal routing logic (barcode, OCR, meal-photo), providing useful context beyond structured fields.

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?

Single sentence of 20 words, front-loading the core purpose. No filler, each 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?

With 10 parameters, no output schema, and only annotations for behavioral cues, the description is adequate but incomplete. It does not explain what the tool returns, how it handles multiple inputs, or error conditions. For a routing tool, minimal completeness, but gaps exist.

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 explain parameters. It only mentions the three analysis types but does not map parameters to those types (e.g., barcode_observation for barcode, nutrition_label_text for OCR, image_description for meal estimation). This leaves the agent guessing how to use the 10 parameters correctly.

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 ('Route') and resources ('barcode, nutrition label OCR, or meal-photo estimation'), and distinguishes from siblings like nourish_lookup_barcode and nourish_estimate_meal_photo by indicating it takes agent-provided observations. The 'without logging' clause adds clarity on non-destructive behavior.

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 makes clear when to use: when the agent has already extracted image observations (text, barcode, etc.) and wants to analyze them. It does not explicitly state when not to use, but the context of siblings suggests raw images should go to other tools. This is clear enough but 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 indicate a write operation (readOnlyHint=false) but not destructive. The description adds that each item goes through the same pipeline, that the batch shares one intent flag, and that per-item success/failure is returned so partial failures don't lose the rest. This covers key behavioral traits beyond annotations, though it does not discuss rate limits or auth.

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?

Three sentences—first states purpose, second clarifies requirement, third gives example. No redundant words, front-loaded with the main action.

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

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

Given no output schema, the description adequately notes the return format (per-item success/failure). It covers the batch behavior, intent requirement, and ties to sibling tool. Could mention potential errors (e.g., invalid items beyond schema constraints), but overall complete for the complexity.

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

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

Schema description coverage is 67%, and the description adds meaning by explaining that `explicit_user_intent` covers the entire batch and that each `items` element gets its own intake entry using the same pipeline as the single-item tool. This supplements the schema's descriptions for `text` and `meal_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 clearly states 'Log multiple intake entries in a single call' and differentiates from the sibling `nourish_log_intake` by noting the same pipeline but batch intent. It provides a concrete use case (Telegram user logging multiple meals), leaving no ambiguity about the tool's 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 description explicitly mentions the requirement for `explicit_user_intent: true` and that the batch shares one intent flag, giving clear context. It implies the alternative single-entry tool (`nourish_log_intake`) but does not explicitly state when to prefer one over the other, e.g., 'For a single meal, use nourish_log_intake'.

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, making behavioral traits clear. The description adds no further behavioral context beyond its purpose.

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

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

The description is a single sentence that directly states the tool's function. It is front-loaded with the verb 'Describe' and contains no unnecessary 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?

Given the tool's role as a meta-capability overview, the description adequately covers its scope. Schema and annotations are rich, and output schema is not needed. A slight gap is the lack of mention of parameter influence on output.

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 50%, with privacy_mode well-described in schema but response_format lacking description. The tool description does not explain either parameter, missing an opportunity to clarify response_format behavior.

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

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

The description clearly states the tool's purpose: to describe supported nutrition workflows, providers, and recommended first tools. This verb+resource structure distinguishes it from sibling tools that perform specific actions.

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 use when an overview is needed, mentioning 'recommended first tools' which hints at ordering. However, it lacks explicit when-to-use or when-not-to-use guidance compared to 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, destructiveHint, and idempotentHint as true. The description reinforces these by stating 'Read-only; never mutates state.' and adds context about data sources (Agribalyse, Our World in Data). No contradictions; the description fully aligns with annotations and adds value.

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

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

The description is extremely concise: two sentences plus attribution and a state disclaimer. It front-loads the core purpose and includes all essential information without redundancy. Every sentence contributes meaningfully.

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

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

Given the tool has 4 parameters and no output schema, the description adequately covers input semantics and behavior. It explains the two input options, swap suggestions, and response format. While the return structure is not detailed, the description is sufficient for correct invocation. Could include a brief example of the output, but not 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?

Schema coverage is 100% (all 4 parameters have descriptions). The description adds value by providing an example format (`items: [{name, grams}, ...]`) and clarifying the interaction between date and items. This helps an AI agent construct correct inputs beyond the schema alone.

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

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

The description clearly states the tool's purpose: estimating carbon footprint of a meal or a day's intake, with optional swap suggestions. It uses specific verbs ('estimate', 'compute') and accurately describes the resource (carbon footprint). No sibling tool overlaps with this functionality, so it is well-distinguished.

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 explains two usage modes: passing items for an arbitrary meal or using a date for logged intake. It also notes that items wins over date when both are provided. While it does not explicitly mention when not to use this tool, the context is clear and sufficient for an AI agent to determine correct invocation. Slight room for improvement in contrasting with other 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, destructiveHint=false, idempotentHint=true. The description reinforces the read-only nature and adds valuable context that logging requires user confirmation via other tools, 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 a single sentence plus a brief clarification, with no wasted words. It is front-loaded with the core purpose.

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

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

The description covers the dashboard's purpose, read-only nature, and scope (today and future coaching). Given 4 parameters and no output schema, it provides sufficient context for an interactive dashboard tool, though parameter details are lacking.

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 only 25% (only date has a description). The tool description does not provide any additional parameter-specific meaning for focus, locale, or response_format. With low coverage, the description should compensate but fails to do so.

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 opens an interactive dashboard for today's nutrition summary, safe meal estimation, and next-meal coaching. It uses specific verbs and resources, distinguishing it from sibling tools like daily_summary, estimate_meal, and suggest_next_meal.

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

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

The description explicitly states the tool is read-only and that logging requires explicit user confirmation through existing tools. This provides clear context on when to use (viewing dashboard) and when not to use (logging), though it doesn't name specific 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 indicate destructive and idempotent behavior. The description adds important context: the tool only operates on local entries and requires explicit user intent, which is not captured by annotations.

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

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

The description is a single, clear sentence with no unnecessary words. It is front-loaded and efficient.

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 four parameters and no output schema, the description is too brief. It omits details about what happens after clearing, the effect of include_hydration, and the required format of the explicit_user_intent parameter, leaving agents with insufficient guidance.

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

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

Schema description coverage is 50%, but the tool description only vaguely references the date parameter ('for a date'). It fails to explain other parameters like response_format, include_hydration, or explicit_user_intent, which are crucial for correct invocation.

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?

Description clearly states it deletes all local intake entries for a date, distinguishing it from sibling tools like nourish_delete_intake or nourish_clear_hydration_day. The inclusion of hydration is optional, but the core intent is 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 mentions 'after explicit user intent', providing a usage condition. However, it does not explicitly compare with alternatives or specify when not to use it, leaving room for confusion with similar 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 indicate destructiveHint=true and idempotentHint=true. The description adds valuable context: the tool requires explicit user intent and does not affect intake entries. This goes beyond just repeating annotation info.

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, no fluff. The first sentence states the primary action and condition; the second provides immediate context about scope and alternatives. Front-loaded with key information.

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

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

Given the destructive, conditional nature of the tool and the presence of closely related siblings, the description is remarkably complete. It covers what, when (with condition), what not, and how to achieve a related action. No missing elements for an agent to select and 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 coverage is low (33%): only explicit_user_intent has a description. The description mentions 'after explicit user intent' which relates to that parameter, but it does not explain the date format or the response_format parameter. The date pattern in the schema is self-explanatory, but the tool description should have clarified the role of the boolean more directly.

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 (Delete), the resource (local hydration entries), and the condition (for a date after explicit user intent). It also distinguishes from sibling tool nourish_clear_day by noting what it does not touch (intake).

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

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

The description explicitly states when to use this tool (after explicit user intent) and provides clear alternatives: pair with nourish_clear_day or use nourish_clear_day with include_hydration:true for both hydration and intake. This leaves no ambiguity.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds value beyond annotations by specifying the exact nutrients computed and that deltas are returned by meal type, providing context on what the tool accesses and produces.

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, front-loaded with the main function in the first sentence and a practical use case in the second. No wasted words.

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

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

The description covers the tool's purpose, returned nutrients, and meal type breakdown. However, without an output schema, it does not describe the response structure (e.g., format of deltas), but this is acceptable for a straightforward diff 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 67% (date_a and date_b have descriptions, response_format has none). The description adds no extra parameter information beyond the schema, so it meets the baseline for moderate coverage.

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

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

The description clearly states the verb 'compute', the resource 'per-nutrient diff between two days' summaries', and lists specific nutrients and meal type breakdown. It distinguishes itself from sibling tools like nourish_daily_summary and nourish_weekly_summary by focusing on comparison.

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

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

The description provides a clear use case ('how was today vs yesterday?' coaching). However, it does not explicitly state when not to use the tool or mention alternative siblings, leaving some ambiguity for an AI 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds non-obvious behavioral promise 'without returning secrets', which is beyond annotations and provides valuable privacy 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?

Single sentence with no waste, front-loaded with purpose and key constraint. 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?

With no output schema, description should specify what 'readiness' means (e.g., per-source booleans or summary). Vague on return structure, leaving agent uncertain about output format.

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 50% (privacy_mode described, response_format not). Tool description does not explain parameters further. No additional meaning beyond what schema provides for privacy_mode, and response_format remains undocumented.

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?

Description clearly states verb 'report' and resource 'local storage, fixture, USDA, and Open Food Facts readiness' with key constraint 'without returning secrets'. Distinguishes from sibling tools focused on food logging, profile, etc.

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 explicit guidance on when to use this tool versus alternatives like nourish_capabilities or nourish_privacy_audit. Agent must infer from context that it checks connection status.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description's role is to add context. It discloses that the tool produces a summary and a 'safe next action', which adds value but does not detail side effects or behaviors like handling missing wearable data beyond what auto_wearable describes. No contradiction with annotations.

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

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

The description is a single, efficient sentence that conveys the core functionality without extraneous words. It is front-loaded and every part adds value.

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?

Despite having 9 parameters, enums, and a nested object, the description does not cover expected output format, behavior for missing data, or edge cases. No output schema exists, yet the return structure is not described. The phrase 'Telegram-style coaching' hints at style but lacks completeness.

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

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

Schema coverage is low at 11% (only auto_wearable has a description). The tool description does not explain the purpose or usage of parameters like date, focus, locale, meal_type, or nested wearable_context. Without compensation from the description, the agent lacks understanding of how to set these 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 what the tool does: it summarizes today's status, goal gaps, wearable context, and a safe next action, specifically for Telegram-style coaching. It distinguishes itself from siblings like nourish_daily_summary and nourish_goal_progress by specifying the coaching angle and the elements included.

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 implicitly suggests using this tool when a coaching summary with goal gaps and wearable context is needed, but it does not provide explicit guidance on when to use it versus alternatives like nourish_daily_summary or nourish_goal_progress. No when-not-to-use or exclusion criteria 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to repeat safety. The description adds context about what is summarized (totals, confidence, source coverage) but does not disclose additional behavioral traits like authentication needs or rate limits.

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

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

The description is extremely concise with only two sentences. The first sentence states the core purpose, and the second adds actionable usage guidance. No fluff or redundant information.

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

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

Given the annotations (readOnly, idempotent) and schema coverage, the description is fairly complete. It explains the main output and the optional comparison feature. It does not explain the meaning of 'confidence' or 'source coverage,' but those are likely clear from context. A minor gap is not mentioning what the summary includes (e.g., per-nutrient breakdown), but the comparison block implies it.

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 high (75%), with descriptions for 3 of 4 parameters. The description adds significant value for the compare_to parameter by explaining its effect (adds a comparison block with per-nutrient deltas) and providing a usage example. The other parameters are well-documented in 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 summarizes local intake totals, confidence, and source coverage for a date, using a specific verb-resource pair. It distinguishes itself from siblings like nourish_hydration_summary (hydration only) and nourish_weekly_summary (weekly).

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

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

The description provides explicit guidance on using the compare_to parameter for trend coaching, including example values and their effects. However, it does not explicitly state when not to use the tool or how it differs from nourish_daily_coach, which is a potential alternative.

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

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

Annotations already indicate readOnlyHint, idempotentHint, etc. The description adds value by disclosing 'without logging intake', a behavioral trait beyond annotations. No contradiction with 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?

One sentence that front-loads the key action and input types. Efficient but could be slightly improved with structured formatting (e.g., list of inputs). No wasted words.

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

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

No output schema exists, and the description fails to explain the result of decoding (e.g., barcode value, product info) or the significance of the response_format parameter. An agent cannot infer the return structure from the description alone.

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

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

Schema description coverage is 0%, so description must carry the burden. It explains image_path, image_base64, and image_data_uri but omits image_mime_type and response_format. Partial coverage, baseline would be 1 without description.

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

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

The description clearly states the tool's action (decode a barcode) and the input formats (image path, base64, data URI). It distinguishes from siblings like nourish_lookup_barcode by specifying 'without logging intake', making the 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 usage for decoding without logging (no intake logged) but does not explicitly state when to use this vs alternatives like nourish_lookup_barcode or nourish_lookup_barcode_image. No exclusions or alternative tool names 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?

Discloses destructive nature, consistent with destructiveHint=true. Adds the autonomy restriction beyond annotations, which is critical for safe usage. No contradictions. Slightly less credit because annotations already cover safety profile.

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 sentences: first states purpose, second gives usage constraint. No extraneous text, front-loaded, and 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?

Covers core function and critical autonomy restriction. Lacks details on reversibility or side effects, but for a simple delete operation with annotations (destructive, idempotent) this is adequate. Complete enough 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?

Adds minimal meaning beyond schema: mentions 'by id' for the required parameter, but does not cover 'response_format'. Schema coverage is 0%, so description partially compensates but leaves parameter documentation incomplete.

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?

Clearly states 'Delete a local intake entry by id.' Verb, resource, and method are explicit. Distinguishes from sibling tools like nourish_update_intake or nourish_log_intake by specifying deletion.

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?

Explicitly states 'requires explicit user intent — agents must not call this autonomously.' Provides clear when-not-to-use context and a strong gating condition, leaving no ambiguity about 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 destructiveHint=true and idempotentHint=true. The description adds the important behavioral requirement that the tool should only be used after explicit user intent, which is a safety guard. It also notes the entry is 'local', providing additional context. No contradictions with annotations.

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

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

The description is a single, well-structured sentence of 13 words. It front-loads the action ('Delete') and precisely conveys the necessary information without any extraneous words. 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 destructive tool with three parameters and no output schema, the description covers the core operation and a key precondition. Sibling tools like nourish_delete_intake and nourish_clear_hydration_day are not mentioned, but the tool's purpose is clear enough. A minor gap: it doesn't clarify that deletion is permanent or that it only affects a single entry.

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 67% with descriptions for 'id' and 'explicit_user_intent'. The description reiterates 'by id' and 'after explicit user intent', adding little beyond what the schema already provides. The 'response_format' parameter is not mentioned. The description does add that the id refers to a 'hydration entry', which is slightly additional context.

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

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

The description clearly states the action 'Delete', the resource 'single local hydration entry', the key identifier 'by id', and a precondition 'after explicit user intent'. This distinguishes it from sibling tools like nourish_delete_intake (which deletes food intake) and nourish_clear_hydration_day (which clears all water entries).

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

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

The description implies usage when the user wants to delete a single water entry, but it does not explicitly compare with alternatives or state when not to use. The precondition 'after explicit user intent' is mentioned, but there is no guidance on when to prefer this over nourish_undo_last or nourish_clear_hydration_day.

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 cover read-only, idempotent, non-destructive behavior. The description adds valuable behavioral context beyond annotations: the payloads are synthetic, verified against real pipelines by a contract test, safe to write a parser against, and include an `inputs` field. This gives agents actionable information about reliability and output composition.

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 information-dense sentences with zero fluff. The primary action is front-loaded, and the verification claim and `inputs` note are placed logically. Every clause 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 demo tool with two optional params and no output schema, the description covers the key facts: what is returned, why it is trustworty, and a notable output field. It does not describe the exact payload structure, but agents can infer it from the three referenced contracts. The minor omissions are acceptable.

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

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

The description does not explain either parameter, but the schema documents `privacy_mode` well and `response_format` is a self-explanatory enum. With 50% schema coverage, the description adds no parameter value, but the remaining gap is minor because the enum values `json`/`markdown` make the meaning obvious. Overall, the schema does the heavy lifting.

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

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

The description opens with a specific verb and object: 'Returns synthetic example payloads' of three named tools. It clearly distinguishes this demo tool from the real sibling tools like nourish_search_food, explaining the purpose as showing the contract before real calls. This is unambiguous and well differentiated.

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

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

The phrase 'so agents see the contract before any real call' gives a clear context for when to use this tool: before invoking the real operations. The named target tools are useful, but the description does not explicitly state when not to use it or point to alternatives for real data, leaving some routing 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?

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds context that the tool 'preserve[s] unresolved and confidence', indicating the output includes uncertainty metrics, and mentions 'deterministic defaults' assuring no external side effects. No contradictions with 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 two short sentences, no redundancy. It front-loads the core action. However, it could be slightly more structured (e.g., bullet points) but remains effective.

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

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

Given 5 parameters (none required), no output schema, and moderate annotations, the description covers the primary purpose and a key behavioral trait (preserving unresolved/confidence). However, it omits details on output format, locale/meal_type effects, and error handling. While adequate, there are clear gaps for an agent to fully understand the tool without checking other sources.

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 only 40%, and the description merely reiterates schema descriptions for text/meal_text ('Accepts text or meal_text'). It does not explain locale, meal_type, or response_format beyond their names. With low coverage, the description should compensate but fails to add meaningful semantic context.

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

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

The description clearly states the verb 'Estimate' and resource 'nutrition for a short meal text', and adds specificity with 'using local deterministic defaults' and handling of unresolved items. This distinguishes it from sibling tools like nourish_estimate_meal_photo (photo input) and nourish_search_food (search).

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

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

The description does not provide any guidance on when to use this tool versus alternatives. It neither mentions exclusions nor suggests preferred scenarios. For example, it could contrast with photo estimation or barcode lookup, but it does not.

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

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

Annotations already indicate readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds behavioral context beyond annotations: it clarifies that the tool requires user confirmation before logging, and that it operates on an 'agent-provided photo observation' (meaning the agent must provide a text description of a photo). This is consistent with annotations and adds value.

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

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

The description is very concise at one sentence, which is good for brevity. However, it lacks structure (no bullet points, sections, or parameter overview). For a tool with five parameters and a complex input schema, the conciseness comes at the cost of omitted parameter details and usage examples.

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 five parameters, no output schema, and 0% schema coverage, the description is insufficient. It does not explain the return format, how to construct the 'detected_items' array, or the role of 'response_format'. While it mentions the confirmation requirement, it lacks completeness for effective tool usage. The tool interacts with meal logging, but the description doesn't connect to related logging tools.

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%, meaning none of the five parameters have descriptions. The description does not elaborate on any parameter, even though it's the primary source of semantic information. For instance, 'image_description' is required but not explained; 'detected_items' is a complex array with no guidance; 'locale' and 'meal_type' have defaults but no purpose. This severely hinders correct parameter usage.

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

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

The description clearly states the tool's purpose: 'Estimate meal nutrition from an agent-provided photo observation'. It specifies the verb ('estimate'), the resource ('meal nutrition from photo'), and includes a critical constraint ('always requires user confirmation before logging'). This differentiates it from sibling tools like nourish_estimate_meal (which likely uses manual input) and nourish_analyze_food_image (which might analyze without full estimation).

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

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

The description provides explicit guidance on when to use this tool: it requires user confirmation before logging. This is a strong usage guideline. However, it does not mention alternatives or when not to use it, such as preferring nourish_estimate_meal for non-photo inputs or nourish_analyze_food_image for just analysis. The confirmation requirement is clear and helpful.

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, which is consistent. The description adds that output is Telegram-friendly but does not disclose behavioral traits like data source or handling of missing data. Annotations carry the transparency burden adequately.

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, efficiently conveying the tool's action and output format. It is front-loaded but could benefit from slightly more structure to improve scannability.

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 9 parameters, nested objects, no output schema, and only 11% schema coverage, the description is inadequate. It does not explain what the tool returns or how to use parameters, leaving significant gaps for an agent to correctly invoke it.

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 only 11% (only auto_wearable has a description). The tool description does not explain any parameters, leaving the agent without guidance for the remaining 8 parameters. No value added beyond the sparse 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 checks late-day protein, calories, and hydration gaps and produces a compact Telegram-friendly next step. It identifies the resource and purpose but does not explicitly differentiate from siblings like nourish_daily_summary or nourish_hydration_summary.

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

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

No explicit guidance on when to use this tool versus alternatives. It implies usage for evening check-ins but lacks when-not-to-use or comparison with sibling tools.

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

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

Adds value beyond annotations by stating data is exported without sensitive fields, default row limit is 500, omitted rows are reported, and the CLI alternative for full exports. No contradiction with read-only/idempotent 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 sentences front-load the purpose and key behaviors. Every sentence adds value with no 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?

Provides sufficient context for an agent to select and invoke the tool correctly, covering format, defaults, scoping, and fallback. Lacks explicit output structure, but the return format (JSONL/CSV) is stated.

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?

Adds practical guidance for since/until and max_rows parameters, explaining how to scope and that omitted rows are reported. The response_format parameter is not mentioned, but schema coverage is 60%, so the description compensates 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 clearly states it exports local intake data as JSONL/CSV without provider secrets/tokens. It specifies the default of 500 most-recent rows and mentions date scoping and max_rows, distinguishing it from similar list tools and the CLI 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?

Explicitly tells when to use date scoping or max_rows to refine the export, and advises using the CLI for full unbounded dumps. Provides clear context for usage and 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 indicate destructive behavior (destructiveHint=true) and idempotency (idempotentHint=true). The description adds the requirement for explicit user intent, but does not elaborate on what happens if the parameter is false or if the id/label is not found. Some behavioral details remain implicit.

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

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

The description is a single, well-structured sentence that front-loads the core purpose. Every word earns its place with no 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 destructive tool with 3 parameters and no output schema, the description is adequate but leaves gaps. It covers the primary operation but does not describe error handling (e.g., missing id_or_label), response behavior, or confirmation steps. Given the tool's complexity, additional context would benefit an AI agent.

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

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

Schema coverage is low (33%), with only explicit_user_intent having a description. The tool description clarifies that id_or_label is used for identification ('by id or label'), adding meaning beyond the schema. However, response_format is not addressed, and the description does not fully compensate for the lack of schema descriptions on all parameters.

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

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

The description clearly states the action (Delete), the resource (local remembered meal), and the criteria (by id or label after explicit user intent). It effectively distinguishes this tool from siblings like nourish_delete_intake and nourish_clear_day.

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 specifies 'after explicit user intent,' which provides clear context for when to use the tool. However, it does not explicitly mention alternatives or when not to use it, though the sibling tools context helps fill that gap.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds the data sources and the method of retrieval, but does not elaborate on behavior such as what happens if the ID is not found or rate limits. Given the annotations cover safety, the description provides minimal extra transparency, not contradicting annotations.

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

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

The description is a single sentence of 17 words, front-loaded with the action 'Fetch'. It is concise, contains no fluff, and every word adds value. Excellent 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 tool with 3 parameters and no output schema, the description covers the core functionality but omits details on response format, error handling, and parameter formats. Given the complexity, it is somewhat incomplete but adequate for basic understanding.

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

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

Schema description coverage is 0%, meaning no parameter descriptions in the schema. The tool description only mentions source_id generically, without explaining the expected format for each source (e.g., numeric for USDA) or the purpose of response_format. It fails to add meaning beyond the parameter names and types.

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

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

The description clearly states the tool fetches a food item from three specific databases (USDA, Open Food Facts, TACO) using an identifier. It uses the verb 'Fetch' and specifies the resource, distinguishing it from siblings like nourish_search_food. However, it could be more explicit about the required parameters and the exact role of each source.

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

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

No guidance is provided on when to use this tool versus alternatives like nourish_lookup_barcode or nourish_search_food. The agent may be confused because there is a separate tool for barcode lookup, but this tool also accepts barcode IDs for Open Food Facts. The description does not help select among siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, setting a clear safety profile. The description adds the context that goals are 'local', implying no network dependency. This is a useful behavioral detail 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 a single, front-loaded sentence with no unnecessary words. Every part contributes to the 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?

The description is adequate for a read tool with good annotations, but it does not mention the return format or structure (e.g., returns goal targets). Since there is no output schema, a brief note on what is returned would improve completeness.

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

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

Schema description coverage is 50% (only privacy_mode has a detailed description; response_format lacks description). The tool description does not explain parameters beyond what is already in the schema, nor does it compensate for the undocumented parameter. An agent must rely on the schema alone for parameter meaning.

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 'Read local calorie, macro, and hydration goals', specifying the verb (read), resource (goals), and scope (local). It effectively distinguishes from siblings like nourish_set_goals (write) and nourish_goal_progress (tracking progress).

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

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

The description implies usage for reading goals but provides no explicit guidance on when to use this tool versus alternatives like nourish_goal_progress or when not to use it. There are no exclusions or context cues to help an agent decide between similar read 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 indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds valuable context: 'Read-only: no logging side effects, no explicit_user_intent required' and describes locale-aware recommendations and output granularity. This goes beyond the annotations by clarifying side-effect-free operation and user intent requirements.

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 long, front-loading the core purpose and then providing key details about outputs and behavior. Every sentence adds value: the first defines scope (periods, nutrients), the second details outputs and special features. No redundant or irrelevant information.

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

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

Given no output schema, the description explains the output structure in detail: per-day breakdown fields, period totals, averages, days_on_target, and recommendations. It also notes locale handling. The parameters are partially described. A more complete description would explicitly mention the response_format parameter and its effect. Overall, it covers the essential aspects for an agent to understand the tool's behavior and output.

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 50%. The description mentions the permissible period values ('today / yesterday / last_7_days / last_30_days') which aligns with the period parameter, adding clarity about the time windows. However, the response_format parameter is not addressed in the description, and its schema description ('json') is minimal. The tool description partially compensates for the schema gap but does not fully cover both 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 it computes per-day progress vs configured goals for specific nutrients (kcal, protein, carbs, fat, water) over defined periods. 'Compute' is a specific verb and 'per-day progress vs configured goals' is a well-defined resource. It distinguishes itself from sibling summary tools by focusing specifically on goal progress, but does not explicitly differentiate from related tools like nourish_daily_summary or nourish_weekly_summary.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. It neither specifies prerequisites nor suggests scenarios where this tool is preferred over other summary or goal-related tools. The absence of usage context leaves the agent to infer its applicability.

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, correctly reflecting the summary operation. The description adds no additional behavioral context (e.g., data freshness, permission requirements), so while it does not contradict, it also does not enrich beyond the structured fields.

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 is efficient, though it could be slightly expanded to include critical parameter notes without losing brevity.

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 moderate complexity (3 parameters, 2 enums), the description provides the core purpose but omits details about the summary content (e.g., totals vs. itemized) and behavior of different privacy_mode values. It is adequate but not fully complete for an agent to predict output without trial.

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 only 33% (only privacy_mode has a description). The tool description does not explain any parameters, including the date format or the effect of response_format. It fails to add meaning beyond the schema, especially for the undocumented 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 'Summarize local hydration for a date', using a specific verb, resource, and scope. It distinguishes itself from sibling summary tools like nourish_carbon_summary and nourish_daily_summary by explicitly focusing on hydration.

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 on when to use this tool versus alternatives such as nourish_list_intake or nourish_clear_hydration_day. There is no mention of prerequisites or preferred scenarios, leaving the agent to infer usage from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint as safe. The description adds behavioral context like filter conjunction, date mutual exclusivity, privacy_mode effects, and default sorting, which goes 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 a single sentence of 20 words, front-loaded with the main purpose, and contains no superfluous information.

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

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

Given the tool has 10 mostly optional parameters, no output schema, and strong annotations, the description adequately covers filter behavior, ordering, and privacy modes. It is complete 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?

With 90% schema description coverage, the schema already documents most parameters. The description adds value by explaining filter combination logic and privacy mode options, but does not significantly exceed baseline for a high-coverage 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 'List local intake entries' with specific verb and resource, and the optional filters distinguish it from sibling tools that perform other actions like log, update, delete, or memory listing.

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

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

The description explains filtering behavior (AND, date ranges, optional filters) and ordering (most-recent-first). However, it does not explicitly contrast with sibling list tools like nourish_list_memory or nourish_search_food, which could be 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 destructiveHint=false. Description adds context about local storage and Telegram, consistent with safe read behavior.

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

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

Single sentence front-loads the core purpose with no wasted words.

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

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

Adequate for a simple read tool with strong annotations, but lacks mention of return format or pagination, which would be helpful given no output schema.

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

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

Two parameters (privacy_mode, response_format) with 50% schema coverage; only privacy_mode has a schema description. Tool description adds no parameter information, failing to compensate for the lack of response_format description.

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

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

Description clearly states verb 'Read' and resource 'local remembered meals and nutrition preferences', with context of 'personal Telegram shortcuts'. It distinguishes from sibling tools like nourish_list_intake and nourish_remember_meal.

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 explicit guidance on when to use vs alternatives. Context implies it's for retrieving stored memories, but no when-not or alternative references.

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?

Despite annotations carrying only generic flags, the description discloses a meaningful behavioral guardrail: the tool should not be invoked without explicit user intent and requires the explicit_user_intent flag to be true after a save/log/register request. It doesn't mention side effects like persistence or non-idempotency, but the consent requirement is a valuable behavioral disclosure beyond the 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?

Two short sentences front-load the critical user-intent requirement before mentioning accepted input forms. Every word adds information and there is no redundancy or 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 17-parameter, nested-object tool with no output schema and low schema coverage, the description is too thin. It does not explain what happens after logging, how to choose between text and structured data, how the bulk sibling differs, or what response the agent should expect. The explicit-intent guidance is necessary but not sufficient for reliable invocation.

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

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

Schema description coverage is only 18% across 17 parameters, so the description needed to compensate but only mentions 'text or meal_text plus structured food data.' It leaves most parameters (food, quantity, nutrients, food_ref, custom_food, grams_estimate, response_format, tags, etc.) without clarification, and does not explain how structured food data should be shaped.

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 names the exact action ('Log'), the resource ('an intake entry'), and the primary input modes ('text or meal_text plus structured food data'), so an agent can tell this is the single-entry logging tool. It does not explicitly reference the sibling nourish_bulk_log_intake or other log-related tools, but the singular scoping is enough to distinguish it from bulk logging.

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

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

The description gives a clear precondition and trigger: call only after explicit user intent, and set explicit_user_intent to true after the user asks to save/log/register. It does not explicitly describe when to prefer nourish_bulk_log_intake, nourish_update_intake, or nourish_log_water, so it stops short of a full when/when-not 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?

The explicit_user_intent requirement is disclosed, adding useful behavioral context beyond the annotations. However, with annotations all false and no output schema, the description does not address what happens on repeated logs, whether entries are appended or overwritten, or what the tool returns.

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

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

Two sentences with no filler; the core operation is front-loaded and the safety/guardrail instruction follows directly. Every sentence contributes.

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?

Adequate for a simple logging action but incomplete: with no output schema and no safe-read annotations, an agent is left uninformed about return values, default date/timestamp behavior, and duplicate handling. Still, the required parameter and key intent flag are 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 only 33%, and the description does not compensate: 'milliliters' and the explicit-user-intent condition merely paraphrase the existing amount_ml and explicit_user_intent schema descriptions. No meaning is added for date, notes, timestamp, or response_format.

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

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

The description states a specific verb and resource: 'Log local hydration in milliliters.' This clearly differentiates water logging from food-intake logging by naming the unit and hydration domain. It does not explicitly name sibling tools, which keeps it from a 5.

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

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

The description gives a contextual trigger ('after explicit user intent' and 'after the user asks to save/log water') but does not state when to prefer this over sibling log tools such as nourish_log_intake or nourish_bulk_log_intake, nor does it give 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 provide strong transparency (readOnlyHint, idempotentHint, openWorldHint), reducing the burden on the description. The description adds the source ('Open Food Facts') but does not elaborate on response behavior, data freshness, or potential errors. With annotations covering safety, this is adequate but 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, efficient sentence with no superfluous words. It frontloads the action and resource, making it easy for an agent to parse quickly.

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

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

Given the simplicity of the tool (a barcode lookup), the presence of rich annotations, and lack of output schema, the description is reasonably complete. It covers the core functionality but could briefly mention the response format or data source specifics.

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

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

Schema description coverage is 50% (only the 'barcode' parameter has a description). The tool description does not add additional meaning or context for 'response_format', leaving its purpose unclear beyond the enum values. The description fails to compensate for the missing schema description.

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

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

The description clearly states the action 'Lookup' and the resource 'a packaged food barcode in Open Food Facts'. It effectively distinguishes the tool from siblings like 'nourish_decode_barcode_image' and 'nourish_lookup_barcode_image' by specifying it directly looks up a barcode value.

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 (e.g., when to use 'nourish_search_food' or 'nourish_get_food'). No context on prerequisites or exclusions is given, leaving the agent to infer usage without support.

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 and idempotent profile is clear. The description adds the specific behavioral steps (decode then lookup), which is valuable beyond annotations. No contradictions with annotations.

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

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

The description is a single concise sentence that clearly communicates the core function. Every word is necessary, and there is no redundant or extraneous information.

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

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

Given no output schema and a moderately complex two-step operation, the description lacks detail about what the tool returns (product info, nutritional data, etc.) and assumes the agent knows how to provide images. It covers the essential action but leaves out important contextual information about image quality requirements or response 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?

Schema coverage is 0%, and the description does not explain any of the five parameters (image_path, image_base64, image_data_uri, image_mime_type, response_format). It only mentions 'barcode image' generically, providing no guidance on which input method to use or how to format the request. This forces the agent to rely solely on parameter names and types.

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

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

The description clearly states the two-step operation: decode a packaged-food barcode image and then lookup the product in Open Food Facts. This specific verb+resource combination effectively distinguishes it from sibling tools like nourish_lookup_barcode (which takes a barcode string) and nourish_decode_barcode_image (which only decodes).

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 you have a barcode image), but it does not explicitly differentiate from alternatives or provide guidance on when not to use it. There is no mention of prerequisites or comparisons to similar sibling tools, leaving the agent to infer usage context from the name alone.

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

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

Annotations already declare readOnlyHint and idempotentHint true. The description adds value by specifying the exact number of questions, that it is an 'onboarding flow', and that data is stored non-secretly at a specific path. No contradiction with 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, consisting of three short sentences. It front-loads the primary action, then adds usage guidance and data handling details without any redundancy or unnecessary 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?

The tool is simple with two optional parameters and no output schema. The description covers purpose, usage context, read-only nature, data storage, and the return of a fixed set of questions. It is sufficiently complete for an agent to understand when and how to use 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?

Schema description coverage is 0%, and the description does not explain the two parameters (locale, response_format) or their default values. However, the parameter names and enum choices are self-explanatory given the tool's purpose. The description adds no explicit parameter semantics but is adequate due to simplicity.

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

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

The description clearly states the tool returns a specific set of questions (11-question onboarding flow) for the shared Delx Wellness profile, using a specific verb and resource. It distinguishes itself from sibling tools like nourish_profile_get by focusing on the flow rather than profile 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 explicit guidance: the agent should ask these questions next to enable personalization. It explains the purpose and data handling (non-secret, stored locally). While it does not list alternatives or when to avoid, the context is clear enough for an agent to decide to call this tool early in the interaction.

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 and idempotentHint, so the description's burden is lower. It mentions using wearable context, which is consistent. However, it does not disclose that auto_wearable may read a local file, which is only in the schema parameter description.

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?

Single sentence, front-loaded with verb, no unnecessary words. Every part earns its place.

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

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

Given 9 optional parameters and no output schema, the description is too sparse. It does not explain output format, relationship to goals, or behavior when wearable context is missing. Many critical details are omitted.

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 low (11%: only auto_wearable has a description). The tool description does not elaborate on any of the 9 parameters beyond vague references. It does not explain date, locale, meal_type, workout_context, or response_format.

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

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

Description clearly states the verb 'suggest', the resource 'light pre-workout nutrition', and the inputs 'goals, current intake, and optional WHOOP/Garmin context'. It distinguishes from siblings by specifying pre-workout 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?

Implicitly suggests use before a workout, but no explicit guidance on when to prefer this over alternatives like nourish_suggest_next_meal or nourish_daily_coach. No exclusion criteria or alternative names given.

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, read-only operation. The description adds no further behavioral context beyond what the tool's name implies, such as that it accesses local storage. Annotations carry the burden here; description is adequate but not enhanced.

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 that efficiently lists the audit topics. It is concise and front-loaded, though it could be slightly more structured to separate the topics clearly.

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

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

For a read-only audit tool with two enumerated parameters and no output schema, the description sufficiently covers what the tool does. It lists the key areas audited, implying the output will describe those areas. The description is complete given the tool's 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 50% (only privacy_mode has a description). The tool description adds explanation for privacy_mode's enum options (summary, structured, raw), clarifying their differences. However, response_format is not explained in the description, and the schema only provides enum values without elaboration.

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 audits privacy-related aspects like local storage, secret handling, source licensing, and safety boundaries. It uses a specific verb (describe) and resource, distinguishing it from sibling tools focused on nutrition logging and profile management.

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

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

No guidance on when to use this tool vs alternatives. The description does not mention when it is appropriate to run a privacy audit, nor does it differentiate from other informational tools like nourish_capabilities or nourish_agent_manifest.

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 provide readOnlyHint, idempotentHint, etc. The description adds value by specifying the exact file location (~/.delx-wellness/profile.json) and listing the data categories (calorie/macro targets, dietary preferences, etc.), which is additional context 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 two sentences, front-loading the primary action and then listing the contents. Every sentence serves a purpose with no unnecessary words, achieving excellent conciseness.

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

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

For a simple read tool with no output schema, the description covers the key output categories. It does not mention the response format (JSON/markdown) controlled by the parameter, but that is documented in the schema. Overall, it is sufficiently complete for the tool's simplicity.

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 50%, and the description does not directly explain the parameters. However, the 'privacy_mode' parameter has a detailed description in the schema, and the tool description clarifies the overall content of the profile, which indirectly aids understanding. No parameter info is added in the description itself.

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

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

The description clearly states the tool returns the shared Delx Wellness profile and specifies its contents (calorie/macro targets, dietary preferences, etc.). The verb 'Returns' combined with the resource makes the purpose unambiguous, and it is distinct from sibling tools like nourish_profile_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 description indicates the tool is read-only and intended for personalization by coach/suggest tools, implying when to use it. It does not explicitly state when not to use it or mention alternatives, but the sibling context (e.g., nourish_profile_update) provides differentiation.

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

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

Annotations already indicate idempotentHint=true and destructiveHint=false. The description adds that it rejects sensitive fields, but does not elaborate on idempotency or consequences of rejection. No contradiction with annotations.

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

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

The description is a single sentence with three crucial clauses: purpose, requirement, and constraint. It is front-loaded with the action and immediately provides key usage conditions, with no wasted words.

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

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

Given the complexity of a nested patch object and no output schema, the description provides the essential purpose, a required flag, and a security rule. It does not describe return values or error handling, but annotations and schema partially fill 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 description adds a meaningful constraint: rejection of secret fields in the patch object, which is not present in the schema's parameter descriptions. Schema coverage is 67%, but the description compensates with this security context. It also reinforces the explicit_user_intent requirement stated in 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 specifies 'Persist a partial patch to the shared Delx Wellness profile', which is a specific verb+resource combination. It clearly states the tool updates the wellness profile, distinguishing it from read-only tools like nourish_profile_get.

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 requires 'explicit_user_intent: true' as a condition for use, telling the agent when to invoke it. It also warns about rejected fields (secrets), guiding proper usage, though it does not compare against sibling update tools like nourish_set_goals.

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, destructiveHint=false. The description adds transparency beyond annotations by stating 'Read-only; never fabricates wearable data' and describing the behavior when no context is persisted. No contradiction with 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 three sentences, front-loading the main action. Each sentence adds essential information: what it does, its safety, and how results are used. No unnecessary 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?

Given the tool's simplicity (read-only, no required parameters, no output schema), the description covers the core behavior and integration points. However, it could be improved by detailing the return structure beyond 'returns available:false' and the fact that it can be passed to other tools.

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 descriptions for both parameters, achieving high schema coverage. The description does not add additional meaning beyond the schema, 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 reads the most recent wellness_context from a specific path, with a specific verb ('Read') and resource ('shared wellness_context'). It distinguishes itself from sibling tools by explaining it provides context for coach tools, avoiding the need for agents to pass data inline.

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 explains when to use it (to get wearable context for coach tools) and what happens if no context exists (returns available:false). It also mentions alternatives (auto_wearable:true on coach tools). However, it does not explicitly state scenarios where it should not be used.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the tool is safe. The description adds behavioral context about personalizing based on current state (USDA key set, OFF enabled, local-dir writable), which is 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 two sentences long, front-loaded with the core purpose, and every word is useful. No unnecessary 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?

Given the tool's simplicity (a walkthrough) and the presence of annotations and detailed schema, the description fully covers what an agent needs: purpose, when to call, personalization, and state adaptation.

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 already describes both parameters with enums and defaults, providing good coverage. The description does not add additional parameter-specific meaning, so it meets the baseline without extra value.

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

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

The description clearly states the tool is a 'Personalized 3-step setup walkthrough for the human user' and adapts to current state. It distinguishes itself from siblings by being a quickstart walkthrough, and specifies when to call it ('when the user asks how do I use this?').

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 says 'Call this first when the user asks how do I use this?', providing direct usage guidance. It does not explicitly state when not to use it or mention alternatives, but the context is clear.

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 idempotency and non-read-only. Description adds critical condition 'after explicit user intent' and 'locally', providing additional safety context 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?

Single concise sentence with a clear example. No 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?

No output schema, description fails to mention return value or behavior for retrieving saved memories. Lacks explanation of non-required parameters. For an 8-param tool, too minimal.

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

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

With only 38% schema description coverage, the description should compensate but only illustrates two required parameters (label, meal_text). Undocumented params like tags, notes, aliases, response_format, default_meal_type remain unclear.

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?

Clearly states the verb (save), resource (personal meal shortcut), and condition (after explicit user intent). Example distinguishes from meal logging and estimation 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?

Implies usage after explicit user intent but does not explicitly state when to use this tool over alternatives like nourish_log_intake or nourish_estimate_meal. No 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, openWorldHint, idempotentHint, and destructiveHint, covering safety and idempotency. The description adds minimal behavioral context beyond provider selection. 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?

Two sentences that are concise and front-loaded with the core purpose. No redundant information. Every word adds value.

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

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

Given 5 parameters and no output schema, the description covers provider selection but omits details on limit (pagination), response_format, and privacy_mode effects. Though defaults exist, added context would improve completeness for an AI agent.

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

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

Schema description coverage is 20% (only privacy_mode has a description). The description adds meaning for the provider parameter and suggests query usage, but does not address limit, response_format, or privacy_mode beyond what schema provides. Thus, some compensation but not full.

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 searches food providers by query, with specific guidance on which provider to use for different food types. This verb+resource combination is distinct from sibling tools like nourish_lookup_barcode and nourish_get_food.

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 context for when to use each provider (e.g., taco for Brazilian staples, open_food_facts for packaged products). It implies when not to use this tool (e.g., for barcode lookup, use the barcode tool), but does not explicitly state exclusions or 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?

Adds important context about requiring explicit user intent and confirmation before saving, which is beyond the annotations (idempotent, non-destructive). No contradiction.

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 well-structured sentences: purpose first, then usage patterns. No wasted words.

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

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

Sufficiently complete given 10 parameters, nested object, and no output schema. Covers usage patterns and the critical explicit_intent guardrail, though success/error behavior is omitted.

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?

Explains the two ways to specify goals (daily object vs flat shortcuts) and the explicit_user_intent parameter, adding value beyond the high-coverage schema descriptions.

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

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

The description clearly states the tool sets local calorie, macro, and hydration goals, and distinguishes it from siblings like nourish_get_goals by requiring explicit user intent.

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 usage patterns (daily object vs flat shortcuts) and the condition to pass explicit_user_intent=true after confirmation, but does not explicitly list when not to use or 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 and idempotentHint, so the description doesn't need to repeat that. It adds context about input sources but does not disclose behavior like how suggestions are generated, what happens if insufficient data, or potential limitations. Acceptable but not enriched 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?

A single sentence that conveys the essential purpose without any fluff. It is appropriately front-loaded and efficient, making it quick 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 tool with 9 parameters, 0 required, no output schema, and a complex domain (nutrition suggestions), the description is too brief. It lacks information about the return format, how suggestions are tailored, or what happens when data is missing. Given the richness of context needed, this is inadequate.

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 very low (11%), with only auto_wearable having a description. The overall description fails to compensate by explaining other parameters like date, focus, meal_type, or how wearable_context is used. The agent would need to infer meaning from names alone, which is insufficient.

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 'Suggest' and resource 'next meal', specifying sources (today's intake, goals, personal memory, wearable context). It effectively distinguishes from siblings like nourish_estimate_meal (estimates nutrients) and nourish_log_intake (logs). This is a specific and helpful purpose statement.

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 explicit guidance on when or when not to use this tool compared to alternatives like nourish_daily_coach or nourish_estimate_meal. The description implies it's for meal recommendations but fails to provide context for selection among siblings.

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

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

Beyond the annotations (destructiveHint=true), the description adds that the tool returns what was undone for confirmation and requires explicit_user_intent. This provides useful behavioral context beyond the schema and 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 three sentences long, front-loads the purpose, and contains no unnecessary words. Every sentence adds value.

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 (undo last entry, kind scope, confirm return), the description covers purpose, parameters, behavioral requirements, and return value. No gaps for an agent to misunderstand.

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 repeats the kind parameter values and emphasizes the explicit_user_intent requirement, but the schema already documents these parameters well (67% coverage). The description adds minimal new semantic insight.

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 undoes the most recent intake or hydration entry, using the verb 'undo' and specifying the resource. It distinguishes from siblings like nourish_delete_intake by focusing on the last entry and recovery context.

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

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

The description provides context for use ('the most common Telegram/agent recovery move') and explains the kind parameter to scope the undo. It also notes the requirement for explicit_user_intent. However, it does not explicitly contrast with other delete/clear 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 signal mutability, idempotency, and non-destructiveness. The description adds meaningful context: quantity or grams_estimate changes rescale nutrients to keep summaries consistent, and the entry is local. This is useful beyond the annotations and does not contradict 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?

Two tight, front-loaded sentences with no filler. The core action comes first, the key side effect second, and the gating constraint last—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 9-parameter tool with no output schema and no per-parameter descriptions, this description is too thin to fully guide correct invocation. It explains rescaling behavior but omits semantics for most optional fields, return behavior, and alternatives.

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 across 9 parameters. It only adds meaning to id, quantity, and grams_estimate; tags, unit, notes, meal_type, timestamp, and response_format remain semantically undocumented.

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 ('Update'), a clear resource ('a local intake entry'), and the lookup basis ('by id'). This is enough to distinguish it from logging, listing, and deleting intake, though it does not explicitly name sibling 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 an explicit gating rule: requires explicit user intent and agents must not call this autonomously. It lacks guidance on when to prefer this over alternatives like delete-and-relog or bulk logging, 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, destructiveHint=false. The description adds behavioral context by specifying the time window (seven days) and the data scope (local intake), which goes beyond just summarizing totals. No contradictions with annotations.

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

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

The description is a single, concise sentence with no waste. It conveys the essential purpose without extraneous detail, fitting the brevity ideal.

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?

Without an output schema, the description omits details on return format, pagination, or error handling. The scope 'local intake totals' is clear but the agent lacks full context on what the summary includes (e.g., macronutrients, items). Adequate for a simple tool but not 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 low at 33%, with only privacy_mode having a description. The tool description mentions 'start date' but does not clarify format, default, or behavior. The description fails to compensate for the poorly documented 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 specifies the verb 'summarize', the resource 'local intake totals', and the scope 'seven days from a start date'. This clearly distinguishes it from siblings like nourish_daily_summary (one day) or nourish_hydration_summary (water).

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 does not provide any guidance on when to use this tool versus alternatives, nor does it mention prerequisites or when not to use it. The purpose is clear but usage contexts are left implicit.

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