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

With no annotations, the description carries the behavioral burden. It adds useful transparency by disclosing that the operation UID is the retry identity and that uncertain attempts are never re-sent, plus the durable-engine framing implies persistence. However, it does not state whether the tool has side effects, requires specific permissions, or what happens on success/failure beyond the conflict note.

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 compact and front-loaded with the main purpose, followed by three short sentences that carry substantive retry and conflict semantics. It avoids filler, though the second and third sentences are somewhat cryptic and could be clearer without adding length.

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 a complex nested input schema, the description omits essential context: how to construct operation and client_offer, what version negotiation entails, when to use this instead of recovery tools, and what external effects execution has. It is not complete enough for an agent to confidently invoke the tool correctly in many scenarios.

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 should compensate by explaining the top-level operation and client_offer parameters. It only obliquely references 'operation UID' and 'version-negotiated', without clarifying how to construct or select values for the two required object parameters. The description adds minimal parameter-level meaning beyond the raw schema.

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

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

The description uses a specific verb-resource pairing ('execute one ... typed operation') and names the durable engine, which makes the tool's core purpose identifiable. It does not explicitly differentiate itself from siblings like recover_operation or release_operation_risk, but 'execute' and 'durable engine' convey enough to separate it from the dominant getter 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 gives no guidance on when to use this tool versus alternatives such as recover_operation or get_operation_status. It implies usage for 'operations' but never states the trigger conditions, prerequisites, or when not to use it. The retry semantics are explained, but not as usage direction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does this well: it explains non-atomicity across separate HTTP reads, hash verification of local composite bytes, shape validation, manifest reporting of unit conflicts and time-axis ambiguity, raw device units for Tymewear VT/VE, and the source-completeness caveat. This is far richer than the structured fields alone.

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 dense but not bloated; each sentence adds a distinct fact about behavior, alternatives, or caveats. It is front-loaded with the core purpose. The paragraph format is harder to scan than bullets, but the information density justifies the length.

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 complex tool with no annotations and 0% schema coverage, the description covers usage context, alternative routing, data-shape guarantees, unit handling, and upstream limitations. The main gaps are the unexplained api_key and expected_athlete_id parameters, but the output schema and rich behavioral detail make the definition substantially complete.

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

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

Schema coverage is 0%, so the description must compensate. It adds meaning for stream_types as a filter and for start_index/end_index as a half-open sample range, and it mentions unit hints separately from source declarations. However, api_key, expected_athlete_id, and activity_id are not explained, leaving notable gaps for a 6-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 opens with a specific verb and resource: 'Export complete raw activity data to the configured local artifact.' It clearly distinguishes itself from the sibling read tools by positioning this as the full raw export, and it even names get_artifact_chunk as the retrieval path for clients without filesystem access. The purpose is 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 gives explicit context: 'Use this after a compact read when the client needs all stream samples and interval records.' It also names an alternative, get_artifact_chunk, for a specific condition. It does not exhaustively list when-not-to-use cases, but the guidance is clear enough for an agent to route 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?

With no annotations supplied, the description carries the full disclosure burden and does so thoroughly: it documents inclusive/exclusive date semantics, empty vs malformed responses, cursor snapshotting, cursor validity constraints, null completeness, and hidden source stub behavior. This is exceptional behavioral transparency.

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

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

The description is dense but every sentence earns its place, covering only substantive behavioral details. The main purpose is front-loaded, followed by targeted clarifications, with no repetition of schema-provided defaults.

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 remarkably complete for a tool with no annotations, addressing pagination, cursors, completeness, and edge-case response behavior. It leaves some parameter semantics unexplained, but the presence of an output schema reduces the need to describe return values, and the core call semantics are well covered.

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

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

Schema description coverage is 0%, so the description must compensate; it does add real meaning for start_date and end_date_exclusive (inclusive/exclusive) and cursor (validity constraints). However, several parameters such as limit, page_size, sports, timezone, and athlete_id are left to their schema names/defaults with no added semantics.

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 the specific verb 'List activities' and the resource, and immediately scopes it to a 'half-open local-date range with bounded paging.' This clearly separates it from sibling activity-level tools like get_activity_details or get_activity_streams, despite not naming them.

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 makes the list/query context clear, but it does not explicitly state when to choose this tool over alternatives like get_activity_details or get_events, nor does it mention exclusions. It provides clear usage context but no explicit routing guidance.

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

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

With no annotations, the description carries the full transparency burden. It discloses that the MCP preserves efforts and metadata, reports average units (W, bpm, m/s, or unknown), performs no FTP/VO2/numeric calculations, and that min_value may expand an effort while source completeness is unknown. This is substantive and beyond schema, though it omits error handling and authentication 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?

