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

Annotations already declare readOnly, idempotent, non-destructive, and open-world, so the safety profile is covered. The description adds that output is organized as daily values with percent changes, which is useful, but it says nothing about the deduplication/cross-source conflict resolution behavior that materially changes results.

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

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

A single front-loaded sentence with no filler; the comparison semantics lead immediately. It is arguably too terse for a six-parameter analytical tool, 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?

Six optional parameters, no output schema, and non-trivial deduplication logic leave the agent under-informed: the return shape (per-day rows? per-metric aggregates? ordering?) and the interaction between deduplicate and source_priority are unexplained. One sentence cannot cover this surface area.

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

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

Schema description coverage is only 50%: source, deduplicate, and source_priority are documented inline, while days (2-90 bound), timezone, and data_types carry no schema descriptions. The tool description mentions none of the parameters, so it does not compensate for the undocumented half — notably how timezone shifts day boundaries or what valid data_types are.

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 (compare) and resource scope (a recent period vs the immediately preceding one) with the metric form (daily numeric values and percent changes). This clearly separates it from plain retrieval siblings like get_metrics or get_daily_summary, though it never names get_trends, the closest analytical alternative.

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

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

The 'recent vs preceding period' framing implies the use case (period-over-period change analysis), but there is no explicit when-to-use guidance, no mention of when to prefer get_trends or get_daily_summary, and no prerequisites stated. Usage must be inferred rather than read.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so safety behavior is covered. The description adds the set of metrics included in the summary, but it does not explain aggregation over days, cross-source deduplication, or how source_priority conflicts are resolved.

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

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

The description is a single well-formed sentence that is front-loaded with the core purpose. Every word contributes to stating what is summarized, with no 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?

With five parameters, source merging, deduplication, timezone handling, and no output schema, the definition is under-specified for correct invocation. It does not explain default time windows, output shape, or how cross-source conflicts affect 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 description coverage is 60%, below the high-coverage threshold, and the description mentions no parameters at all. It does not clarify the 'days' window, timezone behavior, or how source/deduplicate/source_priority interact, so it fails to compensate 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 states a specific verb and resource: summarize recent activity metrics including movement, distance, calories, floors, and heart-rate zones. It is clear what the tool returns, but it does not distinguish itself from siblings such as get_daily_summary or get_health_snapshot.

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

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

There is no explicit guidance on when to use this tool versus alternatives like get_daily_summary, get_health_snapshot, or get_trends. The agent must infer usage from the word 'summary' alone, with no exclusions or prerequisite 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?

Annotations already declare readOnly, idempotent, non-destructive, open-world, so the safety profile is covered. The description adds useful behavioral context by noting normalized units and source metadata in the output, but says nothing about how the 90-day cap or cross-source conflict resolution affects results beyond what the schema already states.

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

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

A single front-loaded sentence that lists scope and output qualities with no filler. Every clause carries information.

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

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

For a read-only aggregate tool with strong annotations and no output schema, the description covers what is returned at a high level (normalized units, source metadata), which is helpful. It is still thin on the default/limit behavior of the time window and on source-conflict handling, which are the parameters most likely to change 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 60%: source, deduplicate, and source_priority are documented in the schema, while 'days' and 'timezone' are undocumented. The description only implies the recency window and adds no format or semantics detail for source selection, timezone handling, or deduplication.

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

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

The description names a specific verb ('Summarize') and enumerates the exact resources covered (weight, body-fat, temperature, height, blood-glucose), so the agent knows precisely what data comes back. It does not differentiate itself from close siblings like get_recent_metrics or get_metrics, which a reader would need to disambiguate.

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

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

There is no statement of when to choose this tool over get_metrics, get_recent_metrics, or get_health_snapshot. 'Recent' hints at a time-window use case but no window, exclusion, or alternative is 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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), so the bar is lower. The description adds genuine behavioral value with 'where available', signaling that fields may be absent rather than guaranteed, but it says nothing about missing-data handling, source merging outcomes, or cost/latency.

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

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

A single front-loaded sentence with the verb first and the metric list following, no filler. The enumeration is long but each item earns its place by telling the agent exactly which data points come back.

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

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

