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

The description discloses trimming of warm-up/cool-down by default and reporting insufficient data, which adds behavioral context beyond the readOnlyHint and destructiveHint annotations. It does not contradict annotations and provides useful operational detail.

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 concise, front-loaded sentences express purpose and a key behavioral default without any filler. Every phrase 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?

The description lacks essential details for an analysis tool: no output format, no units for decoupling, and no specification of sportType values. It mentions insufficient data but not what a successful result looks like. Given the lack of an output schema and low parameter coverage, the description is incomplete for correct invocation.

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

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

Schema description coverage is only 33% (trimPercent has a description, activityId and sportType do not). The description mentions trimming indirectly but does not clarify activityId purpose or sportType allowed values. It fails to compensate for the low coverage, leaving two required parameters ambiguous.

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 calculation (aerobic decoupling) for a defined resource (completed running/cycling activity) with a method (comparing halves). It distinguishes from generic analysis siblings like analyze_completed_activity by naming the exact metric and scope.

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

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

Provides strong context for when to use (completed running/cycling activity) but does not explicitly mention alternatives or when not to use. The agent can infer applicability from the description, but explicit routing to alternative tools would improve 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?

Annotations already carry read-only/non-destructive context, so the description credits by adding a concrete behavioral detail: COROS may reject detailed strength data and supplying the date enables a summary fallback. This is genuinely useful beyond the annotations and not contradicted by them.

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 earning its place: the purpose comes first, supported domains second, and the fallback behavior last. There is no fluff, no repetition of annotations, and no redundant wording.

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 only vaguely says the result is a 'compact coach-ready analysis,' which is a bare minimum for understanding return value shape. It does cover the fallback bound, but it lacks edge-case guidance such as what happens for invalid or incomplete activity data, and it never helps differentiate this from closely related analytic 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?

The schema only documents the date property, so the description carries most of the load for sportType and activityId meaning. It makes sportType more meaningful by naming endurance, strength, walking, hiking, mobility, and active recovery, and it explains why the date matters. It does not specify valid sportType integer values or clarify activityId semantics beyond the obvious activity resource.

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

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

The description states a specific verb and resource: 'Return a compact coach-ready analysis of any completed activity.' This clearly separates it from raw data retrieval tools like get_activity_detail or list_activities. However, it does not explicitly differentiate it from other analysis siblings such as analyze_fit_activity or analyze_workout_execution.

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

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

The description gives useful context about supported sports and the date-based fallback for COROS rejecting detailed strength data. It never says when to choose this tool over the many sibling analysis tools, nor does it name alternatives or exclusion cases. Usage is implied rather than explicit.

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

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

Annotations already signal read-only and non-destructive behavior. The description adds genuinely useful behavioral context by promising bounded summaries and explicitly ruling out raw sample return, preventing an agent from expecting full record data. It does not mention authentication or latency, but the annotations cover the safety profile.

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

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

A single dense sentence front-loads the verb, resource, and scope, then lists the output categories and the one critical exclusion. There is no filler or repetition of schema 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?

With 10 parameters at 0% schema coverage and no output schema, the description leaves substantial gaps: parameter semantics are missing, and return values are only summarized at a high level rather than structurally explained. Scope and output categories are covered, but too much is left for the agent to infer.

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

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

Schema description coverage is 0%, and the description does not explain any of the 10 parameters. The metric list hints at related parameters (e.g., climbs, stops, cadence, HR), but the agent gets no guidance on what targetCadenceMin/Max, stopSpeedMetersPerSecond, stopBoundaryIgnoreSeconds, or maxReturnedClimbs mean or how to choose them.

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

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

Description names a specific verb+resource: download and analyze the FIT file for a completed COROS activity. It distinguishes its output (bounded summaries of HR/cadence/speed/power/temperature/stops/climbs/aerobic decoupling/finish quality) from siblings like get_activity_detail by explicitly stating raw samples are not returned.

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 scope is clearly limited to completed COROS activities and the analysis returns summarized record-level metrics, giving the agent clear context for when to call it. It does not, however, name alternatives or exclusion criteria, leaving sibling disambiguation 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by stating 'without external writes' and enumerating the return fields, giving the agent a clear expectation of the output even without an output schema. 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?

The description is two sentences with zero filler. It front-loads the core purpose and immediately states outputs, making it efficient and easy to parse.

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 absence of an output schema, the description adequately covers the return content (distance, elevation, endpoints, sectors). It does not describe error handling or edge cases, but for a read-only analysis tool with annotations already covering safety, this 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?

Schema coverage is 50% (only gpxXml has a description). The description's mention of 'compact fixed-distance sectors' implicitly relates to segmentDistanceKm, but it does not explicitly explain the parameter's role or range. The description partially compensates for the missing schema description but could be more direct.

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

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

The description uses a specific verb 'Analyze' and resource 'GPX track or route', and lists concrete outputs (distance, elevation, endpoints, sectors with coordinates, grade, bearing). It distinguishes itself from sibling analysis tools by focusing specifically on GPX routes and emphasizing read-only behavior ('without external writes').

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

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

The description implies usage for GPX route analysis but does not explicitly mention when to use this tool versus alternatives like analyze_route_weather or simulate_ultra_route. It lacks exclusions or conditions that would route an agent to the correct sibling, leaving the selection to inference 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?

Annotations already declare readOnlyHint and non-destructive behavior. The description adds meaningful behavioral context beyond that by explaining that COROS cardiovascular load is kept separate from heuristic impact exposure and recorded strength duration, which is valuable and not just a restatement of safety flags. 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?

Two concise sentences with no filler. The main action and scope are front-loaded, and the second sentence adds important detail about how load components are treated. Every phrase contributes value.

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

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

The description is adequate for selecting the tool, but without an output schema it does not describe what the aggregate result looks like or what units are returned. Given the complexity of separating multiple load types, some indication of return shape or metric breakdown would make the definition more 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?

With 0% schema description coverage, the description must compensate for the two parameters. It adds the concept of a 'date range', tying startDate and endDate together, but does not specify format, bounds inclusivity, timezone handling, or any other semantics an agent might need to pass valid 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?

The description uses a specific verb ('Aggregate') and a clear resource ('date range across cycling, running, trail, walking, hiking, strength and mobility'), which states what the tool does. It is clearly distinct from sibling analysis tools by naming the exact sport scope and the load-separation behavior, though it does not explicitly name a competing alternative.

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 context is implied: it should be used when aggregating load across the listed sports over a date range. However, there is no explicit when-to-use guidance, no exclusions, and no comparison to related tools like weekly_training_report or summarize_planned_load, leaving the agent to infer the right 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?

The description adds a read-only/reporting intent and names outputs such as risks and daylight, which is useful beyond the annotations. However, it does not disclose external-service implications, error behavior, or whether the GPX is stored or altered. It does not contradict the 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?

Two sentences, with the core operation front-loaded and a dense but relevant list of reported weather metrics. The balanced bullet-style list in the prose is efficient, though a less ambiguous wording for 'explicit risks' would slightly improve 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?

This is a 5-parameter, moderately complex forecast tool with no output schema, yet the description does not cover output units, error conditions, or how inputs should be composed. It only broadly lists the outputs, leaving meaningful gaps for an agent to correctly invoke and interpret the tool.

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

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

Only a small portion of the parameters are described in the schema, so the description carries the burden of defining the rest. It adds the concept of sector evaluation, which clarifies segmentDistanceKm somewhat, but it leaves totalStopMinutes and averageMovingSpeedKmh largely to name and defaults, and does not explain units or bounds.

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 (combine a GPX route with forecasts) and a specific sense of the result (sector-level weather/risks). The metric enumeration clearly distinguishes it from nearby siblings like analyze_gpx_route.

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

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

The description implies it is for weather-aware route analysis, but it does not not explicitly say when to choose it over analyze_gpx_route or plan_operational_route, nor does it exclude those alternatives. Usage is inferred from content, not explicit.

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

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

Annotations already establish read-only and non-destructive behavior. The description adds useful behavioral context by stating that it covers all completed activities, that classification follows 'transparent rules', and that the planned calendar is returned as part of the result. This goes beyond what the annotations alone reveal.

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, front-loaded with the main action and scope, and every sentence serves a purpose: one for the analysis coverage, one for classification behavior and the planned-calendar output. There is no redundant filler.

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

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

For a single-parameter read-only tool, the description is largely sufficient: it names the input, the scope, the activity types, and the return contents. The phrase 'transparent rules' is vague and there is no output schema, so an agent still lacks detail on the exact classification output format.

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 'date' has full schema description coverage, so the schema already carries the formatting details. The description adds little beyond restating that the analysis is scoped to one date, which is already implied by the parameter name and schema.

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

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

The description uses a specific verb, 'analyze', and a concrete resource: every completed COROS activity on one date, explicitly including several activity types. It further clarifies that it classifies the recorded training day and returns the planned calendar, which helps differentiate it from single-activity or planning-only sibling tools.

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

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

