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

With no annotations, the description fully carries the behavioral transparency burden. It discloses the default cache-backed behavior, the live=True fallback, rate-limit implications, and even the active_minutes aggregation formula (very_active + fairly_active). This is rich, useful context.

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

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

The description is well-structured with a brief summary, a clear note, and parameter breakdown. Each sentence contributes essential information—no redundancy or filler. It is appropriately sized for a data-fetching tool with non-obvious behaviors.

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 output schema exists, return-value details aren't strictly required, but the description still explains the output shape ('one entry per day') and key metrics. It also covers prerequisites and rate limits, making it complete for a wide range of user intents.

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

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

The schema provides zero descriptions, but the description's 'Args' section compensates thoroughly. It explains start_date acceptable formats ('YYYY-MM-DD', 'YYYY-MM', '30d'), default behavior, end_date default, and the live boolean semantics—far exceeding 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 opens with a specific verb-resource combination: 'Get daily activity summaries' and enumerates key data fields (steps, calories, active minutes, distance). This clearly distinguishes it from sibling tools like fitbit_get_sleep or fitbit_get_food_log.

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

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

The description provides clear usage context: it explains the cache-vs-live distinction, instructs users to run fitbit_sync first, and warns about API rate limits. It doesn't explicitly mention when to choose an alternative sibling, but the guidance is practical and actionable.

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

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

With no annotations, the description carries the full burden and does so thoroughly. It discloses the caching behavior ('Returns from local cache by default, auto-syncing if stale'), the option to bypass via live=True, and the exact return shape (per-day total_minutes and per-zone breakdown). It even notes the double-counting rule for Cardio/Peak zones, which is a non-obvious behavioral detail.

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

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

The description is well-organized with a title, a brief explanation, an Args section, Returns section, and a sibling distinction. Every sentence adds value; there is no fluff. It is appropriately sized for the tool's complexity.

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 complete given the tool's context: it explains the metric, the return format, cache behavior, and the distinction from a similar sibling. An output schema exists, but the description still adds valuable context about the per-zone breakdown. No gaps are apparent.

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 documents all three parameters: start_date (formats and default), end_date (format and default), and live (purpose). It also clarifies the return semantics, which is beyond the schema. This compensates completely for the schema's lack of info.

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+resource: 'Get daily Active Zone Minutes (AZM)' and clearly distinguishes this from the sibling fitbit_get_activity by explaining the difference in what each metric counts (zone minutes vs wall-clock minutes). This makes the purpose unequivocal.

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 usage context: when to use live=True vs the default cache, and explicitly contrasts with fitbit_get_activity ('Distinct from active_minutes...'). It also explains the date range defaults, giving clear guidance on when to invoke this tool over 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?

With no annotations provided, the description carries the full transparency burden. It explicitly discloses the cache-first behavior ('Returns from cache by default, auto-syncing if stale'), the 'live' parameter to bypass cache, and the output structure ('one entry per night with breaths_per_min') plus a typical range. This goes beyond most tool descriptions and fully informs the agent about the tool's runtime 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 structured with a clear opening line, a rationale paragraph, an Args block, and a Returns note. Every sentence adds distinct information, and nothing is redundant. Though longer than minimal descriptions, the extra length is justified by the need to compensate for sparse schema info. It remains highly readable and front-loaded.

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

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

Given the tool has no annotations and no schema descriptions, the description covers all essential facets: what it returns, when to use it, how it behaves (cache vs live), parameter formats, and output shape. The presence of an output schema means return details are not a burden, but the description still adds interpretive guidance. It is complete enough for an agent to select and invoke the tool correctly without ambiguity.

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 provides zero descriptions (0% coverage), but the description compensates fully by documenting all three parameters: start_date (with allowed formats and default), end_date (with format and default), and live (explaining its effect). It also adds contextual meaning (e.g., '30d' accepted as a relative date), which is essential 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?

