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

The description omits any details about side effects, such as whether the operation overwrites existing entries, requires prior data, or is idempotent. With no annotations and only a bare action phrase, the agent has no insight into the write behavior or potential consequences.

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, consisting of a single action line followed by a parameter list. However, it is not structured as a narrative or front-loaded with a summary; it reads as a bare enumeration, which is efficient but could be more organized.

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 information about the return value or success/failure indications, despite the presence of an output schema. It also does not highlight which parameters are required (date and weight) or any constraints, leaving the agent with incomplete context for invoking 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?

The description adds moderate value by listing units for some parameters (e.g., weight in kg, percent_fat as percentage), but it does not provide units for all fields (e.g., basal_met) or clarify expected ranges. Given the schema has 0% coverage, this is helpful but incomplete, earning a middle 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 clearly states the verb 'Add' and the resource 'body composition data', making the tool's purpose unambiguous. It is also distinct from sibling tools like add_weigh_in and get_body_composition, so an agent can easily identify this as the write operation for body composition metrics.

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

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

No guidance is provided on when to use this tool versus alternatives such as add_weigh_in or get_body_composition. There is no explanation of prerequisites, relationship to other data, or typical use cases, leaving the agent to infer context from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the high-level association action and does not reveal potential side effects, whether existing gear associations are replaced or appended, error behavior for invalid IDs, or any authorization requirements.

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 well-organized, with a clear one-line summary followed by a focused Args section. Every sentence contributes value, and the parameter documentation is front-loaded and easy for an agent to parse quickly.

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 two-parameter tool with an output schema present, the description covers the basics of what the tool does and what the parameters mean. However, it omits important behavioral context such as whether the operation is idempotent, what happens if gear is already associated, and whether the activity must exist, making it adequate but not 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?

The input schema has 0% description coverage, so the description must compensate, and it largely does. The Args block provides semantic meaning for both parameters: activity_id is 'ID of the activity' and gear_uuid is 'UUID of the gear to add (get from get_gear)', adding useful sourcing context beyond the raw schema types.

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 a specific verb and resource: 'Associate gear with an activity' and 'Links a specific piece of gear to an activity.' It distinguishes the action from unrelated siblings by defining exactly what is being linked, though it does not explicitly contrast itself with remove_gear_from_activity or get_activity_gear.

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 only usage guidance is the hint that the gear UUID should be obtained from get_gear, which is a helpful prerequisite but not a tool-selection guideline. It does not explain when to choose this tool over remove_gear_from_activity or other gear-related tools, nor does it provide any exclusions or alternative conditions.

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

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

With no annotations, the description carries the full behavioral burden and does so exceptionally well: it discloses accumulation semantics, negative-value subtraction, the zero floor, the exact API error message on further subtraction, and the fact that the Garmin API offers no delete so zeroing is the closest to removal. These are exactly the traits an agent needs before mutating hydration 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 most decision-relevant facts (accumulation, negative correction, zero floor) are front-loaded in the first two paragraphs, and the Args block is a compact reference. Length is justified by genuinely non-obvious behavior rather than padding.

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-param mutation tool with an output schema, the description covers everything the agent needs: mutation semantics, correction workflow, floor behavior, error text, and the absence of a delete path. Return values are legitimately omitted since an output schema exists.

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 the Args block does: value_in_ml is 'amount of liquid in millilitres' with negative-subtracts semantics, date is YYYY-MM-DD, and timestamp is YYYY-MM-DDThh:mm:ss.sss. It even explains why the argument is named `date` rather than the historical `cdate`.

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 gives a specific verb and resource ('Add a hydration entry for a date'), so the agent immediately knows this is a write operation on daily hydration. It references the sibling get_hydration_data only incidentally (for the date argument naming), not as a routing cue, so the sibling distinction is present but not fully exploited.

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 effectively tells the agent when and how to use this tool: entries accumulate, and a negative value_in_ml is the documented way to correct an over-log. It does not, however, explicitly say to read with get_hydration_data first or name any exclusions, so it stops short of full when/when-not 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 burden, and it does disclose a genuine behavioral fact: the client validates unit_key against {'kg','lbs'} and rejects anything else with a specific error. That is real value beyond the schema. It still omits other mutation-critical behavior — whether a date/time is assumed, whether re-submitting overwrites, and any auth requirements.

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 docstring-style Args block is compact and easy to scan. The quoted error string is somewhat verbose but earns its place as a warning about a non-obvious validation trap.

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 values need not be explained, and the critical unit_key footgun is covered. But for a mutation with zero annotations, key facts are missing: the time/date semantics that distinguish it from add_weigh_in_with_timestamps and any indication of write scope or reversibility.

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, and it largely does: unit_key is given its valid enum values ('kg' or 'lbs'), explicitly rules out the ambiguous 'lb', and quotes the validation error. weight is documented only as 'Weight value', which is thin but sufficient for a plain number.

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 ('Add a new weight measurement'), so the agent knows exactly what the tool does. However, it gives no differentiation from close siblings like add_weigh_in_with_timestamps or add_body_composition, which a reader cannot distinguish from the description alone.

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 when-to-use guidance and no alternatives named. The sibling add_weigh_in_with_timestamps is an obvious fork (does this one use the current time instead of supplied timestamps?) and the description never addresses 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 behavioral burden. It does not state what happens if the timestamps are omitted (schema defaults them to null), whether an entry for that date is overwritten, whether permissions are needed, or any reversibility/duplication behavior for this write operation.

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

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

The one-line summary is front-loaded and the Args block is compact and scannable. Slight redundancy between the arg list and the schema, but no wasted prose.

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 values need not be explained, but for an unannotated mutation tool the description should clarify the relationship to add_weigh_in and whether the two timestamps are jointly required. Those gaps leave the agent guessing about when and how to use this variant.

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, and it largely does: it documents all four parameters, gives the accepted unit values plus a spelling warning, and specifies the exact timestamp format YYYY-MM-DDThh:mm:ss for both timestamp fields. It falls short on 'weight: Weight value' (tautological) and does not explain that both timestamps are optional or how they interact.

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 gives a clear verb+resource ('Add a new weight measurement') plus the distinguishing feature 'with specific timestamps', which separates it from the sibling add_weigh_in at a high level. However, it never explicitly states how it differs from add_weigh_in beyond the name, so the differentiation is implied rather than stated.

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 only reference to an alternative is inside the unit_key arg note ('Not lb; see add_weigh_in'), which is guidance about unit spelling, not about tool selection. Nothing tells the agent when to prefer this timestamps variant over add_weigh_in, or whether timestamps are required.

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 accurately portrays a read-only operation via 'Get' and 'Returns', and does not claim any side effects. However, it does not explicitly disclose that it does not modify data or mention error conditions, though these are largely implied by the verb.

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

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