The use case is implied by the scope: analyze all completed activities for a single date and also get the planned calendar. However, it never explicitly names alternatives or states when not to use this tool, leaving the agent to infer that this is the daily aggregate analysis option.

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 destructiveHint=false, so the safety profile is known. The description adds meaningful behavioral context: results are conditional on COROS exposing programExerciseIndex, and the tool specifically reports target compliance rather than generic performance metrics. No contradiction exists.

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

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

The description is a single, lean sentence that front-loads the core comparison and then adds the key conditional reporting detail. Every phrase contributes meaning, with no filler or redundant restatement of the tool name.

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 tool with no output schema and no parameter descriptions, the description provides a solid high-level purpose and one important conditional. It does not explain return shape, failure behavior, what happens when programExerciseIndex is absent, or how sportType affects analysis, leaving moderate gaps for an agent invoking 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 description coverage is 0%, so the description must supply parameter meaning. It implicitly maps workoutId to the planned workout and activityId to the completed activity, but sportType is left entirely unexplained, and no parameter-level detail or format guidance is provided.

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 ('Compare'), a clear resource pair (planned COROS workout vs. completed activity linked to program blocks), and a concrete outcome (reports duration and HR/cadence target compliance). This distinguishes it from broad siblings like analyze_completed_activity and compare_plan_to_actual by referencing programExerciseIndex linkage.

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 phrasing implies this tool should be used when comparing a planned workout to its completed activity and when COROS exposes programExerciseIndex. However, there is no explicit statement about when to prefer this tool over similar alternatives or when not to use it, so usage context is only implied.

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 indicate readOnlyHint=false (mutation) and destructiveHint=false (non-destructive). The description adds minimal behavioral context beyond the verb 'assign' – it doesn't disclose whether an existing assignment on the same date is overwritten, whether the operation is idempotent, or any side effects. It does not contradict annotations but also doesn't enrich them.

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 with zero filler. The core action is front-loaded, and the prerequisite is clearly stated in the second sentence. Every word earns its place.

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

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

For a simple 2-parameter mutation with no output schema, the description is adequate. It covers the essential invocation step and prerequisite. A minor gap is the lack of guidance on what happens if the date already has a scheduled workout, but this is not critical for an agent to correctly call the tool.

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

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

Schema coverage is 100% and both parameters are fully described in the schema (workoutId as 'COROS workout ID returned by list_workouts', date format). The description repeats the workoutId source without adding new information, so it provides no additional value 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 uses a specific verb ('assign') and clearly identifies the resource (existing COROS Training Hub workout) and destination (COROS training calendar date). It distinguishes from sibling tools like remove_scheduled_workout, move_scheduled_workout, and swap_calendar_workouts by stating exactly what action it performs.

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 provides a clear prerequisite ('Use list_workouts first to obtain the workout ID') which tells the agent the necessary precondition. However, it does not explicitly mention when not to use this tool or compare it to alternative scheduling tools like create_workout or move_scheduled_workout. The guidance is useful but not exhaustive.

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 destructiveHint=false, and the description reinforces this by stating 'without changing COROS.' It adds value by enumerating what the audit checks (duplicate days, missing management IDs, planned-volume totals), providing behavioral context beyond the annotations. No contradiction.

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, straightforward sentence that front-loads the action and lists the audit targets with a clear safety qualifier. There is no filler, and the structure is compact and easy to parse.

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 tool with two parameters and no output schema, the description should clarify what the tool returns and how to specify the date range. It does neither. While annotations cover the read-only safety profile, the lack of output format and parameter details leaves an agent guessing about the result, and sibling tools performing related audit functions intensify the need for more 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?

Schema description coverage is 0% and the description provides no specifics about startDate or endDate formats, units, or exact meaning beyond 'calendar range.' Both parameters are required strings with no additional documentation, leaving an agent unsure of the expected date format (e.g., ISO, epoch).

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

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

The description uses the verb 'Audit' with a specific resource (calendar range) and lists concrete audit targets (duplicate days, missing management IDs, planned-volume totals). This clearly distinguishes it from modification tools like swap_calendar_workouts or clear_calendar_range, though it does not explicitly contrast with the similar check_calendar_conflicts tool.

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

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

No explicit guidance is given for when to use this tool versus sibling tools such as check_calendar_conflicts or summarize_planned_load. The phrase 'without changing COROS' implies a read-only audit context, but there is no statement of prerequisites, alternatives, or distinguishing scenarios.

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 goes beyond the annotations by disclosing that the API login invalidates the web app session and that the token is stored for later calls. It also explains the env-var fallback behavior. There is no contradiction with the annotations, which already indicate this is not a read-only operation.

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

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

Three short sentences, all of which carry meaningful information: the core action, token storage/auto-login, and a critical side-effect warning. The description is front-loaded and contains no filler.

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

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

The description covers purpose, side effects, auth token behavior, and environment variables. It does not specify what happens on success/failure or what happens if neither env vars nor credentials are provided, but with full schema coverage and no output schema this is a relatively minor gap.

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

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

The input schema already fully describes all three parameters, including optionality of email/password and the region enum with default. The description only reiterates the env-var auto-login mechanism without adding new semantic 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 states a specific verb and resource: 'Log in to COROS Training Hub.' It also clarifies the tool's role by noting that it 'Stores auth token for subsequent calls.' It does not explicitly name a sibling like check_coros_auth, but the login action is distinct enough to avoid confusion.

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

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

The description implies usage before subsequent API calls and mentions auto-login via env vars, but it does not explicitly say when to use this tool versus check_coros_auth or how to confirm an existing session first. The warning about invalidating the web session is a useful caveat, but not full when-to-use 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 establish that this is read-only and non-destructive, so the description doesn't need to repeat safety behavior. It does add useful context by clarifying this is an estimate rather than a medical prescription, and by noting the optional input sources. However, it doesn't describe the shape of the result or any assumptions/defaults when optional inputs are omitted.

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

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

Two sentences deliver the core purpose, input variables, optionality, and a necessary disclaimer with no filler. The main action is front-loaded, making the tool's function immediately scannable.

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 planning calculator with no output schema, the description is nearly complete: it states what is calculated, the inputs required, and the estimate caveat. It could be slightly more explicit about the returned ranges or how optional inputs affect the result, but it gives an agent enough to know when and how to invoke 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 description coverage is 0%, so the description carries the burden of explaining parameters. It names all five inputs in plain language and correctly labels sweat/sodium as optional, which is useful. But it doesn't add significant meaning beyond the schema's self-descriptive property names, units, and required list, nor does it explain the intensity enum values or what 'practical ranges' means for each 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 uses a specific verb ('calculate') with a clear resource ('practical carbohydrate, fluid and sodium ranges for an endurance session'). It identifies the core domain and differentiates itself from the workout/calendar/analysis siblings by describing a unique fueling-planning task.

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 sets clear context: it is for endurance-session planning, uses duration, intensity, temperature, and optional sweat/sodium inputs, and explicitly frames the result as a planning estimate rather than medical advice. It doesn't name alternatives, but no sibling tool provides a similar fueling calculation, so no exclusion is needed.

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 the tool as read-only and non-destructive. The description adds useful behavioral detail by stating that it reports fit error, confidence, and limitations, and that indoor cycling is excluded. No contradiction with annotations exists.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the core operation first, then the exclusion and the outputs, making it easy to parse.

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 calibration tool with three parameters and no output schema, the description covers the input scope and the nature of the output: fit error, confidence, and limitations. It does not precisely define 'comparable' or the exact output structure, but that is not essential for correct invocation.

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

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

The schema covers the endDate format and lookbackDays bounds, but only 33% of parameters have descriptions. The description helps by implying outdoor activity types and excluding indoor cycling, but it does not directly clarify how sport, endDate, and lookbackDays 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 states a specific verb and resource: it fits base speed/pace and an ascent penalty from comparable COROS activity summaries. It also clarifies the intended scope by explicitly excluding indoor cycling, which distinguishes it from generic activity analysis tools.

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

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

The description gives clear context that this is meant for outdoor-route calibration and explicitly excludes indoor cycling. It does not name a specific alternative sibling, but the exclusion is enough to guide an agent toward correct usage.

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 destructiveHint=false, so the safety profile is covered. The description adds the behavioral trait that it returns dates with more than one workout, which is useful, but it does not disclose return format, pagination, or how conflicts are counted (e.g., overlapping vs. same-day). 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?

A single, front-loaded sentence that states the tool's purpose with zero filler. Every word earns its place.

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

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

For a simple read-only tool with two self-explanatory parameters and no output schema, the description is mostly adequate. However, it does not specify the output shape (e.g., list of dates, count, workout details), which an agent might need to interpret results correctly. The annotations cover safety, but the return value is undocumented.

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

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

Schema description coverage is 0%, and the description does not explain startDate/endDate formats or semantics beyond the obvious date-range implication. The parameter names are self-explanatory, but the description adds no detail about date format, inclusivity, or timezone handling, so it fails to compensate 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 uses a specific verb ('Find') and resource ('dates containing more than one scheduled COROS workout'), clearly distinguishing it from sibling tools like list_scheduled_workouts or swap_calendar_workouts. It lacks an explicit mention of the date-range parameters, but the core purpose is unambiguous.

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

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