The description begins with a specific verb+resource: 'Get nightly breathing rate (avg breaths per minute during sleep)' which precisely states the metric and measurement context. It clearly differentiates from sibling tools by focusing on breathing rate, a unique health metric among the listed getters.

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 strong usage context by framing the data as an 'illness/recovery signal' with a concrete threshold ('sustained increases of 2-3 bpm above personal baseline'). This tells the agent when the tool is relevant. However, it does not explicitly mention when not to use it or compare to alternative metrics (e.g., heart rate), so it stops short of full exclusion/alternative 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 provided, the description fully discloses behavioral traits: the source of the estimate, weekly update frequency, default cache behavior with auto-sync, and the live parameter for direct API fetch. It also explains the return format (vo2_max_low/high range) and semantics (equal when single value, higher is better).

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

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

The description is well-structured with a clear purpose statement, brief explanatory notes, and an organized Args/Returns format. Every sentence adds value, and the length is appropriate for the complexity of the tool.

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

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

Given the tool's simplicity and the presence of an output schema (noted but not detailed here), the description covers inputs, outputs, cache behavior, and update frequency. It provides enough context for an agent to select and invoke the tool correctly without needing additional information.

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 explicitly explains all three parameters: start_date formats ('YYYY-MM-DD', 'YYYY-MM', or '30d') and default, end_date format and default, and the live boolean's meaning. This fully compensates for the schema's lack of 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 'Get Cardio Fitness Score (VO2 Max estimate)' with a specific verb and resource, and distinguishes from sibling tools by focusing on cardio fitness rather than other metrics. It further explains what the score estimates (from resting HR, HR during walks/runs, demographics), making the tool's purpose unambiguous.

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

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

The description provides clear context for usage: updates roughly weekly, returns from cache by default, and auto-syncs if stale, which implies when to use the 'live' parameter. It does not explicitly mention alternatives or when-not conditions, but the context is enough to guide the agent on typical use cases.

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

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

With no annotations, the description carries the full burden. It discloses that readings are manually logged, absolute body temperatures, distinct from skin temperature variation, and may appear multiple times per day. It also describes the return structure with datetime and temp_celsius. It does not discuss rate limits or error behavior, but for a read-only data retrieval tool the provided context is substantial.

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

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

Well-organized and front-loaded with the core purpose. The distinction from skin temperature is concise but essential. The Args section is clear and compact, and every sentence serves a purpose 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 annotations and 0% schema coverage, the description is exceptionally complete. It covers what the data is, when to use it, how parameters work, and what the return values look like. The presence of an output schema is noted, but the description still adds useful return-value context.

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

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

Schema coverage is 0%, but the description compensates fully by explaining all three parameters: start_date formats and default, end_date format and default, and the live cache-bypass behavior. This goes well beyond the raw schema, giving an agent everything needed to set 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 starts with a specific verb and resource: 'Get manually-logged core (body) temperature readings' in degrees Celsius. It clearly differentiates from fitbit_get_skin_temperature by emphasizing absolute manually-logged temperatures versus device-derived skin variation.

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 when to use this tool: for fever/body-temperature questions using manually-logged readings. It also explicitly names the alternative (fitbit_get_skin_temperature) and explains why that tool is not appropriate for this use case, plus notes that multiple readings per day can be expected.

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 behavioral burden. It discloses the live-only (no caching) behavior, reflects current device state, and specifies the return structure (one entry per device with listed fields). This goes beyond a simple statement and adds useful operational context, though it doesn't cover auth or error conditions.

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

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

The description is three well-structured sentences: first states the main function, second adds behavioral context and use cases, third details the output fields. Every sentence adds value with no repetition or filler, making it appropriately sized and front-loaded.

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

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

This is a simple no-parameter tool with an output schema, and the description covers all necessary aspects: purpose, behavior, use cases, and return format. It effectively differentiates from the many sibling tools and provides enough context 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?

