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

Beyond the readOnlyHint/openWorldHint annotations, it discloses result ordering ('newest first') and the aggregate fields returned, which are genuine behavioral traits not derivable from the schema. It omits any mention of result caps, pagination, or account/auth requirements for a 1-year-max window.

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?

One front-loaded sentence that leads with purpose and scope before the metric list; no filler or restatement of the name. The field enumeration is long but each item earns its place by telling the agent what data it will get.

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-optional-parameter read tool with an output schema that already documents return structure, the description covers purpose, window, ordering, and content. Only the default-window behavior and any result limits are left unstated.

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 carries the burden for the single 'days' parameter. 'Last N days' does convey that it is a backward-looking time window, but it omits the default of 7 and the 1–365 bounds that the schema supplies structurally.

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 resource (recorded activities) with scope ('last N days, newest first') and enumerates the metrics returned, which clearly separates it from siblings like garmin_workouts_list or garmin_sleep. It does not explicitly name a sibling it is not, 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 only implied: 'recorded activities' suggests completed workouts rather than planned ones, which is the main distinction from the workout siblings, but that contrast is never stated. There are no exclusions, prerequisites, or pointers to alternatives such as garmin_workouts_list for planned sessions.

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

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

Beyond the readOnlyHint/openWorldHint annotations, the description adds a genuinely useful cost signal: 'Makes about 3 Garmin requests per day', letting an agent estimate load for large 'days' values. It also clarifies a structural quirk — most fields are per-day while fitness age is a single current value, and weigh-ins are only present 'any' day one exists. It does not discuss auth requirements or failure behavior, so not 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?

Three tight sentences; the payload of returned fields is front-loaded and the cost note is placed at the end where it is easy to scan. The long field enumeration is dense but each item earns its place by telling the agent what data is available; only the trailing 'plus current fitness age' is slightly ragged in structure.

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

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

With an output schema present and annotations covering safety and open-world scope, the description only needs to convey content and cost — both are covered. The remaining gap is that it never says how the per-day records are aggregated or ordered, though the output schema likely resolves that.

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

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

The single 'days' parameter already has a full schema description ('Number of past days, including today') at 100% coverage, so the baseline is 3. The description's 'per day' wording reinforces the day-granularity interpretation but adds no format, range, or default detail beyond the schema.

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

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

The description enumerates the exact data returned (body battery, steps vs. goal, distance, calories, floors, stress, HR range, intensity minutes, respiration, SpO2, weigh-in, fitness age), which makes the resource unambiguous and implicitly separates it from siblings like garmin_sleep, garmin_readiness and garmin_hr_zones. It lacks an explicit verb (e.g. 'returns'/'fetches') and never names a sibling for direct contrast, so it falls 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 only implied by the field list — an agent can infer 'use when you need daily wellness summaries', but there is no explicit when-to-use statement, no condition selecting it over garmin_sleep or garmin_readiness, and no exclusion guidance. The 'per day' framing with the default of 3 days gives a hint about granularity but not about tool selection.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuine context beyond that: the values are in bpm and reflect the user's own Garmin settings rather than defaults, which matters for interpreting returned numbers. It says nothing about caching, latency, or what happens if zones are unset in Garmin.

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

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

Two short sentences, no filler, with the identity of the data front-loaded before the call-ordering instruction. Every sentence carries information the 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 the description covers purpose and call sequencing for a simple one-parameter lookup. The remaining gap is the undocumented sport parameter, which is the only thing an agent could get wrong here.

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 never mentions the sport parameter, so it adds no meaning beyond the enum values run/ride and the run default. It is left unclear whether zones differ per sport, which is the main semantic question an agent would have about this parameter.

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

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

States a specific verb and resource — the user's own heart-rate zones in bpm, sourced from Garmin settings — which is unambiguous and clearly distinct from siblings like garmin_readiness or garmin_body_metrics. An agent knows exactly what data this returns without opening the 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 an explicit trigger condition: call it before garmin_workout_create whenever a workout is described by zone, naming the specific downstream sibling. It does not state any when-not-to-use conditions, but for a narrow read-only lookup tool that omission is minor.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety and external-service profile is covered. The description adds that output includes both race predictions and current VO2max, which is useful beyond the annotations, but says nothing about data freshness, required device or permission scoping.

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

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

A single front-loaded sentence that lists the returned metrics with no filler. Nothing redundant given the empty 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?

