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

The description adds behavioral context beyond the readOnlyHint annotation by detailing the output (per-metric change, percent change, improved/declined/unchanged assessment). No contradiction with annotations; readOnlyHint is consistent with a read-only comparison operation.

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

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

The description is two concise paragraphs. The first paragraph states purpose and output, the second explains date format and usage. No unnecessary words; every sentence adds value. Front-loaded with key 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 complexity of 4 required string parameters with flexible date formats and the presence of an output schema, the description provides sufficient context: it explains the date format variety, the baseline logic, and the metrics covered. No gaps for an AI agent to correctly invoke the tool.

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

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

The input schema has 0% description coverage, but the description explains that all four parameters accept the same flexible date expressions (e.g., 'today', 'yesterday', 'last week') and provides an example. This adds significant meaning beyond the bare schema, though per-parameter specifics could be more explicit.

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 compares two date ranges across specific health metrics and provides per-metric change, percent change, and an assessment. This distinguishes it from sibling tools like 'get_daily_summary' and 'get_health_overview' which do not perform comparisons.

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

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

The description explains that Period A is the baseline and Period B is compared against it, and provides examples of acceptable date expressions (e.g., 'last week', 'YYYY-MM-DD') and a usage example ('compare last month to this month'). It does not explicitly mention when not to use or compare to alternative tools, but the guidance is clear for typical use.

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

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

Discloses browser interaction, 3-minute wait, and fallback behavior if credentials missing. Annotations add context but description provides crucial behavioral details.

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 key action and conditions, 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?

Covers trigger, behavior, timeout, and prerequisites. Return value not described but output schema exists to cover 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?

No parameters, so description need not add param info. Baseline 4 applies because schema coverage is 100% and no param details are needed.

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

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

Clearly states the tool connects or re-authorizes a WHOOP account, using specific verbs. Distinguishes from sibling data retrieval and analysis tools.

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

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

Explicitly states when to call: only when user asks to connect, reconnect, or fix authorization. Also notes prerequisite of configured WHOOP credentials.

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?

Explicitly states no data is uploaded, describes output files and their contents, and warns about processing time. Annotations are consistent; adds safety and scope details beyond structured fields.

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

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

Extremely concise with no filler. Front-loaded with action and outputs, then safety, then parameter details. 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 three parameters, existing output schema (implied by description), and sibling context, the description covers all needed information for an agent to invoke correctly.

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

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

With 0% schema description coverage, the description fully explains each parameter: date formats for start/end and purpose of include_raw. This compensates entirely for schema's lack of 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 specifies the exact action (export), the resource (WHOOP records in date range), and the output (three local files). It clearly distinguishes from sibling getter tools that fetch single items or summaries.

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

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

Provides clear context for date parameters and performance warning for large ranges. While it doesn't explicitly state when not to use, the description implies this is for bulk exports, contrasting with sibling tools for single queries.

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, so the description's job is to add context beyond that. It does so by specifying supported id forms (day, sleep, workout, etc.), but does not disclose error handling, permissions, or response behavior. The value added is moderate.

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 short sentences with no extraneous information. It front-loads the core purpose and provides the critical id format details efficiently, earning each word's place.

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

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

With an output schema available, the description does not need to explain return values. It sufficiently covers the tool's purpose, input, and usage context. Minor omission: no mention of prerequisites or error conditions, but for a simple fetch with readOnlyHint, this is nearly complete.

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

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

Despite 0% schema description coverage, the description fully compensates by detailing all valid id formats: 'day:YYYY-MM-DD, sleep:<uuid>, workout:<uuid>, cycle:<int>, recovery:<cycle_int>, profile.' This adds crucial meaning beyond the schema's type 'string' alone.

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

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