The tool has zero parameters, so the baseline is 4. The description correctly implies that no filtering is possible (lists all paired devices), which aligns with the empty input schema. No parameter details are missing because there are none.

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 paired Fitbit devices with battery level and last sync time, using a specific verb and resource. This distinguishes it from sibling tools like fitbit_get_activity or fitbit_get_sleep, which target different data domains.

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 use cases (monitoring tracker health, knowing which device produced data, spotting sync gaps) and notes the live-only behavior, implying when to use this tool. However, it doesn't name alternative tools or state when not to use it, leaving some room for interpretation.

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 fully carries the burden. It discloses the cache-by-default behavior, the live fetch option, the need for prior sync, return fields including source, and a data-quality caveat about cycling HR. This is rich, honest behavioral context.

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

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

The description is well-structured with a summary, parameter details, return info, and a caveat. Every sentence serves a purpose, and the length is appropriate for a tool with four parameters.

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?

Even though an output schema exists, the description adds essential behavioral detail: cache vs live source, prerequisite sync, return field list, and a data-quality note. It is fully complete for a cache-backed fetch 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. The Args section thoroughly documents all four parameters with types, formats, defaults, and examples (e.g., 'YYYY-MM-DD', '30d', case-insensitive substring match), adding meaning far 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 uses a specific verb 'Get' with a clear resource 'exercise log entries' and adds 'individual tracked activities' to clarify scope. This distinguishes it from sibling tools like fitbit_get_activity, which likely returns summary 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?

It clearly states when to use the tool (fetching exercise log entries), mentions the cache/default behavior, the live=True alternative, and the prerequisite to run fitbit_sync. It does not explicitly name alternative tools for exclusion, 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?

With no annotations, the description discloses valuable behavior: caching with auto-sync, 'live' mode using one API call per day, and the omission of days with no logging. These details go beyond a basic read operation, but still missing auth requirements or error handling.

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 broken into clear sections: purpose, return summary, behavioral notes, and parameter explanations. Every sentence contributes value, with no redundancy or filling space.

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

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

The tool has only 3 simple parameters and an existing output schema, yet the description still covers return shape, cache behavior, live mode, and data availability rules. This is more than sufficient 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 0%, but the description fully explains all three parameters: date formats for start_date, defaults for end_date, and the semantic and cost implication of live. This precisely compensates for the schema's lack of parameter 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 opens with 'Get daily food and water log summary' – a specific verb, resource, and scope. It clearly differentiates from sibling tools like fitbit_get_activity or fitbit_get_sleep by naming the exact data domain (food/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 implies when to use the tool (for food/water data) and gives important context about data being only present if the user logs in the Fitbit app. However, it does not explicitly name alternatives or exclusion conditions, so it stops short of full '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 are provided, so the description carries full burden. It discloses 'Live-only (no caching)' and 'Weekly omits some fields', which are meaningful behavioral traits beyond the schema. It doesn't cover error handling or authentication, but for a read operation it is sufficiently 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?

Each sentence earns its place: purpose, usage context, parameter definition, return keys, and a caveat. It is front-loaded with the core action and avoids any fluff 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?

Despite its simplicity, the tool has one optional param and an output schema. The description covers purpose, usage, parameters, and output shape, and even ties it to a sibling tool for comparison. This is a complete, self-contained definition for an agent.

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

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

Schema coverage is 0%, but the description compensates fully: it states period accepts 'daily' or 'weekly', defaults to 'daily', and explains the behavioral effect ('Weekly omits some fields'). This adds value well beyond the bare schema.

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

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

States 'Get user-set activity goals' with specific fields like steps, distance, calories, and explicitly contrasts with fitbit_get_activity for actuals. The verb-resource pair is specific and distinguishes this from the 17 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?

