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

No annotations are provided, so the description must disclose behavioral traits. It only states 'Add a biometric entry' without any details about idempotency, duplicate handling, side effects, or required permissions. This leaves significant gaps for an AI agent.

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: a brief opening sentence followed by structured lists. The most important information is front-loaded. It could be slightly more streamlined, but it is well-organized and avoids unnecessary details.

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

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

For a simple add operation with three required parameters, the description fully covers the input. The presence of an output schema (though not visible) reduces the need to explain return values. The description is sufficiently complete for an agent to use the tool correctly.

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

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

The description includes an 'Args' section that explains the allowed values for metric_type, units for value, and format for entry_date. The input schema only has titles and types with 0% coverage, so the description adds crucial meaning beyond the schema.

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

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

The description clearly states 'Add a biometric entry to Cronometer' and lists supported metric types. The tool name and description align, and it is distinguished from sibling tools like 'remove_biometric' and 'get_recent_biometrics'.

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 supported metric types and displays acceptable units (lbs, mg/dL, bpm, %), guiding appropriate usage. It implicitly tells the agent when to use this tool (for adding these specific metrics) but does not explicitly state conditions to avoid or 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?

With no annotations provided, the description carries the behavioral burden. It discloses default behavior for measure_id, quantity, and diary_group fallback, and warns that diary group names are user-configured and may differ from standard ones. It does not detail side effects or error handling, but it covers the most decision-relevant behavior.

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

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

The description is organized as a compact workflow paragraph followed by an Args list. Every sentence adds value, and the structure front-loads the primary action before parameter 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 7 parameters, 0% schema coverage, and no annotations, the description is remarkably complete. It covers the calling sequence, parameter sources, defaults, edge cases for CRDB/custom foods, and how to discover diary groups, leaving no important gap for an agent to invoke it correctly.

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

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

Schema description coverage is 0%, and the description compensates fully by explaining the origin and purpose of every parameter, including food_id, food_source_id, weight_grams, date, measure_id, quantity, and diary_group. It also clarifies relationships like quantity defaulting to weight_grams when measure_id is 0.

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 first sentence states the specific operation and resource: "Add a food entry to the Cronometer diary." It clearly distinguishes itself from sibling tools like remove_food_entry and get_food_log, and the workflow references tie it to search_foods and get_food_details.

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 prescribes a workflow: use search_foods to find IDs, get_food_details for measure and weight, and list_diary_groups for valid group names. It also explains when measure_id and quantity can be omitted for CRDB/custom foods, giving precise selection guidance.

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

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

With no annotations, the description carries the transparency burden and does it well: it explains auto-logging on selected days, quantity units via the coffee example, diary_group case-insensitivity/indexing/default behavior, and days_of_week formats/defaults. It does not discuss what happens on repeated calls or the success/response shape, but the presence of an output schema mitigates the return-value gap.

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

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

The description is well-organized: a one-sentence purpose, a crucial unit-of-measure note with a concrete example, then a clean parameter block. Every sentence adds either behavioral context or parameter guidance, with no filler or redundancy beyond the repetitive but still useful quantity note.

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 six parameters, zero schema descriptions, and no annotations, this description is remarkably complete. It covers the full parameter set, expected lookup workflow, defaults, and edge-case values. The presence of an output schema means return values do not need to be described.

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 fully compensates by explaining all six parameters: food_id and food_source_id provenance, quantity meaning, food_name purpose, diary_group semantics including default, and days_of_week allowed formats including 'all', 'weekdays', and 'weekends'.

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

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

The description states a specific action and resource: 'Add a recurring food entry that auto-logs on selected days.' This differentiates it from sibling add_food_entry (one-off) and delete_repeat_item, even without naming them.

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

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

It gives clear preparation guidance: 'Use search_foods to find food_id and food_source_id' and points to list_diary_groups for diary_group names. It does not explicitly say when-not-to-use this tool versus add_food_entry or delete_repeat_item, but the recurring-entry context makes the intended use reasonably 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?

