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

No annotations are provided, so the description carries the burden of behavioral disclosure. It explicitly states the operation is read-only, specifies the response as a GPX 1.1 XML string, and avoids implying side effects. It does not describe failure behavior for an invalid route ID, but this is minor for a simple read-only export.

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 concise sentences, each adding useful information: what the tool does, where the output is applicable, and how to obtain a valid input. No filler or redundant restatement.

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

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

For a simple one-parameter, read-only export tool with no output schema and no annotations, the description gives enough to select and use it correctly: target resource, output format, input source, and safe behavior. It could mention error outcomes, but that is not essential for initial 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?

The schema already documents routeId as 'Route ID returned by list_routes.' The description adds a similar hint, but no significant new semantic value beyond what the schema provides. With 100% schema description coverage, the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Exports') with a clear resource ('a saved Suunto route') and names the output format ('GPX 1.1 XML string'). It is also implicitly differentiated from the sibling export_workout_gpx, which targets workouts rather than routes.

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 instructs the agent to use list_routes to discover valid route IDs and states that the export is suitable for import into navigation apps. It does not explicitly enumerate when to choose this over export_workout_gpx, but the route/workout distinction makes the appropriate context 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?

No annotations provided, but the description discloses that the tool is read-only, returns empty GPX if no GPS data, and the output is an XML string. This adequately covers behavioral aspects, though some details like internal processing are absent.

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

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

Four concise sentences, front-loaded with the primary action, each sentence adding unique value: format, content, empty case, alternative, and read-only nature. No redundancy or fluff.

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 one-parameter tool with no output schema, the description fully explains the return format, content details, edge case (empty GPX), and provides usage context and sibling differentiation. No gaps remain.

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

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

Schema description coverage is 100%, so the description does not need to add parameter details. The description does not mention the parameter, but the schema itself is sufficient. Baseline score of 3 applies.

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

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

Clearly states it returns the GPS route as a GPX XML string (not JSON), specifies the format and contents of trackpoints, and differentiates from sibling tools like get_workout_samples.

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 tells when to use (for GPS route export) and when not to use (for numeric time-series), and provides the alternative tool get_workout_samples. Also mentions compatibility with common GPS tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses that this is a write operation updating a sidecar file and a history file, names the sidecar path and env var, explains the CTL/ATL/TSB computation, rolling baselines, party-night bucket, and subscription fallback — far beyond what the schema provides.

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 long but almost every sentence carries distinguishing information — side effects, state persistence, calculus, subscription requirements. It front-loads the core purpose and append behavior first. It could be tightened slightly, but it earns its 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 3-parameter tool with 100% schema coverage and no output schema, the description covers everything an agent needs: what to do, when to call, prerequisite subscription, computation, storage side effects, and first-run behavior. Nothing important is missing.

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

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

Schema coverage is 100%, so the schema already documents all three parameters. The description adds key nuance: seedAtl and seedCtl only matter on the first digest, seedCtl should be anchored to the user's watch value, and the date should be yesterday or earlier. That adds value beyond the raw schema.

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

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

The description states a specific verb and resource ('Builds a color-coded daily health digest') and clearly distinguishes it from sibling read-only tools like get_daily_activity or get_sleep by explaining it computes and appends a markdown history file rather than just returning API 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?

It explicitly says to use yesterday or earlier, notes today's data is usually incomplete, and explains that Sleep/Recovery API subscriptions are needed for those sections. It also says what falls back to 'no data' if subscriptions are missing, giving the agent clear when-to-call 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 provided, the description carries the full burden and does well: it states the tool is read-only, requires a specific subscription ('24/7 Activity API subscription'), and discloses empty-payload behavior for days without synced data. The schema adds even more behavioral detail about 200 responses instead of errors.

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?

Four sentences, each earning its place: the core return value, sample contents, empty-result behavior, alternative tool, subscription requirement, and safety profile. It is front-loaded with the most important information and has 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?