Explicitly says 'Use to compare actuals (from fitbit_get_activity) against the targets the user set' and mentions 'Live-only (no caching)'. This gives clear when-to-use context and names a specific alternative tool, satisfying the dimension fully.

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. It discloses that data comes 'from the local cache by default, auto-syncing if stale' and that live=True fetches directly from Fitbit, plus it outlines the daily return structure. It doesn't mention auth/rate limits, but the key behavioral traits are well covered.

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

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

The description is well-structured and front-loaded with a one-sentence summary followed by cache/live details, Args, and return format. Every sentence adds value; no fluff 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?

Despite having an output schema, the description still explains the return shape (one entry per day, resting_hr, zones array with name/minutes/caloriesOut/min/max). It provides all needed context for dates, caching, and live mode, making this a fully self-contained description.

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

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

Schema description coverage is 0%, and the description fully compensates. It explains start_date formats ('YYYY-MM-DD', 'YYYY-MM', or '30d'), defaults, end_date default, and the live flag's effect, adding meaning far 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 opens with a specific verb+resource: 'Get daily resting heart rate and heart rate zones.' It clearly distinguishes this tool from siblings like fitbit_get_hrv or fitbit_get_breathing_rate by naming the exact data returned (resting HR and zone breakdown).

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

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

The description clearly explains cache behavior and when to use live=True ('Use live=True to bypass the cache entirely'), plus date format options. It does not explicitly mention alternatives among sibling tools, but the cache-vs-live guidance provides clear contextual usage.

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

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

With no annotations, the description carries the full burden, disclosing default cache reads, the need for a prior sync, data sparsity, the Premium requirement, and the specific output fields. It also explains the meaning of RMSSD, adding interpretive context beyond a simple fetch.

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

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

The description is well-structured: a one-line summary, followed by cache behavior, caveats, parameter docs, and output explanation. Every section adds necessary 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?

The description is comprehensive for a three-parameter tool, explaining the data source, prerequisites, limitations, and output format. Even with an output schema present, it clearly states the fields returned, and the sync instruction mitigates potential empty-cache confusion.

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 Args section provides detailed semantics for all three parameters, including accepted formats for start_date ('YYYY-MM-DD', 'YYYY-MM', or '30d'), defaults for start/end dates, and the boolean `live` flag. Since the schema has no property descriptions (0% coverage), this fully compensates.

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 opening line 'Get nightly HRV (heart rate variability) data' uses a specific verb and resource, clearly distinguishing it from sibling tools like fitbit_get_heart_rate and fitbit_get_sleep. The cache/live explanation further reinforces its unique role.

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 to 'Run fitbit_sync first to populate the cache' and offers the alternative of 'Use live=True to fetch from Fitbit API', giving clear when-to-use and prerequisite guidance. It also notes the Premium requirement, which helps the agent decide 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?

With no annotations, the description carries the full burden. It discloses 'Live-only (no caching)' and specifies the exact data returned (lifetime totals and personal bests with dates). It doesn't cover edge cases or failure modes, but for a zero-parameter read operation this is adequate.

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

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

The description is three sentences, front-loaded with the main purpose. Each sentence adds value: purpose, return details, and usage context. 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?

Given the tool's simplicity (no params, well-defined return categories) and the existence of an output schema, the description provides sufficient context. It explains what the tool returns and gives a practical use case, making it complete 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?

The tool has zero parameters, so the schema is trivially 100% covered. The description doesn't need to explain parameters, and adds no parameter-related info. Baseline for 0 params is 4, which 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 it 'Get all-time activity totals and personal best records,' with a specific verb and resource. It distinguishes itself from the daily activity sibling by noting it answers long-term context questions like 'what's my best step day ever?'.

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: 'Useful for long-term context that the daily activity table can't easily answer.' This implies when to use it and contrasts with daily activity, but it doesn't explicitly name alternative tools or state when not to use it.

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 discloses that values are relative deviations, not absolute temperature, and that baseline takes ~3 nights. It also describes the return structure (one entry per night with nightly_relative and log_type). Lacks details on error conditions or rate limits, but sufficient for most use cases.

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?