The description implies a read-only analysis use case (finding conflict dates) but does not explicitly state when to use it versus alternatives like list_scheduled_workouts or audit_calendar. The context is clear enough for an agent to infer it is for conflict detection, but no exclusions or alternative routing are 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context about the token/env var source and implies no side effects, but it does not disclose what the check actually does (e.g., whether it validates token expiry or simply checks presence) or what an agent should expect as a 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?

A single, front-loaded sentence with no redundant phrasing. Every word contributes to understanding what the tool does and the source of the authentication state.

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 existence check, the description is nearly complete. It identifies the purpose and data source, and the sibling list establishes the broader COROS workflow. It could briefly state the expected boolean outcome, but the verb 'Check if' already implies a yes/no result.

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 are zero parameters, so there is nothing for the schema to document and little for the description to clarify. The description appropriately mentions the implicit inputs (stored token or env vars), which is meaningful context beyond the empty 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 names a specific verb ('Check'), a clear resource ('COROS authentication availability'), and the source of that availability ('stored token or env vars'). This distinguishes it from sibling authenticate_coros, which actually performs authentication rather than checking it.

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 it clear this is a pre-flight check for COROS auth, and the sibling authenticate_coros implies what to do if auth is missing. However, it does not explicitly state 'use this before COROS operations' or 'use authenticate_coros if this returns false,' leaving the routing 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?

Annotations already mark destructiveHint=true, and the description adds meaningful detail: the destructive scope is 'every scheduled workout occurrence in a date range' and application is gated by confirm=DELETE. This goes beyond what the annotations provide and clearly warns the agent of the destructive nature.

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 compact sentences with no filler. The core operation and scope are front-loaded, and the safety requirement follows immediately. Every word earns its place.

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

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

Covers the operation, scope, and confirmation gate, but omits default behavior (apply=false means preview), what the preview output looks like, and any irreversibility warning beyond the annotations. Since there is no output schema, a bit more context would help an agent invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It links apply/confirm to the destructive action ('Applying requires confirm=DELETE') and startDate/endDate to the date range, but it does not clarify that apply defaults to false for preview mode or specify expected date formats.

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 clear verb ('preview or remove') on a specific resource ('every scheduled workout occurrence in a date range'). The bulk scope distinguishes it from singular tools like remove_scheduled_workout, so an agent can tell what it does 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 useful operational guidance: the tool can preview or remove, and applying requires confirm=DELETE. However, it does not explicitly name alternatives or exclusion conditions, such as using remove_scheduled_workout for a single occurrence, so an agent must infer when this tool is preferred.

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 this as read-only and non-destructive. The description adds useful behavioral context: it is a comparison across up to eight activities, uses normalized metrics and aerobic decoupling, and applies exact sport type filtering. This is meaningful beyond the annotations, though it does not describe output shape or selection criteria for 'similar'.

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

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

The description is a single front-loaded sentence plus a concise filtering sentence. Every phrase contributes meaning, and there is no repetition of schema or annotation 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 moderate complexity (5 parameters, 3 required, no output schema), the description covers the tool's purpose, filtering behavior, and activity cap. The main remaining gap is the lack of detail on what the comparison output contains or how 'similar' activities are determined, but this is not severe for a focused comparison 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%, so the description must compensate, and it does: 'over a date range' maps to startDate/endDate, 'exact COROS sport type' to sportType, 'optional name text' to nameContains, and 'up to eight' to maxActivities. It adds semantic meaning to all parameters, though it omits formats or value constraints that the schema leaves unspecified.

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 ('Compare'), a clear resource ('completed COROS activities'), a scope ('up to eight', 'over a date range'), and the method ('normalized summary metrics and aerobic decoupling'). This distinguishes it from sibling tools like analyze_aerobic_decoupling (single activity analysis) and list_activities (listing without comparison).

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 use case: compare multiple completed COROS activities in a date range, filtered by sport type and name. However, it does not explicitly state when to prefer this over alternatives or mention any exclusions, leaving the agent to infer routing from sibling names.

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 destructiveHint=false, so no side-effect warning is needed. The description adds context that the comparison is scoped to a date range and uses COROS calendar volume, but it does not disclose details like required authentication or whether an open world means data may be incomplete.

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 states the action and scope with no filler or redundant preamble. Every word contributes to understanding the tool's purpose.

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 two-parameter read-only tool, the description is mostly adequate, but the lack of an output schema makes the missing description of the comparison result and the missing date format a real gap. An agent could select the tool confidently but may guess wrong on input formatting.

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 and only string type in the schema, the description needed to provide date format and meaning, but it only says 'selected range.' The names startDate/endDate are fairly self-explanatory, yet the string format and any inclusivity/required semantics are left unspecified.

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 ('Compare planned COROS calendar volume with completed activities') with a clear scope ('by date for a selected range'). This distinguishes it from siblings like compare_activity_history or weekly_training_report, which do not explicitly compare plan vs actual calendar load.

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

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

No guidance is given about when to choose this tool over related siblings such as weekly_training_report, summarize_planned_load, or compare_activity_history. There are no explicit exclusions, prerequisites, or alternative routes, so an agent gets only the general purpose to infer usage.

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, destructiveHint=false, openWorldHint=false, which covers the safety profile. The description adds the specific return fields but does not disclose any additional behavioral traits beyond what annotations and the listed return values imply. It is consistent with annotations but adds minimal new behavioral context.

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 concise sentences with no fluff. The functional return list is front-loaded, and the use case follows immediately. Every word earns its place.

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

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

For a simple read-only tool with no parameters and no output schema, the description provides enough for an agent to understand what it returns and why to use it. It lacks a detailed response format, but the listed return items and the absence of a schema make that 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 tool has zero parameters and schema coverage is 100% (trivially, since the schema is empty). With no parameters, the description does not need to explain parameter semantics, and it does not. Baseline for 0 params is 4, and the description adequately serves the purpose.

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

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

The description clearly states the tool returns specific data (version, tool count, auth state, feature groups) and names its intended use (detect stale ChatGPT tool catalogs). It distinguishes itself from siblings like check_coros_auth by covering broader connector status rather than just 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 provides a use case ('detect stale ChatGPT tool catalogs'), which gives clear context for when to use it. However, it does not mention alternatives or exclusions, so it stops short of full comparative 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?

The description adds useful behavior beyond the annotations: preview mode is hinted by 'Preview or copy', and 'Copies are new library workouts' explains the positive outcome and implies the original scheduled workouts are not altered. This especially helps since readOnlyHint=false but destructiveHint=false.

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 focused sentences, no filler, with the core action front-loaded and a clarifying statement about copies as new library workouts. It is appropriately concise for the level of information provided.

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 definition is too sparse for a 5-parameter tool with no output schema. It omits how apply controls preview vs. actual copy, what nameSuffix does, expected date formats, and how conflicts or shifted dates are handled. An agent would need to guess or inspect other sources to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate, but it only explains 'date range' and 'days shifted'. It does not explain the format or purpose of startDate, endDate, apply, or nameSuffix, leaving most parameters underspecified.

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 operation—copy scheduled workouts from one date range to shifted dates—and clarifies that copies become new library workouts. This clearly differentiates it from sibling tools like shift_calendar_range or move_scheduled_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 context is clear enough to infer it should be used when duplicating workouts across dates, but it does not explicitly state when to choose this tool over alternatives like shift_calendar_range, duplicate_workout, or move_scheduled_workout. There are no explicit exclusions or alternative-routing hints.

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 destructiveHint=false, covering the safety profile. The description adds that the result is 'current' and includes operation names, input contracts, and confirmations, but it does not reveal response format, error behavior, or auth dependencies. That is useful but not richly behavioral.

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 trigger condition and followed by a compact summary of the returned data. Every clause earns its place; there is no repetition or vague 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, read-only discovery tool, the description covers when to call it and what it returns. The only minor gap is leaving 'stable compatibility bridge' unexplained)Skip; that ambiguity prevents a perfect completeness score.

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

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

The tool has zero parameters, so there are no parameter semantics to document. Schema description coverage is 100% by default with an empty schema, and the baseline for zero-parameter tools is 4; the description need not add anything.

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 explicitly states when to use the tool: when a COROS function is missing from the chat catalog or before calling the stable compatibility bridge. It clearly identifies the resource as current read/write operation names, input contracts, and required confirmations, distinguishing it from COROS operation tools and other siblings.

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

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

The description gives explicit conditions for use: when a function is missing or before calling the stable compatibility bridge. It does not list alternatives or when-not-to-use scenarios, but the trigger conditions are concrete and contextual enough for an agent to decide when to call it.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description doesn't need to repeat safety traits. It adds a meaningful behavioral note: 'The schema stays stable while server-side operations evolve,' indicating the tool is a stable interface to dynamic operations. This goes beyond the annotations without contradicting them.

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 sentences, tightly packed with essential information. The usage condition is front-loaded, and the invocation steps are stated efficiently. No redundant words 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 generic dispatcher, the description covers the essential context: when to use, how to use, and a note on stability. The absence of an output schema is acceptable since the response depends on the dynamic operation, and the description directs the agent to coros_capabilities for operation details. It doesn't address error handling, but that's minor given the tool's simplicity and the coverage provided by annotations.

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

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