The description is moderately long but each sentence serves a purpose: it leads with purpose, then parameter constraints, then behavioral notes. It is front-loaded and structured logically, though slightly dense. It avoids fluff and stays focused on actionable details.

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 (10 parameters, output schema present), the description covers the most critical aspects: selector requirement, index sentinels, count limit, and behavioral guarantees. It doesn't explain every parameter (e.g., exclude_intervals) but the output schema handles return structure. Overall, an agent can call this tool correctly with the provided guidance.

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

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

Schema coverage is 0%, so the description must compensate. It explains duration/distance constraints, start_index/end_index semantics (including end_index=0 sentinel and None omission), count limits (1..100), and min_value's effect. It does not clarify api_key, exclude_intervals, or activity_id/stream directly, but the core selectors and indices are well documented, making the tool usable.

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 clear verb and resource: 'Find upstream best efforts by one duration or distance selector.' It specifies the operation (finding ranked efforts on a named stream from Intervals.icu) and distinguishes the selector requirement. While it doesn't explicitly compare to sibling tools, the purpose is unambiguous and distinct from related tools like get_activity_intervals or get_activity_streams.

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 a direct usage context: 'Choose this to ask Intervals.icu for ranked efforts on a named stream.' It also clarifies a critical constraint (exactly one of duration/distance required) and sentinel behaviors for end_index. However, it does not mention alternative tools or conditions when this tool should NOT be used, so guidance is partial.

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

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

With no annotations, the description carries the full disclosure burden and does so thoroughly. It states GET-only access, sample-count vs elapsed-time semantics, null/zero distinctions, ambiguous time axes, independence of metadata and stream failures, the 20-example cap, and respiratory unit caveats.

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

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

The purpose is front-loaded in the opening sentence and every later sentence carries a specific behavioral fact. The block is dense, but it lacks sectioning or bullet formatting, making it heavier than necessary.

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

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

Given that an output schema exists, the description provides the missing interpretive context: sampling semantics, limitations, unit conventions, and inference boundaries. It is complete for a read-only summarization tool with no annotations.

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

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

Schema description coverage is 0% and the description adds no explanation for the two parameters. The names activity_id and api_key are somewhat self-evident, but the description does not compensate for the schema gap or clarify how they should be supplied.

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

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

The first sentence identifies a specific verb and resource ('Summarize all returned stream samples and activity metadata') and 'GETs only' signals read-only. It is clear, but it does not explicitly differentiate the tool from siblings such as get_activity_streams or 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 is largely a list of behavioral caveats rather than usage guidance. It never states when an agent should choose this tool over sibling tools, nor does it describe circumstances that make the tool appropriate or inappropriate to call.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it does so thoroughly. It explains the 'partial' return behavior for source-hidden records, its implications for data availability, the behavior of include_intervals, and the semantic meaning of Tymewear-derived fields (VT, VE, BR). This goes beyond the schema and gives agents the context needed to interpret results safely.

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 front-loaded with the core purpose, followed by dense, high-value caveats and unit clarifications. Every sentence contributes essential information—no fluff, no repetition. The structure moves logically from purpose to edge cases to field semantics.

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 the tool (partial records, interval special cases, Tymewear unit semantics), the description covers all needed operational context. It does not need to explain return values because an output schema exists. The guidance on when to use alternative tools and how to interpret edge cases makes the description complete for correct invocation.

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 explicitly explains include_intervals (requests the embedded interval container, with the caveat that missing intervals still require get_activity_intervals). activity_id is implicitly clear from 'one activity,' and api_key is common context, though not explicitly described. Given that the most complex parameter is well covered, this is a solid score.

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

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

The description begins with a clear, specific statement: 'Return one activity with upstream fields preserved,' which identifies a distinct verb and resource. It further differentiates from siblings by explicitly pointing to 'dedicated interval and stream tools' for those resources, so an agent can distinguish this from get_activity_intervals and get_activity_streams without opening schemas.

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

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

The description provides explicit when-to-use and when-not-to-use guidance: it says source-hidden partial rows are not evidence for metrics/intervals/streams and directs the agent to 'the dedicated interval and stream tools.' It also names get_activity_intervals and get_metric_definitions as the correct alternatives for embedded intervals and calibration evidence, respectively.

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

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

With no annotations, the description carries the full behavioral burden and does so thoroughly: it discloses legacy compatibility, explicit errors for mixed rows, upstream sample indices rather than elapsed seconds, empty-container behavior, and unit/conversion caveats. This goes well beyond what the name or schema convey.

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 purpose is front-loaded and the details are logically grouped: shape, compatibility/errors, indices, empty case, then units. Every sentence adds useful information, though the metric-definition sentences are dense and could arguably be trimmed given the final cross-reference.

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, the description does not need to restate return values. It covers the tool's shape contract, legacy behavior, error conditions, indexing semantics, empty-container behavior, unit interpretation, and points to get_metric_definitions for further context. An agent has enough to 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%, and the description adds no meaning for either parameter: api_key and activity_id are not mentioned. While the parameter names are fairly self-explanatory, the description does not compensate for the low schema coverage as required.

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

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