The description is exceptionally concise, consisting of two short sentences that convey the purpose and output without any redundant or extraneous information. The structure is clean and front-loaded.

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

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

Given the tool's simplicity (no parameters, no annotations, no explicit output schema), the description fully explains what the tool does and what it returns. Agents can invoke it correctly without needing additional context.

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

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

The tool has no parameters, so schema coverage is effectively 100%. The description adds no parameter-specific information, but none is needed. The baseline score of 3 applies because the schema fully covers the (empty) parameter space.

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 with a specific verb ('Get') and resource ('total count of activities'), and implicitly distinguishes it from get_activities by focusing on the count instead of the list. The two sentences are concise and unambiguous.

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

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

The description implies the primary use case (obtaining a count) but does not explicitly state when to prefer this over get_activities or mention any alternative. No guidance on when not to use it is provided, leaving the decision to the 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 full burden. It usefully discloses that the workout is uploaded to Garmin Connect and that Garmin auto-adds T1/T2 transitions, but says nothing about authentication, whether the workout is also scheduled, or what happens on upload failure.

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?

Front-loads the one-line purpose and side effect, then presents parameters as a scannable list. The Args formatting is slightly verbose but every line carries parameter meaning.

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

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

An output schema exists, so return values need not be explained, and all inputs are documented. Only the workflow context (scheduling, auth, idempotency of re-uploading the same name) is left unaddressed.

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%, yet the Args block documents all seven parameters with units, defaults, and examples (e.g. HR zones defaulting to Z2/Z3), which is meaningfully more than the bare schema titles and defaults provide.

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 ('Create a brick workout (bike → run)') plus the side effect ('upload it to Garmin Connect'). The two-segment structure distinguishes it clearly from siblings like create_brick_swim_bike_workout and create_walk_run_workout.

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

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

Usage is implied by the purpose and by the default durations/zones, which suggest a standard brick session, but the description never states when to choose this over create_brick_swim_bike_workout or the single-discipline workout creators, nor any prerequisites.

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

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

No annotations are provided, so the description carries full burden. It usefully discloses the external side effect ('upload it to Garmin Connect'), which the schema does not convey, but it omits auth requirements, whether a duplicate is created on repeat calls, and any scheduling 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 opening sentence front-loads the action and the upload side effect, and the Args block is efficient per-line; it is slightly long but each line earns its place by defining an otherwise-undocumented parameter.

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 values need not be explained, and parameters plus the upload side effect are covered. The only gap for a mutation tool with zero annotations is the absence of prerequisite/auth and repeat-call behavior.

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: every one of the 8 parameters is documented with units and defaults (e.g. 'swim_distance_m: Swim distance in meters (default 1500)', pace as "M:SS/100m"), giving the agent more than the bare schema titles.

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 ('Create a swim → bike brick workout') and explicitly names the destination ('upload it to Garmin Connect'), which cleanly distinguishes it from siblings like create_brick_bike_run_workout and create_swim_endurance_workout.

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 multi-sport structure ('swim segment with pace target → bike segment with HR zone') implies the use case, but there is no explicit statement of when to pick this over a plain swim or cycling workout, nor any prerequisite or exclusion 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?

No annotations are provided, so the description carries the full burden. It discloses the success response (foodId and servingId) and the 204 fallback, but does not mention potential errors, authentication, or other side effects beyond creation. This is adequate but not fully 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 well-structured with an intro, behavioral notes, and an Args list. It is slightly long but every sentence adds value, including the fallback and unit conversion reminders. No redundant or filler 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 schema covers all parameters and an output schema exists (per context), the description adds necessary context about the response and fallback. It tells the agent what to do with the output (use IDs for logging) and how to handle a 204. Missing minor details like uniqueness constraints, but overall complete.

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

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

The schema has no descriptions, but the Args section in the description adds meaningful detail to every parameter, including units (mg, g, mcg) and clarifications like 'NOT %DV' for micronutrients. It also specifies allowed examples for serving_unit and defaults. This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states the specific verb 'Create' and the resource 'custom food in the user's Garmin nutrition library'. It also differentiates from siblings by noting that the returned foodId and servingId are needed for log_custom_food, making the purpose 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 provides actionable guidance: it explains the fallback to get_custom_foods when a 204 is returned, and instructs converting %DV values to absolute units. While it does not explicitly say when to use this vs update or delete, the purpose is clear and these guidelines are helpful.

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 disclose the important side effect that the workout is "upload[ed] to Garmin Connect," which an agent needs to know this is a write operation. However, it says nothing about auth requirements, whether re-creating a same-named workout duplicates or overwrites, or 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?

Front-loaded with the purpose and upload side effect in the first sentence, followed by a compact structured Args block. Every line carries information; the only mild redundancy is restating the ride shape in sentence two after sentence one already established it.

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 values need not be explained, and the parameter docs cover the 0%-coverage schema. The remaining gap is behavioral: for a mutation/upload tool with no annotations, the agent is not told about authentication or duplicate-handling. Still broadly sufficient to invoke correctly.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it documents all five parameters including the Z1-Z5 range for hr_zone and defaults for hr_zone/warmup_min/cooldown_min. It even clarifies that duration_min is the main ride length, implicitly distinct from warmup and cooldown. Minor gap: no explicit statement that name/duration_min are 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?

States a specific verb+resource ("Create a steady endurance cycling workout") and elaborates the structure ("a single continuous aerobic ride with HR zone target"). This clearly distinguishes it from the many cycling siblings (tempo, sweet spot, interval, over-under), which are all named after different workout shapes.

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

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

The description implies when to use it by defining the workout type (steady endurance vs. tempo/intervals), but never explicitly states when to prefer this tool over create_cycling_tempo_workout or create_cycling_sweet_spot_workout, nor any prerequisites such as needing a connected Garmin account.

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 does disclose the key side effect — the workout is uploaded to Garmin Connect — plus the deliberate absence of a power target and how the test is executed. It does not say whether the workout is scheduled, whether it requires authentication/device setup, or what happens on upload failure.

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?

Front-loaded with the action and resource, followed by protocol rationale, then a compact Args block. Slightly redundant with the schema, which already carries the same defaults and types, 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?