For a single-parameter read-only tool with an exhaustive schema description, the description covers everything needed to select and invoke it correctly: what it returns, when to expect empty data, how to get date ranges, the subscription requirement, and its read-only nature.

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

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

Schema description coverage is 100%, so the schema already fully documents the 'date' parameter including format, pattern, examples, and behavioral caveats. The description adds no additional parameter-specific semantics beyond mentioning that the tool covers one calendar day, which is appropriate given the schema's richness.

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

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

The description names a specific verb ('Returns'), a specific resource ('24/7 activity time-series samples for one calendar day'), and even cites the underlying API ('/247samples API'). It also lists sample contents (timestamp, steps, HR), making it clearly distinguishable from siblings like get_daily_activity_statistics and list_daily_activity.

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

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

The description explicitly says 'Use list_daily_activity to fetch a date range', giving the agent a clear alternative condition. The schema further provides concrete usage guidance: use yesterday or earlier for complete results and expect empty/partial payloads for today or future dates.

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 fully bears the burden. It states the tool is read-only, describes the response structure, and discloses behavioral traits like maximum interval and null value meaning. 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?

Three sentences clearly convey purpose, response format, usage guidance, and read-only nature. No redundancy, but could potentially be slightly more concise by merging response format details. Still 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 moderate complexity (2 params, no output schema, no annotations), the description covers all necessary context: what the tool does, what it returns, constraints, and differentiation from siblings. It is complete for a retrieval tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add parameter-specific information beyond what is already in the schema (ISO-8601, UTC, 28-day constraint). The response structure description is helpful but not directly about 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 tool returns aggregated daily step count and energy consumption from the /247 API for a datetime range. It specifies the verb ('Returns') and resource, and distinguishes from sibling list_daily_activity by noting preference when totals are needed vs intraday time-series.

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 advises when to prefer this tool over list_daily_activity (for totals) and notes the maximum fetch interval of 28 days. It also explains that null Value indicates no synced data, providing clear usage context.

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

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

With no annotations provided, the description carries full behavioral disclosure. It reveals the 404-without-subscription behavior, empty payloads for days without data, the read-only nature, and the exact sample fields and enum meanings, going well beyond a minimal statement.

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?

Every sentence earns its place: purpose, output format, empty behavior, alternative tool, subscription requirement, and read-only status. The description is compact, front-loaded with the main action, and contains no repetition or filler.

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

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

For a single-parameter read-only tool with a detailed input schema, the description provides all necessary behavioral context: what is returned, what an empty payload means, what happens without a subscription, and where to go for a date range. Nothing essential 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 100%, and the schema already thoroughly documents the date parameter including format, examples, and the useful caveat about today's incomplete data. The tool description adds scope context ('one calendar day') but does not materially improve parameter meaning beyond the schema.

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

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

States a specific verb and resource ('Returns recovery and HRV time-series samples from the /247samples API') and clearly scopes it to one calendar day. The output sample structure is described, and it is distinguishable from the sibling list_recovery by its single-day scope.

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 names list_recovery as the alternative for date-range queries, making the single-day use case clear. It also states the subscription requirement and the empty-payload behavior, giving agents concrete conditions for when this 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?

With no annotations, the description carries full burden and delivers: read-only status, empty payload for days without data, and 404 on missing subscription. These behaviors go beyond the schema and materially affect invocation 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?

Four tight sentences, front-loaded with purpose and output fields, then edge cases, alternatives, and prerequisites. Every sentence adds distinct value with no redundancy or 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 lacking an output schema, the description enumerates all returned fields, making the response shape predictable. It covers empty results, error conditions (404), subscription requirements, read-only nature, and points to the sibling tool for broader queries.

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 already has 100% detailed description coverage of the date parameter, including format, meaning, and sync caveats. The tool description adds little beyond confirming 'one calendar day', so the baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource ('Returns sleep time-series samples from the /247samples API for one calendar day'), which precisely defines scope. It also lists the exact returned fields and explicitly contrasts with sibling list_sleep, making the tool's distinct role unambiguous.

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

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