The description opens with a specific verb and object: 'Return the activity interval container with index fields intact.' It then clarifies the documented shape (icu_intervals/icu_groups) and contrasts it with a legacy flat list, which distinguishes this from sibling tools like get_activity_interval_stats.

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

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

There is no explicit guidance on when to use this tool versus siblings such as get_activity_interval_stats or get_activity_details. The only cross-reference, 'See get_metric_definitions,' addresses metric semantics, not tool selection. The usage context is left entirely to inference.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It discloses that this is a read operation, performs no numeric calculations, preserves all upstream fields including nulls/zeroes/future fields, adds provenance and units, and explicitly flags that source completeness is unknown. This is far beyond the minimum and gives the agent accurate expectations.

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

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

The description is dense but every sentence earns its place by adding a needed constraint, caveat, or semantic clarification. It front-loads the purpose, then provides usage context, then covers data-handling details. No filler or redundant restatement of the schema is present.

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, the description does not need to explain return shapes, yet it still covers invocation context, range semantics, partial-data behavior, provenance, unit pitfalls, and a cross-reference to get_metric_definitions for conditional documentation. This is complete enough for an agent to invoke the tool correctly despite missing annotations.

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

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

With 0% schema description coverage, the description must compensate, and it does: it explains that indices are sample indices, not seconds, and that the range is half-open. It also clarifies unit semantics for respiratory fields. It does not explicitly explain activity_id or api_key, but those are either obvious from the name or optional with a default, so the most error-prone parameters are well covered.

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

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

The description opens with a specific verb and resource: "Read upstream interval statistics for a half-open sample-index range." It clearly distinguishes this from sibling tools like get_activity_streams and get_activity_intervals by emphasizing the Interval object and sample-index semantics. No ambiguity remains about what the tool does.

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 explicitly tells the agent when to choose this tool: when the client needs the Intervals.icu Interval object for [start_index, end_index). It also names get_activity_streams as the alternative for mapping sample indices to elapsed time. It does not explicitly contrast with the closely named sibling get_activity_intervals, but the primary selection context is clear and actionable.

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

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

No annotations are provided, so the description carries the full burden. It discloses the pagination cap (at most 100 messages), the read-only nature ('this read'), the guarantee that empty lists are possible but members are objects, and that content is untrusted with a fingerprint that does not replace original content. This adds valuable context beyond the schema.

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

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

The description is three sentences, front-loaded with purpose, and avoids fluff. It packs significant behavioral detail efficiently, though the caveats could be tightened, but overall it is well-structured and 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?

Given the tool has two parameters and an output schema, the description covers the core purpose and some behavioral quirks, but it omits any parameter guidance and does not clarify when to use it. The output schema handles return structure, but the lack of parameter semantics leaves an incomplete picture for a 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?

The description does not mention either parameter (api_key or activity_id) at all. Since schema description coverage is 0%, the description should compensate by explaining parameter roles or constraints, but it offers nothing, leaving the agent to infer from schema titles 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 states a specific verb ('Return'), a clear resource ('upstream activity-message list'), and the key property of preserving text and identity metadata. This clearly distinguishes it from sibling tools like get_activity_details or get_activity_streams, which target 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 implies usage by naming the resource, but it does not explicitly state when to use this tool versus alternatives or provide exclusion conditions. It only gives a limitation about pagination, not guidance on selection.

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

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

With no annotations, the description carries the full burden, and it delivers extensively: it discloses response behavior (keeps after_kj, does not infer selector identity), the meaning of compact vs. raw arrays (omitted_fields), that values are upstream watts with no MCP calculations, partial failure tolerance, and even HTTP 422 guidance. This is unusually thorough and transparent.

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

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

The description is longer than average but every sentence adds a distinct technical detail. It is front-loaded with purpose and then flows logically through parameters, response behavior, and error handling. There is no fluff, and the structure makes it easy to scan.

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 needn't explain return values, but it still covers continuation mechanisms, omitted fields, error handling, and parameter nuances. For a tool with five parameters and no annotations, it leaves nothing an agent needs to know to invoke it correctly.

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

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

Schema coverage is 0%, so the description must compensate. It explains durations ('positive seconds selected exactly from the upstream secs axis', omitted uses standard set, full detail preserves axis) and fatigue ('defaults to normal', each selector independent). It also implies the detail parameter's semantics. activity_id is self-explanatory from name; api_key is not explained but is a common auth parameter. It covers most parameters effectively.

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

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