An output schema exists so return values need not be described, and the description covers parameters, the upload side effect, and the workout's intent. The remaining gap is scheduling/authentication context and any constraints on duration parameters.

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: all four parameters are named with their meaning and units (durations in minutes) and their defaults. It stops short of constraints such as minimum/maximum durations or whether test_min changes the workout structure.

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 states a specific verb (Create), a specific resource (20-minute FTP test cycling workout), and the side effect (upload to Garmin Connect). It clearly distinguishes itself from the many sibling create_cycling_* tools (endurance, tempo, sweet spot, interval, over/under) by naming the FTP-test protocol.

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 explains the workout's nature (no power target, free effort, max sustainable pace, average watts recorded) which implies when it is appropriate, but never states when to choose this over get_cycling_ftp or the other cycling workout builders, nor any prerequisite (e.g., needing a power meter).

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 usefully discloses that the tool both creates AND uploads to Garmin Connect, and that targets are encoded as power.between (ID 6) so the device shows '250-270W'. It does not cover authentication requirements, rate limits, duplicate-workout behavior, or failure handling on upload — meaningful gaps for an unannotated write 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?

The action is front-loaded in sentence one, followed by a short implementation rationale and a compact Args list. The Args block duplicates defaults already in the schema, but given 0% schema coverage that redundancy is largely justified.

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 values need not be described, and the parameter list is fully documented. For a mutation tool with no annotations, the only real gap is operational context (auth, upload failure, scheduling follow-up) rather than anything an agent needs to form a correct call.

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

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

Schema description coverage is 0% (properties carry only a title), so the description must compensate, and it does: the Args block defines all 8 parameters with units (watts, seconds, minutes), semantics, and defaults that match the schema. This is close to ideal compensation for a zero-coverage 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, resource, and training modality: create a power-based VO2max cycling interval workout and upload it to Garmin Connect. This is clearly distinguishable from siblings like create_cycling_tempo_workout, create_cycling_sweet_spot_workout, and create_cycling_over_under_workout without opening any schema.

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 'VO2max' and 'power-based' framing implies the intended training context, but there is no explicit when-to-use statement, no exclusion criteria, and no named alternative among the many create_*_workout siblings. The note about exact watt targets implies it is the right choice when the athlete wants absolute watts rather than zones, but that inference is left to the 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 full behavioral burden. It usefully discloses the two-step side effect (create then upload to Garmin Connect), but says nothing about the FTP prerequisite, authentication needs, error behavior, or whether the created workout is persisted/scheduled. Partial disclosure for a mutation 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?

Front-loaded purpose sentence followed by a one-line workout explanation and a clean Args block. Every line earns its place given the 0% schema coverage, though the description is slightly longer than strictly 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?

An output schema exists, so return values need no explanation, and the description adequately covers the create action plus the upload side effect. It is nearly complete for a create tool; the main gap is the undocumented FTP dependency and any failure/permission context, which matters more without 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 coverage is 0%, so the description must compensate, and it largely does: all 8 parameters are named with meaning, units (seconds, minutes, FTP percentage), and defaults. It stops short of giving valid ranges or interactions (e.g., reps vs segment durations), but adds substantial meaning beyond the bare schema titles.

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 (create), a specific resource (over/under threshold cycling workout), and a second action (upload to Garmin Connect). The over/under alternation pattern clearly distinguishes it from the many sibling cycling-workout tools (tempo, sweet spot, interval, endurance, FTP test).

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 workout concept (alternating over/under FTP targets) implies when an athlete would use it, but there is no explicit when-to-use, when-not-to-use, or routing to alternative workout tools. Usage must be inferred from the training description.

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 must carry behavioral disclosure. It does state that the workout is uploaded to Garmin Connect, which is an important side effect, and it describes the workout structure and all default durations. However, it omits prerequisites such as authentication, error behavior, and whether an existing workout is overwritten.

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 definition is front-loaded with the core action and then gives a compact workout structure summary followed by an Args list. It is appropriately sized, with only minor redundancy in repeating defaults already present in the schema.

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

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

The tool has a moderate six-parameter schema with no description coverage, no annotations, and an output schema. The description compensates for the parameter gap and discloses the Garmin upload, but it lacks guidance about when to use this workout creator versus sibling cycling workout tools and does not mention upload prerequisites.

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 documents all six parameters with meanings, units, and defaults, and gives an example format for the workout name. It does not mention accepted ranges or validation constraints, but it substantially closes the schema's semantic gap.

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

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

The description states a specific verb and resource: create a sweet spot interval cycling workout and upload it to Garmin Connect. It distinguishes this tool from sibling workout creators such as create_cycling_interval_workout and create_cycling_tempo_workout by specifying the sweet spot (Z4) block structure with active 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?

The description implies the tool's usage through the workout type and structure, but it does not explicitly state when to choose this over alternative cycling workout creators. There are no when-not conditions or named alternatives provided.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the key side effect that the workout is uploaded to Garmin Connect (a remote, non-read-only action), which is more than most siblings offer. It says nothing about authentication requirements, whether the upload is idempotent, whether it lands in the library vs. being scheduled, or 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?

Front-loaded with the core action and the most decision-relevant fact (upload to Garmin Connect), followed by a compact argument list. No filler sentences; only minor redundancy in restating defaults that also appear in the schema.

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

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

An output schema exists, so return values need not be explained, and parameter documentation is solid despite 0% schema coverage. What is missing is disambiguation among the five cycling workout variants and any note on the upload's effect on the athlete's Garmin account state.

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: all five parameters are named with meaning, defaults for hr_zone/warmup_min/cooldown_min are restated, and an example value ('Tempo 60m') is given for name. Critically, it supplies the Z1-Z5 range for hr_zone, a constraint absent from the schema (no enums defined).

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+resource ('Create a tempo/threshold cycling workout') and adds a notable second action, uploading to Garmin Connect. It partially differentiates from siblings by anchoring to the endurance variant ('Same structure as endurance but with a higher HR zone default'), though it does not distinguish itself from the sweet-spot, interval, or over-under cycling workouts.

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 'Same structure as endurance but with a higher HR zone default (Z3)' gives an implicit signal for choosing this over create_cycling_endurance_workout. However, there is no explicit when-to-use/when-not-to-use guidance and no mention of how it differs from the other cycling workout creators.

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 only says 'Log' and lists input constraints; it does not mention side effects, permissions, reversibility, validation failures, or whether it overwrites anything. For a write operation this is a significant gap.

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 purpose, followed by a useful type_key note and a compact Args list. It repeats a few defaults already in the schema, but the extra format details earn their place. No filler 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 7-parameter write tool with no annotations, the description covers the parameter space well and directs agents to the right reference for valid type_key values. It avoids explaining return values because an output schema exists. Missing error-handling details, but the essentials are 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%, but the description compensates thoroughly: it documents every parameter with formats (YYYY-MM-DD, HH:MM), defaults (09:00, UTC, 0.0, default to type_key), and a meaningful controlled vocabulary for type_key, including a pointer to get_activity_types. This adds exactly the meaning the schema lacks.

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: 'Log a manual activity in Garmin Connect'. The phrase 'manual activity' and 'without a watch' distinguishes it from workout-creation and upload tools like create_strength_workout or upload_workout. Clear intent, no ambiguity.

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 gives the primary use case ('useful for activities done without a watch') and instructs the agent to use get_activity_types for valid type_key values. It does not explicitly name alternatives or exclusions, but the context is sufficient for tool 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?

