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

The description discloses key behavioral traits beyond the annotations: 'Returns exact stats computed on full-resolution samples plus a downsampled series capped at 500 points' and the context-window rationale ('never blows the context window'). It also reinforces the GPS exclusion. These details add genuine value beyond the readOnly/idempotent hints.

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

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

Three sentences, each earning its place: first states purpose, second explains behavior and rationale, third gives usage guidance and an exclusion. No filler, front-loaded with the core concept, and ends with a clear boundary.

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 a rich output schema, six parameters (most well-documented in the schema), and annotations covering safety, the description is complete. It explains the tool's purpose, when to use it, its output constraints (downsampling cap, no GPS), and the context-window benefit. No critical 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 high (83%) and the schema already explains most parameters. The description adds contextual meaning by framing the tool as a 'bounded time-series' and referencing the 500-point cap, which directly informs max_points and resolution_seconds semantics. That extra layer justifies a score above 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 opens with a specific verb+resource: 'Bounded time-series for one activity metric.' It clearly distinguishes itself from siblings by name-dropping alternatives ('Prefer garmin_get_activity / splits / hr_zones first') and stating its unique value ('when you actually need the shape of the effort over time').

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?

Explicit when-to-use guidance is provided: 'Prefer garmin_get_activity / splits / hr_zones first; reach for this when you actually need the shape of the effort over time.' It also states a clear exclusion: 'GPS is never returned here.' This gives the agent actionable selection criteria.

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

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

Annotations already declare readOnlyHint and idempotentHint. The description adds critical context that the tool 'does not call Garmin' and does not expose secrets, reinforcing safety beyond annotations.

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

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

Two sentences, front-loaded with purpose, and no unnecessary words. Every sentence provides essential information.

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

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

Given the tool's simplicity (no required parameters, output schema exists), the description adequately covers non-obvious aspects (no external calls, no secrets). It is complete enough for safe 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?

Schema description coverage is 0%, and the description provides no explanation of the 'client' and 'response_format' parameters. Although the schema has enums and defaults, the description should have added meaning, especially since coverage is low.

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

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

The description clearly states that this tool provides 'Machine-readable install, runtime and client guidance for AI agents' and distinguishes itself from data-fetching siblings by noting it 'does not call Garmin or expose secrets'.

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

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

The description implies usage for obtaining guidance/manifest information but does not explicitly state when to use this tool versus alternatives like garmin_quickstart or garmin_capabilities. No exclusions are mentioned.

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

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

Annotations already indicate safe, read-only, idempotent behavior. The description adds valuable context by specifying the tool avoids asking for secrets, which guides agent behavior beyond the annotations.

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

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

The description is a single, front-loaded sentence with no fluff. Every word contributes to the purpose and constraint, making it highly efficient.

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

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

For a simple documentation tool with strong annotations and an output schema, the description is nearly complete. It could optionally mention that the output format is controlled by the parameter, but the current text is sufficient.

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

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

The input schema has one parameter (response_format) with enum and default, but the description does not mention it. With 0% schema description coverage, the description should compensate, but it does not explain the parameter's effect or choices.

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

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

The description clearly states the tool explains the local Garmin Connect authentication flow, with a specific constraint of not asking the user to paste secrets. It distinguishes from sibling tools like garmin_quickstart or garmin_onboarding.

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

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

The description implies usage when the user needs to understand the auth flow without revealing secrets, but lacks explicit guidance on when not to use it or alternatives (e.g., for actual connection, use garmin_quickstart).

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. Description adds context about enabling the cache and what the tool shows, providing value beyond annotations without contradiction.

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

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

Two sentences, front-loaded with purpose, second sentence adds key enabling info. No wasted words.

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

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

Adequate for a simple status tool given output schema and annotations, but missing explanation of the response_format parameter, which is a gap.

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

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

Schema coverage is 0%, placing full burden on description, yet it does not mention the single parameter (response_format) or its enum values/default, leaving the agent with no guidance.

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

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

Description clearly states verb 'Show' and resource 'optional local SQLite cache status', distinguishing it from sibling tools like garmin_connection_status or garmin_data_inventory.

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?

Tells when to use (to show cache status) and how to enable cache via environment variables, but does not explicitly state when not to use or provide alternatives.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds context about explaining privacy boundaries and workflow, but does not disclose additional behavioral traits like auth requirements or response volume. With strong annotations, the description adds moderate value.

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

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

The description is a single sentence that front-loads the core purpose. It is efficient with no wasted words, though a slightly more structured format could improve scannability.

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

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

Given the tool's meta role among many data-retrieval siblings, the description covers key aspects (data, privacy, workflow, links). The presence of an output schema means return values need no explanation. A suggestion to use this tool first would enhance completeness but is not strictly required.

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

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

The schema has 0% description coverage for the sole parameter (response_format). The description does not mention this parameter or explain how to use it (e.g., selecting markdown vs JSON output). For a tool with one optional parameter, the description should compensate for missing schema descriptions but fails to do so.

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

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

The description uses the verb 'explain' and specifies the resources: 'supported Garmin data, privacy boundaries, recommended agent workflow and project links'. This clearly distinguishes it from sibling tools that retrieve specific data (e.g., get_daily_summary) or handle authentication (garmin_auth_instructions).

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 the tool is for introductory/overview purposes but does not explicitly state when to use it versus alternatives like garmin_quickstart or garmin_agent_manifest. No 'when not to use' or ordering guidance is provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. Description adds specifics about what is checked (config, token, etc.) and that it does not expose secrets, providing extra behavioral context.

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

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

Single sentence, front-loaded with key information, no wasted words.

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

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

