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

With no annotations, the description fully discloses behavior: caching, need for prior health_sync, rate limit, and the calculation of active minutes ('active_minutes = very_active + fairly_active (excludes lightly active)'). It also notes output granularity ('one entry per day').

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?

Although detailed, the description is well-organized: purpose first, then caching behavior, then rate-limit note, then output details. Each sentence adds value without redundancy, making it 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?

Given the simple schema (three optional params), the description covers all relevant aspects: param meanings, default behavior, output structure, and a practical limitation (rate limit). No missing information that would prevent 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 description explains the date formats ('YYYY-MM-DD', 'YYYY-MM', or '30d') and the meaning of 'live' (fetch from API vs cache). It also clarifies the default values and what the output contains, adding significant meaning beyond the bare schema types and defaults.

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

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

The description clearly states the tool's purpose: 'Get daily activity summaries (steps, calories, active minutes, distance).' It identifies the resource (activity summaries) and the action (get), distinguishing it from sibling health getters like heart rate or sleep.

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 provides explicit usage guidance: 'Returns data from the local cache by default. Use live=True to fetch from the API. Run health_sync first to populate the cache.' Also includes a note about rate limits and daily API call behavior, which helps decide when to use live=True.

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 discloses that results come from a local cache by default with auto-sync when stale, that live re-fetches from the API, and that total_minutes is an unweighted sum. This is strong behavioral transparency, though it does not cover failure modes or data availability edge 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?

The description is longer than average but well-structured and entirely informative. It front-loads the core purpose, then uses clear paragraphs for metric definition, caching behavior, arguments, return values, and sibling differentiation. Every sentence contributes value.

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

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

Given the tool's complexity—caching semantics, multiple date formats, zone definitions, and sibling overlap—the description is complete. It even covers return shape and distinguishes this metric from a related tool, leaving little for an agent to guess.

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 with an Args section: it defines start_date formats ("YYYY-MM-DD", "YYYY-MM", or "30d"), defaults (last 30 days), end_date default, and the meaning of live. This adds substantial meaning beyond the raw schema.

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

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

The description opens with a specific verb and resource: "Get daily Active Zone Minutes (AZM)", then clarifies it as the "headline cardio metric". It also distinguishes itself from the sibling health_get_activity by explaining the difference between AZM and active wall-clock minutes, eliminating ambiguity.

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

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

The description gives explicit usage context: it explains the cache/sync default behavior, how the live parameter changes fetching, and explicitly contrasts with active_minutes in health_get_activity. This helps an agent choose between related health tools with clear exclusions.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: it reads from cache by default, auto-syncs if stale, and the live flag forces a re-fetch from the API before reading cache. It does not mention auth requirements or rate limits, so it stops short of a 5.

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?

Front-loads the one-line summary, then the illness-signal rationale, cache behavior, and a clean Args block. Well organized; the 'typical adult range' line is marginally extraneous but arguably aids interpretation of results.

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?

Although an output schema exists, the description still names the return shape (one entry per night with breaths_per_min and data_source), so an agent knows exactly what comes back. For a 3-param read tool with no annotations, coverage of purpose, params, cache behavior, and output is 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 coverage is 0%, so the description must compensate entirely, and it does: all three parameters are documented with accepted date formats ('YYYY-MM-DD', 'YYYY-MM', '30d'), defaults for start_date/end_date, and the exact effect of live. Nothing about the params is left to inference.

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 a specific verb+resource (get nightly breathing rate, average breaths per minute during sleep) and pins the measurement context to sleep tracking, which distinguishes it from siblings like health_get_heart_rate, health_get_hrv and health_get_spo2 without needing to open any schema.

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?

Offers interpretive context ('useful as an illness/recovery signal', 2-3 bpm above baseline) but never states when to choose this tool over the other health_get_* siblings or under what conditions a call is warranted. Usage is implied rather than specified.

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 well: it discloses cache-by-default, auto-sync-on-stale semantics, ~weekly update cadence, and the important trap that two readings may be different measurements that must not be averaged or filled. It doesn't cover auth requirements or rate limits, so it falls short of a 5.

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?