No annotations are provided, so the description carries the full burden. It usefully discloses that the workout is uploaded to Garmin Connect (an external write side effect), but says nothing about authentication requirements, whether re-running creates duplicates, or how failures behave. Adequate but thin for a mutating 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?

Front-loaded with the action and the sibling comparison in the first two sentences, followed by a compact args list. No filler; every line adds information an agent needs.

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 values need not be explained, and parameter defaults are covered. For a write tool with no annotations, the remaining gap is operational context such as auth requirements and duplicate-handling, but the core information needed to invoke it correctly 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, and it does: all five parameters are documented with meaning, units (minutes), and defaults (Z2, 10/10), including the Z1-Z5 range for hr_zone. Only the exact duration constraints and name formatting rules are left implicit.

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 ('Create an easy aerobic run workout') plus the side effect ('upload it to Garmin Connect'). It explicitly positions itself against the sibling create_run_workout, so an agent can distinguish the two without opening either schema.

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?

Names the alternative (create_run_workout) and gives the selecting condition: this one defaults to Z2 with shorter warmup/cooldown, i.e. use it for simpler easy runs. It does not state exclusions or what to do if the user wants a specific zone other than Z2, so it falls short of a full 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?

No annotations are provided, so the description carries the full burden. It usefully discloses the key side effect ('upload it to Garmin Connect') and the effort-based (non-target) nature of the workout, but says nothing about authentication needs, whether an existing same-named workout is overwritten, error behavior, or whether uploading also schedules it.

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?

Front-loads the action and side effect, then uses a compact structured Args block. Every line earns its place; only minor trimming is possible.

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 creation tool with an output schema (so return values need no explanation), the description covers purpose, workout structure, and all parameters. Gaps around upload side effects (overwrite/schedule behavior) and permissions keep it from being 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%, so the description must compensate — and it does, documenting all six parameters with meaning, unit (seconds vs minutes), and defaults. It falls short of full marks only because it omits valid ranges/constraints for values like reps or hill_sec.

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 ('Create a hill repeat running workout') and additionally specifies the structure ('Hill reps with jog-down recovery') and the target mode ('No target — effort-based'). This clearly distinguishes it from siblings like create_run_intervals_workout or create_run_tempo_workout, which are paced/target-based.

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 'No target — effort-based' phrasing implies when this workout is appropriate versus target-based siblings, but no explicit when-to-use, prerequisites, or named alternatives are given. Usage is inferable rather than stated.

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

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

No annotations are provided, so the description carries the full burden. It does disclose that the tool creates a workout and uploads it to Garmin Connect, which is important side-effect information, but it omits permissions, reversibility, rate limits, and error 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?

Front-loaded purpose statement followed by a clean Args list; no filler. Could be slightly tighter by merging defaults, but it is well-structured and 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?

Given seven parameters, no annotations, and an output schema that handles return values, the description covers purpose and all parameter semantics. It is missing explicit usage context and deeper behavioral details, but is otherwise complete enough to invoke correctly.

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

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

Schema description coverage is 0%, and the description fully compensates by documenting all seven parameters with meaning, units, defaults, and examples (e.g., distance_m in meters, hr_zone Z1-Z5). This adds substantial value beyond the bare schema titles.

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?

Specific verb 'Create' and resource 'track-style running interval workout', with scope 'upload to Garmin Connect' and a distinguishing detail about distance-based work intervals. Clearly separates it from sibling run workout creators like create_run_easy_workout or create_run_tempo_workout.

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 workout type implies when to use it (track-style intervals with distance-based ends), but there is no explicit when-to-use guidance, no mention of alternatives, and no exclusions. An agent must infer the context from the name and description.

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 does add real value by disclosing the upload side effect and the custom HR-band encoding detail (targetValueOne/Two, device showing '130-145 bpm' instead of 'Zone X'). But it omits auth/permission requirements, whether the upload is immediate or reversible, and failure behavior for a mutating, remote-upload 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?

Purpose is front-loaded in the first sentence, followed by the differentiating HR-band detail and a clean Args list. The encoder-bug sentence is implementation trivia but earns some place by explaining why the tool exists; overall it is tight and skimmable.

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 values need not be explained, and the description covers all parameters plus the notable upload side effect. The main remaining gap is the absence of any sibling differentiation, which matters given how crowded the create_*_workout family is.

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: the Args section documents all six parameters with units and defaults (hr_min 130, hr_max 145, warmup_min 10, cooldown_min 10), and the HR-band paragraph explains what hr_min/hr_max actually produce on-device. It stops short of stating valid ranges or constraints.

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

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

The description states a specific verb and resource ('Create a long run ... upload it to Garmin Connect') and the opening sentence makes the outcome clear. However, it never distinguishes this from the many sibling workout creators (create_run_easy_workout, create_run_tempo_workout, create_run_intervals_workout, create_run_workout, etc.), so an agent must infer the distinction from the name alone.

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

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

Usage is only implied by the word 'long run' — the description gives no explicit when-to-use versus when-not, and does not route to any of the ~10 similar run/workout creation siblings. There is no prerequisite or exclusion guidance, so the agent must infer 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?

No annotations are provided, so the description carries the burden. It usefully discloses the side effect that the workout is uploaded to Garmin Connect, which is meaningful for a mutation. However it says nothing about permissions, whether an existing workout is overwritten, or upload 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?

Purpose is front-loaded, then a compact conceptual explanation, then a well-organized Args section with a worked example. The two sentences about sequential blocks and increasing zones overlap slightly, 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?