States a specific verb ('Read'), resource ('watts power curves'), and scope ('one activity'), which clearly distinguishes it from sibling tools like get_athlete_power_curves (athlete-level) and get_activity_power_hr (heart rate). The opening sentence immediately establishes what the tool does.

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 'Choose this for best-power points from one activity,' providing clear selection guidance. It also instructs when to use the full_read continuation or detail='full' for complete arrays, which covers the main alternative path. Does not explicitly list when not to use it, but the context is clear enough.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states that values are source-provided, that no new physiological calculations or causal conclusions are made, and that compact mode bounds data to 32 KiB by omitting whole fields. It also explains that exact omissions and a continuation are returned. This is strong transparency for a read-only tool, though it does not address auth or rate-limit 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 appropriately sized and front-loaded with the core purpose. Every sentence adds useful information, and the technical details about data bounding and continuation are compact rather than rambling. No unnecessary filler is present.

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

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

An output schema exists, so return-value details are not required. The description covers the key behavioral nuances: compact vs. full detail, data-size bounding, omission behavior, and continuation. Missing guidance on when to prefer this over sibling analysis tools and the lack of api_key semantics are the main gaps, but overall the description is reasonably complete for a read-only analysis endpoint.

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 adds real meaning to the detail parameter by contrasting compact behavior (first 120 series rows, eight curves, 32 KiB bound) against full detail (complete JSON object). However, it does not explain the api_key parameter, and activity_id is only inferable from its name. The compensation is partial, not complete.

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

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

The description starts with a specific verb and resource: 'Read native power-versus-HR analysis, including upstream HR lag and windows.' This clearly identifies the tool's domain and separates it from sibling tools like get_activity_power_curves, which focus on power curves rather than power-versus-HR analysis. It also clarifies the source-provided nature of the values.

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 given about when to use this tool versus sibling alternatives like get_activity_streams or get_activity_details. The compact/full detail explanation addresses output size, not tool selection. The agent is left to infer the appropriate context entirely from the tool name.

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

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

With no annotations provided, the description carries the full behavioral burden, and it delivers extensively: half-open index semantics, index-not-seconds clarification, preview truncation rules, explicit warning conditions, duplicate/custom stream retention, no invented data array, the 1/min display-hint nuance, alignment.quality limits, snapshot-continuation requirements, and respiratory unit conventions. This is far beyond what annotations would typically supply.

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 front-loaded with the core scoping statement and each subsequent sentence carries substantive behavioral information rather than filler. It is long and somewhat wall-of-text in structure, which hurts scannability, but nearly every sentence earns its place given the tool's complexity and absence of annotations.

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

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

Given the tool's complexity—7 parameters, zero schema descriptions, no annotations—the description is remarkably complete. An output schema exists, so return-value format needs no explanation, and the description covers modes, edge cases, warnings, unit semantics, snapshot continuation, and respiratory interpretation. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: mode (preview/range behavior), start_index/end_index (half-open, not seconds, 10,000 limit), stream_types (warnings, duplicates, data2-only streams), and expected_snapshot_id (snapshot hashing and continuation requirements) all receive deep meaning beyond the schema. Only api_key is left to inference, which is minor given the exceptional compensation elsewhere.

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?

Opens with a specific verb+resource statement: 'Read activity streams by sample index with bounded preview or range.' It distinguishes itself from siblings by explicitly positioning export_activity_data plus get_artifact_chunk as the alternative for larger transfers, and by naming get_metric_definitions and get_custom_items for unit/mapping checks. An agent can tell exactly what this tool does versus its siblings.

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 selection criteria: preview versus range mode, the 10,000-sample limit, and an explicit instruction to use export_activity_data plus get_artifact_chunk for a larger complete transfer. It also directs the agent to get_metric_definitions and get_custom_items when checking mappings and units. This is rare, concrete routing guidance with named alternatives.

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

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

With no annotations provided, the description carries the full burden, and it delivers substantial behavioral detail: base64 chunk decoding, SHA-256 verification against the export manifest, UTF-8 concerns when chunks split multibyte characters, response_complete scope, eof/next_offset semantics, and the upstream composite/atomicity caveat.

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 opens with a crisp summary and follows with dense but purposeful sentences. Every sentence contributes necessary semantics: provenance, decoding, verification, pagination, and a caveat about upstream completeness. There is no filler.

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

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

Despite having no annotations and only a bare input schema, the description gives an agent a complete mental model: how to obtain the artifact_id, how to assemble the artifact, how to verify correctness, how to know when the artifact ends, and what limitations exist. An output schema exists to cover return values, so the description does not need to repeat them.

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 adds meaning for artifact_id by explaining it is opaque and comes from export_activity_data, and it implies offset/max_bytes through the byte-range and chunk language. However, it never explicitly defines offset and max_bytes in terms of byte positions, limits, or defaults, so the compensation is incomplete.

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

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

The opening sentence states a specific verb, resource, and scope: 'Read one verified byte range from a temporary activity export.' This clearly identifies the operation and distinguishes it from sibling tools by referencing the opaque artifact_id and the chunk/byte-range model.

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 tells the agent to use the artifact_id returned by export_activity_data member, and explains that response_complete, eof, and next_offset signal progress through the artifact. It does not explicitly contrast this tool with alternatives or say when not to use it, so it stops short of a 5.

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

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