Front-loaded with the purpose, then derivation, cadence, and caching before the Args block. It is longer than average, but nearly every sentence addresses a real ambiguity; the semantic discussion of vo2_max fields is dense but 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?

An output schema exists, so return-field definitions are not strictly required, yet explaining vo2_max vs vo2_max_low/high and the do-not-average rule prevents real misinterpretation. Combined with cache/live semantics and param formats, the definition is complete enough to call correctly.

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

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

Schema description coverage is 0%, so the description must compensate and it does: it documents all three params and adds accepted date formats ('YYYY-MM-DD', 'YYYY-MM', '30d') and the meaning of live that the bare schema does not convey.

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 a specific verb and resource (Cardio Fitness Score / VO2 Max estimate) and immediately explains how the metric is derived (resting HR, HR during walks/runs, demographics). This is distinguishable from every sibling, each of which targets a different health metric.

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 the cache-first default and when to override it with live=true, plus the default window behavior. It does not explicitly name a sibling alternative or an exclusion, but for a per-metric getter the usage context is clear enough to act on.

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 and does so thoroughly. It discloses that readings are manually logged, may be multiple per day, include timestamps, can be returned with edited duplicates kept beside earlier values, and that live=true refetches from the API before reading cache.

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 and front-loaded: purpose and distinction first, then Args, then Returns. Every sentence adds useful meaning, including the important note about edited readings appearing as multiple entries at the same datetime.

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 lack of annotations, zero schema description coverage, and a rich output schema, the description is complete enough for correct invocation and interpretation. It covers data provenance, sibling distinction, parameter formats and defaults, cache/live behavior, and return-field semantics.

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

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

Schema description coverage is 0%, so the description must document parameters itself, and it does: start_date accepts YYYY-MM-DD, YYYY-MM, or 30d and defaults to last 30 days; end_date accepts YYYY-MM-DD and defaults to today; live controls API re-fetch before cache read.

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

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

The description states a specific verb and resource: getting manually-logged core body temperature readings in Celsius. It explicitly distinguishes this from the device-derived skin-temperature variation from health_get_skin_temperature, so an agent can select it without confusion.

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 when-to-use guidance: these readings are the right source for fever and body-temperature questions. It also names the alternative source to avoid, health_get_skin_temperature, and explains the difference between manual core temperature and device-derived skin temperature.

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, and it delivers with the key disclosure: 'Live-only (no caching) - reflects current device state.' This is critical behavioral information — the agent learns this is a live snapshot, not a cached report. The return-shape description adds further transparency, though it doesn't address error states or empty-device 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?

Three crisp sections: (1) one-sentence purpose, (2) behavioral note with use cases, (3) return-shape enumeration. Every sentence earns its place with zero redundancy. The front-loaded headline sentence allows for quick scanning.

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

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

For a zero-parameter read tool with an output schema available, this is admirably complete — purpose, live behavior, use cases, and return fields are all covered. Could be enhanced with notes on failure modes or empty states, but those are minor for this tool's complexity.

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

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

With zero parameters and 100% schema coverage (trivially satisfied), the baseline is 4. The description adds value by thoroughly documenting the output shape ('id, type, device_version, battery, battery_level (0-100), last_sync_time, mac, features'), giving the agent a full picture of what to expect from the response.

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: 'List paired devices with battery level and last sync time.' This is precise and clearly distinguishes it from siblings like health_get_activity or health_get_sleep — this is the device/resource-discovery tool. The field enumeration (battery, battery_level, last_sync_time) further cements the purpose.

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

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