An output schema exists, so return values need not be explained, and the description covers the create-and-upload behavior and all four parameters. The only gap is the absence of any mention of prerequisites or how the upload interacts with existing workouts.

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 carry everything — and it does: it documents name, the nested block keys (duration_sec as int seconds, hr_zone as Z1-Z5), a concrete three-block example, and the defaults for warmup_min and cooldown_min. This fully compensates for the undocumented 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 ('Create a progressive run workout and upload it to Garmin Connect') and defines the structure (sequential blocks with increasing zones, no recovery), which distinguishes it conceptually from interval-style siblings. It never names an alternative sibling (e.g. create_run_intervals_workout) to make the routing explicit, so it stops short of a 5.

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

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

The definition of a progression (sequential blocks, no recovery, increasing intensity zones) implicitly tells the agent when this tool fits, but there is no explicit when/when-not guidance and no sibling named as an alternative. Usage is inferable but not stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that it uploads a new artifact to Garmin Connect and lists the defaults applied when args are omitted, but it says nothing about authentication/permission needs, idempotency, or what happens on a duplicate name.

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?

Purpose is front-loaded in the first sentence, followed by a compact, well-labeled Args block. Every line carries information; the only mild redundancy is restating the Z4 default already implied by the annotation-free schema.

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

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

An output schema exists, so return values need no explanation, and the description covers purpose, all parameters, and defaults for a creation/upload tool. The main gap is the absence of any behavioral caveats (permissions, upload failures) in the absence of 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 documents all five parameters individually, including an example value for name and the Z1-Z5 range for hr_zone (an enum the schema lacks). It adds real meaning beyond the bare parameter titles, though it doesn't clarify units or interaction between duration_min and the tempo block.

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?

Specific verb ('Create') plus precise resource ('tempo/threshold run workout') and an explicit side effect ('upload it to Garmin Connect'). It even differentiates from the sibling create_run_easy_workout by noting the higher HR zone default, so an agent can separate it from the other run-workout creators.

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 'tempo/threshold run' implies when this is appropriate, and the comparison to 'easy run' hints at the alternative, but it never states when to choose this over create_run_easy_workout, create_run_intervals_workout, or the other run-workout siblings. Usage is left 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?

With no annotations, the description carries the full burden of transparency. It discloses the primary side effect (uploading to Garmin Connect) and the behavior of heart rate targeting with both named zones and custom ranges. It does not mention failure modes or reversibility, but for a creation operation this level of transparency is reasonably complete.

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 well-structured with a headline, an explanatory paragraph, and a parameter list. The heart rate zone example is detailed and valuable but adds a bit of length; overall, it is concise and every sentence serves a purpose without 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?

Given the tool's complexity and the existing output schema (though not displayed), the description adequately covers the input semantics and the primary action. It does not discuss return values, but since an output schema is indicated, that is acceptable. No prerequisites or error conditions are mentioned, but they are not essential for this creation operation.

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 explicitly explains every parameter in a bulleted list, including the nuanced behavior of hr_min and hr_max (must be given together, overrides hr_zone) and the default value of hr_zone. This adds substantial meaning beyond the raw schema, which only lists types and defaults, ensuring the agent understands exactly how to supply each argument.

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 creates a continuous run workout and uploads it to Garmin Connect, with a detailed explanation of a single uninterrupted run interval. It does not explicitly contrast with sibling workout creation tools like create_walk_run_workout or create_strength_workout, but the 'continuous run' phrasing and the example parameter values make the purpose 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 provides clear guidance on when to use hr_zone versus hr_min/hr_max, explaining the pitfall of named zones and the requirement to pass both min and max together. However, it does not explicitly state when to choose this tool over alternative workout creation sibling tools, leaving some ambiguity about the broader selection criteria.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It covers the create+upload side effect, the conversion of exercises to reps-based steps, how exerciseName is only retained when it matches Garmin's keys, and that invalid categories cause a 400 rejection. It also links to the authoritative category list, which is a strong transparency signal.

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 first sentence, followed by concise behavioral details and an Args block. Every sentence adds necessary information, and the long allowed-category list is linked rather than inlined. The length is justified by the number of constraints the agent must handle.

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 2-parameter tool with no annotations and a sparse schema, the description is the only guide to correct invocation. It fully specifies the payload shape, category validation, and Garmin's exerciseName behavior. The presence of an output schema means return values need no description, and nothing critical appears 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 0% and the schema only defines 'name' and an opaque 'exercises' array. The description compensates fully by specifying the required dict keys (name, sets, reps, rest_seconds, optional category), explaining category omission and allowed values, and documenting the failure mode. This adds essential 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 states a specific verb and resource ('Create a strength workout') and immediately adds the distinctive behavior 'upload it to Garmin Connect' plus 'Each exercise becomes a reps-based step.' This clearly differentiates it from siblings like create_run_workout or create_walk_run_workout, 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 detailed parameter constraints but never tells an agent when to prefer this tool over closely related siblings such as create_run_workout, create_walk_run_workout, or upload_workout. No alternatives or exclusions are mentioned, so an agent must infer tool selection entirely from the 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?

No annotations are provided, so the description carries the full burden. It does disclose a meaningful behavioral trait beyond the schema: the set is created and then uploaded to Garmin Connect, implying remote persistence. It omits authentication/scope requirements, whether the workout is auto-scheduled, and whether a failed upload leaves a partial state.

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?

Purpose is front-loaded in the first sentence and the Args block is compact and skimmable. The parameter documentation is longer than usual but justified because the schema supplies no field descriptions.

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 values need not be described, and the description covers the creation-plus-upload behavior plus every input including nested drill keys. Nothing critical is missing for an agent to invoke this 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 nested 'drills' items schema is a bare object with additionalProperties, so the description is doing the heavy lifting. It documents all five parameters, the per-drill keys, defaults for warmup_m/cooldown_m/pool_length, and the accepted equipment vocabulary, compensating for the schema gap; only 'stroke (str): stroke type' remains vague.

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 ('Create a swim drill set') plus the side effect ('upload it to Garmin Connect'), which is more than a name restatement. However, it does not distinguish itself from the several sibling swim-workout creators (create_swim_endurance_workout, create_swim_intervals_workout, create_swim_threshold_workout), so an agent cannot choose among them from the description alone.

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 when-to-use guidance, no statement of prerequisites, and no mention of the alternatives despite the crowded set of sibling swim/run/cycling workout creators. Usage is only implied by the tool name and the drill-oriented parameters.

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 usefully discloses a side effect beyond the schema — that the workout is uploaded to Garmin Connect — but says nothing about permissions, failure behavior, whether an existing workout is overwritten, or other operational constraints.

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

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