Schema description coverage is 0%, so the description must compensate. It does so by directing the agent to call coros_capabilities first to obtain the operation name and input object, which effectively explains how to fill the parameters. It also implies that the input object is operation-specific. While it doesn't detail the input structure, the guidance to discover it via coros_capabilities is a meaningful compensation.

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 its purpose: to be used when a specific COROS read-only tool is absent from an older chat. It explicitly identifies itself as a fallback dispatcher, distinguishing it from the many specific read-only sibling tools. The verb 'use' and the condition 'when a specific COROS read-only tool is absent' make the role unambiguous.

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

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

The description gives an explicit when-to-use condition ('when a specific COROS read-only tool is absent from an older chat') and provides a clear usage sequence: 'Call coros_capabilities first, then pass its operation name and input object.' This is actionable and leaves no room for ambiguity about invocation order.

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. The description adds that writes use an allowlist, validate inputs, and require the exact confirmation returned for the operation. This is useful context beyond annotations, clarifying the safety mechanism and confirmation flow. It does not contradict any 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?

The description is three concise sentences, front-loaded with the usage condition. Every sentence adds value: the trigger condition, the prerequisite call, and the behavioral constraint. There is no fluff or 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?

For a generic write tool with no output schema and 0% schema coverage, the description is incomplete. It tells the agent when to use it and that confirmation is required, but not how to construct valid operation/input values or what the tool returns. It relies on coros_capabilities to fill gaps, but the description does not explain that flow adequately.

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, but it only hints at the confirmation parameter ('require the exact confirmation returned for that operation'). It does not explain what 'operation' or 'input' mean, nor how to obtain the confirmation value. This is a significant gap for a generic write tool.

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

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

The description indicates this is a generic write tool for COROS, but it does not specify what operations are possible or what kind of data it writes. It distinguishes itself as a fallback when specific tools are absent, which helps differentiate from siblings, but the core capability remains vague.

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 clearly states when to use this tool: when a specific COROS write tool is absent from an older chat. It also mandates calling coros_capabilities first, which is a clear prerequisite. This is good usage guidance, though it doesn't explicitly list alternatives, it implies them by contrast.

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 annotation readOnlyHint=false, the description explains that the tool creates a workout and can optionally schedule it on a COROS calendar date, which is important behavioral context for a state-changing tool. It does not go into detail about external synchronization, validation, or persistence, but the annotations already signal write 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?

Two compact sentences rapidly deliver the core purpose and the optional scheduling side effect. No filler or redundant details; high information density.

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 tool with nested arrays and 20% schema coverage, the description is decent but would benefit from a note that 'steps' is an ordered list of step objects or repeat groups, how targets are attached (e.g., intensityMin/intensityMax), and whether authentication is required. However, the high-level purpose is clear enough for an AI agent to select, if not fully specify, the correct payload.

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 schema description coverage at only 20%, the description compensates by paraphrasing key enums: 'time/ms/distance/open steps' maps to targetType, 'HR/pace/power/cadence/speed targets' maps to intensityType, and 'repeat groups' maps to the nested repeat object. It does not fully describe step kinds or edge-case semantics, but it does add meaningful 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 description clearly identifies the action ('Create'), the exact resource ('a structured running or cycling workout'), and lists concrete features (time/distance/open steps, HR/pace/power/cadence/speed targets, repeat groups, optional scheduling). It is specific enough to distinguish from generic workout-creation tools, though it does not explicitly name sibling tools or contrast 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 implies usage context: creating structured run/bike workouts with optional scheduling. It gives no explicit when-to-use versus alternatives such as create_workout, assign_workout_to_calendar, or validate_structured_workout, and does not mention exclusions or prerequisites (e.g., prior authentication).

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 indicate a write operation (readOnlyHint=false, destructiveHint=false), and the description adds useful behavior: entries are validated and calendar conflicts are checked before writing. It does not, however, explain atomicity, partial-failure behavior, or how conflictPolicy affects the outcome, so it adds only modest transparency beyond the 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?

The description is two short sentences with no filler. It front-loads the core action and scope, then adds a relevant safety guarantee. Every word earns its place.

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

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

Despite the highly complex nested schema and no output schema, the description is too brief to be complete. It omits return behavior, error handling, meaning of conflictPolicy values, and how validation failures are surfaced. The mention of pre-write validation and conflict checking is useful but far from sufficient for this tool's complexity.

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

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

Schema description coverage is 0%, and the description does not compensate by explaining key parameters such as date, steps, overview, or conflictPolicy. It only vaguely references validation and calendar conflicts, which is insufficient for such a nested and complex input schema.

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

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

The description uses a specific verb ('Create and schedule') with a clear resource ('structured running/cycling workouts') and an explicit batch scope ('several ... in one request'). This distinguishes it from sibling tools like create_structured_workout, which handles a single workout, and from scheduling-only 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 phrase 'several ... in one request' gives a clear signal that this tool is for batch creation and scheduling, which helps an agent choose it over single-item alternatives. It does not explicitly name alternatives or state when not to use it, but the use case is reasonably 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 already indicate a write operation (readOnlyHint=false, destructiveHint=false). The description adds meaningful behavioral context: it resolves exercise names from the catalog, builds the full API payload, calculates metrics, saves, and syncs to the watch. This goes beyond the annotations and helps the agent anticipate side effects.

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 core action is front-loaded, followed by the internal steps and the sync side effect. 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 create tool with a rich schema and annotations covering the write nature, the description is complete enough. It explains the resolution behavior and the sync side effect. It could mention error cases (e.g., unmatched exercise names) but that is not essential 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?

Schema description coverage is 100%, so the schema already documents all parameters. The description adds high-level context (resolves exercise names, calculates metrics) but does not add per-parameter 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 states a specific verb ('Create'), a specific resource ('strength workout on COROS Training Hub'), and the key behaviors (resolves exercise names, builds payload, calculates metrics, saves). It is clearly distinguishable from siblings like create_structured_workout and update_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 implies usage context (creating a strength workout that syncs to the watch) but does not explicitly state when to prefer this over create_structured_workout or when not to use it. With many sibling tools, explicit routing would help, but the core use case is 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?

The description discloses a mandatory external dependency and sequencing: it must call COROS_MCP_2 querySleepData for seven wake-up days and pass normalized results as officialSleepRecords. This goes beyond the readOnlyHint and destructiveHint annotations by explaining a required data-routing 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?

Two sentences carry the entire description with no filler, and the second sentence efficiently enumerates the data sources. The all-caps routing directive is front-loaded before the main purpose, which makes the structure serviceable but not ideal.

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 gives a usable picture of the data flow and inputs, and annotations cover the safety profile. But with no output schema, it fails to state what the daily briefing returns, what output format to expect, or whether prior authentication is required, leaving important gaps for a complex aggregator.

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 documents date and the shape of officialSleepRecords fields, but the description adds that officialSleepRecords must be normalized results from querySleepData. However, 'normalized' is undefined, and the mandatory tone conflicts with officialSleepRecords being optional in the schema, so the added meaning is only partial.

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 concrete resource and action: build a daily briefing, and lists the data sources that feed it. It is distinguishable from a mere data fetch, though it does not explicitly differentiate itself from weekly_training_report or analyze_training_day.

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

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

There is no explicit when-to-use guidance or mention of alternatives. The 'daily' and 'briefing' wording implies a daily cadence, but the description never says when to prefer this over sibling tools 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?

Annotations already indicate destructiveHint=true, so the description's mention of deletion aligns with that. The description adds value by clarifying what is NOT deleted (scheduled calendar entries), which is useful behavioral context. No contradiction; this is adequate given the 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?

The description is concise and front-loaded with the main action, followed by a clarifying note about what it does not do. Both sentences earn their place, with no fluff or 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?

For a single-parameter mutation tool with annotations covering the destructive nature, the description is mostly sufficient. However, it lacks important details such as whether authentication is required (though there are auth tools in siblings) or what happens if deletion fails, but given the simplicity, this is adequate.

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

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

Schema description coverage is 0%, so the description must compensate. It does not explicitly explain the workoutId parameter, but the parameter name is self-explanatory, and the description's context about deleting a workout implies that workoutId refers to the workout to delete. This is marginal value over the schema, but not substantial.

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 (delete) and the resource (saved workout from COROS Training Hub library), distinguishing it from related tools like remove_scheduled_workout. It is explicit about what is deleted, which is sufficient for purpose clarity.

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

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

The description provides context by clarifying that it does not remove scheduled calendar entries, which implicitly guides when to use this tool versus remove_scheduled_workout or similar tools. It is clear about its scope, though it does not explicitly name alternatives.

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

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

The description adds useful behavioral context beyond the annotations: it clarifies that a copy is created, the original is not modified, and optional rename/description/scheduling side-effects can be applied. This is meaningful for a mutation tool, though it does not mention authentication requirements or return 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?

