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

With annotations limited to a title, the description carries the full burden and does well: it discloses that a real browser window opens, the user logs in normally, and only session cookies and CSRF token are captured and stored, never the password. It also warns about the headless-environment limitation, which is an important behavioral constraint beyond what the schema or annotations convey.

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

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

The description is concise and well-structured: first sentence states what the tool does, second specifies exactly when to use it, and third gives the key environmental restriction. Every sentence adds distinct value with no redundancy or filler.

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

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

For a zero-parameter tool with no output schema, the description provides complete operational context: what happens, what is stored, when to invoke it, and what environment it requires. No critical calling information is missing, and the sibling context reinforces the role without needing further detail.

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 the input schema is empty and there is nothing for the description to clarify. The baseline for zero-parameter tools is 4, and the description appropriately avoids inventing parameter details.

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 ('Authenticate with Garmin Connect'), names the exact resource (connect.garmin.com), and explains the mechanism (opening a real browser window and capturing session cookies/CSRF token). It also differentiates itself from the sibling workout tools by positioning itself as the authentication step tied to check_garmin_auth.

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

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

The description explicitly states when to run this tool: whenever check_garmin_auth reports no valid session or another tool returns a 'not authenticated' message. It also gives a clear environmental prerequisite and exclusion—requires a local display and will not work headless—which is valuable routing guidance.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the description adds valuable context beyond those: it uses a 'cheap authenticated request' rather than a local expiry check, explains why Garmin's session cookie lacks reliable expiry, and states the tool 'never throws.' This is useful behavioral detail the annotations do not convey.

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

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

The description is three sentences with no filler. It fronts the core purpose, then provides rationale and usage direction. Every sentence contributes necessary information about when and how to use 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 zero-parameter, read-only check tool with idempotent annotations and no output schema, the description is complete. It explains the purpose, the execution strategy, the failure mode, and the recommended next step. Nothing essential is missing for an agent to invoke it correctly.

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

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

The tool has zero parameters and the schema is empty, so there is no parameter ambiguity. The description appropriately omits parameter details, and the baseline for a zero-parameter tool is a 4.

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 identifies the tool as a probe for Garmin Connect session validity, using the specific verb 'Probe' and a distinct resource (stored session state). It also differentiates itself from the sibling tools by framing it as a preliminary check before 'whether the other tools will work.'

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

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

The description explicitly says 'Use this first when unsure whether the other tools will work,' giving a direct when-to-use instruction. It also names the alternative path, 'run authenticate_garmin if the session is missing or has expired,' making the decision clear.

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

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

Annotations carry only a title (no readOnly/destructive/idempotence hints), so the description bears the full behavioral burden. It discloses the return payload (workoutId and a Connect link) and a distinctive error mode (re-auth message rather than an exception for missing sessions). It does not cover idempotency or name-uniqueness behavior, but for a create action the mutating side effect is self-evident.

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: purpose, then routing, then return value, then error behavior, then example. Every sentence earns its place and there is no filler. The example makes it moderately long, but that length is justified by the nested complexity of the steps 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?

With no output schema, the description supplies return values and auth-failure behavior, and the schema covers all parameters at 100%. The only notable gap is not pointing the agent to the authenticate_garmin sibling when the re-auth message is received; otherwise the definition is complete for a complex, write-side tool with minimal 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 100%, so the baseline is 3. The description adds value beyond the schema through a concrete step/repeat-block example and a summarizing list of target types, which materially helps an agent construct the deeply nested 'steps' parameter correctly.

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

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

The description names a specific verb and resource ('Create a new structured workout in Garmin Connect') and enumerates the content scope: durations, pace/HR/power/cadence targets, repeat blocks, and swim-specific fields. It explicitly names the sibling it is not, update_garmin_workout, so an agent can route correctly without inspecting schemas.

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

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

'Use to add a workout; to change one that exists, use update_garmin_workout instead' is explicit when-to-use and when-not-to-use with a named alternative. The create-vs-update decision is the key routing ambiguity among the siblings, and it is resolved directly.

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?

Even though destructiveHint is already set, the description adds important behavioral context: the operation is irreversible, there is no undo or trash, and it returns an authentication prompt instead of throwing an error when no session exists. These details go beyond the annotation and meaningfully inform agent behavior.

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

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

The description is three sentences with no filler. The core action is front-loaded, followed by the irreversibility warning and the necessary preconditions/fallback behavior. Every sentence earns its place.

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

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

For a one-parameter destructive tool with no output schema, the description covers the purpose, the irreversible side effect, the recommended confirmation step, and the authentication failure behavior. Nothing critical is missing for an agent to invoke it correctly.

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

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

The single parameter workoutId is fully documented in the schema with its type and origin. The description mainly reinforces using the right ID by listing sources, but does not need to add more because schema coverage is 100%.

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 ('Permanently delete'), a specific resource ('workout from Garmin Connect'), and the key identifier ('by workoutId'). It is clearly distinguishable from sibling tools like update_garmin_workout or schedule_garmin_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?

It explicitly instructs the agent to use list_garmin_workouts or get_garmin_workout first to confirm the workoutId, which is actionable pre-use guidance. It also explains what happens when no valid session exists and directs the agent to authenticate_garmin, covering the main failure 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?

Annotations already mark readOnlyHint and idempotentHint as true, so the description's 'Read-only' is redundant. However, it adds the no-session behavior ('returns a message asking you to run authenticate_garmin rather than throwing') and clarifies that the full structure includes steps, targets, and repeat blocks, which is not covered by annotations. No contradiction with annotations.

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

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