With no annotations, the description carries the full behavioral burden. It spells out response modes (compact vs detail='full' with raw curve), clarifies the potentially misleading include_normalised flag, and documents edge cases: empty upstream lists are valid, malformed shapes fail explicitly, missing durations/null values are preserved, and source completeness remains unknown.

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?

All six sentences earn their place, with core purpose and usage front-loaded. The later sentences pack edge-case detail efficiently, though the paragraph is dense and could slightly benefit from better visual separation.

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 an 11-param tool with no annotations, the description covers key behaviors and edge cases and relies on the output schema for return shape. It could clarify season/date parameter semantics, but the naming plus defaults makes them reasonably inferable.

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

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

Schema coverage is 0%, so the description must compensate. It explains durations as positive integer seconds, detail modes, and include_normalised's legacy meaning. However, it leaves several parameters (last_season, this_season, start_date, end_date, indoor_outdoor, activity_type) unexplained, relying on name inference. Partial compensation only.

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

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

The description opens with a specific verb and resource: 'Read selected athlete power-curve durations in seconds.' It further clarifies the tool's niche by stating it is for 'season or custom-range best-power comparisons,' which distinguishes it from activity-level siblings like get_activity_power_curves.

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

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

The phrase 'Choose this tool for season or custom-range best-power comparisons' gives explicit when-to-use context. It does not name alternatives or exclusions, but the 'choose this tool' framing is enough to route an agent without ambiguity.

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

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

With no annotations, the description carries the behavioral burden. It adds 'live-verified' context, suggesting the tool performs active verification rather than returning a static list, and 'describe' implies a read-only operation. However, it does not clarify potential side effects, failure behavior, or whether verification could be slow or require connectivity.

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, tightly written sentence with no filler. It packs the key scoping qualifiers ('implemented', 'configured', 'live-verified') into minimal space, and 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 low complexity (zero parameters) and the presence of an output schema, the description is largely sufficient for invoking the tool correctly. However, it omits any scenario-level guidance about when capability discovery is relevant, which is a minor completeness 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 tool has zero parameters diagnostic an empty input schema, so no parameter documentation is needed. The description appropriately avoids inventing parameter details. Baseline 4 applies because there is nothing for the description to compensate for.

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

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

The description uses a clear verb ('Describe') and a specific resource ('integration capabilities'), further scoped by 'implemented/configured/live-verified.' It distinguishes itself from sibling data-access tools by focusing on capability discovery rather than domain data like activities or events.

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 about when to call this tool versus siblings, when it should be used in a workflow, or whether it is meant as an initial discovery step. The description only states what the tool does, not the conditions that make it the right choice.

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

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

With no annotations, the description carries the behavioral burden and does so well: it explains the compact vs. full detail modes, what each preserves or omits, that full mode treats upstream content as untrusted data, and how an upstream '{}' maps to NOT_FOUND. This is substantive behavior beyond the name and schema.

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

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

The purpose is front-loaded in a single clear sentence, and the remaining sentences earn their place by explaining detail modes and error behavior. The full-mode sentence is dense but contains necessary distinctions.

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, the description does not need to explain return values. It covers ID constraints, detail variants, untrusted-data semantics, and the NOT_FOUND edge case. It is slightly incomplete only in not clarifying the roles of api_key and athlete_id, but it remains sufficient for correct invocation.

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 adds real meaning for item_id ('positive integer') and detail ('compact' vs. 'full' with behavioral differences), but api_key and athlete_id are left entirely unexplained, leaving a clear gap.

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

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

The description opens with a specific verb and resource: 'Read one custom-item definition by positive integer ID.' It clearly distinguishes this single-item lookup from the sibling get_custom_items by emphasizing 'one' and 'ID.'

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 establishes a clear context: use this tool when you need a single custom-item definition identified by a positive integer ID. It does not explicitly name alternatives or exclusions, but the singular/ID framing is an unambiguous usage cue.

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

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

With no annotations, the description carries the full burden and does an exceptional job: it declares the operation is read-only, that scripts are never executed, that empty lists are valid while wrappers/malformed members are errors, and that units/origin are unverified metadata. It also explains compact vs full output structure and derived metadata placement.

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 dense but every sentence adds behavioral or routing information, and the first sentence is a clear front-loaded definition. It could be slightly better structured with parameter guidance, but it is not padded.

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

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

For a read/list tool with an output schema, the description covers content semantics, error behavior, and the full-read continuation well. The main gap is the undocumented optional parameters, but that is already captured in parameter_semantics; overall the agent gets enough context to call the tool 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 0% and the description does not compensate. Only 'detail' is indirectly referenced via detail='full', while api_key and athlete_id are never explained; without enums or schema docs the agent cannot infer valid values or their roles.

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 'Read custom-item definitions without executing their content', stating a specific action and resource and adding a key safety qualifier. It also distinguishes itself from get_custom_item_by_id by framing the sibling as the continuation for full per-item reads.

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

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