No annotations provided, and the description fails to disclose behavioral details such as side effects, permissions, or reversibility beyond preserving the schedule.

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?

Extremely concise with two short paragraphs and an Args section; front-loads purpose and provides essential context without waste.

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

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

For a simple tool with one parameter and an output schema, the description covers the core functionality and prerequisite step, though it omits edge cases on non-active fasts.

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%, but the description adds meaning by specifying that fast_id must belong to an active fast, compensating for the lack of 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 verb 'cancel' and the resource 'active fast', and distinguishes from deleting the schedule by noting preservation of recurring schedule.

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

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

Provides explicit guidance to use get_fasting_history to find active fasts, but does not mention when not to use or alternatives like delete_fast.

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 key behavior (server-side, additive, covers all entry types) but omits potential failure modes, authorization requirements, or return value details. Adequate given no annotations.

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

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

Concise, front-loaded with main purpose, every sentence adds value. No 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?

Explains overall behavior adequately for a copy tool with simple parameters. Output schema exists so return values not needed. Minor gaps like edge case behavior (e.g., same date) not covered.

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 meaning beyond schema by specifying format YYYY-MM-DD for both parameters. Schema covers 0%, so 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?

Clearly states verb (copy), resource (all diary entries), and scope (from one date to another). Distinguishes from sibling tools that operate on individual 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?

Explains that it is server-side, copies all entries additively, implying use when duplicating date data without overwriting. Does not explicitly mention alternatives but context makes it 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?

No annotations provided, so the description carries full burden. It mentions the optional side effect of assigning to all days of the week, but lacks disclosure about overwriting existing templates, required permissions, or any destructive actions. For a creation tool, more behavioral context is needed.

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

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

The description is compact, front-loaded with the purpose, and uses a clear docstring format with bulleted arguments. 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?

For a tool with 6 parameters, no annotations, and an existing output schema (not described), the description adequately covers inputs and the optional side effect. However, it omits any description of the return value, error conditions, or uniqueness constraints on template_name, making it slightly incomplete.

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%, but the description provides explicit docstring-style explanations for all 6 parameters, including units (grams, kcal), example values, and default behavior for assign_to_all_days. This fully compensates for the lack of 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?

Description clearly states 'Create a new saved macro target template in Cronometer' with specific verb (Create) and resource (macro target template). It is distinct from sibling tools like list_macro_templates (listing), set_macro_targets (setting current targets), and set_weekly_macro_schedule (scheduling).

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 versus alternatives; for example, it does not clarify when to use create_macro_template vs set_macro_targets or set_weekly_macro_schedule. The optional assignment to all days is mentioned but not linked to alternative scheduling 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?

No annotations are provided, so the description carries full burden. It only states that the tool deletes a fast entry, without disclosing whether the action is reversible, requires permissions, or what side effects occur. This is insufficient for a mutation tool.

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

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

The description is extremely concise: two sentences plus an Args section. Every sentence adds value, and the purpose is front-loaded. 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?

For a simple one-parameter delete tool with an output schema, the description covers purpose, parameter, and prerequisite. It doesn't describe return values, but that may be covered by the output schema. Overall, it's adequate for the complexity level.

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 explains the fast_id parameter as 'The fast ID to delete,' adding meaningful context beyond the schema's title and type. Since schema description coverage is 0%, 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 explicitly states it deletes a fast entry from Cronometer, using a specific verb and resource. It distinguishes itself from sibling tools like cancel_active_fast by implying it's for historical entries, and provides a prerequisite step.

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 instructs to use get_fasting_history first to find the fast_id, which is a clear usage guideline. It does not explicitly mention when not to use it or alternatives, but the prerequisite is well stated.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It describes a destructively mutable operation but fails to mention side effects, irreversibility, permissions needed, or return values. The only added context is a hint to find the ID.

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 a parameter line. It front-loads the primary action and immediately follows with a crucial usage hint. No 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?

For a simple delete tool with one parameter and an output schema, the description is minimally complete. It covers the action and parameter purpose but omits expected behavior on success/failure, error handling, or any confirmation. An agent might need additional context for robust 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?