For a diagnostic tool with an output schema, the description covers the main checks. It is sufficient for an agent to understand the tool's scope, though it could mention that output schema provides 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?

Schema has 0% description coverage. The description only hints that 'client' relates to MCP client readiness, but does not explain 'response_format' or provide meaning beyond enum values. Schema already provides defaults, but description does not compensate for the lack of parameter documentation.

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

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

The description clearly states it checks local Garmin config, token file, Node version, privacy mode, cache readiness, and optional MCP client readiness without calling Garmin or exposing secrets. It distinguishes from siblings which likely fetch data from Garmin.

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

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

The description implies usage for checking connection status without API calls, but does not explicitly say when to use or when not to use alternative tools. Context is clear, but no exclusions or alternative guidance.

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

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

Annotations already declare readOnlyHint and idempotentHint; the description reinforces 'Read-only and non-medical' and adds 'when available', which is behavioral context about data completeness not covered by annotations.

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

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

Single sentence conveying purpose, data sources, and safety disclaimer. No wasted words; front-loaded with critical information.

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

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

For a simple aggregator tool with an output schema, the description adequately covers purpose and behavioral caveats. Minor gap: no mention of return format or how missing data is handled, but output schema likely fills that.

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

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

Schema description coverage is 67% (2 of 3 parameters documented). The tool description does not augment parameter meaning or add details for the undocumented 'response_format' parameter. Baseline 3 is appropriate given high coverage but lack of additional description.

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

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

The description clearly states it builds a practical daily summary from multiple Garmin data sources (activity, sleep, HRV, etc.) when available, distinguishing it from individual metric-fetching siblings. The verb 'Build' and resource 'daily summary' are specific.

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

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

The description says 'practical daily summary' and 'Read-only and non-medical' but does not differentiate from the sibling 'garmin_get_daily_summary', leaving ambiguity about which to choose. No explicit when-to-use or when-not-to-use guidance is provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds that it does not call APIs or expose user data, providing extra confidence about its nondestructive nature.

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

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

Two sentences, front-loaded with the primary purpose, no filler. Every word adds value.

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

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

The tool is a simple inventory/discovery tool. The description covers its scope, boundaries, and limitations. An output schema exists to detail the return format, so no further explanation needed.

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

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

The single parameter response_format is fully defined in the enum in the schema. The description adds no additional meaning about when to choose markdown vs json, but the schema already makes it clear. Baseline of 3 is appropriate.

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

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

The description explicitly states it inventories supported Garmin data domains, auth scope requirements, privacy boundary, and recommended first calls. This clearly differentiates it from sibling tools that actually retrieve user data or perform actions.

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

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

The description notes it does not call Garmin APIs or expose user data, implying it is safe to call anytime for orientation. However, it does not explicitly state when to use it versus alternatives like garmin_quickstart or garmin_capabilities.

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

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

Beyond annotations that mark it as read-only and idempotent, the description adds critical context: it returns example payloads and does not make real API calls. No contradictions with annotations.

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

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

Single sentence capturing purpose and target tools. No wasted words; front-loaded with the key action.

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

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

Given no output schema, the description serves as the contract by naming the three example tools. It could mention that payloads are realistic but not live data, but still adequate for a demo 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?

With 0% schema description coverage, the parameter (response_format) is not explained in the description, but it is self-explanatory via its enum. The description does not add meaning beyond the schema.

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

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

The description clearly states the tool returns 'realistic example payloads' for three specific tools, distinguishing it as a demo/preview tool among siblings that make actual Garmin Connect calls.

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 using this tool before making real calls to understand the data contract, but does not explicitly state when not to use it or mention alternatives. Clear enough for its demo purpose.

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

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

Annotations already indicate destructiveHint=true, and the description adds valuable context: it deletes a local token file (not account-level) and does not change the Garmin account. This goes beyond annotations by clarifying the scope and safety profile of the destructive action.

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

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

The description is two sentences, front-loads the core action, and includes necessary clarifications without redundancy. Every sentence adds value, making it highly efficient.

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

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

Given the presence of an output schema (not shown) and the tool's straightforward nature (single action), the description covers the key points: what it does, what it doesn't do, and the prerequisite. It is sufficiently complete for an agent to use safely.

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% (explicit_user_intent has description, response_format does not). The description adds semantic meaning to explicit_user_intent by framing it as a safety gate, but provides no additional info for response_format. Since the enum and default are self-explanatory, a score of 3 is appropriate.

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

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

The description clearly states 'Delete the local Garmin token file', specifying the verb and resource. It distinguishes itself from siblings by focusing on local disconnection without affecting the Garmin account, making its unique purpose evident.

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 'use only when the user explicitly wants to disconnect this MCP' and emphasizes the explicit_user_intent requirement. While clear on when to use, it does not provide guidance on when not to use or suggest alternatives, but the context of sibling tools (mostly read-oriented) indirectly clarifies usage.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds no further behavioral traits, such as the effect of privacy_mode on output or potential restrictions. It does not contradict annotations.

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

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

The description is a single, concise sentence with no extraneous information. It is appropriately front-loaded, stating the primary action immediately.

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

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

Given the tool has 4 parameters, enums, and an output schema, the description is too brief. It omits important context such as the behavior of privacy_mode, the difference from other activity tools, and any prerequisites or limitations.

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 75% (3 of 4 parameters described), so the baseline is 3. The tool description adds no additional meaning beyond what the schema provides; it only mentions 'by activity id' which is already in the schema.

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

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