A single front-loaded sentence covers the purpose and all optional behaviors with no filler. Every phrase earns its place, and the structure is ideal for quick agent parsing.

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 relatively simple duplicate operation, the description covers the main action and all optional behaviors. The missing explicit mention of workoutId as the source identifier is a gap, but the required schema field mitigates it somewhat. Not having an output schema is acceptable here since the tool's effect is the created copy.

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 carries the parameter-documentation burden. It maps newName to 'rename it', overview to 'change its description', and date to 'schedule the copy', but it never explicitly identifies the required workoutId parameter as the workout being duplicated, leaving the most important parameter under-specified.

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

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

The description names a specific verb and resource: 'Duplicate any COROS library workout' - this clearly distinguishes the tool from create/update/delete siblings. The optional rename, description change, and scheduling are explicit, leaving no ambiguity about what the tool does.

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

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

The phrase 'Duplicate any COROS library workout' implies the use case of copying an existing workout, but it never explicitly contrasts with create_workout, update_workout, or other sibling alternatives. No when-not-to-use guidance or exclusions are provided, so the agent must infer usage from the wording.

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 destructiveHint=false, so the safety profile is known. The description adds useful context that credentials are not included and the output is JSON, but it does not disclose auth prerequisites, pagination behavior, or how workoutLimit affects results.

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 core action, resource, and output format. The second sentence adds a relevant exclusion. It is slightly sparse but contains no filler or wasted words.

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

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

With no output schema and zero parameter documentation, the description leaves too much to guesswork: date formats, limit semantics, output structure beyond 'JSON', and whether authentication is required. It is minimally adequate as a label but not as invocation guidance.

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

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

Schema description coverage is 0%, and the description does not mention startDate, endDate, or workoutLimit at all. The agent gets no guidance on date format, inclusiveness, timezone handling, or how workoutLimit caps the export, so parameter meaning is entirely undocumented.

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: 'Export COROS workout-library metadata and raw calendar data as JSON.' It also scopes the purpose to backup/inspection and explicitly excludes credentials, making it clearly distinguishable from sibling read/export 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 phrase 'for backup or inspection' gives a clear context for when to use this tool. However, it does not name alternatives like get_activity_export_url or coros_read, nor does it state when NOT to use this tool, so the guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds valuable behavioral context by noting that large graph arrays are omitted, and that the activity must be completed. This goes beyond the annotations and helps manage expectations.

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

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

The description is two sentences with no wasted words. The primary purpose is front-loaded in the first sentence, and the second sentence adds a crucial limitation. It is highly efficient and well-structured.

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 only 2 parameters and no output schema, so the description must cover both input semantics and return format. It explains the general content (metrics, laps, zones) and the omission (graph arrays), but does not describe the exact structure of the response or clarify the role of sportType. This leaves some ambiguity for the agent, though the tool is relatively simple.

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

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

Schema description coverage is 0%, so the description must compensate for the two parameters (activityId, sportType). The description mentions 'one completed COROS activity' which implicitly suggests activityId identifies the activity, but it does not explain sportType or how it affects the query. No parameter-level guidance is provided, making this a significant 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 uses a specific verb ('Read') and identifies the resource precisely: detailed metrics, laps, and zones for one completed COROS activity. It clearly distinguishes itself from sibling tools like get_workout_details (likely for workouts, not activities) and analyze_completed_activity (which implies analysis rather than raw read).

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

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

The description states the tool's purpose and scope ('one completed COROS activity') but does not explicitly compare with alternatives or provide when-to-use versus when-not-to-use guidance. The context is clear enough to infer usage for retrieving detailed activity data, but no exclusions or alternative routing are given.

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 note readOnlyHint=true and destructiveHint=false. The description adds useful behavior beyond that: the URL is temporary, may expire, and is limited to a single completed activity. This is meaningful context without contradicting the 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?

A single sentence delivers the core action, the supported formats, the single-activity scope, and the expiry caveat. There is no filler or 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?

For a simple URL-return tool this is mostly usable, but with no output schema it leaves some ambiguity about the response shape and whether the URL is returned synchronously. It also omits the meaning of the required sportType, which an agent needs to call the tool correctly.

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

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

Schema descriptions are absent (0% coverage), so the description must compensate, but it only partly does. It conveys the meaning of format by listing FIT/GPX/TCX/KML/CSV and hints that activityId identifies an activity, but the required sportType parameter is completely unexplained.

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

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

Description uses a specific verb ('Request'), a clear resource ('temporary COROS download URL for one completed activity'), and enumerates the supported formats. It clearly distinguishes itself from nearby siblings like get_activity_detail or export_coros_backup.

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 intended use is implied clearly: use this when you need a downloadable file for one completed activity. However, it never explicitly mentions when not to use it or names alternatives, such as using export_coros_backup for bulk exports.

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 destructiveHint=false, which covers safety. The description adds a meaningful behavioral guarantee beyond annotations: 'Missing data is explicit and never estimated,' which is critical context for interpreting results. It also clarifies the scope of the returned profile, adding value beyond the schema.

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

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

One tightly scoped sentence with no filler. The core action, resource, and key metrics are front-loaded, and the missing-data guarantee is appended as a compact, high-value clause.

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 lookup with only two parameters, the description covers the returned metrics and the key behavioral contract. However, without an output schema, a bit more detail about how lookbackDays influences the trend window would have made it fully self-sufficient.

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

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

Schema coverage is only 50%, so the description should compensate for lookbackDays, especially since its schema entry lacks a description. The phrase 'period trends' hints at time-window semantics but does not explicitly explain that lookbackDays controls the aggregation period. asOfDate is documented in the schema, so the description adds no additional clarification there.

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

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

The description uses a specific verb ('Return') and a concrete resource ('consolidated COROS physiological profile and period trends') followed by enumerated metrics: VO2max, lactate threshold HR/pace, base fitness, training indices, HRV, and resting HR. This clearly distinguishes it from sibling tools like get_hrv_data or get_daily_metrics by emphasizing the consolidated, trend-oriented nature of the output.

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 this tool by its content and consolidated nature, but it does not explicitly state when it should be preferred over alternatives such as get_hrv_data or weekly_training_report, nor does it mention any exclusions. Usage context is inferable, 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the daily metric scope and date range, but it does not disclose return shape, timezone handling, pagination, or aggregation behavior. This is adequate but not rich.

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

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

The description is a single, properly front-loaded sentence with no filler. It states the action, the resource, and the key scope efficiently.

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?

This is a relatively simple two-parameter read tool, and annotations cover the read-only/destructive aspects. However, the description still omits date format details and return value expectations, and it does not help disambiguate from similar health-metric 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?

Schema description coverage is 0%, so the description must compensate for startDate and endDate. It only says 'for a date range,' which does not add meaningful information beyond the parameter names. Date format, inclusivity, timezone, and range limits are all missing.

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

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

The description uses a specific verb ('Read') and names a concrete resource: COROS daily HRV, resting heart rate, fatigue, training load, load ratio, and fitness metrics for a date range. It is clear what the tool does, though it does not explicitly distinguish itself from overlapping siblings like get_hrv_data or weekly_training_report.

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 only implies usage with 'for a date range' and provides no explicit when-to-use or when-not-to-use guidance. It does not name alternatives or explain why an agent should choose this over other metric-focused 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds useful scope details like 'nightly' and 'COROS Training Hub dashboard', but it does not disclose other behavioral traits such as authentication requirements or how 'recent' is defined.

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 names the action, data scope, and source with no filler. Every word contributes to the agent's understanding.

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 tool, the description is largely complete: it states what data is returned and where it comes from. It could add the exact lookback window or return format, but those are not essential given the simple call signature and strong 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?

The tool takes no parameters, so there is no parameter burden for the description to carry. The schema coverage is trivially 100%, and the description's mention of HRV, baseline, and variability provides sufficient context for a zero-input read.

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

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

The description uses the specific verb 'Read' and names the resource ('recent nightly HRV, baseline and variability') plus the source ('COROS Training Hub dashboard'). This clearly distinguishes it from adjacent sibling tools like get_sleep_data or get_daily_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?

The description implies the tool is for retrieving recent HRV-related metrics, but it gives no explicit when-to-use guidance, exclusions, or alternatives. For a zero-parameter read this is workable, but the agent must infer when this tool is preferable to siblings.

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

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

Beyond the readOnly/destructive annotations, the description adds the critical constraint 'Do not invent a readiness score' and requires a specific data flow (officialSleepRecords from querySleepData). It also names the data sources that feed the summary. No contradiction with annotations; the routing and combination behavior are consistent with a read-only, open-world 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?

Two terse sentences with the critical routing constraint front-loaded. The wording is dense and uses an internal tool reference (COROS_MCP_2 querySleepData) but contains no filler. It lacks a one-line purpose statement, which would make it clearer, but it is well under the usual size limits.

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 omits what the tool returns (no output schema), how it obtains HRV, load, completed activities, and calendar data, and what to do if querySleepData fails or officialSleepRecords is missing. It covers only the sleep-input path. For a composite analysis tool, this leaves significant operational ambiguity.

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 coverage, the description compensates by explaining that 'date' is the wake-up date and that officialSleepRecords must be the normalized result from querySleepData. It does not explain the individual schema fields, but those are structurally defined in the schema. The description strongly encodes the expected value of both parameters, even though it implies officialSleepRecords is mandatory while the schema marks it optional.

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 the tool combines sleep, HRV, load, completed activities and calendar, which clearly indicates a readiness-summary computation, and 'Do not invent a readiness score' sharpens its role. It does not explicitly say 'returns a readiness summary' and the opening line is a routing instruction rather than a purpose statement, but the resource and action are inferable. This differentiates it from siblings like daily_training_briefing only by the listed data sources.

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

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