Purpose is front-loaded in the first sentence and the per-parameter list is scannable. It is slightly verbose but every line carries needed information, and nothing appears to be padding.

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 seven parameters, no annotations, and an existing output schema (so return values need not be explained), the definition is nearly complete: purpose, side effect, and all parameter semantics are covered. The only gap is the lack of any routing guidance relative to its many workout-creation siblings.

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 fully, and it does: it documents all seven parameters, gives the pace format ("M:SS/100m"), enumerates valid stroke types, and restricts pool_length to 25 or 50. This adds substantial meaning beyond the bare schema.

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

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

States a specific verb (create), resource (swim workout), and key attribute (continuous, with pace target), which implicitly separates it from the swim_intervals sibling. However, it does not explicitly distinguish itself from create_swim_threshold_workout or create_swim_drills_workout, so an agent still has to reason about the boundary.

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

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

There is no explicit when-to-use or when-not-to-use statement and no named alternative among the several create_swim_* siblings. The word 'continuous' hints at the distinction from intervals, but this is only implied and left 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?

With no annotations, the description carries the full burden. It does disclose the key side effect — the workout is uploaded to Garmin Connect — which is genuinely useful behavioral information. However, it says nothing about auth requirements, whether the workout is only uploaded or also scheduled, failure behavior, or whether it overwrites anything.

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 sentence is front-loaded and followed by an ordered arg list that reads quickly. Mild redundancy in restating defaults already present in the schema, but the added units and pace format justify most of 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?

An output schema exists, so return values need not be explained, and the description covers the creation-plus-upload behavior and all parameter meanings. It falls short only on the missing differentiation from sibling swim-workout creators and on failure/permission behavior for an unannotated mutation 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% (properties have titles only), so the Args block does the heavy lifting and does it reasonably well: it supplies units for every distance parameter, the 'M:SS/100m' format for pace, and an example value for name. Stroke type is named but its allowed values are not enumerated, which is the main 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 first sentence gives a concrete verb+resource ('Create a CSS threshold swim interval workout and upload it to Garmin Connect'), which is more specific than the bare name. However, it never differentiates itself from the very similar sibling 'create_swim_threshold_workout' (nor 'create_swim_endurance_workout' / 'create_swim_drills_workout'), leaving the agent to guess which swim workout creator to pick.

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 when-to-use, when-not-to-use, or alternative routing guidance. Given four sibling swim-workout creators, the description should say what makes this interval/CSS variant the right choice, but it offers nothing beyond the parameter list.

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

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

With no annotations, the description carries the full burden, and it does disclose the key side effect: the workout is uploaded to Garmin Connect, i.e. a remote resource is created. However, it says nothing about auth requirements, whether re-uploading duplicates, or failure behavior for a mutation 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?

Front-loaded with the action and the use case in two short sentences, then a structured Args list. The Args block largely restates schema fields but is justified by the 0% schema description coverage; no filler sentences.

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 values need no explanation, and all 7 parameters are covered. For an unannotated mutation tool the remaining gap is error/auth/idempotency behavior, but the creation-and-upload semantics are clear enough 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?

Schema description coverage is 0%, so the description must compensate, and it documents all 7 parameters with meaning plus format guidance ('pace as "M:SS/100m"', name example 'CSS Test 800m'). This substantially exceeds what the bare schema titles provide, though it doesn't explain unit/validity constraints for pool_length or stroke values.

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+resource: 'Create a single threshold swim set and upload it to Garmin Connect,' with the scope narrowed by 'single' and 'one continuous threshold block after warmup.' This implicitly separates it from create_swim_endurance_workout, create_swim_intervals_workout, and create_swim_drills_workout, though it never names those siblings explicitly.

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

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

'Good for CSS testing' gives an intended use case, which is more than nothing, but there is no explicit when-to-use/when-not guidance and no routing to the endurance, intervals, or drills swim-workout siblings. Usage is implied rather than stated.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It clearly states that the tool uploads to Garmin Connect and returns a new workout ID, which are the primary side effects and return value. It does not mention potential failure modes or authorization requirements, but the main behavioral traits are 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 concise, consisting of two sentences that convey the purpose and key outputs, followed by a parameter list that adds necessary semantics. No redundant or filler content is present. The structure is clear and 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?

Given the tool's moderate complexity (7 parameters) and the existence of a return value (workout ID), the description covers the essential purpose and parameters. It does not describe the output schema, but the returned ID is sufficient for many use cases. It lacks details on error handling or prerequisites, but within the context of sibling tools, it is reasonably complete.

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

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

The schema provides only titles and types with zero descriptions, so the parameter explanations in the description are essential. Each parameter is given a brief semantic definition (e.g., 'Duration of each run interval in seconds', 'Target heart-rate zone (Z1-Z5, default Z3)'), covering all seven parameters. It lacks constraints like minimum values or exact allowed enum values for hr_zone, but the core meaning is clear.

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

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

The description clearly states the verb 'Create' and the resource 'walk/run interval workout', and specifies that it uploads to Garmin Connect. The mention of 'walk/run interval' distinguishes it from sibling tools like create_run_workout and create_z2_walk_workout, making the purpose 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 does not provide any explicit guidance on when to use this tool versus the alternative creation tools (e.g., create_run_workout, create_z2_walk_workout) or upload tools. There is no mention of 'use this when...' or 'not for...', leaving the selection criteria implicit.

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 well: it discloses the multi-step side effects (uploads AND schedules all workouts), the required per-entry date, and the non-obvious failure mode where a missing date still uploads but reports schedule_error. It lacks any auth/permission or idempotency note, keeping it short of a 5.

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?

Front-loaded with the core action, then structured into behavior, format example, and edge case. The embedded JSON sample consumes space but earns it by pinning down the file format for a 0%-coverage parameter. Slightly long, but no filler sentences.

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 the description needn't detail return values, and it only briefly notes it 'returns a summary.' Combined with thorough format and edge-case documentation, it is complete enough for an agent to call correctly; only the absence of sibling routing and auth details keeps it from 5.

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 lone parameter has no schema description, so the description must compensate — and it does, defining plan_yaml_path as an absolute path to a JSON/YAML file and specifying the exact expected entry structure. This is far more than the bare schema conveys.

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

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

The description opens with a specific verb+resource: 'Create and schedule a full week of workouts from a plan file,' and even enumerates the internal steps (parse, map, upload, schedule). The purpose is unmistakable and reads as a high-level orchestrator. It does not, however, explicitly differentiate itself from close siblings like schedule_week or upload_workouts, so it stops short of a 5.

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

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

Usage is implied by the plan-file input: an agent can infer this is the bulk/week-batch entry point rather than the single-workout creators. But there is no explicit when-to-use/when-not guidance and no alternative named (e.g. schedule_week or the individual create_*_workout tools), leaving the routing decision 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?