The description 'Get a Garmin activity summary by activity id' clearly states the verb (Get) and resource (activity summary) with a specific identifier (activity id). It is not a tautology but lacks explicit differentiation from siblings like garmin_get_activity_details, which might return full details.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., garmin_list_activities, garmin_get_activity_details). There is no mention of prerequisites or context for usage, making it difficult for an agent to select correctly.

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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds 'when available,' hinting at conditional availability of samples, but does not disclose how privacy_mode or response_format alter behavior, or what happens if samples are unavailable.

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, short sentence (7 words). While concise, it is too terse to provide sufficient context for a tool with 4 parameters and an output schema. Could be improved without becoming verbose.

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 existence of many sibling tools with similar purposes, the description lacks key context about what specific data this tool returns (e.g., sample-level data, GPS points) and how it differs from others. The output schema exists but the description does not bridge the gap.

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

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

Schema description coverage is 75%; all parameters have individual descriptions. The tool description does not add any additional meaning beyond the schema. With high coverage, baseline of 3 is appropriate.

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

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

The description states 'Get detailed Garmin activity samples when available.' It identifies the verb and resource but is vague about what 'detailed' means and lacks differentiation from sibling tools like garmin_get_activity or garmin_get_activity_splits.

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

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

No guidance on when to use this tool versus alternatives such as garmin_get_activity, garmin_get_activity_splits, or other activity detail tools. The description provides no context about appropriate use cases or prerequisites.

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, so basic safety is clear. The description adds only 'when available', hinting that heart-rate zones may not exist for all activities, but fails to disclose error behavior, data structure, or performance implications.

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

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

The description is a single concise sentence with no extraneous words. The key information ('Get Garmin activity heart-rate zone time') is front-loaded, allowing quick understanding.

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

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

Given the tool's simplicity and the presence of an output schema, the description is somewhat complete. However, it lacks context on when heart-rate zones are available, what the output contains, and how it relates to other activity tools.

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

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

Schema description coverage is 75%, so the schema itself explains most parameters. The description refers to 'by activity id' corresponding to the required 'id' parameter, but adds no extra meaning beyond the schema.

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

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

The description uses a specific verb 'Get' and identifies the resource 'Garmin activity heart-rate zone time', making the purpose clear. It includes qualifiers 'by activity id when available' which helps distinguish it from general activity tools like garmin_get_activity.

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 only states 'by activity id when available', providing minimal guidance. It does not explain when to use this tool over siblings like garmin_get_activity_splits or garmin_get_activity_details, nor does it mention prerequisites or conditions for availability.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, indicating a safe, read-only operation. The description adds no further behavioral context, such as response size, pagination, or potential fallbacks, missing an opportunity to add value beyond the annotations.

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

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

The description is a single, clear sentence that conveys the essential purpose with no extraneous words. It is front-loaded and efficient.

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

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

Given the presence of an output schema (details of return values not needed), annotations covering safety, and a straightforward retrieval task, the description is mostly complete. However, it could mention that the id must be from a valid Garmin activity, but this is implied.

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 high coverage (75% described, but actually all parameters are described in schema). The description does not add meaning beyond the schema, e.g., it doesn't explain the effect of privacy_mode or response_format. 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?

The description ('Get Garmin activity splits/laps by activity id.') clearly states the action and resource. It distinguishes from sibling tools like garmin_get_activity (which gets the entire activity) and garmin_get_activity_details (which may provide different detail), but does not explicitly call out the difference.

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

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

The description provides no guidance on when to use this tool versus alternatives or any prerequisites. It only states the basic function, leaving the agent to infer context without explicit usage directions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, indicating safe read behavior. The description adds the nuance 'when available,' implying the tool may return no data for some activities. This is a useful addition but minimal beyond that. No contradictions with annotations.

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

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

The description is a single sentence that immediately states the tool's purpose with a verb and resource. It is concise and front-loaded, with no extraneous information. Ideal structure 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?

The tool has 4 parameters, an output schema, and several siblings. The description is minimal but covers the core functionality. It does not explain 'when available' in detail or how privacy_mode/response_format affect output, though these are in the schema. Adequate but with gaps.

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

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

The description does not mention any parameters. Schema coverage is 75% (3 of 4 parameters have descriptions), so the schema already provides parameter meaning. Per guidelines, baseline is 3 when schema coverage is high, so this score is appropriate.

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

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

The description clearly states 'Get Garmin activity weather by activity id' with a specific verb and resource. It adds the qualifier 'when available,' indicating that weather data may not exist for all activities. However, it does not distinguish itself from similar sibling tools like garmin_get_activity or garmin_get_activity_details.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention contexts in which weather data is typically available (e.g., outdoor activities) or suggest checking other tools first. Given the many similar sibling tools, usage guidance is lacking.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds only a disclaimer ('Not medical advice'), which is not behavioral. With strong annotations, minimal extra context is needed, so a baseline 3 is appropriate.

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

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

The description is two short sentences, front-loaded with the purpose. Every word is necessary; the disclaimer is justified for health data. No 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 the existence of an output schema and comprehensive annotations, the description is largely complete for a simple data retrieval tool. It could be slightly more descriptive about the report content (e.g., charge, status), but the minimal description is adequate for the context.

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

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

The input schema covers 67% of parameters with descriptions, including defaults and examples for 'date', 'privacy_mode', and 'response_format'. The tool description does not add any additional meaning beyond what the schema provides, so baseline 3 is correct.

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

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

The description clearly states the verb 'Get' and the resource 'Garmin Body Battery daily report', specifying scope 'for a date'. It distinguishes from sibling 'garmin_get_body_battery_events' which likely provides event-level data.

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

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