With no output schema, the description's metric enumeration usefully compensates by describing the return surface, and annotations cover safety. The remaining gap is modest: it doesn't explain what a 'where available' miss looks like or how cross-source conflicts surface, but the tool is otherwise well-covered.

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

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

Schema description coverage is 100%, so date format, source enum, deduplicate, and source_priority are all already documented in the schema. The description adds no extra meaning about how these parameters affect the returned metrics, so the baseline 3 applies.

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

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

States a specific verb ('Read') and a concrete resource (daily Fitbit metrics) and enumerates the exact metrics returned, so the agent knows precisely what it gets. However, it never distinguishes itself from close siblings such as get_health_snapshot, get_activity_summary, get_sleep_summary, or get_metrics, leaving overlap unresolved.

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

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

The phrase 'in one call' hints at aggregation convenience, but there is no explicit when-to-use guidance, no when-not-to-use, and no named alternative among the 16 siblings. The agent must infer that this is the broad single-day rollup versus the more focused siblings.

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

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

Annotations already declare readOnly, idempotent, non-destructive behavior, so the safety profile is covered. The description adds real interpretive context beyond that: it flags that API-limited metrics exist and that missing data must not be read as zero, which shapes how an agent interprets the result. It stops short of describing the returned report's structure.

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

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

A single front-loaded sentence listing exactly what gets diagnosed, with no filler or repetition of the tool name. Every clause carries distinct 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?

With six optional parameters, an enum, an array of 39 data types, and no output schema, the description should sketch what the diagnostic returns (per-type coverage? per-source counts?). It defines the scope well but leaves the result shape entirely unspecified, so an agent cannot predict what it will get back.

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

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

Schema description coverage is 50% – source, deduplicate, and source_priority are documented in-schema, while days, timezone, and data_types are not. The description gestures at recency ('recent') and provenance, but adds no detail on lookback window bounds, timezone handling, or filtering the 39 data types. Partial compensation, not full.

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

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

Names a specific verb ('Diagnose') plus the exact resources examined: data coverage, missing records, source provenance, and API-limited metrics. The closing clause ('without treating missing data as zero') gives it a distinct identity as a quality-audit tool, separating it from value-returning siblings like get_metrics or get_recent_metrics.

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?

Use is implied by the diagnostic framing – you call it to check whether data is trustworthy before analyzing it – but the description never states when to prefer it over get_sync_status, get_data_source_info, or list_available_metrics. No exclusions or alternative routing are given.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld. The description adds value beyond them by signalling that read-only boundaries and availability limitations are surfaced, which matters for interpreting results. It doesn't cover return format or auth, but the key behavioral context is present.

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

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

Two tight sentences with the purpose front-loaded and the usage instruction second. No filler; every clause earns its place.

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

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

For a zero-param informational tool with no output schema, the description adequately explains what information is returned and why it matters. The exact shape of the response is left unspecified, which is the only minor gap.

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

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

Zero parameters, so baseline is 4. There is nothing for the description to disambiguate at the parameter level, and none of the field semantics undermine correctness.

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 precisely what the tool returns: data source, API used, read-only boundaries, and availability limitations. It carves out a distinct informational role relative to the metric-fetching siblings, though it doesn't name them explicitly.

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 'Call this before interpreting metric results,' giving a clear when-to-use trigger. It doesn't enumerate when-not-to-use or name a specific sibling, but the precedence rule 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds meaningful scope by naming the connected account and the conditional Fitbit Air exposure, but does not describe return shape or any account/auth caveats beyond the scope phrase.

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

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

The description is a single efficient sentence, front-loaded with the action and resource, with no wasted wording.

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 no-parameter read-only list tool with rich annotations and no output schema, the description gives enough scope to invoke it correctly. A minor gap is the absence of explicit return-structure detail, though that is less critical for such a simple tool.

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

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

The tool takes zero parameters, so the baseline is 4. The schema is empty and requires no parameter explanation from the description.

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

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

The description states a specific verb and resource: list devices paired with the connected Google Health account. It is clear what the tool returns, though it does not explicitly differentiate itself from sibling read tools such as get_data_source_info or get_profile.

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

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