With no parameters, an output schema present, and annotations covering safety and open-world behavior, the definition is essentially complete. Only minor context such as data currency or the Garmin account requirement is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies; the description correctly avoids inventing parameter detail.

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

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

The description names the concrete data returned — predicted 5K, 10K, half marathon and marathon times plus VO2max — so an agent knows exactly what this fetches. It does not explicitly distinguish itself from nearby siblings like garmin_readiness or garmin_body_metrics, but the data domain is distinct enough to tell them apart.

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 suggestion. The agent must infer that this is the right tool when race-time forecasts or VO2max are requested, purely from the data types named.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful context beyond that: an approximate request budget of ~3 Garmin calls per day, which matters for an external API with likely quota constraints. It doesn't discuss latency or failure modes, so not 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?

Three tight sentences: metrics first, use cases second, cost caveat last. Every sentence carries distinct information and the most decision-relevant content is front-loaded.

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

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

With only one optional parameter at full schema coverage, an output schema already defining return values, and annotations covering the read-only nature, there is nothing an agent needs to call this correctly that is missing.

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

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

The single parameter has 100% schema coverage, including its default of 3 and range of 1-30, so the schema carries the semantics. The description says nothing about the days window or how it affects returned metrics, so it adds no meaning beyond the schema — baseline 3 is appropriate.

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

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

The description names the specific resource and enumerates the metric families returned: training readiness, recovery time, HRV vs baseline, training status and load, VO2max, endurance and hill scores. That precision distinguishes it from siblings like garmin_sleep or garmin_body_metrics without the agent needing to open 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 explicit trigger questions ('am I recovered?', 'should I go hard today?') that map directly to intent, which is strong when-to-use guidance. It stops short of naming an alternative sibling or stating when not to use it, so it falls just short of the top band.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds no behavioral context beyond the annotations — it is purely a restatement of return fields, which the output schema already carries, and says nothing about missing nights, timezone handling, or data availability.

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?

One compact sentence with no filler, and the most important signal (per-night granularity) is front-loaded. The comma-separated field list is dense but readable.

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

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

With an output schema present, the description needn't explain return values, yet that is nearly all it does. It is adequate for a simple one-parameter read tool but omits any framing of scope, data gaps, or relationship to sibling health tools.

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

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

Schema coverage is 100% and the single 'days' parameter is fully documented in the schema (default 7, range 1-30). The description never references the lookback window, so it adds no meaning beyond the schema; baseline 3 applies.

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

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

The description enumerates the specific resource (per-night sleep metrics: score, duration vs sleep need, stage minutes, HR, HRV, stress, respiration, restlessness), which makes the tool's domain unmistakable. It lacks an explicit verb ('retrieve') and never distinguishes itself from overlapping siblings like garmin_readiness or garmin_body_metrics, 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?

There is no when-to-use guidance, no mention of the days window in prose, and no routing to or away from alternatives such as garmin_readiness. The agent must infer usage entirely from the field 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds real boundary semantics ('including today', forward-only window) and the identity fields returned, but says nothing about behavior when the calendar is empty or about date/timezone handling.

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

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

Two sentences, front-loaded with the scope and immediately followed by the returned identifiers. The mention of schedule_id and workout_id partly duplicates the output schema, but the parenthetical pointing at garmin_workout_unschedule earns its place.

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

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

With an output schema present and readOnly/openWorld annotations supplied, the description need not explain return shape, and it covers scope, inclusivity of today, and follow-up chaining. Only minor gaps remain, such as empty-calendar 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%, but the single 'days' parameter is fully disambiguated by the phrase 'next N days, including today', which resolves whether the window is forward-looking and whether today counts. Default (14) and bounds (1-60) are left to the schema's default/maximum fields, so the description carries the semantic load that matters.

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 resource and scope: workouts on the user's Garmin calendar within a forward-looking day window, including today. This implicitly separates it from garmin_workouts_list (the workout library), though it never names that sibling 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?

There is no explicit when-to-use or when-not-to-use guidance relative to garmin_workouts_list or garmin_workout_get. It does, however, route the agent forward by noting schedule_id is the input for garmin_workout_unschedule, which is useful chaining context.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the write/non-destructive profile is already structured. The description adds useful context beyond that: the workout syncs to a physical watch and optionally lands on the user's calendar. It stops short of saying whether creation is idempotent or what happens on invalid step 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?

Three short sentences, each doing distinct work: purpose, optional scheduling, step-encoding rule, plus a routing pointer. The core operation is front-loaded with no filler.

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

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