The description provides no guidance on when to use this tool versus siblings like 'garmin_get_body_battery_events' or others. The only extra line is a disclaimer 'Not medical advice', which does not address usage 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 safe, idempotent, and non-destructive behavior. The description adds minimal value beyond a disclaimer; no additional behavioral details are needed given good annotations.

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

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

Two sentences, concise and front-loaded with the purpose. The disclaimer is not about tool function but is brief; slightly more detail could be beneficial but not detrimental.

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 3 parameters with enums and an existing output schema, the description is minimal. It does not explain what body battery events are or how to interpret them, but the output schema compensates somewhat.

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

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

Schema coverage is 67% with clear parameter descriptions. The description does not add parameter-specific meaning, so baseline score of 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?

The description clearly states the verb 'Get' and the specific resource 'Garmin Body Battery charge/drain events' with a date scope, distinguishing it from sibling tools like garmin_get_body_battery_day which likely returns overall body battery 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?

No guidance on when to use this tool versus alternatives like garmin_get_body_battery_day or garmin_get_sleep_day. Lacks context for optimal usage 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, indicating a safe read-only operation. The description adds minimal extra context, only stating what the tool does. It does not mention privacy implications, parameter effects, or rate limits. Since annotations cover the safety profile, a 3 is appropriate.

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

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

The description is a single, concise sentence that front-loads the purpose. No wasted words; every part is 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?

While an output schema exists (so return values are handled), the description does not differentiate from the sibling garmin_daily_summary tool, nor does it explain when to use this vs. more granular day-specific tools. It provides adequate purpose but lacks integration context.

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

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

Schema description coverage is 67% (2 of 3 parameters have descriptions in the schema). The tool description does not add any further meaning beyond what the schema already provides. Baseline 3 is correct as the schema does most of the work.

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

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

The description clearly states the verb 'Get', the resource 'Garmin daily movement and wellness summary', and the scope 'for a date'. It distinguishes from specialized sibling tools like garmin_get_steps_day and garmin_get_sleep_day by offering an aggregated 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 provides no guidance on when to use this tool versus alternatives such as garmin_daily_summary or individual day metrics tools (e.g., garmin_get_steps_day). No when-not-to-use or exclusion criteria are mentioned.

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

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

The description states the tool retrieves data, which aligns with readOnlyHint=true and destructiveHint=false from annotations. However, it adds no additional behavioral context beyond what is obvious from the name and annotations (e.g., data freshness, rate limits). With good annotation coverage, a score of 3 is adequate.

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

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

The description is a single sentence plus a brief disclaimer, with no wasted words. It is front-loaded and immediately conveys the core functionality.

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

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

The description is minimal for a tool with 3 optional parameters and an output schema. It does not explain how privacy_mode or response_format affect output, though the output schema likely covers return values. Given the low complexity, a score of 3 reflects adequate but not rich completeness.

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

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

Schema description coverage is 67% (2 of 3 parameters have descriptions). The tool description does not add any meaning beyond what the schema already provides. For parameters like privacy_mode and response_format, the description could clarify their impact but does not.

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

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

The description clearly states the verb (Get), resource (daily heart-rate samples and resting heart-rate context), and scope (for a date). The added disclaimer 'Not medical advice' further clarifies the tool's purpose. It is easily distinguishable from sibling tools like garmin_get_steps_day or garmin_get_sleep_day.

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

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

The description provides no guidance on when to use this tool vs. alternatives, nor does it mention prerequisites or exclusions. With many sibling tools for different health metrics, explicit usage direction is missing.

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 openWorldHint. The description adds value by noting that data is returned only when available ('when available') and specifies it is overnight HRV metrics, which are behavioral traits beyond annotations. No contradictions with annotations.

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

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

The description is a single, front-loaded sentence plus a brief disclaimer, with no wasted words. It efficiently conveys the core purpose and constraints.

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 presence of an output schema (which covers return values), the description is sufficiently complete. It mentions the key behavioral trait (data availability) and the specific metric type (overnight HRV). Minor gaps like prerequisites are not critical, as sibling tools handle connectivity.

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

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

Schema description coverage is 67% (2 of 3 parameters have descriptions). The description does not add meaning beyond the schema; it simply ties parameters together. Baseline is 3, and credit is not given for redundant info.

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

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

The description clearly states the verb 'Get' and the specific resource 'Garmin HRV status and overnight HRV metrics' with a scope 'for a date when available', distinguishing it from sibling tools that focus on other metrics. The disclaimer 'Not medical advice' adds clarity.

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

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

The description provides no guidance on when to use this tool versus alternatives like garmin_get_heart_day or garmin_get_sleep_day. It only states 'when available', which implies data existence but does not offer explicit when-to-use or when-not-to-use instructions.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering safety and idempotency. The description adds minimal behavioral context with 'when available', hinting at potential data absence. Adequate given annotation coverage.

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

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

The description is a single, concise sentence with no redundant information. It front-loads the verb and resource, making it efficient for an AI agent to parse.

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

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

Given the presence of comprehensive annotations and an output schema, the description is sufficiently complete for a simple daily hydration getter. It lacks details about units or data format, but the output schema presumably covers that.

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

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

The input schema provides detailed descriptions for 'date' and 'privacy_mode' (67% coverage). The tool description does not add any further parameter meaning beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'Get' and the resource 'Garmin hydration summary for a date'. It specifies the data type and temporal scope, effectively distinguishing from sibling tools targeting other metrics 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?