It explicitly directs agents to get_custom_item_by_id(..., detail='full') when full field preservation is needed, giving a concrete alternative condition. It does not enumerate exclusions for other siblings, but the 'read without executing' framing and compact-output behavior imply when this list tool is appropriate.

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

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

No annotations are provided, so the description carries the burden. It discloses that a list, scalar, or null response is an error, that the empty-object {} response is the compatible NOT_FOUND result, and that linked events are not resolved. This is meaningful behavioral context beyond the schema. It could add auth or rate-limit details, but for a read tool the disclosed response contract is strong.

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 compact and front-loaded: the first sentence states the core purpose, and the second sentence adds critical behavioral constraints and routing guidance. Every sentence earns its place with no filler.

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

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

The tool has an output schema, so return values need not be fully described. The description covers the main purpose, the error contract, and the distinction from get_events. It is slightly incomplete because it does not explain the api_key and athlete_id parameters, but for a simple read-by-ID tool with an output schema, the essential context is present.

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 explains the meaning of event_id ('numeric ID') and the return semantics, but it does not explain api_key or athlete_id parameters. The description adds some value for event_id but leaves the other two parameters undocumented, so it only partially compensates for the schema gap.

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

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

The description states a specific verb ('Return'), a specific resource ('one event by numeric ID'), and a key behavioral constraint ('preserving its upstream object'). It also distinguishes itself from get_events by explicitly saying it does not resolve linked events, which helps an agent tell it apart from the sibling list tool.

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

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

The description explicitly says to use get_events for date-range discovery and notes that this tool intentionally does not resolve linked events. This gives clear when-to-use and when-not-to-use guidance, and names the alternative 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?

With no annotations provided, the description carries the full behavioral burden and does so thoroughly. It discloses empty-list/error response shape, verbatim preservation of upstream strings, an explicit completeness caveat, the over-fetching query strategy from 0001-01-01, and how unresolved candidates with unknown ends are treated. This is far beyond the minimum and makes behavior predictable.

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 first sentence is a strong front-loaded summary, and the rest is organized into date semantics, result semantics, upstream behavior, and flag guidance. Minor redundancy keeps it from a 5: the exclusivity of end dates is stated in the first sentence, repeated for end_date_exclusive, and restated as 'End dates are exclusive.'

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 complex tool with 8 parameters, no annotations, no per-parameter schema descriptions, and an output schema present, this description is unusually complete. It covers date semantics, error/empty behavior, data fidelity, completeness limits, over-fetching side effects, unresolved-candidate handling, and both boolean flags, leaving an agent well equipped to call it correctly.

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

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

The schema has 0% description coverage, but the description compensates with precise semantics for start_date (inclusive), end_date_exclusive (exclusive), end_date (deprecated inclusive alias), resolve, and include_overlapping. It does not explicitly explain timezone or athlete_id, though the 'local-date range' phrasing and parameter names partially carry those.

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 precise verb and resource: 'Return calendar events overlapping a half-open local-date range.' It also distinguishes itself from the single-event sibling by noting that 'event-by-ID intentionally remains unresolved,' so an agent can tell this list-oriented tool apart from get_event_by_id.

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 clear decision context: set resolve only when the API's current resolved workout document is needed, and set include_overlapping=false for the original upstream start-date selection, such as resolving an already identified event on its exact start day. It does not explicitly name a sibling tool such as get_event_by_id, so it stops short of fully explicit alternative routing.

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

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

With no annotations, the description carries full responsibility and succeeds. It discloses that no account data is fetched, no training calculation is performed, unknown selectors appear in unknown_names, Tymewear volume is relative rather than calibrated liters, and the catalogue does not identify the recording device.

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

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

The description is lengthy but information-dense; each sentence contributes usage guidance, behavioral disclosure, or a necessary caveat. The core purpose is front-loaded, followed by when-to-use, then important limitations.

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, the description does not need to enumerate return fields. It covers selector optionality, default catalogue behavior, unknown-name handling, unit caveats, and device limitations, making it complete for a catalogue-lookup tool.

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

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

Schema description coverage is 0%, but the description compensates well. 'Selectors are optional; omitting both returns the small curated catalogue' explains the default behavior of both parameters, and 'unknown selectors remain explicit in unknown_names' clarifies failure semantics. Concrete metric examples like VT/tidal_volume add practical meaning.

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

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

The description opens with a specific verb and resource: 'Explain selected metric names and fields from the local catalogue.' It further distinguishes itself from data-fetching and computation tools by stating 'No account data is fetched, no training calculation is performed,' making its role clear among the 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?