An output schema exists, so return values need no explanation, and the description covers the tricky nested step encoding that the schema alone leaves implicit. The remaining gap is the relationship to garmin_workout_schedule and whether scheduled_date duplicates or replaces that tool's role.

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?

Top-level schema description coverage is 0%, so the description carries real weight, and it does explain the two non-obvious parameters: scheduled_date's calendar effect and the required flat-list shape of steps ("5x1km is 5 interval+recovery pairs"). It adds nothing about name or sport, and the nested WorkoutStep fields rely entirely on their in-schema descriptions.

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

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

The description gives a specific verb and resource ("Create a structured workout in Garmin Connect") and adds scope ("ready to sync to the user's watch"). It explicitly distinguishes itself from garmin_workout_update, so an agent can separate create from modify 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?

It names the alternative for the modify case (garmin_workout_update) and states the condition for calendar placement via scheduled_date. However, it never addresses the sibling garmin_workout_schedule, leaving ambiguous whether an agent should pass scheduled_date here or call the schedule tool separately.

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

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

Annotations already flag destructiveHint=true, but the description adds what those annotations cannot: the deletion is irreversible, it also removes the workout from the calendar, and it requires a human confirmation step. That is exactly the behavioral context an agent needs before firing a destructive call.

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

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

Three short sentences, front-loaded with the destructive scope, then the irreversibility warning, then the confirmation workflow. Nothing is wasted or buried.

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 and full annotation coverage, the description supplies the safety and confirmation context an agent needs. The only gap is not explicitly ruling out unschedule as the alternative when the user merely wants the workout off the calendar.

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

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

Schema coverage is 100% and the schema's own field description already says "From garmin_workouts_list," so the description's ID provenance note largely repeats structured data. Baseline 3 is appropriate when the schema carries the parameter meaning.

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

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

States a specific verb and resource ("Permanently delete a workout from Garmin Connect") and adds scope ("including from the calendar"), which distinguishes it from garmin_workout_unschedule in the sibling list. An agent can pick it out without opening the 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 a clear precondition (obtain explicit user go-ahead after naming the workout) and constrains the ID source to garmin_workouts_list. It stops short of explicitly contrasting with garmin_workout_unschedule, though "including from the calendar" implicitly signals the broader scope.

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

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

Annotations already establish readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description goes further by disclosing a non-obvious behavioral trait: repeat groups are returned expanded as individual steps, meaning the returned structure is flattened/lossy relative to the stored definition. That is exactly the kind of context an agent needs before round-tripping into garmin_workout_update, though error behavior for a missing id is not mentioned.

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

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

Two short sentences, zero filler. The core capability is front-loaded and the caveat about repeat-group expansion follows as supporting detail. Nothing could be removed without losing 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?

An output schema exists, so return values need not be documented, and the single id parameter is fully described in the schema. The description covers the round-trip use case and the flattening caveat, which is what matters most for this read tool. Only the not-found/error case is left unaddressed, a minor gap at this complexity level.

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?

There is a single required parameter with 100% schema description coverage, and the schema already explains where the id comes from ('From garmin_workouts_list'). The description adds no further semantics about the id, so the baseline of 3 applies — the schema does the work and the description does not need to compensate.

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

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

The description states a specific resource and scope: 'One saved workout with all of its steps', which clearly distinguishes it from the plural garmin_workouts_list sibling. It also names the downstream consumer (garmin_workout_update) whose input format the result matches. It never uses an explicit verb like 'retrieve', but 'One saved workout with all of its steps' is unambiguous enough for an agent to know the purpose.

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: the note that the result is 'in the format garmin_workout_update accepts' hints at a get-then-update round trip, and the schema's 'From garmin_workouts_list' points at the prerequisite listing call. There is no explicit 'use this when...' or exclusion against siblings like garmin_upcoming_workouts or garmin_workouts_list, leaving the agent to infer the selection criteria.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so the write-to-external-calendar nature is partly covered. The description adds that the target is the user's Garmin calendar, but says nothing about idempotency, what happens if a workout is already scheduled on that date, timezone handling, or whether the operation can be undone — meaningful gaps 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?

A single front-loaded sentence with the action, target resource, and scoping dimension in that order. No filler, no redundancy with the title or 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 annotations cover the safety profile. However, for a calendar-mutating tool the description omits conflict/overwrite behavior and timezone assumptions, leaving an agent without guidance on edge cases it will likely encounter.

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

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