The description implicitly indicates when to use this tool: when hydration data for a specific date is needed. No explicit exclusion or alternatives provided, but the context of sibling tools makes the intent clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. The description adds no extra behavioral context (e.g., data freshness, error handling), but does not contradict annotations. With rich annotations, this is minimally adequate.

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

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

The description is a single sentence, but it is so brief that it misses opportunity to add context. It is not wasteful, but given 3 parameters and many siblings, it is under-specified.

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

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

Despite having an output schema and annotations, the description does not explain return values, error conditions, or how this tool fits with siblings. It is incomplete for a tool with multiple parameters and many related tools.

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

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

Schema coverage is 67%, with descriptions provided for all three parameters. The description does not add any meaning beyond the schema (e.g., does not clarify privacy_mode behavior or response_format nuances). Baseline given coverage is around moderate.

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 'Get Garmin intensity minutes for a date.' clearly states the action (get) and resource (intensity minutes) with a specific scope (date), distinguishing it from sibling tools like garmin_get_steps_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?

No guidance is provided on when to use this tool versus alternatives, prerequisites, or when not to use it. The description is a single generic statement without 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 readOnlyHint, openWorldHint, idempotentHint=true, so the burden is lower. The description adds 'when available', implying potential null result, but does not elaborate on behavior when device is not set or on authentication 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?

Single sentence, no extraneous text. Efficiently conveys the core purpose.

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

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

Despite an output schema existing, the description is too brief. It fails to explain what constitutes a 'primary training device', how it relates to other device data, or why this tool exists alongside garmin_list_devices. More context is needed for an agent to use it appropriately.

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

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

Schema description coverage is 67%, with two parameters having descriptions in the schema. The tool description adds no information about parameters, so it meets the baseline of not needing further 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?

The description clearly states 'Get the primary Garmin training device when available', specifying the verb, resource, and a condition. It distinguishes from sibling tools like garmin_list_devices by focusing on the 'primary' device.

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

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

No explicit guidance on when to use this tool versus alternatives such as garmin_list_devices. The description lacks context about the meaning of 'primary training device' and when it is appropriate to call this tool.

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 mark it as read-only, idempotent, and non-destructive. The description adds that privacy mode affects output, providing behavioral context beyond annotations without contradiction.

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

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

The description is a single, well-formed sentence that conveys the essential action without superfluous words.

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

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

While annotations and output schema cover safety and return types, the description lacks usage context and differentiation from sibling tools, making it moderately complete for a simple read tool.

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

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

Schema description coverage is 67%, and the description does not add significant parameter details beyond what the schema already provides. 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?

The description clearly states it retrieves the Garmin profile (specific resource) with a privacy mode qualifier, differentiating it from sibling tools for other data types or updates.

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 guidance on when to use this tool versus alternatives like garmin_get_user_settings or the similarly named garmin_profile_get, leaving the agent to infer.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds 'when available' indicating potential absence of data, and 'Not medical advice' is a disclaimer. This provides some extra context but does not significantly extend beyond annotations.

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

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

The description is a single sentence with a necessary disclaimer, efficiently conveying the core purpose without unnecessary details. It is front-loaded with the action and resource.

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 3 optional parameters and an output schema, the description is minimal. It does not explain what respiration data includes (e.g., RR intervals, breathing rate) or the implications of privacy_mode. Compared to sibling tools, it could benefit from more details, but output schema may compensate.

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

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

Schema description coverage is 67% (date and privacy_mode have descriptions; response_format does not). The tool description does not elaborate on param meanings or usage beyond schema, missing opportunity to clarify privacy_mode and response_format defaults or effects.

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

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

The description clearly states the verb 'Get' and the resource 'Garmin respiration data', with a condition 'for a date when available'. This distinguishes it from sibling tools like garmin_get_heart_day and garmin_get_sleep_day, avoiding tautology.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions 'when available' but does not specify prerequisites, limitations, or compare with similar tools like garmin_get_respiration_day v.s. garmin_get_stress_day.

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

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

Annotations already indicate safe, read-only, idempotent behavior. The description adds only a legal disclaimer ('Not medical advice.') and no additional behavioral context such as caching, rate limits, or data freshness.

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

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

The description is extremely concise with two sentences, no redundancy, and gets straight to the point.

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

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

For a simple getter with comprehensive annotations and an output schema, the description is minimally sufficient. However, it omits practical context like response format options or privacy mode effects, which the schema partially covers.

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

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

Schema coverage is 67% (two of three parameters have descriptions). The description adds overall return value context (sleep summary, stages, window) but does not elaborate on parameter details beyond the schema.

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

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

The description explicitly states the verb 'Get' and the resource 'Garmin sleep summary, stages and sleep window for a date.' It clearly distinguishes this sleep-specific tool from sibling tools that retrieve other health 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?

The description provides no guidance on when to use this tool versus alternatives like other daily health data tools (e.g., garmin_get_steps_day). It lacks context about prerequisites, limitations, or comparative advantages.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the description carries a lower burden. It adds the behavioral context 'when available', indicating data may not always be present, and the disclaimer 'Not medical advice'. This provides some additional transparency but not rich behavioral detail.

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

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

The description is extremely concise: two sentences that state the core purpose and a necessary disclaimer. Every word is meaningful, and the most critical information (action, resource, date scope) is front-loaded.

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

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

Given the tool's simplicity, a read-only SpO2 retrieval, and the presence of an output schema, the description is adequate but not thorough. It hints at data availability ('when available') but does not explain what happens if data is missing, how privacy modes affect output, or the impact of the 'raw' option. It covers the basics but leaves important operational details implicit.

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 schema description coverage at 67% (one parameter likely missing a description in the schema), the description adds no meaning beyond the schema. It does not mention or elaborate on any of the three parameters (date, privacy_mode, response_format), missing an opportunity to clarify usage or defaults. The baseline is 3 for high coverage, but here coverage is moderate and description contributes nothing.

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

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