The description provides clear use-case context: 'monitoring tracker health, knowing which device produced data, and spotting sync gaps.' This tells the agent when to reach for this tool. However, it does not explicitly name alternatives or include when-not-to-use language, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It discloses some behavioral details such as the waveform's size and the need for scaling and sampling rate, and that waveform samples may be null. However, it lacks information about cache behavior details (e.g., when live is false), potential errors, or rate limits, leaving a moderate 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-structured with a brief overview, clear usage guidance, a compact Args section, and a return summary. Each sentence adds value and the description is front-loaded with the purpose, making it efficient and easy to parse.

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

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

The tool has 4 parameters, no annotations, but an output schema that details the return structure. The description explains the purpose, usage, and key parameters; the output schema covers return values. It lacks some behavioral details (e.g., cache semantics, error cases), but it is sufficient for a health data retrieval tool, but not perfect.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain start_date and end_date formats and defaults, and describes the live and include_waveform parameters' effects. However, it omits the sampling_hz and scaling_factor fields from the parameter list (though they appear in the output), and doesn't provide full detail on date range conventions, so it partially compensates but not completely.

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 ECG readings from a watch, specifying the metric (single-lead trace, rhythm classification) and the main use case (heart rhythm or AFib checks). It also distinguishes itself from health_get_heart_rate, a sibling tool, by explicit contrast, 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 explicitly states when to use this tool: for questions about heart rhythm or AFib checks, and when not to use it: for resting rate over time, for which health_get_heart_rate is recommended. This provides clear, actionable usage guidance and directly names the alternative, exceeding the minimum.

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 well: it discloses the GPS-only precondition, that routes are fetched per sync window, that TCX payloads can reach hundreds of kilobytes, and that the heavy payload is opt-in via include_tcx. That size/opt-in behavior is exactly the kind of trait an agent needs before calling.

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?

Front-loaded with the core action and format, then supports it with preconditions and payload caveats. Slightly long, and the 'Returns' sentence partly duplicates the output schema, but every sentence adds usable context.

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 a small two-parameter tool with an output schema already defining the return shape, the description covers precondition, payload size risk, and opt-in behavior. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it documents both parameters: log_id with its cross-reference to health_get_exercises, and include_tcx with its default-off implications. Nothing about invocation is left to guess.

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 a specific verb and resource ('Get the GPS route of one exercise') and pins the format ('as the TCX file Google exports'). It is clearly distinct from health_get_exercises, whose log_id it consumes, so an agent can route between the two without opening schemas.

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?

Gives clear context: only GPS-recorded exercises have a route, sync scope determines route availability, and the TCX is returned only when include_tcx is set. It names the prerequisite source (health_get_exercises) but does not explicitly say when to prefer this over sibling reads like health_get_exercises.

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

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

With no annotations, the description carries the full behavioral burden and does so well: it explains cache vs live API behavior, the health_sync dependency, what include_detail changes, how detail_counts can be null, and even warns that cycling HR data may be unreliable.

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?

Purpose, Args, and usage guidance are front-loaded and useful, but the long Returns paragraph repeats what an output schema already conveys. Since the context notes an output schema exists, much of that return-field enumeration is redundant and makes the description longer than necessary.

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

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

Given five parameters, no schema descriptions, no annotations, and a cache/live data model, the description is complete enough to call correctly. It covers prerequisites, parameter meanings, edge cases, and output semantics.

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 documents all five parameters, including date input formats, defaults, case-insensitive substring matching for exercise_type, and the unusual refusal behavior when no cache workout name matches.

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 gives a specific verb and resource: 'Get exercise log entries (individual tracked activities).' It distinguishes this from sibling activity tools by specifying individual tracked exercise sessions rather than general activity or sleep 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 clearly states the default cache-based behavior, when to use live=True, and the prerequisite to run health_sync first. It does not explicitly name a sibling alternative or state when not to use this tool, so it falls slightly short of a 5.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It discloses that only hand-logged data appears, that cache is used by default with auto-sync, that 'live' forces a re-fetch, and that empty days are omitted. This goes well beyond a simple one-line summary and gives the agent accurate expectations.

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

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