The description clearly states the tool fetches a full document for an id returned by `search`, with specific verb ('fetch') and resource ('WHOOP document'). It distinguishes itself by being a generic fetcher for any id, setting it apart from the many get_* sibling tools that target specific document types.

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 context by saying to use ids from `search` and lists supported id formats, but it does not explicitly state when to use this tool versus alternatives like get_workout or get_sleep. No exclusions or when-not-to-use guidance is given, making it adequate but not explicit.

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 aligns with this by describing a mapping operation. No additional behavioral details are added beyond what annotations provide, but there is no 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 two sentences long, front-loads the purpose and usage context, and contains no redundant information. Every sentence earns its place.

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

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

Given the single parameter and existence of an output schema (not shown but noted), the description adequately covers the tool's purpose and use case, though it does not detail the output 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?

The description adds meaning to the parameter 'activity_v1_id' by explaining it is a legacy WHOOP v1 identifier, and states the result is a v2 UUID, which compensates for the 0% schema description coverage.

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

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

The description explicitly states 'Map a legacy WHOOP v1 activity id to its v2 UUID', clearly identifying the verb (map) and resource (activity id), and distinguishes from sibling tools which focus on other data retrieval or analysis.

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

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

The description provides clear context: 'Useful when older exports, links, or integrations refer to an activity by v1_id', indicating when to use the tool, though it does not explicitly mention when not to use it or suggest 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?

Discloses behavioral traits beyond the readOnlyHint annotation: lists specific checks (app credentials, token state/expiry, granted scopes, live API check). No contradiction 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?

Two succinct sentences: first describes what the tool does, second gives usage guidance. 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 zero parameters, an output schema exists (implied), annotations are present, and description covers both purpose and usage. Tool is simple and fully specified.

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

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

No parameters exist, so schema coverage is 100%. Description adds no param info, but none is needed. Baseline score of 4 is appropriate for zero-parameter tools.

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?

Describes exactly what it checks (credentials, token state, scopes, live API) and distinguishes itself with the specific instruction to call it first when WHOOP data tools fail, making its purpose clear and distinct from sibling tools.

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

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

Provides explicit guidance on when to use ('call this first when WHOOP data tools fail'), but does not mention when not to use or list alternatives among siblings, though the context is already strong.

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, so no mutation concerns. The description adds behavioral context: day-to-day analysis, Pearson r, strength labels, plain-English interpretations. 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 paragraph that front-loads the main purpose and lists correlations. It is concise with no extraneous words. Could be structured with bullet points for readability, but not necessary.

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

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

Given the existence of an output schema (not shown), the description does not need to detail return format. It provides enough context on the nature of correlations and interpretation. The missing parameter link reduces completeness slightly.

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 only parameter 'days' has default 90 and no schema description (0% coverage). The description mentions '7-180 day window' but does not explicitly state that the parameter controls the window length. This is a gap for a single-parameter tool.

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

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

The description clearly states the tool computes how user metrics move together day-to-day over a 7-180 day window. It lists specific correlations (strain vs recovery, etc.) and distinguishes from sibling trend tools like get_recovery_trends which show individual trends, not relationships.

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 the time window and includes a caution ('correlation, not causation'). It implies usage for understanding pairwise relationships between metrics, but does not explicitly contrast with sibling tools. Slightly improved by stating when to use alternatives like get_recovery_trends.

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 confirms the read-only behavior (consistent with readOnlyHint annotation) and explains the optional parameters' effects, including the include_raw flag for raw API records. 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?

Two sentences, front-loaded with the main purpose, no unnecessary 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 has 4 parameters, an output schema exists, and annotations are provided, the description fully covers the key behavior and optional features. No 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?

With 0% schema description coverage, the description compensates by explaining three parameters: include_recovery, include_sleep, and include_raw. It adds context beyond the schema titles, though cycle_id is not explicitly described (but is clear from context).

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 'one cycle by id', and the optional inclusions of recovery and sleep. This distinguishes it from sibling tools like 'get_cycles' (plural) and others that fetch different 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 explains when to include recovery, sleep, and raw data, providing context on WHOOP's data relationships. However, it does not explicitly state when to use this tool vs. alternatives like 'get_cycles', though the singular nature implies 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=true, so the description adds value by noting the newest cycle is usually in progress and the default date range. It does not contradict annotations and provides behavioral context beyond the structured fields.

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

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