It explicitly directs users to list_sleep for date ranges, and the date parameter schema provides rich context on when to use which date (bedtime semantics, sync cadence). It also discloses a hard prerequisite: Sleep API subscription, with 404 behavior without 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?

No annotations are provided, so the description carries the full burden. It does add useful behavioral context: 'polls' implies transient, non-destructive repeated reads, and the status examples ('Queued', 'Processing', 'Processed', 'Error') plus the delayed appearance of workoutKey clarify when the poll is complete. However, it does not disclose behavior for an invalid/unknown uploadId or whether there is any terminal retry/error pattern, which is a noticeable gap for an unannotated polling tool.

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

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

Three sentences, each carrying useful cargo: purpose, return shape, and downstream routing. No filler, and the main verb and context are front-loaded in the first sentence.

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

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

The tool is simple (one required string parameter), has no annotations, and no output schema. The description compensates well by specifying the status enum and the workoutKey result, plus the follow-up step with get_workout. The only gaps are edge-case behavior for invalid upload IDs or polling termination decisions, which are minor for a tool this small.

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 100%, and the input schema already explains uploadId as 'Upload ID returned by upload_workout.' The description merely repeats this provenance ('initiated by upload_workout') without adding new syntax, format, or lifecycle details, so it does not raise the value above the baseline.

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

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

The description states a specific verb ('polls') and resource ('processing status of a workout upload'), and explicitly ties it to upload_workout as its origin. This clearly distinguishes it from get_workout and other siblings by framing it as the polling stage in an upload workflow.

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 workflow is explicitly laid out: this poller follows upload_workout ('initiated by upload_workout') and its output is consumed by get_workout ('Use the returned workoutKey with get_workout for full detail'). This gives the agent exact when-to-use context and routes it to the correct next step.

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. It declares read-only behavior, clearly states the error condition, and lists the types of data returned. This is sufficient for an agent to understand the tool's behavior without surprises.

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 (3 sentences), front-loaded with the main purpose, and every sentence adds value. No fluff or repetition.

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

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

Given no output schema, the description explains return content (laps, HR zones, training-effect, sport-specific), mentions error handling, and references related tools. It is complete for a simple retrieval tool.

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

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

The input schema has 100% coverage, but the description adds significant context: the opaque nature of workoutKey, requirement to discover via list_workouts, and the specific error on invalid key. This goes beyond the schema's own description.

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

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

Description clearly states it returns the full summary for one workout, listing specific fields (laps, HR zones, training-effect, sport-specific metrics). It distinguishes from siblings like get_workout_samples and list_workouts by specifying what this tool does versus alternatives.

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 tells the agent to use list_workouts to discover valid workoutKey values and directs to get_workout_samples for time-series data. Also warns that invalid key throws SuuntoNotFoundError, providing clear when-to-use and when-not-to.

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 burden, and it does well: it states read-only behavior, describes the compact vs full response modes, and warns that responses can exceed 100 KB. It doesn't cover failure modes or authentication, but the key behavioral traits are disclosed.

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 action, then efficiently explains both modes and gives a clear recommendation. 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?

Since there is no output schema, the description appropriately explains the default return shape and characterizes full mode as raw record-level data with a size caveat. It could detail the full-mode record schema more, but it provides enough for correct selection and 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 100%, so the baseline is 3. The description adds value beyond the schema by spelling out the compact summary fields and quantifying the full-mode response size, which helps the agent choose correctly.

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

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

The description names a specific verb and resource: it downloads the workout's binary FIT file from Suunto and parses it to JSON. This clearly distinguishes it from nearby siblings like get_workout, get_workout_samples, and export_workout_gpx.

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 guidance on when to use full=false versus full=true and warns about large responses in full mode. It stops short of explicitly contrasting with sibling tools, so it doesn't earn 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?

Discloses read-only nature, error thrown (SuuntoNotFoundError), sampling rate, and data volume caveat for long workouts, all 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?