With 0% schema description coverage, the description adds a minimal explanation for the single parameter: 'The ID of the repeat item to delete.' This provides some clarity beyond the schema property name, but lacks details like validation constraints or example values.

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 'Delete a recurring food entry', which is a specific verb and resource. It distinguishes from related tools like remove_food_entry (for regular entries) and the sibling add_repeat_item and get_repeated_items.

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

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

The description tells users to use get_repeated_items to find the repeat_item_id, which provides a prerequisite step, but does not explicitly state when to prefer this tool over alternatives (e.g., remove_food_entry) or when not to use it. The guidance is implied but not comprehensive.

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

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

No annotations provided, so the description fully carries the burden. It notes 'full unprocessed export' implying no transformation, and describes parameters. However, it does not disclose any potential side effects, what the output looks like, or error conditions. Adequate but not detailed.

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

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

The description is short and to the point, with a clear summary sentence, a usage note, and a structured list of parameters. No redundant information, though it could be slightly more compact.

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 3 parameters and no annotations, the description covers all parameter semantics well. It does not describe return values, but an output schema is present (though not shown) which likely covers that. The description is sufficient for a simple export 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%, so the description must compensate. It lists allowed values for export_type, explains start_date and end_date defaults and format. This adds significant meaning beyond the bare schema properties.

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 'Export raw CSV data from Cronometer for any data type', specifying verb and resource. It also lists valid export types. It distinguishes from sibling tools like get_daily_nutrition which likely return JSON, so purpose is distinct and clear.

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

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

The description says 'Useful when you need the full unprocessed export', which gives a usage hint but does not explicitly state when not to use or compare with alternatives like the get_* tools. It lacks explicit when-to-use and when-not-to-use guidance.

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

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

No annotations provided, so description carries full burden. It implicitly indicates a read-only operation ('Get daily nutrition summary') but does not explicitly state that no data is modified. It lacks details on authentication, rate limits, or side effects, though such details are not critical for a simple retrieval tool.

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

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

The description is front-loaded with the tool's purpose and return values, followed by a concise parameter specification. No unnecessary sentences or redundancies. Could be slightly more compact by merging the parameter info into the main text, but still 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?

Given that an output schema exists (has output_schema: true), the description appropriately lists expected return fields and date range defaults. It covers the essential aspects for an agent to decide and invoke the tool correctly. Minor omission: no mention of potential empty results or error cases, but these are likely captured in the 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?

The description compensates for the input schema's lack of property descriptions by detailing each parameter's format ('YYYY-MM-DD') and defaults (7 days ago for start_date, today for end_date). This adds clear meaning beyond the schema's basic type and title.

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 retrieves daily nutrition summaries with macro totals (calories, protein, carbs, fat, fiber). It distinguishes from sibling tools like get_food_log and get_macro_targets by specifying 'daily overviews and trend analysis,' but does not explicitly list alternative scenarios.

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 advises using this tool for 'quick daily overviews and trend analysis.' However, it does not specify when not to use it or mention alternatives among siblings, which would improve differentiation.

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

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

No annotations are provided, so the description carries the full burden. It describes the return values but does not explicitly state that the tool is read-only, non-destructive, or any other behavioral traits like pagination or rate limits. For a simple retrieval tool, this is adequate but not thorough.

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

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

The description is concise, with a front-loaded purpose statement followed by clear, bullet-style parameter documentation. Every sentence adds value without redundancy.

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

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

Given the tool's simplicity (2 optional params, output schema exists), the description adequately covers what the tool does and its parameters. It does not mention error handling or range limits, but for a retrieval tool this is acceptable.

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

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

The input schema covers 0% of parameter descriptions, but the description adds format and usage for start_date and end_date (e.g., 'YYYY-MM-DD', 'omit for all history'), which provides meaning beyond the schema's type and default. This compensates for the schema gap.

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 'Get fasting history from Cronometer' and specifies it returns fasts with status, names, recurrence rules, and timestamps. It distinguishes from sibling tools like get_fasting_stats (stats) and cancel_active_fast (mutation) by focusing on historical data retrieval.

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

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