With no annotations, the description carries the full burden, and it does disclose the key external side effect: upload to Garmin Connect. It also clarifies that hr_min and hr_max are used only for the description rather than setting the target, which prevents an incorrect assumption. However, it does not address duplicate names, overwrite behavior, or required permissions.

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

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

The description is two compact sections: a front-loaded purpose statement followed by a terse argument list. Every sentence contributes information, with no filler or repetition of the schema titles.

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

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

The description covers the operation, all required parameters, and the key side effect, and an output schema exists so return values need not be specified. It is only slightly incomplete in not addressing when to prefer this over sibling workout-creation or upload tools and in not documenting edge cases such as duplicate workout names.

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 parameter semantics fall entirely on the description, and the description documents all four required arguments with units and purpose. It usefully explains that hr_min and hr_max are descriptive only while the target is Z2, adding meaning the schema does not provide.

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: create a steady Z2 walking workout and upload it to Garmin Connect. The Z2 walking scope differentiates it from sibling tools like create_run_workout, create_strength_workout, and the more generic create_walk_run_workout.

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 use case (steady Z2 walking workout plus upload) is implied by the first sentence, but there is no explicit when-to-use guidance or exclusions. An agent is not told when to choose this tool over upload_workout, create_walk_run_workout, or create_run_workout.

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 well: it states the deletion is permanent, cannot be undone, and takes the activity and its recorded data with it. It does not mention authentication requirements or any server-side restrictions, but the core destructive profile is clearly 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 permanent-deletion warning is front-loaded and the guidance is efficient. The paragraph explaining why the tool exists ('Exists because create_manual_activity could write a record the server had no way to remove (§D9k)') is backstory that does not help an agent select or invoke the tool.

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 destructive single-parameter tool with no annotations, the description covers purpose, irreversibility, data loss, and intended use. An output schema exists so return values need not be explained, but permission prerequisites and whether recorded activities are technically deletable are left implicit.

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

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

Schema coverage is 0%, so the description must compensate. It adds 'ID of the activity to delete,' which gives the parameter's meaning, but the schema allows either integer or string and the description does not clarify which form is expected or provide examples.

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: 'Permanently delete an activity from Garmin Connect.' It clearly distinguishes itself from sibling readers like get_activity and sibling mutators like set_activity_name by naming the destructive action and target resource.

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

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

Explicitly says it is 'Intended for removing a manual activity logged in error' and warns to 'think twice before pointing it at a recorded session.' This gives clear when-to-use and when-to-be-cautious guidance, though it does not name an alternative tool for any edge case.

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

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

With no annotations, the description carries the full burden, and it does disclose the destructive nature plus the version-matching behavior (the version must correspond to the reading being removed, an optimistic-concurrency constraint not visible in the schema). It stops short of stating irreversibility, permission requirements, or failure modes on a version mismatch.

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 core instruction is front-loaded in the first two sentences, and the Args block is tight and useful. The parenthetical rationale about the server needing a delete path (§D9k) is meta-commentary that adds little for an agent choosing a tool, slightly diluting the otherwise efficient text.

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

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

Two required parameters are both documented with formats and provenance, an output schema exists so return values need no explanation, and the workflow dependency on set_blood_pressure is spelled out. Nothing needed to invoke this 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: 'date' is specified as YYYY-MM-DD and 'version' is defined as the value returned by set_blood_pressure or get_blood_pressure, which is essential given the schema's loose integer-or-string anyOf.

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 ('Delete') and resource ('a single blood pressure measurement'), and explicitly scopes to one reading rather than a bulk operation. It also names the sibling that produces the required identifiers (set_blood_pressure), making it distinguishable from get_blood_pressure and set_blood_pressure without opening any schema.

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?

Gives clear workflow context: call after set_blood_pressure and pass back the date and version it returned. It does not state explicit exclusions (e.g. what happens if the version is stale or whether deletion is permanent), but the 'when' is unambiguous for the primary path.

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 carries the full behavioral burden because no annotations are provided. It identifies the action as destructive, but does not disclose whether the deletion is permanent or irreversible, what dependent data may be affected, whether authorization is required, or how invalid IDs are handled. For a destructive tool with zero annotation coverage, this is a significant gap.

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

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

The description is very compact and well-structured: the first sentence states the operation, and the second line defines the sole parameter and how to source it. Every sentence earns its place; there is 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?

For a single-parameter destructive tool with an output schema present, the description supplies the essential call information: what to delete and how to get a valid ID. It lacks explicit irreversibility or edge-case caveats, but the overall operation is simple and the output schema covers return shape.

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 meaningfully compensates by explaining that `course_id` is the ID of the course to delete and by directing the agent to `get_courses` as the reliable source of valid IDs. This adds real value beyond the bare integer field.

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

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

The description opens with a specific verb-resource pair ('Delete a course') and identifies the exact domain ('Garmin Connect'), making the intended tool unambiguous even among siblings like `delete_workout`, `delete_weigh_ins`, and `upload_course`. No other plausible interpretation exists.

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 a genuine usage hint by telling the agent to obtain course IDs from `get_courses`, which is a useful prerequisite. However, it does not explicitly say when to use this tool versus alternatives or state any exclusions. The usage context remains mostly implied rather than explicitly spelled out.

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 present, the description carries the full burden and does disclose the key behavioral facts: the deletion is permanent, and there is a referential-integrity guard against foods used in logged meals. It does not say what happens on failure (error vs silent no-op) or whether the caller needs any special permission, which leaves a modest gap.

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?

Purpose and precondition are front-loaded, and the prose is tight. The trailing 'Args:' block is partly redundant with the schema but earns its place by supplying the hex-string format and provenance that the schema lacks.

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 values need no explanation, and for a single-parameter mutation the description covers the destructive nature and the blocking precondition. Remaining omissions are error semantics and auth expectations, which are secondary for an agent deciding whether and how to call it.

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

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