Two sentences, front-loaded with purpose, followed by field list, caveat, alternative, and error condition. 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?

Without an output schema, the description explains the output contents and key behaviors. It could explicitly state the output is a list, but the context is sufficient.

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

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

The schema already provides a description for workoutKey, but the description adds crucial context about the key's origin and discoverability, enhancing understanding.

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 returns time-series sample streams for one workout, listing all fields and distinguishing it from get_workout_fit.

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 tells when to use (detailed data) and when not (long workouts), and suggests an alternative tool (get_workout_fit with full=false).

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 provided, so description carries full burden. States read-only, omits days without synced data, accepts future dates with no entries, and confirms chronological ordering. Lacks details on rate limits or pagination, but sufficient for basic understanding.

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 plus one for alternatives/requirements. No redundant words, front-loaded with core functionality. 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 simplicity (2 params, no output schema), description covers return structure, ordering, and data omission. Could mention sample frequency or additional metrics, but still adequate 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 100% with both parameters having detailed descriptions (date format, constraints, behavior like silent omission). Description adds minimal extra meaning beyond schema, so baseline 3 is appropriate.

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

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

Description clearly states it returns 24/7 activity time-series samples with verb 'returns' and specifies resource, scope, and ordering. Distinguishes from siblings get_daily_activity (single day) and get_daily_activity_statistics (aggregated).

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 advises when to use siblings for single day or aggregated totals. Also mentions required subscription, providing clear usage context. No ambiguous phrasing.

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, but description fully discloses behavior: chronological order, omission of days without data, future dates accepted but yield no entries, and subscription requirement. Marks read-only.

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?

Five sentences, each adding value. Front-loaded with main action, followed by output format, sibling reference, error conditions, and optimization tip.

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?

Complete without output schema: includes output structure, enum meanings, API source, and prerequisite. 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?

Schema has 100% coverage; description adds context: days without data silently omitted for 'from', future dates accepted with no entries and responsiveness hint for 'to'.

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 it returns recovery and HRV time-series samples for a date range, ordered chronologically. Distinguishes from sibling 'get_recovery' for single day.

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

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

Explicitly says 'Use get_recovery for a single day', mentions subscription requirement and 404 error, and advises preferring ranges ≤30 days.

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 correctly carries the disclosure burden by stating the operation is read-only and specifying what data will be returned. It does not discuss pagination or edge cases like an empty route list, but for a read-only list operation this is sufficient.

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 with no filler. It front-loads the core result, lists return fields, and flags the main alternative in one compact statement.

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 parameterless list operation, the description fully defines behavior, output contents, read-only nature, and how to get track data. Nothing essential 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?

The tool has zero parameters, so there is nothing for the description to clarify. The baseline 4 applies because the description fully covers the no-input behavior and return fields.

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

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