The description is concise with two sentences in the first paragraph and a second paragraph for parameter details. It is front-loaded with purpose and ordering, then parameter guidance, with no unnecessary words.

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

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

Given the output schema exists (return values likely documented there), the description covers purpose, ordering, default range, and parameter formats completely. It is sufficient for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It thoroughly explains the accepted formats for start and end parameters, adding significant meaning. However, the limit parameter is not described, leaving a small gap.

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

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

The description clearly states the tool lists physiological cycles (WHOOP's wake-to-wake days) with specific data fields (strain, calories, heart rate) and ordering (newest first). It distinguishes from sibling tools like get_cycle (singular) and get_daily_summary (daily aggregates).

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

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

The description specifies default behavior (last 14 days) and explains accepted date formats for start/end parameters. While it doesn't explicitly state when not to use or compare with alternatives, the context implies it's for listing multiple cycles, and the parameter guidance is clear.

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

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

The description adds context by listing the data components returned, but readOnlyHint already indicates no destructive behavior. The description does not cover other behavioral aspects like auth requirements or rate limits, so score 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 three sentences, front-loaded with the core purpose and key information. Every sentence adds value without redundancy.

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

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

Given the presence of an output schema, the description sufficiently covers the tool's inputs and outputs. It explains the parameter format and lists the data types returned. For a single-parameter tool, it is complete.

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

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

With 0% schema description coverage, the description compensates well by detailing the day parameter's accepted formats: 'today | yesterday | N days ago | YYYY-MM-DD'. However, it could be more exhaustive (e.g., range or relative days).

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 one day of WHOOP data with specific components (recovery, sleep, strain, workouts, summary). It also distinguishes itself as the best first tool for common queries, setting it apart from sibling tools.

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

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

The description explicitly recommends this tool for 'how am I doing' or 'how did I sleep' questions, providing clear guidance on when to use it. It also explains the day parameter format. However, it does not explicitly mention when not to use 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 declare readOnlyHint=true. The description adds the specific window (7-180 days) and the content (trends, correlations, etc.), providing meaningful behavior context beyond annotations. No contradictions.

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

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

Two sentences, no wasted words. Front-loaded with purpose, then details content. Every sentence earns its place.

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

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

For a tool with one optional parameter and existing output schema, the description provides sufficient context: window range, content types, and recommended usage. Complete for an agent to understand what the tool returns.

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?

Only one parameter 'days' with default 90, but schema description coverage is 0%. The description implies the parameter controls the window with '7-180 day window', but does not explicitly mention the parameter name, default, or that it's optional. Partially compensates for missing schema descriptions.

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

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

The description clearly states the tool provides a holistic overview of health metrics (status, trends, training load, personal records, correlations) over a 7-180 day window. It uses specific verbs and distinguishes itself from sibling tools by calling it the 'best first call' for a full picture.

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

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

Explicitly says it's the best first call for 'give me the full picture of my health', indicating when to use. Does not explicitly list alternatives or when not to use, but the context of sibling tools like get_recovery_trends implies specificity. Slight improvement possible.

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 and openWorldHint=false, and the description adds behavioral context by listing the types of records (best/worst recovery, HRV, etc.) and the valid window range (7-180 days). This provides value beyond the annotations, though it does not detail output structure or computation.

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, readable sentence that front-loads the key action and lists examples. 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 single optional parameter and the existence of an output schema, the description provides a good overview of the tool's capabilities (window, types of records). It is complete enough for an agent to understand what the tool returns and how to use it.

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 'days' parameter. The description clarifies its purpose as the window size and specifies the allowed range (7-180 days), adding meaning beyond the schema's 'Days' label.

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 'bests, worsts, and streaks' over a customizable window (7-180 days) and lists specific examples like recovery, HRV, sleep, strain, etc. This distinguishes it from sibling tools like get_recoveries or get_sleeps, which focus on individual 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 implies usage for viewing aggregated personal records and streaks, but does not explicitly state when to prefer this over specific sibling tools (e.g., get_recoveries) or when not to use it. Usage context is implied but not fully clarified.

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, confirming safety. The description adds that include_raw=true attaches raw records, providing some behavioral context beyond annotations. However, it lacks details on authentication requirements, rate limits, or response size.

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 tightly written sentences with no unnecessary words. First sentence covers purpose and data returned; second sentence explains the optional parameter. 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 tool's simplicity (one optional param) and presence of an output schema, the description covers essential usage. Could be slightly improved by explicitly stating the return includes standard profile fields, but overall complete.

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

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

Despite 0% schema description coverage, the description explains the sole parameter include_raw: setting it to true attaches untouched profile and body-measurement records. This adds clear semantics beyond the schema's default value.

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 the user's WHOOP profile and body measurements, listing specific fields (name, email, height, weight, max heart rate). This distinguishes it from sibling tools like get_cycle or get_sleep that focus on other resources.

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 fetching profile info, but provides no explicit guidance on when to use this tool versus alternatives like fetch or get_connection_status. No exclusions or alternative suggestions are given.

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

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

Annotations already declare readOnlyHint=true, and the description adds behavioral context: it returns specific metrics, orders newest first, and defaults to a 14-day range. No contradiction exists.

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

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

Two short sentences with essential information front-loaded: the action, resource, fields, ordering, and defaults. 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 existence of an output schema, return values need not be explained. However, with 0% schema coverage and 3 parameters, the description should mention the limit parameter and possible pagination. The default 14-day range is useful but not complete.

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

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

The description explains the start and end parameters with concrete allowed values (today, yesterday, etc.), which are not in the schema. However, the limit parameter is not described, and with 0% schema coverage, this is a gap.

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

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

The description clearly states the tool lists recovery records with specific metrics (recovery %, HRV, etc.) and specifies newest-first ordering. While it doesn't explicitly differentiate from sibling tools like get_recovery_trends, the focus on individual records is implied.

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

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

It provides default behavior (last 14 days) and acceptable date formats for start/end. However, it lacks guidance on when to use this tool over alternatives (e.g., get_recovery_trends) and doesn't mention the limit parameter's role or limitations.

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 readOnlyHint=true. The description adds that trend directions account for metric polarity (rising HRV good, rising RHR bad), which is useful behavioral context beyond annotations. Still lacks details on edge cases like days outside 7-180.

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

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

Two sentences, no waste. Front-loaded with purpose and immediately provides specifics. Every word earns its place.

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

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

Given the output schema exists (not shown), the description covers the key aspects: metrics, window, polarity. Could mention the return format lightly, but overall sufficient for a one-param trend 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?

Only one parameter (days), and schema description coverage is 0%. The description implicitly documents the valid range (7-180 days) but does not mention the default of 30 days, which is in the schema. For a single parameter with no enums, this is adequate compensation.

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 lists specific metrics (recovery %, HRV, resting heart rate) and outputs (statistics, trend direction, unusual days, daily table), distinguishing it from siblings like get_recoveries which likely returns raw recovery points.

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

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

No explicit when-to-use or when-not-to-use guidance. The description implies it's for aggregated trend analysis over a window, but does not mention alternatives like get_recoveries for raw data.

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 readOnlyHint=true. Description adds value by explaining the include_raw parameter attaches the raw WHOOP record, beyond what annotations provide.

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

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

Two sentences, no wasted words. Front-loaded with primary purpose, then optional behavior.

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 output schema exists and low complexity, description sufficiently covers ID sourcing and optional raw data retrieval. Complete for a get-by-id 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 coverage, the description fully explains both parameters: sleep_id as UUID from specific sources, include_raw as attaching raw record. Compensates completely.

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

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

Clearly states 'Get one sleep record by its UUID' with specific resource and identification method. Distinguishes from sibling tools like get_sleeps.

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

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

Provides clear context on sourcing the UUID (from get_sleeps or recovery's sleep_id) and optional include_raw parameter, but does not explicitly state when not to use it.

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

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

Adds behavioral details beyond annotations: sorting (newest first), default range, and accepted date formats. Annotations declare readOnlyHint=true, and description is consistent.

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 front-load purpose, then provide usage details. 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?

Covers purpose, parameters, defaults, and ordering. Output schema exists. Could mention sibling tools for more context, but within scope it 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?

Schema coverage is 0%, but description adds significant meaning for start/end parameters with accepted formats. However, include_naps and limit are not explained beyond their names.

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

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

Description clearly states the verb (List) and resource (sleep records) and lists included fields. However, it does not explicitly differentiate from sibling tools like get_sleep or get_sleep_stream.

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

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

Provides default behavior (last 14 days) and acceptable date formats, but no explicit guidance on when to use this tool vs alternatives like get_sleep or search.

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 adds value beyond readOnlyHint by detailing the return data (heart rate, skin temperature, lowest heart rate, timestamp) and the behavior when the stream is unavailable. It also mentions the include_raw option. A slight deduction for not explicitly stating that it is a single-record operation (one sleep), but that 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?

The description is concise with no redundant sentences. It front-loads the core purpose, then provides sourcing, availability note, and optional parameter guidance in a logical order.

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 complexity (3 parameters, output schema exists), the description covers input sourcing, parameter behavior, return data summary, and an edge case (unavailable stream). It is complete and self-contained.

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

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

Despite 0% schema description coverage, the description explains each parameter: sleep_id source, resolution_minutes as 'downsampled to resolution_minutes buckets', and include_raw as attaching the untouched payload. This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states it provides 'minute-level overnight sensor data for one sleep' with heart rate and skin temperature curves, plus stats. It also specifies how to obtain the sleep_id, distinguishing it from sibling tools like get_sleeps or get_daily_summary.

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

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

The description explicitly says 'Get the sleep_id from get_sleeps, get_daily_summary, or a recovery record' and notes that the stream may not be available for all accounts, with a clear note returned instead of an error. This provides when-to-use and when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, indicating a safe read operation. The description adds behavioral details: naps are counted but excluded from nightly averages, and the window range is 7-180 days. This goes beyond annotations to inform agents about data handling constraints.

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: the first front-loads the main purpose and covered metrics, the second adds a crucial detail about nap handling. Every part is informative with no redundancy.

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

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

Given the single optional parameter with default, the presence of an output schema, and annotations, the description covers all key aspects: metrics included, window range, and nap handling. No significant 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?

The input schema has 0% description coverage, but the description compensates by explaining that the 'days' parameter defines the window length (7-180 days). This adds essential meaning beyond the schema's default value and type.

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 sleep trends over a window (7-180 days) and lists specific metrics (hours slept, performance, efficiency, consistency, sleep debt, statistics, trend directions, unusual nights, nightly table). It distinguishes from sibling tools like get_sleep, get_sleeps, get_sleep_stream which are for single entries, multiple entries, or raw data.

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

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

The description implies usage for aggregated trend analysis over a period but does not explicitly state when to use this tool versus alternatives like get_sleep (single night) or compare_periods. The context is clear but lacks explicit when-not or exclusion 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?

Annotations already declare readOnlyHint=true, so the description adds behavioral context by specifying the returned data elements and the condition for the acute:chronic load ratio ('when enough data exists'). No contradiction 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?

A single sentence efficiently communicates all essential information: what the tool does, the data window, and specific data returned. No extraneous words, front-loaded with key purpose.

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

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

Given that an output schema exists (not shown but indicated), the description does not need to detail return structure. It covers the tool's purpose, parameter range, and a conditional aspect. Slightly more context about prerequisites or data source could be added, but overall 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?

With schema description coverage at 0%, the description adds meaning by specifying the valid range ('7-180 days') for the 'days' parameter, which is absent from the schema (only default and type). This clarifies usage 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 specific verbs and nouns: 'Strain and training-load trends' with a defined window, and lists all data components (daily strain, calories, workout totals, acute:chronic ratio). It clearly distinguishes from sibling tools like get_recovery_trends and get_sleep_trends by focusing on strain and load.

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 trend analysis over a customizable time window (7-180 days), but does not explicitly state when to use this tool versus alternatives such as get_daily_summary or get_correlations. No when-not-to-use or exclusion criteria 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 declare readOnlyHint=true, so no destructive behavior. The description adds detail on output structure (per-day grid, weekly averages, workout totals) beyond annotations, but does not mention other behavioral aspects like pagination or rate limits, which are not needed given the simple read-only 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?

The description is concise (two sentences plus a parameter note), front-loading the core purpose. Every sentence adds value with no redundancy.

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

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

Given the tool's simplicity (one optional parameter, read-only, output schema exists), the description sufficiently covers what the tool does, its output content, and how to use the parameter. No gaps remain for the agent to make an informed call.

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, but the description explicitly explains the 'week_of' parameter with acceptable formats ('this week', 'last week', 'YYYY-MM-DD'), adding essential meaning beyond the bare schema.

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

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

The description clearly states it produces a 'Monday-to-Sunday report' with specific metrics (recovery, sleep, strain, weekly averages, workout totals), distinguishing it from siblings like get_daily_summary or get_sleep. The verb 'get' and resource 'weekly report' are well-defined.

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

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

The description provides clear parameter guidance ('week_of' accepts specific values), and the weekly nature implies use for weekly overviews. However, it does not explicitly state when to use this tool versus related siblings like get_recoveries or get_sleep_trends.

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. Description adds useful behavioral info: the effect of 'include_raw' parameter (attaches raw API record). No contradictions.

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

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

Two efficient sentences, no fluff, front-loaded purpose. 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?

Output schema covers return format. Description explains single-item retrieval and raw data option. Does not mention error handling or missing UUID scenarios, but overall adequate 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 has 0% description coverage. Description explains 'include_raw' parameter's effect, but does not describe 'workout_id' format or constraints beyond being a UUID. Partial compensation for schema gap.

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

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

Description clearly states 'Get one workout by its UUID', specifying verb, resource, and identifier. Distinguishes from sibling 'get_workouts' by referencing it as the source for UUID.

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?

Indicates that the UUID comes from 'get_workouts', implying proper usage flow. Does not explicitly state when not to use, but context is clear. A slight gap in excluding 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, so the description correctly implies no side effects. It adds value by specifying default time range, ordering, and filter semantics, which go 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 concise (4 efficient lines) and front-loaded with purpose. Every sentence adds value; no redundancy.

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

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

Given the 4 parameters, the description covers start, end, and sport well but omits 'limit'. An output schema exists but is not provided; the description does not need to cover return values, but the missing limit parameter is a minor gap.

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

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

Schema description coverage is 0%, but the description explains start/end date formats and sport substring matching. It does not mention the 'limit' parameter, which is present in the schema with a default. Overall, it compensates well for the missing schema descriptions.

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

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

The description clearly states the tool lists workouts with specific fields (sport, strain, calories, heart rate, distance, HR zones) and sorts newest first. It distinguishes from sibling tools like 'get_workout' (singular) and other data-retrieval 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 explains when to use: to list workouts with optional sport filter and date range. It provides default behavior (last 30 days) and date format options. However, it does not explicitly mention when not to use or suggest 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 declare readOnlyHint=true, description adds that it returns documents with IDs that can be passed to fetch, providing 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?

Single-paragraph description is efficient, front-loaded, and no unnecessary words. Slightly verbose but acceptable.

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 output schema existence and many sibling tools, description fully explains return type and integration with fetch tool, making it complete.

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

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

With 0% schema coverage, description compensates by clarifying that query is a natural-language string and gives examples, though lacks formal constraints.

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 tool performs search across WHOOP data using natural-language queries, with examples. It distinguishes from sibling tools which are specific getters.

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

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

Implicitly suggests use for broad queries, mentions returned documents can be fetched, but does not explicitly state when to use versus alternative specific getters.

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