The description is concise (~110 words), front-loaded with the main purpose, and organized into clear sections for behavior, arguments, and return values. Every sentence adds useful information; there is 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?

Given the tool's moderate complexity—optional date handling, cache semantics, and a live override—the description covers all necessary context. It even describes the return shape despite an output schema being present, making the tool self-sufficient 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?

The input schema has 0% description coverage, so the tool description must compensate, and it does. It explains start_date formats including '30d', default behavior for both dates, and the meaning of 'live' in the context of cache re-fetching. This is meaningful semantic value beyond the raw schema.

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

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

The description uses a specific verb plus resource ('Get daily food and water log summary') and clearly differentiates this tool from siblings by scoping it to food/water logging and calorie/water intake. It states exactly what data is returned, leaving no ambiguity about the tool's function.

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 on when this tool is appropriate: it covers food/water logs from connected apps, only includes hand-logged entries, and explains cache versus live behavior. It does not explicitly name alternative tools or state when not to use it, but the context is sufficient for selection among related health 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, the description carries the full burden and does so well: it discloses cache-first behavior, automatic staleness sync, the effect of 'live', and the important quirk that zone data only exists on days that arrived via import and is not written by a sync. It does not mention auth/permission requirements or rate limits.

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

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

Front-loads purpose, then behavior, then args, then return shape. Slightly verbose in the returns section, but every sentence (zones-only-on-import, calculation_method) adds real 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?

An output schema exists, so the description did not need the return-value detail it provided, yet that detail (resting_hr, zones, calculation_method, data_source) is accurate and helpful. Combined with cache/sync semantics, nothing an agent needs to call this correctly is missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it gives accepted date formats ('YYYY-MM-DD', 'YYYY-MM', '30d') and defaults for start_date, a format and default for end_date, and the operational meaning of live. All three parameters are fully specified.

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 a specific verb and resource ('Get daily resting heart rate and heart rate zones') and the exact payload. It is clearly distinguishable from sibling tools like health_get_hrv, health_get_spo2, and health_get_sleep_sessions.

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 the default operating mode (local cache, auto-sync if stale) and gives a clear condition for using 'live' (re-fetch this window from the API). No explicit sibling routing or when-not-to-use guidance, but the context an agent needs to choose parameter values is present.

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

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

With no annotations provided, the description carries the disclosure burden and does well: it reveals the caching default, the live refetch path, and the ten-year default window rationale. It does not mention auth requirements or sync side effects, which are the remaining gaps.

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?

Front-loaded with purpose and behavior, then a compact Args block. Slight duplication with the schema parameter names and a return-value sentence that is redundant given the existing output schema.

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

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

For a three-parameter, no-annotation tool with a rich output schema, the description supplies everything needed to call it correctly: formats, defaults, cache-versus-live behavior, and the reason for the wide default window.

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: it documents all three parameters with accepted date formats ('YYYY-MM-DD', 'YYYY-MM', 'Nd'), defaults for each, and what live=true actually triggers.

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 a specific verb and resource ('Get height readings') plus the unit ('in millimetres as Google reports them'), which no sibling covers. An agent can distinguish it from health_get_weight_readings and other metric getters immediately.

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 context that drives usage: height is usually logged once, often years back, so the default window is ten years, and data comes from the local cache unless live=true. It never explicitly names an alternative tool or a when-not-to-use case, but the caching/live trade-off is clearly laid out.

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

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

With no annotations, the description carries the full behavioral burden and does well: it discloses the cache-vs-live tradeoff, the sync prerequisite, and the sparsity constraint ('only nights with on-wrist sleep tracking produce readings'). This prevents the agent from misinterpreting empty results. It omits auth/permission requirements, keeping it from a 5.

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?

Front-loaded with the core purpose, then behavior, then Args. Size is reasonable, though the RMSSD definition and return-field enumeration could arguably live closer to the output schema. Every sentence serves a purpose, so no serious 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?