The description gives a mandatory precondition (call querySleepData and pass its result as officialSleepRecords) but never says when to choose this tool over siblings like daily_training_briefing, analyze_training_day, or taper_readiness. Usage is implied by the tool name rather than explained, and no alternatives or exclusions are mentioned.

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 destructiveHint=false. The description adds important behavioral context: this tool depends on a prior official COROS MCP read and normally requires normalized official sleep records as input. It does not disclose fallback behavior if the official read fails, but the added dependency information goes beyond the 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?

Two sentences carry the essential precondition and exception with no filler. The mandatory requirement is front-loaded and unambiguous.

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?

There is no output schema, so the description should explain return behavior, but it does not. It also omits date format expectations, normalization specifics, and what to do if the official read fails. The tool's core behavior remains underspecified for an agent trying to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only explains officialSleepRecords and says the date range must match the official read; startDate and endDate formats are not described, and the meaning of the individual sleep record fields is left entirely to 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 does not explicitly state what get_sleep_data does; it only mandates a precondition involving the official COROS sleep tool and the officialSleepRecords parameter. The tool name and the mention of 'sleep tool' imply it returns sleep data, but there is no direct verb+resource statement such as 'Retrieves sleep data for a date range.'

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

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

The description gives explicit, mandatory usage instructions: first read the same date range with the official COROS MCP sleep tool, normalize the result, and supply it as officialSleepRecords. It also states when not to call the tool (when officialSleepRecords is omitted, unless the official read failed). It does not compare against sibling tools, but the precondition is clear and actionable.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is covered. The description adds useful context about the return content (steps and targets) but does not mention authentication requirements or error handling. The description is consistent 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?

A single, front-loaded sentence with zero redundancy. The verb and resource appear immediately, and the scope is stated succinctly. Every word contributes 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?

For a simple read-only tool with one parameter and no output schema, the description is reasonably complete. However, it omits auth prerequisites (a sibling authenticate_coros exists) and does not describe the return format, leaving the agent to guess.

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 of explaining workoutId. It does not, beyond the implicit meaning from the tool name and context. The parameter is not elaborated beyond the schema's basic string type.

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

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

The description states a specific verb ('Return'), a precise resource ('complete COROS definition of one library workout'), and scope ('including every step and target'). It clearly distinguishes this from list_workouts (list vs. detail) and other activity/analysis 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 is clear enough that the agent can infer when to use it (when full details of a single library workout are needed). However, it does not explicitly name alternatives or exclusion conditions, so it stops short of a 5.

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

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

Annotations already declare the tool read-only and non-destructive, so the description's added value is limited to scoping to 'completed' activities and listing included fields. It does not disclose pagination behavior, date handling, or authentication expectations, but the safety profile is already covered by 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?

The description is a single, dense sentence with no filler. The core resource is stated first, and every phrase adds relevant detail about scope or returned fields.

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?

As a simple list operation with read-only annotations, the description communicates the essential purpose and output fields. However, with no output schema and no pagination or date-format details, an agent still needs to infer important invocation details from parameter names alone.

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

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

Schema description coverage is 0%, and the description does not explain startDate/endDate formats, page semantics, or size limits. While the parameter names are self-explanatory, the absence of date-format guidance and the failure to compensate for the schema gap leaves meaningful ambiguity for correct invocation.

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

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

The description uses a specific verb ('List') and resource ('completed COROS activities'), and enumerates the returned metrics (duration, distance, heart rate, training load, power, elevation). This clearly distinguishes it from scheduled-workout or creation tools, though it does not explicitly name or contrast sibling alternatives.

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

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

The description implies this is the tool for browsing completed activity history, but it gives no explicit guidance about when to choose this over list_workouts, list_scheduled_workouts, get_activity_detail, or the analysis tools. No exclusion criteria or alternative recommendations are 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?

Annotations already provide the read-only and non-destructive profile, so the description does not need to repeat that. It adds the useful detail that the result includes IDs used for later mutations, but it does not disclose other behavioural aspects such as pagination, ordering, or date-range handling. It is consistent with the 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?

The description is a single, efficient sentence. It front-loads the primary action ('List workouts in the COROS calendar') and then adds a valuable and previously relevant detail about the returned IDs, with no fluff or 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?

Given there is no output schema and the description does not mention the required date-range parameters, this description makes the description incomplete. It also only vaguely characterizes the return payload; saying the result includes IDs does not tell an agent what other fields or date range boundaries are returned. The absence of a date-range explanation is particularly problematic because the tool has two required 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?

With schema description coverage at 0%, the description had the full burden of explaining startDate and endDate, yet it never mentions either parameter or their meaning (e.g., that they define the range of scheduled workouts). The names give a weak hint, but no format or range semantics are provided, which is a significant gap for correct invocation.

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

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

The description uses a specific verb ('List') and a concrete resource ('workouts scheduled in the COROS calendar') and adds that it includes IDs needed to move or remove those workouts. This not only states what the tool does but also differentiates it from sibling tools like list_workouts, move_scheduled_workout, and remove_scheduled_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 implies a usage context: if you need IDs to move or remove scheduled workouts, this list is the source. However, it does not explicitly name alternatives (e.g., list_workouts) or state when not to use this tool, leaving the when/alternative guidance somewhat 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safe-read nature is covered. The description adds only the source ('COROS Training Hub') and does not disclose ordering, pagination, return shape, or whether all workouts or only available ones are returned, but this is a simple read operation and the annotations carry much of the burden.

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

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

The description is a single, direct sentence with no filler or wasted words. It is appropriately brief for a simple listing tool, though it provides only the minimum context and does not add scoping or sibling-routing 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 straightforward read-only list operation, the schema and annotations cover the essential calling needs: all parameters are optional and documented, and safety is indicated. However, there is no output schema and the description does not clarify what fields the listed workouts contain or how results are ordered, so an agent is left with some ambiguity about the returned data.

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

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

The input schema has 100% description coverage: name, limit, and sportType are all documented, including defaults and the sportType filter meaning. The description itself adds no additional parameter semantics, so the schema is doing the heavy lifting, making a baseline score of 3 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 action ('List') and the resource ('workouts from COROS Training Hub'), so the core purpose is unambiguous. It does not explicitly differentiate itself from sibling tools like list_scheduled_workouts or get_workout_details, though the resource wording implies a broader listing operation.

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 guidance on when to choose this tool over siblings such as list_scheduled_workouts, get_workout_details, or search_exercises. No context is given about typical use cases, prerequisites, or situations where an alternative would be preferred.

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 signal a mutating but non-destructive operation. The description adds the useful detail that contents do not change, but it does not explain conflict behavior, what happens to the original source date, or whether the move is a reschedule with side effects. It adds context without being comprehensive.

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 terse sentences provide immediate action and the key prerequisite. The first sentence is front-loaded with the action and scope; the second delivers necessary guidance without any 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?

Given a fairly simple 3-parameter mutation tool and no output schema, the description gives an important precondition but omits date format details, conflict/error behavior, and whether a successful move removes the original scheduled slot. It is adequate for launch but leaves meaningful uncertainty for an autonomous agent.

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. It implies newDate is the target date and tells the user to retrieve scheduled information from list_scheduled_workouts, which helps identify sourceDate and idInPlan. But it never explicitly maps each parameter or explains formats, IDs, or requirements.

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

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

The description opens with the specific verb 'Move' and the resource 'a COROS calendar workout', and narrows the action to changing the date 'without changing its contents'. This clearly distinguishes it from swap, copy, replace, or update tools in the sibling list.

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 supplies a concrete prerequisite: 'Use list_scheduled_workouts first', which tells the agent what to do before invoking. However, it does not name alternatives such as swap_calendar_workouts or replace_scheduled_workout nor explicitly say when not to use move, 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?

The description says 'Read-only', which matches the readOnlyHint and destructiveHint annotations, so there is no contradiction. It adds some functional context (stops, climbs, weather, fueling) beyond the annotations, but these are more about output scope than behavioral traits, and no additional information is given about side effects, permissions, or external dependencies.

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 one focused sentence that starts with the action and resource, front-loads the primary purpose, and closes with safety-relevant 'Read-only'. It contains no filler or redundancy, making it appropriately concise for its core purpose.

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 complex (20 parameters, no output schema), and the description does not explain what the response contains or how the three stated timing scenarios are returned. It does not describe validation, error behavior, or dependencies such as the optional COROS calibration. For an agent to plan a route, the description is too thin to support correct or advanced usage.

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 35% with 20 parameters, so the description must compensate for the many undocumented parameters. It only hints at features like stops, climbing, daylight, fueling, and weather, but never explains how those map to the dozens of unifying parameters (e.g., calibration lookback, ascent/descent penalties, fueling intervals). An agent cannot reliably construct correct argument values from this description.

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

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