Efficiently structured: summary line, critical clarification, usage note, then parameter list. No redundant information; 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?

Despite having an output schema, the description explains the return format (nightly_relative and log_type). It also provides baseline establishment information and use-case context, making the tool well-understood.

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 fully compensates by explaining each parameter: start_date format options ('YYYY-MM-DD', 'YYYY-MM', or '30d'), end_date format, and the live parameter for cache bypass, including defaults.

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

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

The description clearly states the tool retrieves 'nightly skin temperature variation (degrees Celsius from personal baseline)', identifies it as a relative measurement, and distinguishes it from the sibling tool for absolute core temperature. It also lists use cases (illness/cycle/recovery signal).

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 when to use (relative skin temp) and when not to (use fitbit_get_core_temperature for fever/body temp). Also notes that Fitbit needs ~3 nights to establish a baseline, guiding the agent on data availability.

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 for behavioral disclosure. It reveals that data comes from local cache by default, that live=True fetches from the API, that fitbit_sync must be run first, and that data is sparse (missing travel/off-wrist/manual logs). This is rich, honest context beyond the basic function.

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

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

The description is appropriately sized for the tool's complexity, with a clear 'Args:' section. It is front-loaded with the main purpose and usage caveats. A few sentences could be tightened, but 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?

The description covers the tool's behavior (cache vs. live, sync dependency), input formats, data sparsity, and return fields (total_minutes, efficiency, start/end times, stage breakdown). With an output schema present, it doesn't need to detail return types further, making it complete for a 3-parameter tool with no annotations.

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

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

Schema description coverage is 0%, so the description must fully explain parameters. It does: start_date formats ('YYYY-MM-DD', 'YYYY-MM', or '30d') and default (last 30 days), end_date format and default (today), live boolean default false. It also explains the return structure, compensating entirely for the missing 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 'Get nightly sleep data (duration, stages, efficiency)', using a specific verb and resource. It differentiates from sibling Fitbit tools by focusing on sleep and describing cache vs. live data. The tool name and description align perfectly.

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: 'Run fitbit_sync first to populate the cache' and 'Use live=True to fetch from Fitbit API.' It also warns about data sparsity for nights without watch-tracked sleep. However, it doesn't explicitly state when not to use this tool versus other sleep-related siblings, though 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?

With no annotations, the description fully discloses behavioral traits: default local cache, live fetching option, dependency on sync, data sparsity, and Premium requirement. It also explains normal range and health implications, exceeding basic transparency.

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

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

The description is well-structured with a clear first sentence, then bullet points and parameter details. It is moderately concise; a minor reduction in health background could tighten it slightly, but overall it is 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 the tool's moderate complexity (3 parameters, health context), the description covers purpose, behavior, parameter semantics, output format (one entry per night with avg/min/max), and prerequisites. The output schema exists, so return details are adequately supplemented.

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%, yet the description adds significant meaning: it specifies date formats (YYYY-MM-DD, YYYY-MM, 30d), defaults (last 30 days for start_date, today for end_date), and the boolean live parameter. This thoroughly compensates for the schema's lack of 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 retrieves nightly SpO2 data, distinguishing it from sibling tools that handle other health metrics (e.g., heart rate, sleep). The verb 'Get' and resource 'nightly SpO2 data' are specific and 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 explains when to use live=True vs default cache, and prerequisites (run fitbit_sync first). It notes data sparsity and Premium requirement. Although it does not explicitly contrast with alternatives, the unique SpO2 focus makes context 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?

With no annotations provided, the description carries full burden. It discloses that data comes from a local cache by default, requires a sync first, is sparse (only days with weigh-ins), and returns one entry per weigh-in with specific fields. This is valuable behavioral context 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?