The description uses a specific verb ('Get') and resource ('Garmin Pulse Ox / SpO2 data') and explicitly ties it to a date, distinguishing it from sibling tools that retrieve other health metrics like heart rate or sleep. The inclusion of 'when available' clarifies data availability constraints.

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

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

The description provides no guidance on when to use this tool versus alternatives. With over 30 sibling tools for different data types (e.g., steps, heart, sleep), there is no mention of use cases, prerequisites, or when not to use SpO2. The agent must infer from context alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds that it returns a summary chart, which is useful but does not disclose additional behavioral traits like data granularity or caching. With annotations covering safety, a 3 is appropriate.

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 redundant information. Every word is necessary: 'Get Garmin daily steps and summary chart for a date.' Perfectly concise.

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 an output schema present, the description need not detail return values. However, it does not clarify what a 'summary chart' entails (e.g., markdown table or image). The tool has 3 parameters and no required ones; the description is minimal but adequate for basic understanding.

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

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

Schema coverage is 67% (missing description for response_format). The description does not explain any parameters. However, the schema provides enums and defaults for all parameters, making them fairly clear. The description adds no extra meaning, so a baseline 3 is given.

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

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

The description clearly states the tool retrieves daily steps and a summary chart for a given date. The verb 'Get' and resource 'Garmin daily steps and summary chart' are specific. Among siblings like heart or sleep, the name and description distinguish it, but without explicit differentiation it loses a point.

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

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

No guidance is provided on when to use this tool versus alternatives like garmin_get_heart_day or garmin_get_sleep_day. The description implies it's for steps, but lacks explicit context or exclusion hints.

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 convey readOnlyHint, idempotentHint, destructiveHint, and openWorldHint. The description adds only a legal disclaimer ('Not medical advice'), which does not provide behavioral context beyond annotations.

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

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

The description is very concise: two sentences covering purpose and a necessary disclaimer with no wasted words.

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

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

The description lacks usage context such as prerequisites, error handling, or interpretation of results. However, the presence of an output schema reduces the need to explain return values.

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

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

With 67% schema description coverage, the tool description adds no additional meaning about parameters (date, privacy_mode, response_format) beyond what the 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?

The description explicitly states the action (Get) and resource (stress summary and samples for a date), clearly distinguishing it from sibling tools like garmin_get_steps_day or garmin_get_heart_day.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., other day-specific health metrics tools) or when not to use it.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering safety. The description adds minimal behavioral context: 'when supported by the device/account' and 'Not medical advice.' It does not describe return behavior, error cases, or data freshness. With annotations present, the description provides marginal added transparency.

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

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

Two sentences, 16 words total, front-loaded with the action. Every word earns its place; the disclaimer is appropriately separated. No wasted text.

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

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

Given the tool has 3 optional parameters with defaults and an output schema exists, the description is minimally complete. It lacks explanation of what 'training readiness' means, possible values, or how it differs from similar metrics. The output is not described, but the output schema compensates. Still, a bit more context would improve completeness.

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

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

Schema description coverage is 67%, and the parameter names and schema descriptions already convey meaning (date format, privacy modes, response format). The tool description adds no additional explanation or examples beyond what the schema provides. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the verb ('Get'), the resource ('Garmin training readiness'), and the scope ('for a date when supported by the device/account'). It distinguishes this tool from sibling tools like garmin_get_training_status_day by focusing on readiness specifically.

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 guidance on when to use this tool versus alternatives, no prerequisites mentioned beyond the vague 'when supported', and no exclusions or when-not-to-use advice. The description lacks context for proper tool selection among many similar 'get' tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, making the safety profile clear. The description adds only the aggregated nature and device support condition, which is already implied. It does not disclose rate limits, authentication nuances, or potential data gaps beyond device support.

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

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

The description is a single sentence plus a disclaimer, with no wasted words. It is front-loaded with the core action and immediately provides the key condition and legal caveat.

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

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

Given the tool's simplicity (read-only, idempotent, no destructive effects) and the presence of annotations, input schema, and output schema, the description adequately covers the purpose and major constraint. However, it does not explain what types of training status are included (e.g., load, focus) or how to interpret the output, though the output schema likely fills that 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?

The input schema covers all three parameters with descriptions, achieving 100% coverage based on the provided schema. The tool description adds no additional parameter meaning beyond what the schema already provides. A baseline score of 3 is appropriate given high schema coverage.

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

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

The description clearly states the verb 'Get', the resource 'Garmin aggregated training status', and the scope 'for a date when supported by the device/account'. The addition of 'Not medical advice' is a relevant disclaimer. It effectively distinguishes from sibling tools that retrieve specific metrics (e.g., steps, heart rate) by focusing on aggregated training status.

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

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

The description includes a conditional phrase 'when supported by the device/account', which hints at prerequisites but does not explicitly state when to use this tool vs alternatives like garmin_get_training_readiness_day or garmin_get_daily_summary. No when-not-to-use guidance or alternative tool references are provided.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds context about the type of data returned (units, display preferences) but does not go beyond what annotations cover.

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

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

Single sentence, front-loaded with the key action and resource, no wasted words.

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

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

Adequate for a simple read tool with good annotations and an output schema. Provides enough context about the data returned, though it could mention output format availability.

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

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

Schema description coverage is 67%; the description adds no additional parameter information beyond what the schema already provides. Baseline of 3 is appropriate.

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

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