Given a 3-param tool with 0% schema coverage, no annotations, and an output schema, the description fills the gaps: parameter formats, cache/live behavior, prerequisites, and data sparsity. An agent has everything needed to call it correctly and interpret empty results.

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 fully — and it does. It documents all three parameters: accepted date formats ('YYYY-MM-DD', 'YYYY-MM', '30d') with defaults for start_date/end_date, and the re-fetch semantics of live. This adds substantially more than the bare schema types.

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

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

States a specific verb and resource: 'Get nightly HRV (heart rate variability) data.' The scope ('nightly') and the explicit RMSSD explanation clearly distinguish it from siblings like health_get_heart_rate, which covers a different metric.

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?

Gives clear operational context: data comes from the local cache by default, live=True re-fetches from the API, and health_sync must run first to populate the cache. It stops short of explicitly naming which sibling to use for the raw heart-rate metric, so it is clear but not fully routing.

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 transparently explains that alerts are not a diagnosis, describes the nature of the data (background checks), explains the 'live' parameter's cache behavior, and describes the return structure. No contradictions exist.

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 clear sections, each sentence serving a purpose. It opens with a clear purpose statement, then provides contextual guidance, parameter details, and return info. No fluff or redundancy.

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

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

Given the tool's moderate complexity (3 params, output schema present), the description is complete. It covers the operational context, parameter semantics, and even describes the return format despite the output schema existing. It's both sufficient and effective.

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 provides detailed semantics for all three parameters: start_date format and default, end_date format and default, and live's purpose. It also clarifies the return fields. This adds significant meaning beyond the generic 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 action: 'Get irregular heart rhythm notifications raised by the watch.' It also distinguishes from sibling health_get_ecg by specifying that ECG is for a deliberate reading with a trace, whereas this tool retrieves background checks. This makes the purpose 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?

It provides explicit context on when to use: these are background checks, not a diagnosis, and most accounts never have one. It also explicitly directs to use health_get_ecg for deliberate readings. Parameter usage is explained with defaults and formats, leaving no ambiguity for the agent.

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

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

With no annotations, the description fully carries the burden. It discloses that results are cache-bounded, includes a coverage block with specific fields, and explicitly states absence of tracker split and active score. This goes well beyond a generic read, providing actionable caveats.

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

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

The description is succinct and front-loaded with the main purpose. It uses three short paragraphs/sentences, each adding distinct value: purpose, breakdown of records, and important caveats. No filler or redundancy.

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

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

Given there is an output schema, the description doesn't need to detail return values, but it still explains the coverage block and its importance. It covers what the tool does, its limitations, and how to interpret results—sufficient for a no-param read 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, so the description naturally adds no parameter syntax. Per the baseline for 0-param tools, a score of 4 is appropriate—there is nothing to compensate for.

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: 'Get all-time activity totals and personal best records.' It clearly defines scope (totals for steps, floors, distance, calories) and distinguishes from siblings like health_get_activity by noting exclusions (no tracker-versus-total split, no active score).

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 provides clear context on data freshness ('bounded by what has been synced') and instructs to read the coverage block before quoting totals as all-time. It does not explicitly name alternative tools for missing features, but it does state what this tool does not provide, which guides selection.

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

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

No annotations are present, so the description carries the full burden, and it does so well: cache-first reading, the UTC fetch timestamps, and the important null semantics ('A record is null when it has never been fetched, which includes one whose permission the grant lacks'). It stops short of stating auth/permission requirements or error behavior more concretely.

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?

Front-loaded with the operation, then record contents, then cache behavior, then the parameter. Slightly wordy ('Each is the record Google returns, kept whole') but every section delivers a distinct piece of information and nothing is repeated.

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?