The description implies usage for retrieving fasting history, optionally within a date range, but does not explicitly compare to alternatives such as get_fasting_stats or clarify when to omit dates. No 'when not to use' guidance is provided.

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

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

No annotations are provided, so the description carries the burden. It explicitly states that the tool retrieves data and lists what is returned, implying a read-only operation with no side effects. This is sufficient for the simple query.

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 list outputs with no wasted words. Every sentence earns its place.

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

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

Given zero parameters and an output schema present, the description fully covers what an agent needs: what the tool does and what it returns. Sibling tools provide additional context for differentiation.

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

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

There are zero parameters and schema coverage is 100% trivially. The description adds value by listing the specific return fields, which provides context beyond the schema for what the tool outputs.

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 retrieves aggregate fasting statistics from Cronometer and lists four specific metrics (total fasting hours, longest fast, 7-fast average, completed fast count). This directly states verb+resource and differentiates from sibling 'get_fasting_history' which likely returns raw 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 implies usage for aggregate stats but provides no explicit when-to-use, when-not-to, or alternatives. Given the tool name and context, usage is clear but not explicitly 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?

No annotations are provided, so the description carries the full burden. It mentions returning all available serving sizes with IDs and gram weights but does not disclose potential side effects or authentication requirements. As a read-only tool, this is adequate but not comprehensive.

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 clear sections: purpose, usage context, and argument details. It is front-loaded with the main purpose.

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

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

Given the tool has an output schema, the description need not explain return values. It covers the parameter and usage context thoroughly for a simple lookup 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%, but the description explains the parameter 'food_source_id' as coming from search_foods results, adding meaning beyond the schema's type and title.

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

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

The description clearly states 'Get detailed food information including available serving measures' and specifies its role in the workflow after search_foods and before add_food_entry, distinguishing it from sibling tools.

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

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

The description explicitly advises using it after search_foods to obtain measure_id for add_food_entry, providing clear usage context and workflow integration.

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

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

With no annotations, the description carries full burden. It mentions the return content (entries with macros and micros) but does not disclose behaviors like pagination, error handling, or performance implications. The transparency is adequate but not detailed.

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: two short paragraphs with front-loaded purpose, a usage hint, and well-structured parameter descriptions. Every sentence adds value without redundancy.

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

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

The tool has a simple interface with two optional parameters and has an output schema. The description covers the return content, usage context, and parameter details. Minor omission: no mention of behavior when no entries exist for the date range.

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%, so the description must compensate. It explains the date format (YYYY-MM-DD) and default behavior (defaults to today) for both parameters. This adds value beyond the schema's type and title.

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

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

The description clearly states the verb (get) and resource (food log with individual entries and full nutrition). It distinguishes from sibling tools like get_daily_nutrition or get_micronutrients by emphasizing detailed entries and micronutrients.

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 use case ('great for analyzing what was eaten and spotting nutrient gaps') and implies when to use it for detailed analysis. However, it does not explicitly contrast with siblings or state when not to use.

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

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

With no annotations, the description should disclose behavioral traits. It explains the meaning of the parameter and what is returned, but does not explicitly state that the tool is read-only, has no side effects, or any authentication requirements. The behavioral transparency is adequate for a simple getter but could be improved.

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 two sentences plus an Args list. It front-loads the purpose and immediately explains the parameter. Every sentence is informative and there is 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?

For a tool with one optional parameter and an output schema, the description sufficiently explains the return fields and the parameter. A minor gap is the lack of clarification on what happens if the date has no targets, or whether the return includes all days when using 'all'. However, overall it is complete enough for typical usage.

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

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

Despite 0% schema description coverage, the description fully explains the parameter target_date: format (YYYY-MM-DD), default (today), and special value 'all' for weekly schedule. This adds significant value beyond the schema type information.

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

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