The description clearly states the tool retrieves user settings and gives concrete examples (units, display preferences). It distinguishes itself from sibling tools like garmin_get_profile by specifying 'user settings' rather than profile data, but does not explicitly differentiate.

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

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

No guidance on when to use this tool versus alternatives like garmin_get_profile or other settings-related tools. Usage context is implied by the name but not explicitly stated.

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

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

Annotations already declare this as read-only, idempotent, and non-destructive. The description adds only 'Not medical advice,' which is a disclaimer, not a behavioral trait. It does not disclose rate limits, pagination, data availability conditions, or any side effects, adding minimal value beyond the annotations.

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

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

The description is exceptionally concise with two short sentences. The first sentence delivers the core purpose efficiently, and the second is a necessary disclaimer. No superfluous words 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 presence of an output schema and annotations covering safety, the description is largely complete for a simple read operation. It clarifies the data type (weight/body composition) and scope (date range). However, it lacks any mention of how the optional privacy_mode and response_format affect the output, which could be inferred from schema but would benefit from brief surface-level context.

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

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

Schema coverage is high (75%), so most parameters are already described in the input schema. The description adds no additional meaning or constraints beyond what the schema provides (e.g., date format defaults, privacy mode options). Baseline score of 3 is appropriate as the description does not compensate for the uncovered 25%.

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 weight/body-composition logs for a date range, using a specific verb ('Get') and resource ('Garmin weight/body-composition logs'). It distinguishes from the many sibling tools that focus on other data types or daily summaries, making the purpose immediately clear.

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

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

The description implies usage for retrieving historical weight data over a range, but provides no explicit guidance on when to use this tool versus alternatives (e.g., daily summary tools). It does not state when not to use it or mention any prerequisites, leaving the agent to infer context from the tool name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds behavioral context about pagination, date filters, and privacy modes, which are beyond what annotations provide. No contradictions.

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

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

The description is a single sentence that is front-loaded with the action ('List recent Garmin activities') and efficiently lists key capabilities. No wasted words.

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

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

For a tool with 10 parameters and an output schema, the description covers core features (listing, pagination, date filters, privacy) but omits mention of activity_type, explicit_user_intent, and the environment variable GARMIN_PRIVACY_MODE. It is adequate but not fully comprehensive.

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 90%, so the schema already documents most parameters. The description summarizes functionality (pagination, date filters, privacy) but does not add significant new meaning beyond the schema's 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 clearly states the tool lists recent Garmin activities, distinguishing it from siblings like garmin_get_activity (single activity) and garmin_get_activity_details (details for one). It specifies supported features (pagination, date filters, privacy modes), making it unambiguous.

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

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

The description implies when to use this tool (for multiple activities) but does not explicitly contrast with alternatives like garmin_get_activity or garmin_daily_summary. No exclusions or when-not-to-use guidance is provided.

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

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

Annotations (readOnlyHint, idempotentHint, destructiveHint false) already cover safety and side effects. The description adds no behavioral context beyond listing devices, which is adequate but not enhanced.

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

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

The description is a single, efficient sentence with no redundant information, achieving maximum conciseness.

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

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

Given the output schema and annotations, the description is minimally complete but lacks details on filtering, pagination, or parameter effects. It suffices for basic usage but could be improved.

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

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

Schema coverage is 67%, and the description does not elaborate on parameters beyond what the schema provides. Baseline 3 applies as the schema carries most of the load.

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

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

The description clearly states the tool lists devices registered to the Garmin account, using a specific verb and resource, and distinguishes it from sibling tools that focus on activities, settings, or other data.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it specify prerequisites or exclusions. Users must infer its purpose from the name and minimal text.

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

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

Annotations already declare readOnlyHint=true, and the description reinforces 'Read-only' while adding context about return contents (11 questions, profile state, missing fields) and shared profile reuse across connectors, going beyond the annotations.

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

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

The description is four sentences, front-loaded with the core purpose, then workflow, then sharing context. Efficient with no wasted words, though slightly redundant with 'Read-only' earlier and later implied.

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

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

The description covers purpose, workflow, and cross-connector reuse, but lacks details on the meaning of 'missing critical fields' and how response_format affects output. Given no output schema, slightly more detail would improve completeness.

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

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

Schema coverage is 50% per context, but both parameters have semantic descriptions in the schema. The tool description does not add any extra meaning for parameters beyond what the schema provides, so it meets the baseline but does not exceed.

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

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

The description clearly states the tool returns the 11-question Delx wellness onboarding flow plus shared profile state and missing fields, distinguishing it from sibling tools like garmin_profile_get and garmin_quickstart by specifying shared-profile reuse across connectors.

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

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

Explicitly instructs the agent to ask questions one-by-one and then call garmin_profile_update with explicit_user_intent=true, and mentions alternative {connector}_onboarding tools, providing clear when-to-use and workflow guidance.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the bar for transparency is lower. The description adds that secret values are not revealed, which is useful. However, it does not mention authorization requirements, rate limits, or other behavioral details beyond what is implied.

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 of 15 words that clearly communicates the tool's purpose. Every word is necessary, no redundancy.

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

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

The tool has an output schema, so return values are defined elsewhere. However, the description could be more complete by mentioning that the tool is safe to call multiple times (idempotent) and that it requires no credentials beyond the local environment. Given the low complexity, a score of 3 is 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?

The schema has no parameter descriptions (0% coverage), and the tool description does not mention the 'response_format' parameter or its effect. This leaves the agent without guidance on how the parameter influences output, despite it being the only parameter.

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

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