An output schema exists, so return values need not be re-explained, yet the description's note on null-vs-never-fetched and the fetch timestamps adds useful interpretation. For a low-complexity single-parameter read tool it is essentially complete; only the sibling overlap with health_get_irregular_rhythm is left unaddressed.

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 single 'live' parameter must be explained by prose, and it is: 'If true, re-fetch the records from the API before reading the cache.' That fully compensates for the missing schema documentation, though with only one boolean parameter there is little room to exceed this.

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 a specific verb and resource ('Get the account's profile, settings and irregular-rhythm enrolment') and then enumerates exactly what each of the three returned records contains. An agent can distinguish it from health_get_devices, health_get_irregular_rhythm, and the other siblings without opening the schema.

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 a real, actionable default ('Returns data from the local cache by default') and explains the live flag as the way to bypass it, which is genuine usage guidance. However, it never states when to prefer this over the overlapping sibling health_get_irregular_rhythm, nor any explicit when-not conditions.

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 and does: it discloses that values are device-derived RELATIVE deviations, can be negative, that a ~3-night baseline lag suppresses early values, and that live=true re-fetches from the API before reading the cache. These are non-obvious traits an agent cannot get from structured fields.

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

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

Front-loads the core distinction (relative vs absolute) before the Args block, and every sentence adds information: unit, scope, sibling reference, baseline lag, and return shape. 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?

Though an output schema exists, the description summarizes the return fields (nightly_relative, absolutes, stddev, log_type, data_source) with useful interpretation, and covers the required date-parsing and freshness semantics. Nothing an agent needs to call this correctly is missing.

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

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

Schema description coverage is 0%, yet the description documents all three parameters, specifying accepted date formats ('YYYY-MM-DD', 'YYYY-MM', '30d') and the non-schema default of 'last 30 days' for start_date, plus today for end_date and the live caching behavior. It 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?

States a specific verb and resource ('Get nightly skin temperature variation') plus the exact unit (degrees Celsius from personal baseline), and explicitly distinguishes itself from the sibling health_get_core_temperature. An agent can identify this tool's distinct output without opening a schema.

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?

Gives an explicit when-not rule ('for fever / body-temperature readings use health_get_core_temperature instead') naming the alternative, plus a prerequisite ('a baseline takes about three nights to establish') and intended use cases (illness/cycle/recovery signal). Routing is unambiguous.

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 takes on full responsibility for behavioral disclosure. It explains the default cache-read behavior, the live fetch option, and the sparse nature of sleep data (missing nights due to travel, off-wrist, or manual logs). This is significant contextual information beyond a simple 'get' operation, though it doesn't mention auth or rate limits.

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

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

The description is appropriately structured: a brief summary sentence, then succinct optional details on cache/live behavior and data sparsity, followed by parameter documentation and return description. Every sentence adds value, and it remains compact despite covering edge cases.

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, the description still adds meaningful details about return contents (total_minutes, efficiency, start/end times, stage breakdown) and the cache/live data flow. It covers prerequisites, data quality caveats, and parameter formats, making it complete for a data retrieval tool.

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

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

Schema description coverage is 0%, and the description fully documents all three parameters: start_date formats ('YYYY-MM-DD', 'YYYY-MM', '30d'), end_date format and default, and live as a boolean controlling API re-fetch. This completely compensates for the minimal schema.

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

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

The description clearly states it retrieves nightly sleep data including duration, stages, and efficiency. The verb 'Get' and resource 'nightly sleep data' are specific, and the scope is unambiguous, distinguishing it from sibling health_get_* 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?

Provides explicit usage context: default reads from local cache, live=True fetches from API, and health_sync must be run first to populate the cache. It also notes data sparsity conditions. However, it does not explicitly mention alternatives or exclusion criteria, though the tool name and sibling list make the domain 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 largely succeeds: it discloses the caching layer ('re-fetch this window from the API before reading the cache'), that include_stages materially changes payload size ('a night runs to dozens'), and that segment_counts can be absent when a stored record is unreadable. It could be slightly more explicit about failure/empty-window behavior, but the safety-relevant behavior is well surfaced.

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?

Front-loaded with the key distinction before any detail, and the Args/Returns blocks are efficient. It is somewhat long, and the Returns section partially duplicates what the output schema already conveys, but every sentence remains substantive rather than filler.

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

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

For a 4-parameter read tool with zero schema description coverage and a complex nested return, the description supplies exactly what's missing: parameter formats, defaulting, cache behavior, and the shape/optionality of the result. An agent has everything needed to call 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%, so the description must do all the work — and it does. It documents all four parameters: start_date accepted formats ('YYYY-MM-DD', 'YYYY-MM', '30d') with its default, end_date with default, live's cache-bypass semantics, and include_stages' effect on the returned segment arrays. This adds meaning far beyond the bare schema property names.

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 a specific verb (get) and resource (each sleep session) and explicitly contrasts the scope with sibling health_get_sleep ('sums them per night, while this returns each one whole'). An agent can distinguish the two tools immediately without opening schemas.

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?

Names the alternative tool (health_get_sleep) and the exact condition that selects this one over it — wanting per-session granularity rather than a nightly total. It also clarifies when a night yields multiple sessions (wake-and-resume, nap), giving concrete selection context.

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

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

With no annotations provided, the description carries the full behavioral burden and does so well: it discloses the default cached read path, the need to sync first, the sparse nature of SpO2 data, live refetch semantics, return field interpretation, data provenance, and normal/abnormal ranges.

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 logical sections for usage, args, and returns, and the key cache/live behavior is front-loaded. It is longer than strictly necessary for tool selection because it includes detailed return-field interpretation, but most sentences remain useful.

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 an output schema exists, the description need not explain return structure, but it still provides essential context: cache/live mechanics, sync prerequisite, sparsity caveat, parameter formats, and clinical interpretation. An agent has enough context to call and interpret the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It documents all three parameters: start_date accepted formats and default, end_date format and default, and live behavior. This fully 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 states a specific verb and resource: 'Get nightly SpO2 (blood oxygen saturation) data.' It clearly identifies the metric and distinguishes it from sibling health metric tools such as health_get_heart_rate or health_get_sleep.

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 prerequisites and cache-vs-live behavior: data comes from the local cache by default, health_sync should run first, and live=true re-fetches from the API. It does not explicitly name alternative tools or when not to use this one, but the metric-specific scope makes that largely unnecessary.

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 well: it discloses the caching model, that live=True re-fetches the window before reading, the sync prerequisite, and that the data is sparse (only weigh-in days present). These are exactly the behavioral traits an agent needs.

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?

Front-loads purpose and cache semantics before the args, with zero filler sentences. Minor redundancy: the fields weight_kg, bmi, fat_pct are restated in the Returns block after already being named in the opening line.

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?

Although an output schema exists (so return-value documentation is optional), the description still completes the picture with cache/live behavior, sparse-data caveat, sync prerequisite, and full parameter formats. Nothing needed to call it correctly is missing.

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

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

Schema coverage is 0%, so the description must fully compensate, and it does: it documents all three params, including accepted start_date formats (YYYY-MM-DD, YYYY-MM, relative '30d') and defaults for start_date, end_date, and live that the schema does not express.

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 a specific verb+resource (get weight log entries) with the exact fields returned (weight, BMI, body fat percentage). It explicitly distinguishes itself from the sibling health_get_weight_readings by noting that individual weigh-ins live there while this tool returns one entry per day.

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

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

Explicitly states the default path (local cache), the alternative (live=True fetches from the API), and a prerequisite (run health_sync first to populate the cache). It also routes the agent to health_get_weight_readings for per-weigh-in granularity.

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 and does well: it discloses cache-vs-live behavior ('re-fetch this window from the API before reading the cache') and that values are returned in Google's native units (weightGrams, percentage). It does not cover auth requirements or rate limits, but for a read-only getter this is solid 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?

Front-loaded with the key differentiator in the first sentence, then structured Args/Returns sections. The Returns block restates what the output schema already provides, making it slightly redundant, but no sentence is wasteful for comprehension.

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

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

All three parameters are explained, behavior (cache/live) is covered, and return shape is described even though an output schema exists. Complete enough for an agent to invoke correctly; the returns restatement is the only redundancy.

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: it documents accepted date formats ('YYYY-MM-DD', 'YYYY-MM', or '30d'), the default windows, and the live flag's effect. This adds real meaning beyond the bare schema types.

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

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

States a specific verb and resource ('Get every weigh-in and body-fat reading') and immediately distinguishes itself from the sibling health_get_weight by scope: 'health_get_weight keeps one row a day; this returns every reading.' An agent can route between the two without opening either schema.

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?

Names the alternative (health_get_weight) and the condition that selects the other tool (daily rows vs every reading), and documents default windows and the live/cache tradeoff. It does not explicitly say when to prefer this tool, but the contrast makes the use case 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 behavioral burden and does well: it discloses incremental-only fetching, first-sync semantics, that 'days' is ignored on subsequent syncs, that 'since' overrides both incremental resume and 'days', and that since..until performs an upsert over exactly that window. It does not mention authentication requirements, rate limits, or error/timeout behavior, which leaves a modest gap for a network-bound mutation of the local cache.

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?

Front-loaded with purpose, then behavior, then parameters, then exclusions. The only bulk is the enumerated data_types list, which is necessary because the schema has no enum, so it earns its place. Slightly verbose but nothing is wasted.

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 4-parameter write-to-cache tool with no annotations, the description covers purpose, sequencing relative to siblings, incremental semantics, override precedence, and the full option set for data_types. An output schema exists, so not detailing the per-type return payload is appropriate.

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

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

Schema description coverage is 0%, so the description must compensate entirely, and it does: all four parameters are documented with formats (YYYY-MM-DD), defaults, comma-separated syntax, the full list of 23 data_types options, and the precedence rules between days/since/until. This adds far more meaning than the bare-typed schema provides.

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 a specific verb+resource ('Sync health data to the local cache') and immediately clarifies the mechanism ('Fetches data from the Google Health API and stores it in SQLite'). It clearly distinguishes itself from the health_get_* siblings by declaring it is a precondition rather than a query tool.

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?

Gives explicit sequencing guidance ('Run this before using other health_get_* tools') and an explicit exclusion ('Not for querying data - use health_get_heart_rate, health_get_activity, health_get_sleep, etc. instead'). It also explains when to use the since/until parameters (backfill, gap repair) vs. the default incremental path.

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 delivers: it discloses cache-backed reads, auto-sync-if-stale behavior, the compare-mode override semantics, spo2/cardio_fitness dual-definition quirks, and that edited core_temperature readings are double-counted. It does not state read-only/destructive posture explicitly, but 'analyse' strongly implies a read.

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 Args block is well front-loaded and cleanly organized, but roughly half the text explains return-field semantics for spo2, cardio_fitness, and core_temperature even though an output schema exists, which is verbose for a description.

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

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

Given 5 undocumented params, no annotations, and the analytical complexity, the description covers inputs, caching/sync behavior, comparison mode, per-datatype return semantics, and edge cases, leaving nothing an agent needs to call it correctly unaddressed.

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 and does so fully: it enumerates each param, lists the allowed enum values for data_type and period, gives defaults, date formats ('YYYY-MM-DD' or '365d'), and worked compare examples with the override rule.

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 a specific verb and resource ('Analyse trends in cached health data', computing averages/totals over time) and explicitly distinguishes itself from the health_get_* raw-data siblings. An agent can identify the tool's scope without opening the schema.

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 routes raw-data needs to health_get_* tools and explains that compare overrides period/start_date/end_date. It gives clear usage context but does not name a specific alternative sibling (e.g. health_get_lifetime_stats) for cases where trends is wrong.

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