It gives explicit timing guidance: 'Use this before interpreting activity streams, intervals, wellness, or custom-item content.' It does not name specific alternative tools or state when not to use it, but the usage context is clear enough for an agent to decide.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose a key behavioral trait: this read does not contact Intervals, implying it returns a locally stored/durable status. However, it doesn't disclose what happens if the operation is not found, whether the status is stale, or whether this is a safe/idempotent read. The description adds some value but leaves important behavioral gaps.

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

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

A single, dense sentence that front-loads the verb and resource, then adds the key qualifier. Every word earns its place. No fluff, no repetition of schema details.

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 covered elsewhere. The description is adequate for a simple one-parameter read, but it doesn't explain the relationship to execute_operation or recover_operation, nor does it clarify what 'durable' means in this context. For a status-checking tool, an agent would benefit from knowing whether this is the canonical way to poll operation progress.

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

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

Schema description coverage is 0%, so the description must compensate. The description names the operation_uid parameter implicitly through 'typed-operation status' but doesn't explain what a valid operation_uid looks like, how to obtain one, or what 'typed-operation' means. With only one parameter, the baseline is 4, but the description's lack of detail about the parameter's origin or format drops it to 3.

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

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

The description states a specific verb ('Read') and resource ('durable typed-operation status') and adds a meaningful qualifier ('without contacting Intervals'). This distinguishes it from execute_operation and recover_operation, though it doesn't explicitly name those siblings. The phrase 'durable typed-operation status' is somewhat technical but clear enough for an agent familiar with the domain.

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 this is a lightweight read path ('without contacting Intervals'), which suggests when to use it: when you need the cached/durable status rather than a live check. However, it doesn't explicitly state when to prefer this over execute_operation or recover_operation, nor does it mention any prerequisites or side effects. The usage context is implied rather than 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?

With no annotations provided, the description carries the full burden, and it delivers: it discloses that output is current-at-fetch (not historical), that the MCP performs no physiological calculations, that source completeness is unknown, and that pace_units is only a display preference. It also explains the compact vs full_read/detail='full' behavior and unit conventions. This is rich behavioral context beyond what the schema shows.

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 dense but well-organized: purpose first, then selector semantics, then output modes, then units, then caveats. Every sentence adds information. It is longer than the minimum, but the density justifies the length; a slight trim of the unit list could improve it, but nothing is wasted.

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

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

Given the tool has an output schema and no annotations, the description covers the essential selection criteria, parameter semantics, unit conventions, and behavioral caveats. It does not explain api_key/athlete_id, but those are standard context parameters. The main gap is that it doesn't describe the exact return shape, but the output schema exists, so the description needn't repeat 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 0%, so the description must compensate, and it does for the key parameters: sport (selector semantics), detail (compact vs full_read/detail='full'), and the unit meanings for ftp/p_max/w_prime/after_kj0/after_kj1/threshold_pace. It does not explicitly explain api_key or athlete_id, but those are conventional auth/context parameters and the description's unit and selector detail goes well beyond the bare schema.

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

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

The description opens with a specific verb ('Read') and resource ('current-at-fetch settings for one sport or settings ID'), then enumerates the exact use cases (FTP, zones, load order, fatigue thresholds). It clearly distinguishes itself from activity-assigned historical thresholds and from sibling tools like get_activity_power_hr or get_workout_snapshot by focusing on current sport settings.

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 'Choose this for the athlete's current FTP, zones, load order, and fatigue thresholds,' which gives clear when-to-use guidance. It also explains the selector semantics ('sport is one selector: a sport name such as Ride or the current settings ID') and the detail modes. It does not explicitly name sibling alternatives to avoid, but the context is strong enough for an agent to select this tool over the listed siblings.

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

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

With no annotations provided, the description carries the full burden and does so thoroughly: it explains inclusive/exclusive date semantics, the possible response shapes, valid empty results, error shapes, field preservation including null/zero values, unknown source completeness, and specific metric interpretation caveats like hrv being rMSSD.

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 dense but every sentence carries meaningful information, from core behavior to edge-case shapes to field-interpretation guidance. It is front-loaded with the main purpose and date semantics before diving into detailed return-shape nuances.

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

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

Given the tool's complexity, the description covers return shapes, error conditions, field semantics, and a pointer to get_metric_definitions. It is missing explicit documentation for several parameters and does not discuss prerequisites or authentication, but the presence of an output schema reduces the need to explain return values. Overall, it is well above minimum viability but has clear gaps.

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

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

Parameter schema coverage is 0%, so the description must compensate. It explains start_date, end_date_exclusive, and end_date as a deprecated alias, and touches on field preservation relevant to include_all_fields. However, it leaves athlete_id, timezone, api_key, and the exact meaning of include_all_fields undocumented, which is a notable gap given seven parameters.

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

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