Schema coverage is 0% and the schema itself only offers a bare anyOf(integer|string) with no description, so the description must compensate and largely does: it defines food_id as a 32-char hex string and names the two tools that produce one. Note a minor tension — the schema also permits an integer, while the description implies a hex string is expected.

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 states a specific verb and resource ('Delete a custom food from the user's Garmin nutrition library'), scoping it to the custom-food library rather than food logs or workouts. This is enough to distinguish it from delete_food_log, delete_workout, and update_custom_food without opening any schema.

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 a clear workflow pointer ('Use get_custom_foods to find the foodId') and an explicit precondition ('must not be actively referenced in a logged meal'), which functions as a when-not rule. It stops short of naming a sibling alternative for removing logged entries (delete_food_log), so routing between the two delete tools still requires 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?

With no annotations, the description carries the full burden, and it delivers the most safety-critical fact: the removal is permanent (irreversible). It also notes the entry-type scope, which helps interpret effects. It omits auth/permission needs and error behavior, keeping it below 5.

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?

Front-loads the destructive action, then scope, then sourcing guidance, then per-argument detail. Every sentence adds information; the Args section cleanly mirrors the two parameters without waste.

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

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

For a 2-param destructive tool with an output schema (so return values needn't be explained), the description covers purpose, irreversibility, entry-type scope, ID sourcing, and both parameter formats. It's complete enough to call correctly, only missing edge/error handling nuance.

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 schema only offers a bare anyOf(integer,string) for log_id, so the description must compensate. It does: log_id is a 32-char hex UUID sourced from get_nutrition_daily_food_log, and meal_date is YYYY-MM-DD. This adds substantial meaning the schema lacks.

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 (Delete) and resource (food log entry / logged food item from the nutrition log), and clarifies it covers both QUICK_ADD and REGULAR_LOG entry types. This reasonably distinguishes it from the sibling delete_food (custom foods) and delete_activity, though it doesn't name those siblings explicitly.

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

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

Explicitly directs the agent to call get_nutrition_daily_food_log first to obtain the logId and date, which is real prerequisite guidance. It stops short of stating when-not-to-use or what to do if the entry is missing, so it doesn't reach a full 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?

No annotations are present, so the description carries the burden. It states the destructive action, but does not disclose whether deletion is permanent, what happens if delete_all is false, or any return/error 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?

Short, direct, front-loaded with the action and argument list; no unnecessary words.

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

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

The tool lacks output description and leaves delete_all false ambiguous; for a destructive operation, more context is needed to be 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?

It adds date format and describes delete_all as controlling whether all measurements for the day are deleted. It does not explain the false behavior or default, and there are no property-level descriptions in the schema.

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

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

Clearly identifies the action (delete), the target (weight measurements), and the scope (specific date). It is distinct from sibling add/get weigh-in 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 purpose statement implies the use case: call this when deleting weight measurements for a date. It does not explicitly mention alternatives or when not to use it.

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

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

No annotations are provided, so the description carries the full burden. It explicitly discloses that deletion is permanent, which is the critical behavioral warning for a destructive operation. It does not mention side effects on scheduled workouts, but the permanence statement is valuable and non-obvious.

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 main action, the permanent effect, and the only parameter are stated in three short sections. There is no filler or redundant information.

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

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

For a single-parameter tool, the description is mostly adequate for invoking it correctly. However, it omits important context about the sibling delete_workouts, whether deleting also unschedules workouts, and any authorization requirements. The output schema presence makes missing return-value details 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?

The schema only defines workout_id as an integer with 0% description coverage. The description compensates by explaining the parameter's role and pointing to get_workouts as the source of valid IDs, which is actionable guidance beyond the schema field name.

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 identifies the action as deleting a single workout from Garmin Connect and emphasizes that the removal is permanent. It does not explicitly contrast with the sibling delete_workouts, but the singular wording and single workout_id make the scope reasonably clear.

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

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

Provides a useful prerequisite by directing the agent to get IDs from get_workouts. However, it does not mention when to prefer this tool over delete_workouts or unschedule_workout, nor does it explain scenarios where deletion may be inappropriate.

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 of behavioral disclosure. It clearly labels the operation as permanent removal, which is essential for a destructive tool, and notes the batch nature of the call. It does not discuss failure behavior or permissions, but the core destructive consequence is 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 key purpose, then adds the permanence warning and a compact Args explanation. No extraneous 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?

For a simple one-parameter deletion tool, the description plus schema covers the action, the permanent effect, and the ID source. An output schema exists, so return-value details are not required. It could still mention the singular delete_workout alternative or what happens with invalid IDs, but nothing critical 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 0%, so the description compensates by explaining that workout_ids is a list of workout IDs and pointing to get_workouts as the source. This is sufficient for the only parameter.

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

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

The description states a specific action and resource: deleting multiple workouts from Garmin Connect and permanently removing them from the workout library. The word 'multiple' and 'single call' distinguish it from the sibling delete_workout, which appears to handle a single workout.

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 clear this is for deleting multiple workout IDs at once and tells the agent to obtain IDs from get_workouts. It does not explicitly mention when to use the singular delete_workout instead, so there is a small exclusion gap.

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, but the description fully discloses behavioral details: it saves a file to disk, overwrites existing files, supports a one-off output directory override that is not persisted, and returns a needs_setup status when no directory is configured.

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 well-structured and front-loaded, but the directory resolution and needs_setup behavior are described twice in nearly identical terms, adding minor redundancy.

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

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

The description covers the key operational context and user prompting flow, but it does not describe the actual return value on success or the response schema, leaving some ambiguity about what the caller receives.

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?

Although the schema description coverage is 0%, the prose explains all three parameters: activity_id is the Garmin activity ID, format has default 'fit' and supported values, and output_dir is an optional non-persisted override.

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 downloads an activity and saves it to disk as a file. It identifies the resource (activity), the action (download/save), and the output (file), which differentiates it from related tools like download_course_gpx and download_workout.

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 guidance on when to use the tool: it explains supported formats (fit, gpx, tcx, csv), the directory resolution precedence, and the fallback needs_setup behavior with instructions to ask the user and call set_fit_download_dir.

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 of explaining behavior. It discloses that binary data is not returned directly but confirms availability, which is a meaningful behavioral trait. However, it does not mention permissions, side effects, or any other behavioral details.

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

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

The description is concise and front-loaded with the primary purpose. It uses a clear first line followed by a brief elaboration and an explicit Args section, making it easy to scan and understand.

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, and the description covers the core action and an important limitation. While it does not specify the exact return value, the statement 'confirms the workout is available' implies a confirmation response, which is sufficient for this simple tool.

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

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

The schema provides only the parameter name and type (integer) with no description. The description adds the explanation 'ID of the workout to download', which clarifies the parameter's purpose but provides no additional detail about constraints, format, or default 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 clearly states the tool downloads a workout as a FIT file, naming the resource (workout) and action (download). It is distinct from sibling tools like download_course_gpx and download_activity_file, which target different resources.

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

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

The description does not indicate when to use this tool versus alternatives such as download_activity_file or upload_workout. It mentions a limitation (binary data cannot be returned) but offers no explicit guidance on selection criteria or preconditions.

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