Usage is implied by the phrase 'List devices paired with the connected Google Health account,' but the description gives no explicit when-to-use guidance, no exclusions, and no mention of alternatives among the many sibling read tools.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior, so the safety profile is covered. The description does add that the snapshot reports 'freshness' and 'unavailable metrics', which tells an agent the tool tolerates partial data rather than erroring, but it never explains how those signals are represented or what 'compact' means in terms of response shape.

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

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

A single front-loaded sentence with no filler; the domain list follows immediately after the verb and resource. Slightly list-heavy, but every phrase carries meaning.

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?

There is no output schema, so the description bears the burden of explaining what comes back; it names the six data domains but not the structure, ordering, or how freshness and unavailability are surfaced. For a zero-required-parameter aggregate tool with five parameters, this is adequate but incomplete.

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

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

Schema description coverage is 100%, so date, source, timezone, deduplicate, and source_priority are fully documented in the schema already. The description adds only the 'current-day' framing, which loosely implies the date defaults to today, without any additional semantics for source filtering or deduplication.

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

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

The description uses a specific verb ('Return') and resource ('current-day Fitbit snapshot') and enumerates the domains covered: activity, heart rate, body composition, sleep, freshness, and unavailable metrics. That is enough to distinguish it from narrow siblings like get_sleep_summary or get_body_metrics, but it never contrasts itself with the closest sibling, get_daily_summary.

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

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

The description implies usage ('current-day' overview data) but never states when an agent should choose this over get_daily_summary, get_metrics, or get_recent_metrics, all of which sound overlapping. It provides no prerequisites or exclusions.

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

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

Annotations already establish read-only, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The description adds that output is raw normalized records with source metadata, which is useful since there is no output schema, but says nothing about volume limits, pagination, or how deduplicate/aggregate_daily alter results.

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 short sentences, zero filler, and the primary action is front-loaded before the pointer to the helper tool. Nothing repeats the schema or the annotations.

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 7-parameter query tool with no output schema, the description at least sketches the return shape, but it leaves the agent without guidance on cost of wide ranges, conflict resolution behavior, or how aggregation changes granularity. Adequate as a minimum, not complete.

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

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

Schema description coverage is 100%, so all seven parameters including enums, defaults, and examples are already documented. The description only restates the date-range and multi-metric aspects at a high level, adding no behavioral meaning beyond the schema (e.g., how source_priority interacts with deduplicate).

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 (read) and resource (Google Health API v4 metric types) plus the scoping parameter (date/time range), which differentiates it from snapshot/summary siblings. It does not explicitly distinguish itself from closer siblings like get_recent_metrics or get_trends, so the boundary is only implied.

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 the agent to list_available_metrics for valid metric names, which is concrete and actionable. It gives no guidance on when to choose this versus get_recent_metrics, get_body_metrics, or get_trends, so it falls short of full when/when-not coverage.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered elsewhere. The description contributes only the word 'connected', hinting that authentication/an active link is required, but says nothing about what identity fields come back or whether the call can fail when the connection is absent.

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

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

A single ten-word sentence with the resource front-loaded and zero filler. Every word earns its place and nothing is buried.

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

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

With no parameters, no output schema, and rich annotations, the description only needs to convey purpose and scope, which it does. The minor gap is that 'identity metadata' is left undefined, so an agent cannot predict whether it yields a user ID, email, or device account details.

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 takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The schema itself is an empty object, consistent with the parameterless description.

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

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

The description states a specific verb (Read) and a specific resource (the connected Google Health/Fitbit profile and identity metadata), which is clearly distinct from the metric-oriented siblings like get_metrics or get_trends. It stops short of explicitly routing between the closest neighbors (get_devices, get_settings, get_data_source_info), which are all identity-adjacent reads.

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

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

There is no explicit when-to-use or when-not guidance and no named alternative; the agent must infer that this is the tool for account/identity questions rather than device or settings questions. Usage is implied by the resource named, which meets the minimum-viable bar but leaves ambiguity against the identity-adjacent siblings.

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

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

Annotations already declare read-only, idempotent and non-destructive behavior. The description adds genuinely new semantics: metric isolation means unsupported types degrade gracefully rather than failing the whole response, which an agent cannot infer from annotations or schema.

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

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