The description states a specific verb and resource: 'Return raw wellness records' with a half-open local-date range. It clearly distinguishes itself from the many activity, event, and custom-item siblings by targeting wellness data.

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

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

The description clearly explains the date-range semantics and advises consulting get_metric_definitions before interpreting fields, giving practical usage context. However, it does not explicitly contrast this tool with siblings like get_activities or get_events, so the when-not-to-use guidance is implicit rather than 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?

With no annotations provided, the description carries the full burden, and it does substantial work: it discloses that the token is versioned by MCP rather than an upstream ETag, that missing fields/null/zero remain distinct, that pairing evidence is read by exact identity, and that the read does not authorize a write. It also flags unverified aspects (source completeness, atomic conditional writes). This is rich behavioral disclosure beyond a simple 'read' label.

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 first sentence is a strong front-loaded summary, but the rest is a dense paragraph of caveats and domain-specific rules. Every sentence carries information, but the structure is heavy and could be broken into clearer sections. It is not bloated, yet it is harder to parse than necessary for an agent.

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

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

Given the tool's complexity and the presence of an output schema, the description covers the critical behavioral context: versioning semantics, pairing checks, precondition safety, and write authorization limits. It does not explain the return structure, but the output schema exists and the description need not duplicate it. The main gap is parameter semantics for api_key and athlete_id, but overall the agent has enough to 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 for the three parameters. It explains the central role of event_id (the event whose snapshot is read) and mentions event-by-ID and calendar-day logic, but it does not explicitly define api_key or athlete_id or explain when they are needed. The description adds meaning for the main parameter but leaves the optional parameters under-specified.

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

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

The description opens with a clear verb and resource: 'Read a workout's raw event, server version and execution precondition.' This distinguishes it from sibling getters like get_activity_details or get_events by focusing on the snapshot/versioning purpose. However, it does not explicitly name a sibling alternative, and the dense follow-up text makes the core purpose slightly harder to isolate.

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 strong usage context: it explains when this read is appropriate (binding data.event_fingerprint in an execute_operation precondition) and when it is not ('This read does not authorize a write'). It also warns that unpaired_observed does not prove the athlete did not train. It does not explicitly name alternative tools, but the context is clear enough for an agent to decide when to call it.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It discloses the key trait that this is a read-only reconciliation and never resends the mutation, which is crucial. However, it doesn't mention what happens on mismatch, failure, or whether it modifies any state, leaving gaps in the behavioral picture.

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, dense sentence that front-loads the critical constraint. Every word earns its place, and there is no redundancy or fluff. It's exceptionally concise while conveying the core 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 the complexity of a recovery operation with two parameters and no schema descriptions, the description is far from complete. It fails to explain parameter semantics, expected input formats, or any side effects. While an output schema exists, the description does not compensate for the missing parameter details, making it inadequate for safe invocation.

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% and the description makes no mention of either parameter (operation_uid or candidate_identity). The agent has no explanation of what these parameters mean, what format operation_uid should take, or how candidate_identity is used. This is a severe deficiency for a tool with two parameters.

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

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

The description clearly states the action (reconcile) and the method (independent read-back), and distinguishes it from execute_operation by explicitly forbidding resending the mutation. It's specific and actionable, though it doesn't explicitly mention 'recover' or 'retry' which could add 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 gives a strong directive ('never resend the mutation') which implies when not to use this tool, but it doesn't explicitly state when to use it versus alternatives like get_operation_status or execute_operation. The guidance is implied rather than explicit, leaving some ambiguity for an agent.

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

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

With no annotations, the description carries the transparency burden and does well: it discloses that the tool does not change the historical unknown result and cannot replay it, while limiting its effect to releasing the hold. It does not mention permission/authentication requirements or rate limits, but the admin-role and explicit-direction constraints are present in the schema.

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

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

Two short sentences, with the primary action front-loaded and the second sentence clarifying an important non-behavior. No filler or repetition; every clause 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?

For a narrow risk-release tool, the description captures the essential context: admin acceptance, releasing only the hold, and no replay. An output schema is present, so return-value details are not required, and the input schema already enumerates accepted risks. A brief note about when not to use it relative to recovery would make it fully complete.

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

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

Schema description coverage is 0% and the description adds no per-parameter meaning. It does not explain release_uid, operation_uid, accepted_risks, or reason beyond what their names and the schema's enum values already imply, so an agent gets little help choosing or formatting the actual arguments.

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

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

The description names a specific action ('release only its hold') on a specific resource (operation risk hold), and distinguishes it from replaying or changing the historical result. This clearly separates it from sibling tools like execute_operation and recover_operation, even without naming them.

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

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

The description provides clear context for when this tool is appropriate: after an explicit admin risk acceptance, to release only the hold. It also states a firm exclusion ('cannot replay it'), which helps an agent avoid using this tool when the goal is to re-run or recover an operation. It stops short of naming concrete alternative tools for those cases.

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