The description clearly states the tool returns a specific set of privacy-related information (local privacy, cache, token-path, env-presence posture), distinguishing it from siblings like garmin_cache_status or garmin_auth_instructions. The verb 'return' is precise.

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

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

The description implies usage for auditing privacy posture, but does not provide explicit guidance on when to use this tool over siblings (e.g., garmin_cache_status). No when-not-to-use or alternative recommendations.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds context about the shared profile location and cross-connector nature, but does not disclose what happens if the profile is missing or other edge cases. Since annotations cover the safety profile, the description adds sufficient value.

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

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

The description is three sentences, concise and well-structured. The first sentence states the action, the second lists returned data, and the third provides cross-connector context. It is efficient with no wasted words.

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

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

Given no output schema, the description covers the types of returned data (preferred name, goals, etc.) but does not specify exact fields or structure. It lacks information on error conditions or missing profile. The presence of a similarly named sibling adds ambiguity. Overall, adequate but with gaps.

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

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

The schema has 0% description coverage, yet the description does not explain the single parameter 'response_format' (enum: markdown/json, default: markdown). The parameter controls output format, which is important for an AI agent to know. The description misses this opportunity to add meaning beyond the schema.

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

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

The description clearly states it reads a shared wellness profile and lists the types of data returned. It mentions cross-connector availability, which aids in distinguishing from other MCP tools, but does not explicitly differentiate from the similarly named sibling 'garmin_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?

The description does not provide guidance on when to use this tool versus alternatives like 'garmin_get_profile' or other profile-related tools. It only implies usage for reading the shared profile, with no explicit when-to-use or when-not-to-use statements.

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?

Given annotations are largely false (not readonly, not destructive, not idempotent), the description adds value by clarifying it never stores secrets, lists allowed top-level keys, and mentions validation rejection. It does not, however, describe side effects like file creation or concurrency behavior.

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

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

The description is five sentences long, front-loading the purpose and requirement, then listing fields, constraints, and context. Every sentence adds unique value without redundancy.

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

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

For a write tool with nested parameters and no output schema, the description thoroughly covers input constraints and behavior. The only gap is the lack of information about the return value or success/failure indicators.

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

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

Schema coverage is high (67% with descriptions), and the description significantly enriches the patch parameter by enumerating valid top-level keys and subfields of profile. This provides concrete guidance beyond the generic schema definition.

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

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

The description explicitly states the tool persists a partial patch to a shared wellness profile, listing top-level fields and distinguishing from sibling tools like garmin_profile_get by highlighting its cross-connector nature and update role.

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

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

It clearly requires explicit_user_intent=true but does not explicitly state when to use this tool versus alternatives. While it implies the tool is for writing and others for reading, no direct comparisons or exclusions are provided.

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

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

Annotations indicate readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds value by specifying it's a 3-step walkthrough that adapts to the user's current state, which is beyond what annotations provide. No contradictions.

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

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

The description consists of two concise, front-loaded sentences with no wasted words. Every sentence adds value.

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

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

Given the tool's simplicity and lack of output schema, the description adequately covers purpose, usage, and behavioral aspects. It could mention the return format but the purpose is clear enough.

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% for the single parameter (response_format). The description does not mention this parameter or add any meaning beyond the schema enum. As coverage is low, the description fails to compensate.

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's a 'Personalized 3-step setup walkthrough for the human user' that adapts to current state. This distinguishes it from sibling tools like garmin_auth_instructions and garmin_onboarding by focusing on a step-by-step quickstart process.

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

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

The description explicitly says 'Call this first when the user asks 'how do I connect Garmin?'' providing a clear trigger for usage. While it doesn't list alternatives or exclusions, the context is sufficient for this kind of tool.

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

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

Annotations already indicate readOnlyHint=true; the description adds 'Read-only and non-medical' but provides limited behavioral context beyond that (e.g., no details on data freshness, handling of missing data, or output format).

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

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

The description is a single sentence that conveys the tool's purpose and constraints without any fluff, making it highly concise and well-structured.

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

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

Given the tool's simplicity, the presence of an output schema, and annotations covering read-only behavior, the description adequately frames the tool, though it could mention more about the output report format.

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

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

Schema coverage is 75%, and the description adds no further meaning to parameters beyond what the schema already provides, so baseline score of 3 is appropriate.

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

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

The description clearly states it builds a 'weekly Garmin scorecard' and lists specific metrics (movement, sleep, HRV, stress, Body Battery, bottlenecks, actions), distinguishing it from daily summaries or individual metric tools.

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

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

The description implies use for weekly overviews but does not explicitly mention when to prefer this over siblings like garmin_daily_summary or individual getters, nor does it provide exclusion criteria.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and destructiveHint false. The description adds context by explaining the transformation into a shared shape for recommendations, which goes beyond the annotations without contradicting them.

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

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

A single sentence of 20 words is highly concise and front-loaded with the verb. No extraneous information is included.

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 and annotations are present, reducing the burden. The description mentions the key data sources, but lacks detail on normalization logic and optional parameters. Still, it is sufficient for a well-documented 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 only 33% (2 of 6 parameters described). The description does not explain any parameters, failing to compensate for the low coverage. Parameters like notes, soreness, and injury_flags are left undocumented.

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

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

The description clearly states the verb 'normalize' and the specific resources (readiness, sleep score, Body Battery, movement load) into a shared shape for recommendation engines. This distinguishes it from sibling getters by indicating aggregation/normalization.

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

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

The description implies usage when normalized wellness context is needed, but does not explicitly state when to use this tool versus alternatives (e.g., specific data retrieval tools). No when-not or alternative guidance is provided.

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