Two short sentences with the scope stated first and the failure-isolation caveat second; no filler. Slightly compressed to the point that the default-range point and the isolation point are the only content.

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

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

Adequate for a 7-parameter read tool with full schema coverage and safety annotations, but with no output schema the description says nothing about the response shape or granularity, and it leaves the sibling-selection question entirely open.

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 100%, so every parameter is already documented with defaults, bounds and enums. The description only restates the 7-day default and adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Read recent Fitbit metrics') plus a scope ('safe default 7-day range'). It does not differentiate from siblings like get_metrics, get_health_snapshot, or get_trends, and the 'Fitbit' framing is slightly at odds with the HEALTH_KIT source option.

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

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

No indication of when to prefer this over get_metrics, get_health_snapshot, get_trends, or get_daily_summary, despite a very crowded sibling set. 'Recent' plus the 7-day default only weakly implies a contextual use case.

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

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

Annotations already declare readOnly, idempotent, non-destructive, open-world, so the safety profile is fully covered. The description adds that it is a multi-metric summary for informational context, but says nothing about deduplication handling or source-conflict resolution behavior beyond what the schema fields describe. With annotations carrying the safety burden, this is adequate but not rich.

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

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

A single well-formed sentence with no wasted words, and the resource list is front-loaded after the verb. Efficient, though the trailing 'for informational recovery context' is slightly vague rather than informative.

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

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

With no output schema, 5 params, and 60% coverage, the description should clarify return shape or default behavior. Annotations cover safety and the metric list covers scope, but the agent still lacks guidance on what the summary contains or how defaults apply. Marginally adequate.

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

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

Schema description coverage is 60%, with source, deduplicate, and source_priority documented in-schema. The description names the metrics but adds no meaning about days, timezone, or prioritization behavior beyond the schema, so it neither compensates for the gaps nor adds value. Baseline 3 fits.

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 ('Summarize') and enumerates the exact resources covered (sleep, heart rate, HRV, oxygen saturation, respiratory rate), so the agent knows precisely what data is aggregated. It doesn't distinguish itself from overlapping siblings like get_sleep_summary or get_health_snapshot, so it stops short of a 5.

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

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

'For informational recovery context' hints at purpose but gives no explicit when-to-use vs when-not guidance. Several siblings (get_sleep_summary, get_daily_summary, get_health_snapshot) overlap heavily and the description never names an alternative or a selecting condition.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=true, so safety and idempotency are covered structurally. The description adds that the settings come from a connected Fitbit/Google Health account, hinting at an external dependency, but does not disclose behavior when no account is connected or what auth is needed — meaningful given openWorldHint=true.

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

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

A single front-loaded sentence with no filler. It is efficient, though it is arguably too terse for a tool with an undisclosed return shape.

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?

Simple no-arg read with annotations covering safety, but there is no output schema, so an agent has no idea what 'settings' and 'preferences' actually contain (units, timezone, sync config, etc.). A brief enumeration of the returned settings would materially improve call planning.

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?

Zero parameters, so the baseline is 4; the description correctly makes no parameter claims and instead scopes the resource, which is the right move for a no-arg tool.

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 ('Read') and resource ('connected Fitbit/Google Health settings and configured preferences'), which is distinguishable from siblings like get_profile, get_devices, and get_sync_status. It does not explicitly contrast with those siblings, keeping it below 5.

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

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

Usage is implied by the resource name: an agent wanting configuration/preferences would pick this. No explicit when-to-use or when-not guidance, and no alternatives named (e.g., get_profile for personal info, get_devices for device list).

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so safety is covered. The description adds meaningful context with 'normalized' and 'stage totals,' hinting that sessions are reconciled across sources, but it does not explain the deduplicate/source_priority behavior or what normalization entails beyond that single word.

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

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

A single front-loaded sentence with no filler. It is efficient, but it is also arguably too terse given the number of undocumented parameters and the absence of an 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?

With no output schema, five parameters and 60% schema coverage, the description should say more about what 'stage totals' contains and how the date range maps to the days parameter. It is adequate to call the tool, but the agent lacks clarity on return shape and range 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 60%: source, deduplicate and source_priority are documented, while days and timezone are not. The phrase 'recent date range' loosely gestures at the days parameter, and 'normalized' gestures at deduplication, but neither adds real syntax or semantics beyond the schema, making 3 the appropriate baseline.

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

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