The description clearly states 'Get current daily macro targets' with a specific verb and resource. It distinguishes from sibling tools like set_macro_targets and list_macro_templates by focusing on retrieval. It specifies what is returned (protein, fat, carbs, calories, template name), 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 provides no guidance on when to use this tool versus alternatives. For example, it does not contrast with set_macro_targets (modification) or get_daily_nutrition (which likely returns all nutrition). An agent would have no explicit context for tool selection beyond the name.

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

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

No annotations are provided, so the description must cover behavioral traits. It mentions default values for start_date and end_date but lacks details on side effects, performance, or output structure beyond 'vitamins, minerals, and other micronutrients.' Minimal behavioral disclosure.

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 (two short paragraphs) with the purpose stated first followed by parameter details. No extraneous information is present.

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 (2 optional params, output schema exists), the description is sufficiently complete for a query tool. It covers purpose, usage, and parameter meaning, though it could mention output schema or sibling differentiation.

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

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

With 0% schema description coverage, the description adds significant value by explaining the format (YYYY-MM-DD) and defaults for both start_date and end_date. This compensates for the schema's lack of parameter documentation.

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

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

The description clearly states that the tool retrieves a detailed micronutrient breakdown with vitamins and minerals per day and period averages, which distinguishes it from macronutrient-focused siblings like get_daily_nutrition. However, it does not explicitly differentiate from siblings.

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

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

The description includes 'Use this to identify nutrient gaps and plan meals,' providing a clear usage scenario. However, it does not specify when not to use this tool or mention alternative tools for similar purposes.

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

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

No annotations, so description carries burden. It states it returns recent values for common biometrics, implying read-only behavior. Lacks detail on recency or behavior when empty, but acceptable.

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-loaded with action and resource, no 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?

Output schema exists, covering return values. Description lists example biometrics, providing context. Could specify 'most recent entry per type' but sufficient.

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?

No parameters; schema coverage is 100%. Description adds no param info, which is fine. Baseline 3 due to high coverage.

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

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

Clear verb 'Get' and resource 'recent biometric entries', with examples distinguishing from sibling tools like add_biometric and remove_biometric.

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, but purpose is clear enough for simple retrieval; not confused with other get 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?

No annotations are provided, so the description carries the full burden. It clearly states what the tool returns, which is the key behavioral aspect. It does not disclose non-obvious traits like rate limits or auth, but for a simple list operation it is adequate.

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

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

Two well-structured sentences, no wasted words. The first sentence conveys the core purpose, and the second adds necessary detail about return contents.

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 zero-parameter input and existence of an output schema, the description is complete enough. It lists all relevant return fields, and the sibling tools provide context for this read-only list operation.

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

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

The tool has zero parameters, and the input schema is complete (100% coverage). The description adds no parameter information, which is appropriate given the absence of parameters. Baseline for 0 params is 4.

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

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

The description clearly states 'List all recurring food entries' using a specific verb and resource. It also details the returned fields (food name, quantity, etc.), which unambiguously defines 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?

No explicit guidance on when to use this tool vs alternatives like add_repeat_item or delete_repeat_item. The usage context is implied by the 'List' verb, but the description does not provide when-not or alternative recommendations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly explains what the tool returns (wire_index, name, enabled status), clarifies that wire_index is the 0-based value expected by add_food_entry, and warns about user-configured names. This gives the agent actionable behavioral context beyond a generic list operation.

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

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

The description is front-loaded with the core purpose and result, then adds necessary caveats about user-configured names and enabled-state restrictions. Each sentence earns its place; there is no filler or repetition.

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

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

The description fully prepares the agent for the tool's role in the workflow: it explains what data is returned, what that data means for downstream calls to add_food_entry, and the practical gotchas about custom names and enabled groups. Given the simple no-input nature of the tool, no additional context is needed.

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

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

The tool has zero parameters, so parameter semantics are inherently trivial. The description adds useful meaning by explaining what the returned wire_index means in the context of add_food_entry, which compensates for the empty schema. The baseline of 4 applies since no parameter documentation is needed.

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

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