Schema description coverage is 100%: workout_id already documents its source ('From garmin_workouts_list') and scheduled_date documents the YYYY-MM-DD format. The description adds no syntax, format, or constraint detail beyond the schema, so the baseline 3 applies.

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

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

The description gives a specific verb ('Put') and resource ('a saved workout on the user's Garmin calendar') plus the scoping parameter (a date), which is enough to distinguish it from siblings like garmin_workout_unschedule or garmin_workout_create. It stops short of naming those siblings explicitly, so it is clear but not maximally differentiated.

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 'saved workout' (the workout must already exist, presumably from garmin_workouts_list), but there is no explicit when-to-use/when-not guidance and no mention of the unschedule sibling as the inverse operation. An agent can infer the context but is not told about alternatives or preconditions such as whether the workout must be created first.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety profile is covered. The description adds only that results come from the user's saved library versus scheduled items, and that workout_id is included. It says nothing about pagination, ordering, or the default cap that would affect completeness of the result.

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

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

Two sentences, purpose first, usage second, with no filler. Every clause carries information the agent needs to route correctly.

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

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

An output schema exists, so return-value detail is unnecessary. However, for a tool explicitly recommended as an existence check, silence on the default limit of 20 is a material gap that could produce false negatives on large libraries. Otherwise adequate for a one-optional-param read tool.

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

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

The single `limit` parameter has 0% schema description coverage, and the description never mentions it or that the list is truncated by default. An agent reading only the description would not realize the result set is capped at 20 and may wrongly conclude a workout does not exist.

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?

"Saved workouts in the user's Garmin library with their workout_id" names the resource and the key field returned, which is enough to separate it from garmin_upcoming_workouts (scheduled) and garmin_workout_get (single fetch). The listing verb is only implied by the noun phrase rather than stated, which keeps it 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?

It gives two concrete situations: find a workout to modify, and de-duplicate before creating. That is actionable context tied to the workflow of garmin_workout_update and garmin_workout_create. It stops short of naming a sibling alternative such as garmin_upcoming_workouts for the scheduled case, so no explicit 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered. The description adds genuinely new behavioral context: the destruction is limited to the calendar entry and the workout object survives in the library, which materially changes how an agent should weigh confirmation. It omits idempotency/error behavior if the schedule_id is not currently scheduled.

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

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

Two short sentences, zero filler, with the scope of impact front-loaded right after the action. Every clause carries 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?

A single-parameter mutation with full schema coverage and an output schema, so the description need not explain return values. What remains is minor: it does not mention preconditions (the workout must currently be scheduled) or whether the operation is reversible.

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

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

Schema description coverage is 100% and the single parameter already carries strong guidance ('From garmin_upcoming_workouts. Not workout_id.'). The description adds nothing about the identifier, so the baseline 3 for fully documented schemas applies.

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

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

States a specific verb and resource ('Remove a workout from the calendar') and immediately scopes the effect ('The workout stays in the user's library'), which implicitly separates it from garmin_workout_delete. It does not name that sibling explicitly, so the distinction is inferred 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 retention note implies when this tool is appropriate (calendar removal without permanent loss), but there is no explicit redirect such as 'to remove permanently from the library, use garmin_workout_delete'. An agent must infer the alternative from the sibling list rather than the 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?

Annotations already declare destructiveHint=true and openWorldHint=true, but the description goes further by explaining the concrete mechanism: Garmin replaces the entire workout, so any step not passed is lost. It also states the compensating benefit that the id and calendar dates survive, which annotations cannot convey.

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

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

Two sentences, zero filler. The destructive core behavior and the preserved id/dates are front-loaded, and the read-first pointer is the last thing an agent sees before acting.

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 mutation tool this covers the essentials: what is replaced, what is kept, and how to inspect current state first. Return values are covered by the output schema, and the remaining gap is the unmentioned name/sport semantics.

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 only 25%, so the description must compensate, and it does partly by establishing that the step list must be COMPLETE rather than a delta. However, it says nothing about the required name parameter or the sport enum, leaving those entirely to the terse 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?

States a specific verb and resource ("Replace a workout in place") and pins down the scope distinction that matters against siblings: the id and calendar dates are preserved, unlike a create. An agent can distinguish it from garmin_workout_create and garmin_workout_get 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?

Gives explicit routing guidance for the read path: "read it with garmin_workout_get first if needed," naming the sibling and the condition. It does not explicitly tell the agent when to prefer garmin_workout_create instead (new workout vs. in-place replacement), which 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.