The description names a specific verb ('Return'), a specific resource ('sleep sessions and stage totals'), and a scope ('recent date range'). It clearly separates the tool from non-sleep siblings like get_activity_summary or get_recovery_summary, though it does not differentiate itself from get_daily_summary, which could plausibly also contain 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?

There is no explicit when-to-use or when-not-to-use guidance, and no alternatives are named among the many sibling summary tools. 'Recent date range' only faintly implies a boundary, and the agent must infer whether this tool or get_daily_summary is the right call.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and openWorld behavior. The description adds scope (account metadata, paired devices, metric recency) but does not mention auth requirements, rate limits, what happens if no account is connected, or how fresh the freshness check is.

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

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

A single front-loaded sentence with no filler. Each element (account metadata, paired devices, metric recency) is directly relevant.

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 gives a general sense of what is checked but does not fully explain the return content in the absence of an output schema, nor does it provide usage context relative to similarly named siblings. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so all three parameters are fully documented in the schema. The description adds no parameter meaning beyond the schema; baseline 3 is appropriate.

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

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

States a specific verb ('Check') and concrete resources: account metadata, paired devices, and data recency for Fitbit/Google Health. The purpose is clear, but it does not distinguish itself from siblings like get_devices or get_data_source_info, which cover overlapping areas.

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

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

No explicit when-to-use or when-not-to-use guidance is provided, and no alternatives are named. An agent can infer it is a sync-status check, but nothing tells it when to choose this over get_devices or get_data_source_info.

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

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

The annotations already declare this as a read-only, idempotent, non-destructive operation, so the safety profile is covered. The description adds useful behavior by naming the aggregate statistics and noting that percent change is returned 'where possible,' but it does not mention rate limits, permission requirements, or result-shape caveats beyond that.

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

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

The description is a single front-loaded sentence with no wasted text. The purpose and returned statistics are expressed efficiently.

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 six-parameter aggregation tool with no output schema, the description is minimally adequate: it says what is calculated but not how the time window, source filter, timezone, or deduplication affect results. Some parameter details are covered by the schema and safety is covered by annotations, but meaningful gaps remain.

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

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

Schema description coverage is only 50%, and the description does not compensate for the undocumented parameters such as days, timezone, and data_types. It also does not explain how source_priority or deduplicate affect the calculation, leaving most parameter meaning to the schema or 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?

The description uses a specific verb (Calculate) and resource (numeric trend summaries) and enumerates the summary statistics returned. It is clear what the tool does, but it does not distinguish itself from similar siblings such as get_metrics or get_recent_metrics, and it says 'Fitbit metrics' even though the source enum includes HEALTH_KIT and all.

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 no explicit when-to-use guidance, prerequisites, or alternatives. It implies the tool is for trend summaries but does not tell an agent when to choose it over get_metrics, get_recent_metrics, or get_health_snapshot.

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

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

Annotations already declare readOnly, idempotent, non-destructive, open-world behavior, so safety is covered. The description adds real semantic context — that the namespace is Google Health v4 rather than Fitbit Web API — but says nothing about the return shape (flat list of identifiers? names plus descriptions?) or that the catalog is effectively static.

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

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

Two sentences, no waste, with the scope statement front-loaded and the disambiguation immediately after. Nothing is repeated from annotations or 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 zero-param, no-output-schema listing tool the description is close to sufficient, but it omits the one thing an agent most needs: that the returned identifiers are what the get_* metric tools expect as input. Without that link the discovery step is guesswork.

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?

Zero parameters, so there is nothing to disambiguate; baseline 4 applies. The description correctly spends no words on parameter explanation.

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

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

States a specific verb (List) and a precisely scoped resource (Google Health API v4 data types available through this Fitbit-synced integration). The second sentence disambiguates it from a Fitbit Web API catalog, which usefully separates it from siblings like get_metrics. It stops short of saying the list is the source of valid metric identifiers.

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 'not a direct Fitbit Web API catalog' caveat implies this is the discovery entry point for the integration's naming, but the description never says to call this before get_metrics/get_trends or that its results feed those tools. Usage is implied rather than stated.

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