The description is well-structured with a brief introduction, a note on cache and sparse data, and a clear Args list. Every sentence adds value—no redundancy or irrelevant details. The format is easy to scan and understand.

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 complete for the tool's complexity: it covers parameters, return format, cache behavior, and prerequisites. Some minor missing details like error handling or timezone considerations, but these are not essential for selection and invocation. The output schema also lessens the need to describe return values.

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's Args section fully explains each parameter: start_date format and default, end_date format and default, and live flag meaning. This compensates entirely for the schema's lack of descriptions, adding critical format details like 'YYYY-MM-DD', 'YYYY-MM', or '30d'.

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 weight log entries (weight, BMI, body fat percentage)', specifying the verb, resource, and scope. It distinguishes from sibling tools like fitbit_get_food_log and fitbit_get_activity by focusing on weight-specific data, and the mention of cache vs. live modes further clarifies its role.

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: 'Run fitbit_sync first to populate the cache' and 'Use live=True to fetch from Fitbit API instead of cache.' It also clarifies default behavior (cache) and data sparsity. It does not explicitly contrast with alternative tools, but the prerequisites and mode selection are 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?

With no annotations, the description carries the full burden and excels: it explains incremental sync, first-sync behavior, the role of 'since'/'until' for backfill and gap repair, and the return summary. This goes beyond basic semantics and provides operational context.

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

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

The description is lengthy but well-structured: a one-line summary, a brief context statement, a clear argument section, and a closing note on return value. Every sentence adds information, and the structure makes it scannable.

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

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

Given the tool's complexity (four parameters, incremental logic, special backfill scenarios) and the empty schema/annotations, the description covers all necessary ground: purpose, usage, parameter semantics, and return behavior. It is complete enough for an agent to invoke correctly without additional clarification.

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 no descriptions (0% coverage), so the description is entirely responsible for parameter meaning. It thoroughly explains data_types with options and default, days with its behavior, and since/until with precise usage examples. This fully 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 opens with a specific verb+resource statement: 'Sync Fitbit health data to the local cache.' It clearly distinguishes itself from the fitbit_get_* tools by stating it fetches data from the Fitbit API into SQLite, not for querying.

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 instructs to 'Run this before using other fitbit_get_* tools' and provides a clear exclusion: 'Not for querying data - use fitbit_get_heart_rate, fitbit_get_activity, fitbit_get_sleep, etc. instead.' This leaves no ambiguity about when to use versus 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?

With no annotations available, the description carries the full burden of behavioral disclosure. It discloses that the tool auto-syncs from the local cache if stale, implying potential network or cache side effects. It also details return values per data type and notes that compare ignores other date parameters. It lacks error-handling or permission details, but overall it is 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 longer than a typical two-sentence summary but is well-structured with a one-line overview, an Args section, a Returns section, and a final note. Every sentence adds value, especially the detailed parameter options and per-data-type outputs. It is front-loaded with the core purpose and uses clear formatting, though it could be slightly tightened.

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 5 optional parameters, a complex compare feature, and 13 data types with varied output fields, the description covers parameter semantics, return values, and cache-sync behavior. It even provides examples for compare and date formats. It omits edge cases like invalid dates or empty data, but the presence of an output schema and the description's thoroughness make it sufficiently complete.

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

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

The input schema provides zero parameter descriptions (0% coverage), so the description's 'Args' section is essential and fully compensates. It defines data_type and period options with defaults, start/end date formats, and the compare format with examples. Every parameter is semantically described, including the behavior that compare overrides others.

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

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

The description opens with a specific verb and resource, 'Analyse trends in cached Fitbit data,' then elaborates on computing averages and totals over time. It clearly distinguishes itself from sibling fitbit_get_* tools by explicitly stating it is not for raw data and by listing supported data types. This makes its 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 clear guidance on when to use the tool for aggregated trends and explicitly notes 'Not for raw data - use fitbit_get_* tools instead,' naming the alternative. It also explains the compare feature and how it overrides period/start_date/end_date, giving users context. However, it stops short of describing specific scenarios beyond the raw-data exclusion, so it is not a full 5.

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