Three sentences with no fluff. The core purpose is front-loaded, the update sibling relationship is placed second, and the auth note is last. Every clause earns its place, and the text is compact yet informative.

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

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

For a single-parameter read tool with no output schema, the description covers the return format (raw JSON with full structure), the exact use case, and the behavior when authentication is missing. Nothing an agent needs to decide whether or how to call it is left out.

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% — the workoutId parameter is already described as the numeric Garmin workout id from create/list. The description only repeats 'by its workoutId' without adding new meaning (e.g., format, validation, or source). Therefore, a 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 clearly states the verb 'Fetch' with the resource 'complete stored structure of one workout' and specifies the components (steps, targets, repeat blocks) and output format (raw JSON). It also differentiates from siblings by naming update_garmin_workout and authenticate_garmin, so an agent can distinguish it from list or delete operations 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?

It explicitly says 'Use this to inspect a workout, or to get its full contents before calling update_garmin_workout' and warns that update replaces rather than patches. It also addresses the auth edge case by mentioning authenticate_garmin as the alternative when no valid session exists. This gives clear when-to-use and a conditional fallback.

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 and idempotentHint annotations, the description discloses ordering (most recent first), the returned fields, and a non-throwing auth failure mode. This gives the agent useful behavioral expectations that the annotations alone do not cover.

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

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

Three sentences with no filler: the first states the core behavior, the second explains the workflow purpose and sibling relationship, and the third covers the auth edge case. Information is front-loaded and every sentence earns its place.

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

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

For a read-only listing tool with one documented parameter, the description is complete: it names the output fields, ordering, and failure behavior. There is no output schema, so the explicit return-field list is valuable and sufficient for an agent to call it correctly.

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

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

The single optional limit parameter is fully described in the schema with default, maximum, and semantics, so the 100% schema coverage earns the baseline. The description adds no additional detail about the parameter, but none is needed because the schema already carries that burden.

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

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

The description opens with a specific verb and resource: list workouts stored in the Garmin Connect account, and adds concrete details (most recent first, returning name/sport/workoutId). It references the sibling tools by name, making clear this is the list/index operation versus get/update/delete/schedule, so an agent can disambiguate immediately.

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

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

It explicitly states the intended use: find a workoutId to pass to get_garmin_workout, update_garmin_workout, delete_garmin_workout, or schedule_garmin_workout. It also handles the auth precondition by saying that an invalid session produces a prompt to run authenticate_garmin rather than failing, which routes the agent to the correct alternative.

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 provide only a title, so the description carries the behavioral burden. It discloses the scheduling side effect, the sync-to-device outcome, the prerequisite that the workout must already exist, and the non-throwing auth-failure behavior. It does not mention whether scheduling on a date replaces an existing scheduled workout, but it covers the most important behavioral traits.

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 tightly written sentences: purpose and outcome, prerequisite and exclusion, and error behavior. Every sentence contributes unique information and there is no filler or repetition of schema content.

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

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

For a simple two-parameter tool with no output schema, the description covers purpose, prerequisites, expected result, and failure behavior. It could ideally state the successful return value or confirmation format, but nothing essential for invoking it correctly appears to be missing.

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

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

Schema description coverage is 100%, with both parameters clearly documented in the schema itself. The description adds useful context about where the workoutId comes from, but does not need to add more parameter detail. A baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description opens with a specific verb and resource: 'Put an existing workout on the Garmin Connect calendar for a specific date.' It clearly states the outcome, that it schedules rather than creates, and distinguishes itself from create/list tools. This is exactly the kind of precise purpose statement an agent needs.

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

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

The description explicitly states the precondition that a workoutId must already exist from create_garmin_workout or list_garmin_workouts, and explicitly says 'this tool does not create workouts.' This gives clear when-to-use and when-not-to-use guidance, and points to the relevant upstream sibling tools.

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

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

The description discloses several behavioral traits beyond the annotations: this is a full overwrite, fields omitted are dropped, the workout id is preserved, and invalid sessions produce an authentication-prompt message rather than an exception. These details are not conveyed by the annotations or schema. There is no contradiction with the idempotentHInt.

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

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

Three sentences, no filler. The core action and overwrite semantics are front-loaded, followed by the critical warning and the auth-failure behavior. Every sentence carries useful 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?

The description is strong given the rich input schema and workflow guidance. It covers overwrite semantics, the need to fetch first, and authentication failure behavior. Minor gaps remain: it does not describe what a successful update returns, and it does not say what happens if the workoutId does not exist. These are not fatal, but they leave some ambiguity for an agent without an output schema.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds the important semantic that omitted fields are dropped, which affects how optional parameters like poolLength and poolLengthUnit are interpreted. Otherwise it does not add much per-parameter meaning beyond the schema's own descriptions, 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 states a specific verb and resource: 'Replace the entire contents ... of an existing workout, identified by workoutId, keeping its id.' It clearly distinguishes this from create_garmin_workout by emphasizing full overwrite on an existing workout and explicitly says it is not a partial patch. An agent can immediately tell this tool from its siblings 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?

Provides clear context and a concrete prerequisite: 'Call get_garmin_workout first to see the current contents before changing them.' It also warns that omitted fields are dropped, telling the agent to include all desired fields. It does not explicitly name create_garmin_workout as the alternative for new workouts, but the 'existing workout' language makes the intended use apparent.

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