The description clearly states the tool lists diary groups and explicitly ties the returned values to what add_food_entry accepts. This distinguishes it from sibling tools that log food or retrieve nutrition data, leaving no ambiguity about its 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 instructs the agent to call this tool before assuming a diary group name exists, and it explains why: names are user-configured and may differ from defaults. It also notes that only enabled groups are writable, giving clear guidance on when and how to use the result for add_food_entry.

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 it lists all templates and returns specific fields. No annotations provided, so description carries full burden; it adequately describes a read-only listing operation with no side effects. No contradictions.

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

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

Two short sentences, front-loaded with core action and return values. Every sentence adds value without redundancy.

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

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

Given no parameters and presence of output schema, description is complete. It explains the tool's purpose and its relationship to a sibling tool, covering all necessary context.

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

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

No parameters in input schema, so description does not need to explain parameter semantics. Schema coverage is 100% (vacuously). Baseline score of 4 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?

Clearly states the tool lists all saved macro target templates in Cronometer, specifying returns (names, IDs, macro values) and linking to a sibling tool. Distinguishes itself from siblings like create_macro_template or get_macro_targets.

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

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

Explicitly states to use this tool to find template_name for set_weekly_macro_schedule, providing clear context. Does not mention exclusions or alternatives, but the use case is well-defined.

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

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

No annotations provided, so description carries burden. It indicates deletion but lacks disclosure on permanence, authorization, or side effects. Adequate for a simple operation.

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

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

Two sentences plus an Args section, front-loaded with the main action. Every sentence adds value without 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 single-parameter deletion tool with an output schema (present but not described), the description adequately covers core purpose and ID retrieval. Could mention return value but not critical.

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

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

Input schema has 0% description coverage, but description adds an example format ('e.g. BXW0DA'), which compensates and clarifies the expected string 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 clearly states 'Remove a biometric entry from Cronometer', using a specific verb and resource. It distinguishes from sibling tools like add_biometric.

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 guides the agent to use get_recent_biometrics to find the biometric_id. Does not mention when not to use or alternatives, but provides necessary context for ID retrieval.

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

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

No annotations are provided, so the description must fully convey behavioral traits. It only indicates removal without discussing side effects, idempotency, or error handling (e.g., behavior if serving_id does not exist). This is insufficient.

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

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

The description is extremely concise: one sentence for purpose and one line for the parameter. It is front-loaded with the essential action 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 simplicity and the presence of an output schema, the description is adequate for basic usage. However, it lacks details on behavior (e.g., success/failure indication) that would make it fully complete.

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

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

The description adds valuable context to the serving_id parameter by specifying it is 'the serving ID returned by add_food_entry' and providing an example. This compensates for the 0% schema description 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 'Remove' and the resource 'food entry from the Cronometer diary'. It is distinct from siblings like add_food_entry and get_food_log, which are for addition and retrieval.

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

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

The description explicitly states that the serving_id must come from add_food_entry, providing clear context for when to use the tool. However, it does not mention when not to use it or suggest alternatives, which for a simple removal tool is acceptable.

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 some behavioral context (returns IDs and source info) beyond schema, but lacks details like pagination, error handling, or search matching behavior. No annotations provided.

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 plus an Args line. Purpose is front-loaded, 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?

Adequate for a simple search tool with one parameter and output schema. Could mention search behavior (fuzzy vs exact), 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 0%, but description explains the query parameter with examples, adding meaning beyond the schema's type definition.

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 it searches Cronometer's food database by name, and specifies returned data. Distinguishes from sibling tools like add_food_entry or get_food_details.

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?

Implied usage for finding foods before adding them, but no explicit when-to-use or when-not-to-use compared to alternatives like get_food_details.

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 description explains the basic behavior (toggle complete/incomplete) but does not disclose any side effects, permissions, or return values. Since no annotations are provided, the description carries the full burden, but it is adequate for a straightforward toggle operation.

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

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

The description is concise, consisting of one line for purpose and two lines for parameters. It is well-structured with no 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 the tool's simplicity and the presence of an output schema (not shown), the description covers the essential purpose and parameters. It does not explain downstream effects, but for a toggle operation, this is acceptable.

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

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