The description states a clear verb and resource — 'Build an operational GPX plan' — and enumerates the covered activity types and plan contents (three timing scenarios, named stops, climbs, daylight, fueling, optional weather). However, it does not explicitly differentiate from siblings like analyze_gpx_route or simulate_ultra_route; the planning-vs-analysis distinction is left to inference.

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 no explicit when-to-use conditions or exclusions, and it does not mention alternatives or tell the agent when to choose this over related tools such as simulate_ultra_route or calculate_fueling_plan. The implied usage of 'build a plan' is present, but there is no tangible decision 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=true and destructiveHint=false, so the description's 'Never change the calendar' reinforces but does not contradict them. The mandatory sleep-routing precondition adds useful behavioral context beyond the annotations by telling the agent what must happen before this preview can be called.

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 short and front-loads the most operationally important instruction. Every clause earns its place, though the all-caps 'MANDATORY' is unnecessary noise and the final 'Then preview the daily adjustment' mostly restates the tool name.

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 must explain what the agent can expect from the preview and what inputs it truly needs; it does neither. Terms like 'required recent wake-up days' and 'normalized results' are undefined, and the purpose of a 'daily adjustment' is never explained. The safety profile is covered by annotations, but call correctness is not.

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 date parameter is the only one described in the schema, while officialSleepRecords and its many nested fields are not. The description does add some meaning by explaining that officialSleepRecords should be normalized results from querySleepData, but it does not specify field mapping, required recency, or normalization rules. It partially compensates for the 50% schema coverage but leaves significant gaps.

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 says 'preview the daily adjustment,' which is close to a tautology with the tool name and never defines what a daily adjustment is or what previewing it entails. The lengthy mandatory-routing preamble obscures the core purpose instead of clarifying it. There is no differentiation from sibling planning or summary tools.

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

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

The description gives explicit sequencing: first call COROS_MCP_2 querySleepData, pass normalized results as officialSleepRecords, then preview. It also adds a clear boundary with 'Never change the calendar.' What it lacks is any guidance on when this tool should be chosen over sibling tools or when it should not be used.

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 communicate destructive behavior (destructiveHint=true, readOnlyHint=false), and the description's 'Remove' wording aligns with that. The description adds only mild value beyond the annotations by specifying 'one workout occurrence' and the suggested prerequisite call. No contradiction exists, but there is little additional behavioral context such as irreversibility or effect on the overall plan.

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 short sentences with no filler. It front-loads the core purpose and follows with an actionable prerequisite, so every word earns its place.

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

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

For a simple destructive operation on one calendar occurrence, the description states the purpose and a critical prerequisite. However, because the parameters are completely undocumented and the agent is not told which fields from list_scheduled_workouts map to planId and idInPlan, the description is only minimally adequate rather than 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 for the three parameters. It does not explain planId, idInPlan, or planProgramId at all. The vague instruction to call list_scheduled_workouts first is not enough for an agent to know how to populate the parameters 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 explicit phrase 'Remove one workout occurrence' defines exactly what the tool does, and 'Use list_scheduled_workouts first' sets a clear invocation workflow, even though it does not name alternatives or say when not to use this tool.

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

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

It clearly says when to use the tool: to remove a single scheduled occurrence. The instruction 'Use list_scheduled_workouts first' provides a concrete prerequisite and indirectly tells the agent where to obtain the needed identifiers. It does not, however, name alternatives or exclusion conditions, so it falls short of a fully explicit routing guide.

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 this as destructive and not read-only; the description adds a specific behavioral detail: the replacement is scheduled before the old occurrence is removed, implying a defined order and safer failure mode. It also makes clear the old calendar occurrence is removed, identifying what is affected.

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 front-load the purpose and then add one relevant behavior detail. No wasted words or repeated schema 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 destructive, write-side tool with no output schema and 0% parameter documentation, the description leaves significant gaps: no parameter details, no when-to-use guidance, and no mention of how success is indicated. An agent could select the tool but would be guessing at sourceDate/idInPlan format.

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 burden is on the description. It identifies 'library workout' as the replacement source and a 'calendar occurrence' as the target, but it doesn't explain the formats or distinct roles of sourceDate, idInPlan, and replacementWorkoutId beyond that coarse mapping.

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

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

The description uses a clear action verb ('Replace') and names both the target resource ('one calendar occurrence') and the source ('another library workout'), so the core operation is unambiguous. It reads distinctly from move/remove/assign siblings even though it doesn't name an alternative.

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

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

No guidance is given for when to choose this tool over swap_calendar_workouts, move_scheduled_workout, or remove_scheduled_workout. The only context is 'replace', which agents must infer. No exclusions or conditions are 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value beyond annotations by stating the catalog size (~383 exercises) and explicitly listing the return fields (names, muscles, equipment, default sets/reps), which is especially useful since there is no output schema. It does not contradict the openWorldHint=false, as the fixed catalog size aligns with a bounded world.

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 with zero filler. The main purpose is front-loaded, followed by the filter dimensions and the return content. Every sentence contributes essential information, and it is appropriately sized for the tool's simplicity.

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 complete for a read-only catalog search: it defines the resource, filters, and return fields, while the schema fully documents the parameters. The only minor gap is that pagination/limiting behavior is not explicitly described in prose, but the 'limit' parameter with default/maximum covers that in the schema. No output schema exists, so the explicit return-field listing appropriately compensates.

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% – every parameter has a descriptive name and explanation with examples. The description only rephrases the filter options ('Filter by name, muscle group, body part, and/or equipment') without adding new semantics or clarifying interactions (e.g., AND logic, partial match behavior). This matches the baseline where 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 uses a specific verb ('Search'), a clear resource ('the COROS exercise catalog'), and a scoping detail (~383 strength exercises). It also lists the filter dimensions and return fields, making it immediately distinguishable from sibling tools like list_workouts or get_workout_details, which operate on workouts, not exercises.

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

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

The description clearly establishes the context: use this tool to search/filter the exercise catalog, which is the only tool among siblings that does this. It does not explicitly name alternatives or when-not-to-use scenarios, but the purpose is unambiguous enough that an agent can infer appropriate timing. No exclusions are necessary given the dominant sibling focus on workout management rather than exercise lookup.

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 and destructiveHint=false, so the write-capable nature is known. The description adds the bulk-scope behavior (moving all workouts in a range) and preview modality via the apply parameter, but does not disclose side effects like conflict handling or reversibility. With annotations present, this is adequate but not rich.

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 conveys the core action and scope without waste. It could add a brief note about the apply parameter or date format, but as it stands every word earns its place.

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

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

For a bulk-move tool with no output schema, low parameter coverage, and only minimal annotations, the one-sentence description leaves critical gaps: date format expectations, sign of days, inclusivity of endDate, conflict behavior, and preview response format. An agent would need to inspect sibling tool patterns or infer details to call 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 only 25%, with startDate, endDate, and days lacking any schema descriptions. The description's phrase 'fixed number of days' gives minimal meaning to days, but it does not clarify date formats, sign conventions for days, inclusivity of endDate, or preview semantics beyond repeating apply's default. The description does not sufficiently compensate for the low schema coverage.

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 pair ('Preview or move') and a precise resource ('every scheduled workout in a date range by a fixed number of days'). This clearly differentiates it from singular operations like move_scheduled_workout and range operations like copy_calendar_range or clear_calendar_range.

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 is for bulk date-range shifts, and the schema's apply parameter distinguishes preview vs. apply mode. However, it does not name alternatives or state when to prefer this over move_scheduled_workout, copy_calendar_range, or clear_calendar_range. Context exists but exclusions are absent.

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 destructiveHint=false, so the safety profile is covered by structured data. The description adds context about scenario generation and output content, but it does not disclose how edge cases, invalid GPX, or default penalty selection are handled, which would be richer behavioral detail beyond the 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?

Two sentences with no filler and a clear front-loaded action. The first sentence communicates both inputs and scenario variants; the second states the output. Every word contributes to the selection and invocation decision.

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-purpose simulation tool with annotations already covering safety, the description gives enough high-level context to select and call the tool: inputs, scenario types, and output object kinds. It is not fully complete because it does not describe how the three scenario levels differ or the shape/units of the returned sector checkpoints and finish times, but the lack of an output schema makes that a modest mismatch rather than a fatal omission.

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 maps the high-level factors—GPX route, departure time, flat speed, planned stops, climbing penalty—to the parameter domain, which adds some relational meaning. However, it does not explain formatting rules, units for every input, how segmentDistanceKm affects checkpoints, or what the climbing penalty default is; with 50% schema description coverage, the meager parameter explanation carries only partial weight.

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 concrete operation—build optimistic, probable, and conservative timing scenarios—and names the key resource and outputs (sector checkpoints, finish times). It is easy to distinguish from most sibling tools such as list_workouts or auth checkers, but it does not explicitly separate itself from route-analysis/planning siblings like analyze_gpx_route or plan_operational_route, leaving some differentiation to inference.

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

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