The description names a specific verb (Returns) and resource (routes saved in the user's Suunto account), and enumerates the exact fields returned. It is clearly distinguishable from siblings like list_workouts and export_route.

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 directs agents to use export_route when navigation data is needed, establishing a clear alternative and condition. It doesn't contrast with list_workouts, but the resource is clearly route-specific.

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: read-only, inclusive date bounds, omission of nights without recorded sleep, field-level output shape, and subscription-derived 404 behavior are all disclosed.

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 efficient: purpose, output shape, edge case, sibling alternative, prerequisite, and safety hint are each handled in one sentence. There is no filler or repetition, and key information is front-loaded.

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

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

The tool has no output schema, so the description compensates by enumerating every returned field with units. It also covers omissions, subscription dependency, read-only nature, and the correct alternative tool—everything an agent needs 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 100% and both from and to already have detailed descriptions covering format, inclusive bedtime-date semantics, ordering constraints, future-date behavior, and range-size guidance. The description adds little per-parameter meaning beyond reaffirming inclusivity, so the high-coverage baseline of 3 is appropriate.

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

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

The description states a specific verb ('Returns sleep time-series samples'), the API source (/247samples), the date-range scope, and chronological ordering. It also explicitly distinguishes itself from the sibling get_sleep, so an agent can tell them apart immediately.

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

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

It names the alternative ('Use get_sleep for a single night'), states the subscription prerequisite, and documents the failure mode ('returns 404 without it'). The schema additionally advises ranges ≤ 30 days, giving clear practical 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 adequately discloses read-only behavior, empty array response, and a prerequisite (Subscriptions API product). Lacks details on authentication or rate limits, but sufficient for this simple read 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?

Three concise sentences, each providing essential information: output format, empty state, and usage guidance. No redundant or missing words.

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

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

For a parameterless tool with no annotations or output schema, the description fully covers purpose, behavior, and usage context, enabling an agent to correctly select and 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 zero parameters, so no parameter documentation is needed. The description adds value by specifying the output structure and usage 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 tool returns all active webhook subscriptions as an array with specific fields (id, eventType, callbackUrl, createdAt), distinguishing it from sibling tools focused on workouts, activities, sleep, and recovery.

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 advises using the tool to audit existing subscriptions before adding new ones, and notes it is read-only. Does not explicitly mention alternatives or when not to use, but the context is clear given the specialized functionality.

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

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

No annotations are provided, so the description carries the full burden — and it delivers. It declares read-only status, documents newest-first ordering, discloses automatic offset-based pagination, and adds critical field-level caveats: activityId is numeric with no plain-language sport field, energyConsumption is in joules not 'totalCalories', and hrdata.max is the account overall max HR rather than the workout peak (hrdata.workoutMaxHR). These are exactly the behaviors that would cause silent data misinterpretation if omitted.

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 long (~130 words) but every clause earns its place: field enumeration with units, three disambiguation caveats that prevent wrong data interpretation, sibling routing, pagination semantics, and a read-only declaration. The core purpose is front-loaded in the first sentence, and the density is justified because each caveat prevents a distinct class of agent error. Nothing is filler.

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

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

With no output schema and no annotations, the description must document the return contract itself — and it does, listing all response fields with units (workoutKey, activityId, startTime, totalTime, totalDistance, totalAscent, totalDescent, energyConsumption, hrdata avg/max/workoutMaxHR). It covers pagination, ordering, read-only safety, and directs to siblings for missing detail. The only minor blemish is listing hrdata as '{ avg, max }' before referencing workoutMaxHR, but the caveat text resolves it; nothing critical is missing 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 100%, so the baseline is 3 and the schema already documents limit/since/until thoroughly. The description adds marginal but real value by explaining the offset-based pagination mechanism and its termination condition ('until limit is reached or no more workouts exist'), which clarifies how limit interacts with paging beyond the schema's 'Pagination is automatic' note. This nudges it above baseline without the description carrying the parameter documentation burden.

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 names a specific verb, resource, and scope: 'Returns the user's recent Suunto workouts ordered newest-first (Workout API v3).' It goes further than most by enumerating the exact response fields, which makes the tool unmistakable, and it explicitly distinguishes itself from get_workout (full detail on a single result) and get_workout_fit (sport name lookup). An agent could not confuse this with a sibling.

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 routes the agent to alternatives under specific conditions: 'use get_workout_fit for the parsed FIT file's session.sport if a sport name is needed' and 'Use get_workout for full detail (laps, HR zones, sport-specific metrics) on a single result.' It also explains when pagination stops ('until limit is reached or no more workouts exist'), giving the agent a clear decision procedure for list vs. detail calls.

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 disclosure burden, and it does so thoroughly. It discloses the write nature, the auto-advance mechanism, the target-HR display capability, the environmental prerequisite, and the 'no live push' delivery caveat. These are exactly the behavioral traits an agent needs to anticipate correct 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 compact and front-loaded: purpose, differentiation, behavior, requirements, and caveat are each handled in direct, memorable sentences. No sentence is wasted or merely repeats schema content.

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

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

Given the high schema coverage and absent annotations, the description adds the missing behavioral context: it explains the async sync behavior, the write operation, and the most important execution constraint (environment variable match). It does not discuss error conditions or update-via-guideId side effects, but those are secondary for a tool with this clear schema and no output schema.

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 already documents all 4 parameters with 100% coverage, so the baseline for this dimension is 3. The description goes beyond by explaining the practical meaning of the parameters: durationSec/distanceM drive auto-advance, and targetHrMin/targetHrMax can appear live alongside the segment display. This contextual layer helps the agent understand how parameter choices affect device behavior.

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: 'Pushes an interval/cardio guide ... to the user's Suunto account via the SuuntoPlus Guide Cloud API.' It also explicitly differentiates itself from push_workout_guide by contrasting auto-advancing interval segments with manual lap-per-exercise, making its purpose and distinct role unmistakable.

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 states its context and alternative: interval/cardio guides with auto-advance should go here, while manual lap-by-lap guides belong to push_workout_guide. It also gives practical usage constraints, like the SUUNTO_APP_NAME environment variable requirement and the after-sync delivery behavior, helping the agent decide when this 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?

The description reveals that delivery depends on normal Suunto app sync, there's no direct live push to the watch, and the guide may need manual pinning in the Suunto app if it doesn't appear. It also notes it's a write operation. However, it doesn't discuss failure modes, rate limits, or whether a guideId update is destructive to existing data.

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 bit lengthy but every sentence contributes context: the API used, the step conversion, env var requirement, and sync behavior. It could be tightened slightly but is not bloated.

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

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

The description lacks a clear contrast with push_interval_guide, but the context of the SuuntoPlus Guide Cloud API and sync behavior is sufficiently explained. There is no output schema, so the return value is not described, but for an async API push that might be acceptable.

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?

Description adds meaning to the exercises parameter by explaining each exercise becomes one step and is advanced by a lap-button press, and it interprets the detail field as a display string. However, with 75% schema coverage, the guideId parameter is documented in the schema but the description adds little beyond stating it updates an existing guide. The date and title are already well described by the schema.

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

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

The description clearly states the tool's purpose: pushing a text-step workout guide to the user's Suunto account via the SuuntoPlus Guide Cloud API. It distinguishes itself from siblings like push_interval_guide and upload_workout by explicitly mentioning it pushes a text-step workout guide and describing the exercise-to-step conversion. This provides a clear verb, resource, and conceptual 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 explains when to use this tool, especially noting the env var requirement and behavior around syncing. However, it doesn't explicitly contrast with push_interval_guide for choosing which guide type to push. Usage context is fairly clear (a workout guide), though not as definitive as listing 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, the description explicitly labels the call 'Write operation,' describes the async processing delay, and states that the file appears in the Suunto app shortly after upload. It also discloses the .gpx risk and the uploadId return value, though it omits duplicate/failure 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?

Every sentence contributes: core action, file-path requirement, async behavior and return value, and file-format caveat. It is front-loaded with the action and stays within a focused paragraph with no wasted words.

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

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

No output schema exists, so the description must convey the return value, and it does by naming uploadId and pointing to get_upload_status. It also covers processing delay and file-format caveats, leaving an agent with enough information to invoke the tool and follow up 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 covers 100% of parameters, so the baseline is 3; the description adds real value by explaining the absolute-path requirement, the .fit/.gpx distinction, and the MIME used for .gpx. This extra guidance helps agents choose a correct value for the required filePath parameter.

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

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

States a concrete action — 'Uploads a workout file to the user's Suunto account' — and names the artifact, destination, and follow-up. The explicit 'Write operation' label and returned uploadId make it easy to distinguish from the read/list/export 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 workflow guidance: the returned uploadId should be polled via get_upload_status, and it steers users to .fit for reliability rather than .gpx. It does not explicitly enumerate when not to use this tool versus sibling upload tools, but the context is clear.

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