With 0% schema description coverage, the description adds crucial meaning: it specifies the date format (YYYY-MM-DD) and clarifies the boolean parameter's effect ('True to mark complete, False to mark incomplete'). This compensates well for the empty 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 action: 'Mark a diary day as complete or incomplete.' This is a specific verb-resource pair, and it distinguishes this tool from siblings like add_food_entry or cancel_active_fast.

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 versus alternatives, such as copy_day or set_macro_targets. It lacks context about prerequisites or scenarios where marking a day complete is appropriate.

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

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

With no annotations, the description covers key behavioral traits: it reads current targets first, only updates provided values, and defaults for target_date and template_name. It could mention error handling or required authentication but is notably transparent.

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: one sentence for purpose, one for behavior, and a clean Args list. 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?

Given the tool has an output schema and no annotations, the description is largely complete, explaining update strategy and defaults. Minor gaps: no error handling or response format description, but overall sufficient for correct use.

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

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

The schema has 0% description coverage, so the description fully compensates by defining each parameter's unit (grams, kcal), format (YYYY-MM-DD), and defaults. This adds essential meaning beyond the schema's type-only definitions.

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 ('Update daily macro targets') and the resource ('Cronometer macro targets'), distinguishing it from sibling tools like get_macro_targets and set_weekly_macro_schedule.

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?

It explains the read-before-write behavior and that omitted values remain unchanged, providing clear usage context. However, it does not explicitly state when NOT to use this tool or mention specific alternatives.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool updates the default schedule (a write operation) but does not specify whether it overwrites existing schedules, required permissions, or undoability. Given the lack of annotations, this is adequate but could be more explicit about behavioral traits.

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

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

The description is front-loaded with the main action, followed by a clear explanation of scope and mechanism. The Args section is well-structured. Every sentence adds value without redundancy.

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

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

Given the tool's simplicity (2 params, 1 required, output schema exists), the description covers the core functionality and parameter semantics well. It omits details like error handling or valid day enumerations, but these are minor gaps. The output schema exists, so not explaining return values is acceptable.

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

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

The description adds detailed meaning beyond the input schema, which only has titles and types. It explains that template_name refers to saved templates and days can be comma-separated day names or 'all', filling the 0% schema coverage gap entirely.

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 'Set' and resource 'recurring weekly macro schedule' with action 'assigning a template to days.' It distinguishes from sibling tools like set_macro_targets by specifying it's for a weekly recurring schedule, not daily targets.

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

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

The description explains that the tool updates the DEFAULT schedule for all future dates, not a specific date override. While it doesn't explicitly mention when not to use it or alternatives, the context is clear enough for an AI to differentiate from 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?

No annotations are provided, so the description carries full burden. It discloses that the tool downloads and saves files, mentions the output directory default and environment variable, but does not address authentication requirements, rate limits, or side effects like overwriting existing files. It adds some behavioral context but is not comprehensive.

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 (9 lines) with a front-loaded summary followed by details and parameter explanations. Every sentence adds necessary information without redundancy.

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

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

The description explains the action, output types, parameters, and directory configuration. Given the tool's complexity (4 optional parameters, local file output), it covers most essential aspects. It could mention overwrite behavior or prerequisites, but overall it is fairly complete.

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

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

Schema description coverage is 0%, so the description must compensate, and it does excellently. Each parameter is given a clear format, default, and meaning (e.g., 'start_date: Start date as YYYY-MM-DD (defaults to `days` ago)'). This adds substantial value beyond the schema titles.

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 ('Download Cronometer data and save locally'), the resource ('Cronometer data'), and the output format ('JSON + food-log.md'). It distinguishes itself from sibling tools (mostly get_/add_ operations) by emphasizing the local storage action.

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 a use case for downloading and saving data locally, but it does not explicitly provide when to use this tool versus alternatives like get_daily_nutrition or export_raw_csv. No exclusions or alternative recommendations are given, leaving the agent to infer the appropriate context.

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