The description gives no when-to-use or when-not-to-use guidance and names no alternatives. It implies a timing-simulation use case, but in a sibling set containing route analysis and route planning tools, an agent must infer that this tool is meant specifically for simulating optimistic, probable, and conservative timing rather than those other tasks.

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 destructiveHint=false, covering the safety profile. The description adds the behavioral clarification that the result is planned volume, not physiological load, which is useful context beyond the annotations. However, it does not disclose return format, pagination, or other behaviors, which is acceptable for a read-only summary.

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 sentences, front-loaded with the primary action and result, and the second sentence adds an important distinction without redundancy. It is concise and well-structured, though slightly more detail on parameters could be added without bloat.

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 what the tool returns (count, duration, distance by sport) and clarifies the planned vs physiological distinction. However, it does not specify output format, potential edge cases, or date format conventions, and with no output schema, the agent must rely on the description for return expectations. For a straightforward summary tool with obvious parameters, this is adequate but not comprehensive.

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 mentions 'date range' but provides no details on date format, inclusivity, or any additional semantics. With schema description coverage at 0% and no parameter descriptions in the schema, the description does not compensate for the lack of guidance beyond the obvious start and end dates.

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

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

The description clearly states the action (summarize), resource (planned workouts), and specifics (count, duration, distance by sport) for a date range. It also distinguishes from physiological Training Load, but does not explicitly contrast with sibling tools like weekly_training_report, leaving some ambiguity about when to choose it over alternatives.

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

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

No explicit guidance on when to use this tool versus alternatives is provided. The only contextual hint is the note that it reports planned volume, not COROS Training Load, which clarifies what it is not but does not advise on selection among siblings. No alternative tools are mentioned.

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 cover the read-only/destructive profile (readOnlyHint false, destructiveHint false, openWorldHint true). The description adds a useful behavioral detail—'preserving their calendar identities'—which implies a lightweight exchange rather than delete/recreate. However, it does not mention authentication, conflict checking, or any other side effects beyond the swap.

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 room for waste. It states the operation, the object, and an important constraint. It could carry more context, but it is appropriately concise for a clear purpose.

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 mutating tool with four required parameters, no output schema, and no parameter documentation, the description is incomplete. It does not state what success, what the response contains, whether it performs any conflict checks, or how the two 'occurrences' are actually identified binding together the date and id 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 coverage is 0% and all four parameters are bare strings, so the description must compensate. It only vaguely maps 'dates' to the expected firstDate/secondDate parameters, and does not explain the {firstIdInPlan} identifiers or how they relate to occurrences. The agent mostly relies on parameter names, not the description.

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

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

The description uses a specific verb ('swap') with a specific resource ('two scheduled COROS workout occurrences') and scope ('between dates'), and adds a meaningful constraint about preserving calendar identities. It does not explicitly differentiate from sibling tools like move_scheduled_workout or replace_scheduled_workout, relying on the verb alone to signal a two-way exchange.

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 choose this tool over alternatives such as move_scheduled_workout, replace_scheduled_workout, or shift_calendar_range. There are no explicit conditions, prerequisites, or exclusion criteria—the agent must infer usage from the name (swap).

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 destructiveHint=false, so the description needs less safety disclosure. It adds useful behavior beyond annotations: the tool depends on externally supplied, normalized sleep records and does not fetch them internally. 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?

The description is two sentences with no filler. The critical mandatory sleep-routing instruction is front-loaded, and each sentence carries necessary information for correct invocation.

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 assessment tool with annotations covering safety, the description supplies the key dependency and the data dimensions used. It does not describe the return shape, but the absence of an output schema and the tool's analytic nature make this less critical. The main gap is not explaining how it relates to get_readiness_summary or when to choose 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?

The schema describes asOfDate and raceDate formats, but leaves officialSleepRecords undocumented. The description compensates by explaining that officialSleepRecords should be normalized results from querySleepData for the required wake-up-date range. It doesn't fully map that range to raceDate/asOfDate, but it adds meaningful parameter context.

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

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

The description clearly states that the tool assesses taper readiness using load, sleep, HRV, and resting heart rate. It names a specific verb and resource, but it does not explicitly differentiate itself from sibling tools like get_readiness_summary.

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

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

The description gives an explicit mandatory workflow: first call querySleepData, normalize, and pass as officialSleepRecords. This is strong contextual guidance, but it does not state when to prefer this tool over 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?

Discloses that the tool mutates local state by rebuilding the local catalog and that authentication is required, which adds value beyond the annotations. It does not state whether the rebuild is incremental or destructive, whether existing exercises are removed, or what happens if the upstream API fails, leaving some important runtime behavior unspecified.

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 short and front-loads the primary action. The second sentence is somewhat redundant with the first, but it adds the useful i18n detail. Overall, it is efficient and 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?

The tool is simple, with one optional parameter, and the description covers the data source, authentication, and the local rebuild effect. However, there is no output schema and no mention of return values, completion signals, or the impact on existing catalog entries, so an agent must guess what a successful invocation returns.

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

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

The schema already documents the only parameter (sportType) with its default and meaning, reaching 100% coverage. The description adds no parameter-level guidance, so it remains at the schema-coverage baseline. No additional ambiguity is introduced, but the description also does not help the agent choose a non-default sportType.

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 operation: fetching the latest exercise catalog from COROS APIs and rebuilding the local catalog. This is far more informative than the bare tool name and makes the tool's role clear. It does not explicitly name or distinguish from sibling tools like search_exercises, but the resource and action are 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?

Gives a clear use case (refresh/rebuild the exercise catalog) and an explicit prerequisite (authentication exists). However, it does not say when not to use this tool or when a sibling like search_exercises would be more appropriate. With a large sibling set, the missing routing guidance is a real 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?

The description discloses the clone-based behavior and explicitly explains what happens to the original ('retained unless deleteOriginal=true'), which is valuable context beyond the destructiveHint annotation. This is consistent with readOnlyHint=false and destructiveHint=true, so there is no contradiction.

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 tight sentences with no filler. The most important safety behavior is front-loaded, and each sentence adds necessary 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 core edit-and-clone behavior and retention rule are clearly covered, but the description does not explain return values, partial-update behavior when only workoutId is supplied, or more details on how step replacement works. With no output schema and a complex steps schema, this is only minimally 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 carries the burden of explaining parameters, but it only addresses deleteOriginal and the replaceability of steps. It adds no semantic guidance for name, sport, or overview, leaving much to be inferred from 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 action ('edit a workout') and the distinctive mechanism ('creating an updated clone'), which clearly separates it from direct-editing, deletion, or duplication siblings. It also includes the critical retention condition that defines the tool's behavior.

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 some usage context by saying this is a safe edit and that steps can be replaced for running/cycling, but it does not explicitly say when to prefer this over related tools like update_exercises or duplicate_workout. Alternatives and exclusions are left 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: the operation is local, performs validation and calculation, and has no side effects on COROS. This goes beyond what annotations provide by clarifying the local execution aspect. It doesn't describe what 'calculate' produces (e.g., totals, duration), but the core non-destructive behavior is well 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?

A single sentence that front-loads the action ('Validate and calculate'), names the resource, and states the critical side-effect constraint ('without writing anything to COROS'). Every word 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 read-only validation tool with a rich input schema, the description is nearly complete. It tells the agent the operation is local and non-persistent, which is the key contextual fact. It doesn't describe the return value (e.g., validation errors, calculated metrics), but with no output schema and a complex nested input, a bit more detail on what 'calculate' returns would improve completeness. Still, the essential context for safe invocation 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 carries the burden of explaining parameters. However, the description doesn't mention any parameter names or semantics. The schema itself is quite detailed with enums and nested structures, so an agent can infer meaning from property names like 'name', 'sport', 'steps', and 'overview'. The description adds no parameter-level meaning, but the schema is self-explanatory enough to warrant a baseline 3.

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

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

The description states a specific verb ('Validate and calculate'), a specific resource ('a structured workout'), and a clear scope ('locally without writing anything to COROS'). This clearly distinguishes it from sibling tools like create_structured_workout, which writes to COROS, and get_workout_details, which reads from COROS.

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

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

The description clearly implies when to use this tool: when you need to validate or calculate a structured workout without persisting it. It doesn't explicitly name alternatives or exclusions, but the 'without writing anything to COROS' phrase strongly signals it's the non-destructive alternative to create_structured_workout. A clear context is provided, though no explicit when-not-to-use guidance is given.

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 destructiveHint=false, so safety is covered. The description adds meaningful behavioral context: the tool has an external dependency on querySleepData, expects the caller to normalize results, and then produces a seven-day report with comparison. This is valuable beyond the annotations, though the report's exact output/return shape is not 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 a single dense sentence front-loaded with 'MANDATORY SLEEP ROUTING' and a clear two-step procedure. There is no filler or repetition, though some terms like 'required wake-up-date range' and 'COROS_MCP_2' are under-explained—this is a completeness concern rather than a conciseness problem.

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 tool with a complex nested parameter and no output schema, the description gives the essential workflow but misses important details: how the wake-up-date range is derived from endDate, what 'normalized' means for the sleep records, and what the seven-day comparison should contain. An agent can attempt the call, but several details must be inferred or discovered from external schemas.

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