garmin-personal-mcp

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

With no annotations, the description carries the burden and does disclose the key non-obvious trait: this is a disk-writing operation that saves a file to the user's machine and returns the absolute path. It also summarizes the payload contents. It omits overwrite behavior, whether the destination directory is fixed, and permission/error cases.

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-loaded with the action and side effect, followed by the return value. No filler; every clause carries information.

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

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

For a single-parameter, no-output-schema tool, the description covers the action, the side effect, and the return value, which is sufficient to call it correctly. It stops short of stating where the file lands or what happens on repeated downloads.

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 one parameter exists and schema description coverage is 100% ('Garmin activity id'), so the schema already fully documents it. The description adds no format, sourcing, or lookup guidance for activityId beyond what the schema provides.

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 ('Download the ORIGINAL .FIT file of an activity') and emphasizes 'ORIGINAL' plus 'save it on the user's computer', which separates it from metadata readers like getActivity or getActivityLaps. It does not explicitly name a sibling, so an agent must infer the boundary.

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

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

Usage is implied: fetch the raw file when second-by-second data is needed locally, rather than the parsed summaries returned by getActivity/getActivityLaps. There is no explicit when-to-use / when-not-to-use statement or named alternative, 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?

With no annotations, the description carries the burden and does well: it discloses that layout replaces the whole layout, that widgets saves into the shared library affecting every template page, and that forgetWidgets removes from the library while removeWidgets only affects this page. It doesn't cover auth/permission needs or reversibility, but the destructive-vs-scoped distinctions are clearly surfaced.

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

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

Front-loaded with verb and resource, then the read-mode caveat, then per-parameter detail — a sensible ordering for a 10-param tool. It is dense and adjective-free, though the single dense paragraph with inline examples makes it slightly heavy to scan; a list per parameter would read faster. Every sentence still carries operational 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 complex 10-param, 0-required, nested-object tool with no output schema and no annotations, the description is remarkably complete: it documents the read-mode return payload (layout, widgets, missing texts, catalogue, widgetApi), the write semantics of each parameter, and the persistence side effects. Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 80% so baseline is 3, but the description adds real meaning: it explains place as 'adds widgets at the end of a board', the scroll/layout replace semantics, the widget library persistence, the '|' singular/plural text convention, and missing-texts-fall-back-to-English. Concrete JSON examples for widgetTexts and languages further clarify the nested shape beyond the schema.

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

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

States a specific verb + resource ('Changes the layout, the custom widgets or the languages of the dashboard page') and immediately clarifies it operates on a template page requiring writeDashboard first. The dual read/write nature is spelled out ('Without arguments it only reads'), so an agent can tell exactly what this does versus writeDashboard.

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 the key precondition ('call writeDashboard first') and an explicit no-argument read mode with a description of what it returns. It further explains per-parameter intent (layout replaces, place appends, widgets add-or-replace, removeWidgets vs forgetWidgets scope). It stops short of enumerating when NOT to use it or pointing to siblings like showDashboard for 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?

With no annotations, the description does the minimum safety work by declaring the call 'read-only GET'. But for an arbitrary-endpoint escape hatch it says nothing about authentication, rate limiting, error behavior on bad paths, or response shape, all of which matter more here than for a fixed-endpoint tool.

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

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

Three sentences, each load-bearing: purpose, path format, query format. The format constraints are front-loaded before the examples, and there is 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?

Only two parameters and no output schema, but this is a generic pass-through where an agent has no idea what comes back or what a failed call looks like. The description covers inputs thoroughly and is silent on return/error semantics, which is the remaining gap for a catch-all tool with zero annotation coverage.

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 already 100%, so baseline is 3. The description exceeds that by adding format rules the schema omits: 'path' must be relative and start with '/', 'query' takes no leading '?', plus concrete examples of both. The example path and query string materially reduce malformed calls.

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

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

States a specific verb and resource ('read-only GET on the Garmin Connect Personal API') and immediately carves out its niche: endpoints not covered by the other tools. That positioning lets an agent distinguish it from the named get* siblings without opening any schema.

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

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

Gives two explicit selection conditions: the endpoint isn't covered by another tool, or a query parameter name must be adjusted. The 'not covered by the other tools' phrasing functions as an implicit 'when not to use' that routes the agent to the specialized siblings first.

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

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

With no annotations, the description carries the full burden. 'Get' implies a read-only operation and the description discloses the main response components, but it does not state authentication requirements, error behavior for invalid IDs, or any rate-limit considerations.

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 with the core purpose and returned content front-loaded. There is no redundant or wasted text.

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

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

For a simple one-parameter read tool with a fully documented schema and no output schema, the description is mostly complete: it identifies the resource and summarizes the return payload. The main omissions are sibling differentiation and how to obtain a valid activityId, which would improve completeness but are not critical to invoking 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 the single parameter is already documented in the schema as 'Garmin activity id'. The description adds no additional meaning, constraints, or examples beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: get the full detail of one activity. It also lists the returned contents (summary, metadata, splits/laps) and format (JSON), which helps distinguish it from listActivities. However, it does not explicitly differentiate itself from sibling activity tools such as getActivityLaps or getActivityWorkouts.

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

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

Usage is implied by 'one activity' and the required activityId, suggesting it is for retrieving a single known activity. But the description gives no explicit when-to-use guidance, no alternatives, and no note that listActivities should be used to discover activity IDs.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the source of truth (original .FIT file), the row granularity (one row per lap), trigger types (manual, auto-lap, workout steps), intensity enum values, the null-means-n/a convention, and the edge case where free-run auto laps may be tagged interval. That is rich behavioral context an agent could not infer from 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?

The content is dense but front-loaded with the return shape, then usage, then the run-specific split/work payload. Nearly every clause carries information, though the field enumeration runs long enough that the key routing sentence is buried mid-block rather than first.

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

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

No output schema exists, so the description must explain returns — and it does exhaustively, covering lap rows, foot-sport vs other-sport unit differences, and the optional split/work objects. An agent has everything needed to call it and interpret the response.

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

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

There is a single parameter (activityId) and schema description coverage is 100%, so the schema already documents it. The description adds nothing about the identifier's origin or format, leaving this at the baseline for fully covered parameters.

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

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

States a specific verb+resource (laps of an activity) plus the data source (.FIT file) and enumerates the returned fields in detail. It explicitly distinguishes itself from the sibling getActivity by noting that getActivity lacks lap data, so an agent can route correctly without opening either schema.

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

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

Names the use cases directly ("Use it for intervals and per-km splits") and names the alternative plus the exclusion condition ("getActivity does not have them"). The guidance is explicit about when to prefer this tool over its closest sibling.

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

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

With no annotations, the description carries the behavioral burden and does so well: it discloses the data source (.FIT file), the important caveat that later Garmin Connect edits are not reflected, and field-level nullability (weight absent, e1rmKg null). It stops short of stating auth needs or performance characteristics, so not a 5.

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

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

The core return-shape info is front-loaded in the first sentence and the rest unpacks fields. It is dense and slightly run-on across many clauses, but nearly every clause conveys distinct, useful data (top, e1rmKg, restSec), so little is wasted.

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

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

There is no output schema, so the description must explain return values, and it does so thoroughly—per-exercise entries, set fields, derived top/e1rmKg definitions, and the .FIT-edit caveat. An agent has enough to interpret the output 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?

Only one parameter (activityId) and schema description coverage is 100%, so the schema already documents it. The description adds no additional semantics about activityId beyond what the schema provides, matching the baseline 3 for high-coverage schemas.

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

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

States a specific verb and resource: reads strength training sets from an activity's original .FIT file, one entry per exercise. This is clearly distinguishable from siblings like getActivityLaps and getActivityWorkouts, which cover different data.

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

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

Usage is implied by the resource name and 'strength training sets' framing, so an agent can infer this is for strength-workout exercise breakdowns. However, it never explicitly says when to reach for this versus getActivityLaps or getActivityWorkouts, and gives no exclusions or alternatives.

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

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

With no annotations the description carries the full burden, and it delivers: it defines the return shape (ordered steps, intensity, duration type, targets, coach notes), documents the empty-list case, documents that null fields are omitted, and explains the non-obvious REPEAT_UNTIL_STEPS_CMPLT semantics. Missing only minor traits such as error behavior when activityId is invalid.

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

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

Front-loaded with the resource definition, then fields, then the repeat-step special case, then the comparison hint. The enumerations of intensity/target values are dense but each earns its place; the REPEAT_UNTIL_STEPS_CMPLT sentence is long but necessary.

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

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

No output schema exists, so the description must explain returns — and it does, covering step structure, ordering, empty results, and omitted nulls. A user can invoke and interpret the tool from this alone; only the repeat-step wording is slightly hard to parse.

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% for the single activityId parameter, so the schema already defines it. The description adds no parameter-level guidance (e.g., where to obtain the id, whether the workout is keyed to a different id), so baseline 3 applies.

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

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

Names the concrete resource (the planned workout an activity followed, as created in Garmin Connect) and what it contains, which is more specific than the tool name alone. It stops short of a clean verb-first statement ('Returns the planned workout for an activity'), but the intent is unambiguous and it distinguishes itself from the laps/sets siblings.

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

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

Provides one situational hint: 'Compare it with getActivitySets or getActivityLaps for plan against done,' which implies this is the 'plan' side. It does not state when not to use it, or that the activity must exist / be synced, so usage is implied rather than spelled out.

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

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

With no annotations, the description carries the full burden. It discloses the maximum date range (14 days) and the types of events included, but omits behavioral traits such as whether the operation is read-only, authentication requirements, rate limits, or error handling. This is a read tool, but the description does not explicitly confirm that.

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 that efficiently conveys the tool's purpose and output content. It is dense but not overly verbose, though it could be slightly more structured with bullet points.

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 simple two-parameter schema and no output schema, the description adequately explains what data is returned per day, including charge/drain, readings, and events. It covers the essential information an agent needs to call the tool correctly, though it could mention output format or error conditions.

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 both parameters. The description only reiterates the date format (yyyy-MM-dd) and the 14-day limit, adding no new meaning beyond what the schema provides.

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 (get) and resource (Body Battery) and details the data returned per day, including charge/drain, readings, and events. It clearly distinguishes this tool as focused on Body Battery data, though it does not explicitly name sibling tools for differentiation.

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 by specifying a date range up to 14 days and listing the data returned, but it offers no explicit guidance on when to choose this tool over alternatives like getDailySummary or getSleep. No exclusions or prerequisites 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?

With no annotations, the description carries the full behavioral burden. It discloses that results are daily and include resting heart rate, but it does not mention permissions, timezone/local-date behavior, no-data handling, or the returned data shape.

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 filler. Every component—resource, scope, included resting heart rate, and date format—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 one-parameter getter with full schema coverage, the description is minimally adequate. However, with no output schema and no annotations, it could say more about the returned daily heart-rate structure and edge cases.

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

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

Schema description coverage is 100%, and the only parameter is already documented as a yyyy-MM-dd date. The description repeats the date format but adds no further semantics such as timezone or range constraints, so the baseline of 3 applies.

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

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

The description states a specific verb/resource and scope: daily heart rate for one date, including resting heart rate. It is clear what the tool returns, but it does not explicitly distinguish itself from related siblings such as getHeartRateZones, getHrvRange, or getDailySummary.

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 one-date scope implies when the tool is applicable, but there is no explicit when-to-use or when-not-to-use guidance. It also does not name alternatives or explain how to choose between this and related heart-rate or daily-summary tools.

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

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

No annotations exist, so the description carries the full burden: it does disclose two non-obvious behaviors — the hard 14-day range cap and that range responses use Garmin's v2 field names rather than the single-date shape. It omits whether this is strictly read-only, whether auth/existing Garmin session is required, and how errors surface for over-long ranges.

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: purpose and metrics first, scope and parameters second, format notes parenthetically. No filler and nothing to cut.

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 zero required params, no annotations, and no output schema, the description does the necessary work by listing the returned metrics and flagging the differing range response shape. The residual gap is that 'Garmin's v2 field names' is not actionable without external docs and the mutual exclusivity of 'date' vs. fromDate/toDate is only implied.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning beyond the schema: the pairing requirement is framed as an either/or mode choice and the undocumented 14-day maximum is introduced. It still doesn't say what happens when both 'date' and the from/to pair are supplied.

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?

Names a specific resource ('Daily user summary') and enumerates the returned metrics (steps, calories, stress, body battery, resting HR), which distinguishes it from narrower siblings like getBodyBattery, getDailyHeartRate, and getSleep. The single-date vs. range scope is stated up front.

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

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

It explains the two invocation modes ('for one date, or for up to 14 days') and which parameters select each, which is genuine usage context. However, it never says when to prefer this aggregate over the many sibling single-metric tools (getSleep, getBodyBattery, getDashboardData), so the agent still infers the choice.

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

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

With no annotations, the description carries the behavioral burden and discloses significant traits: local caching and delta Garmin fetches, sync metadata, units/locale, null loads, partial weeks and missing readiness. It stops short of explicitly stating read-only safety, auth requirements, rate limits or error behavior.

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

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

Purpose is front-loaded, but the body is a dense run-on paragraph mixing return fields, cache behavior, parameter notes and edge cases. Bullet points or sections would substantially reduce parsing cost; most details are relevant, so the issue is structure rather than 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?

For a two-parameter aggregate with no output schema and no annotations, the description is largely complete: it enumerates returned sections, explains the digest and sync blocks, and covers edge cases like null loads and missing readiness. The main omission is an explicit safety/mutation profile, e.g. whether the local cache write is the only side effect.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds real semantics for `workouts` (last 8 repeats, older FIT files, deduplication) and ties `weeks` to the activity window, going meaningfully beyond the schema text.

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?

Names the exact aggregate resource (training dashboard data) and enumerates the constituent data sets: HR zones, fitness age, activities, HRV, sleep and daily summaries. The 'in one call' framing plus the enumeration distinguishes it from single-domain siblings such as getSleep or listActivities.

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 useful context for incremental refreshes ('keeps a local cache ... a rebuild or an update needs few calls') and says to use the activities for another date range. However, it never names a sibling tool explicitly or states when to prefer getSleep, getHrvRange, listActivities, etc., over this aggregate.

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

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

With no annotations, the description carries the behavioral burden. It usefully enumerates the returned values and components, but it does not disclose access requirements, data availability, or other operational context for the read operation.

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

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

The description is a single front-loaded sentence with no wasted words. It prioritizes the main resource and then briefly explains the returned components.

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

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

For a simple one-parameter read tool with a fully described schema, the description gives enough output context, including the key returned metrics, even though no output schema exists. The main gap is the absence of usage guidance relative to sibling tools.

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

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

Schema description coverage is 100%, so the single date parameter is already documented. The description repeats the yyyy-MM-dd format but adds no extra semantics such as timezone or valid date range, making the baseline score 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 resource and scope: Garmin fitness age for a given date, including what the result compares and which components are returned. It is clearly distinct from metric siblings such as getSleep or getDailySummary, though it does not explicitly 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?

The description does not say when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. Usage is only inferable from the tool name and the mention of a date parameter.

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

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

No annotations are present, so the description carries the full burden. 'Currently configured' usefully signals a read-only snapshot of stored settings rather than a mutation or a computed metric, but it does not state whether zones are default or user-customized, whether they are sport-specific, or on what basis zone boundaries are 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 tight sentence fragment with no filler, and the key discriminator ('currently configured') is front-loaded. It is arguably slightly too terse given the absence of annotations and an output schema, but nothing is wasted.

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

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

With no annotations and no output schema, the description is the only source of behavioral context, and it omits the one thing an agent most needs: what comes back. Garmin zones vary by sport and by basis (%max, %LTHR, %reserve) and include zone boundaries, so leaving the return shape entirely unspecified is a real 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 tool takes zero parameters and the schema is an empty object with full coverage, so there is nothing for the description to disambiguate. The description correctly implies no inputs are needed, so the baseline of 4 applies.

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

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

Names a specific resource (heart rate zones) with a meaningful qualifier ('currently configured in Garmin Connect'), which implies a retrieval of stored settings rather than measured heart-rate samples. There is no explicit verb and no sibling is named, but an agent can still tell this apart from getDailyHeartRate based on the 'configured' framing.

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 on when to use this versus getDailyHeartRate, getHrvRange, or getFitnessAge—all of which surface heart-rate-related data. There are no prerequisites, no exclusions, and no statement that it takes no arguments and needs no user/sport 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?

No annotations exist, so the description carries the full disclosure burden. It implies a read-only retrieval and states the data is daily/overnight, but says nothing about return shape, missing-data behavior, date-range limits, or whether ranges are inclusive.

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 compact sentence with the resource and the date format front-loaded and no filler. It is telegraphic enough that it reads more like a fragment than a complete instruction.

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

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

For a simple two-parameter read tool with full schema coverage, the essentials are present, but with no output schema the agent gets no hint about the returned HRV fields or aggregation. Adequate but with a clear 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?

Schema coverage is 100%, with both fromDate and toDate documented as yyyy-MM-dd, so the description's format note is redundant rather than additive. Baseline 3 applies since the schema already does the work.

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?

Names a specific resource (daily overnight HRV summaries) and scope (date range), which clearly separates it from siblings like getSleep or getDailyHeartRate. It never explicitly contrasts itself with those siblings, keeping it short of a 5.

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

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

There is no guidance on when to use this versus getDailySummary, getSleep, or other date-range health tools, and no stated prerequisites. The date-range scope is implied by the parameter names rather than explained.

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

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

With no annotations, the description carries the full burden and largely delivers: it discloses the 14-night cap, that output is one compact row per night, that missing values are omitted rather than nulled, and that a night without sleep data returns only its date. It doesn't mention auth requirements or rate limits, but for a read-only data getter the behavioral profile is unusually complete.

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

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

The mode-selection information is front-loaded, and the long field enumeration earns its space because there is no output schema. The middle clause is dense and reads as a run-on, but nothing is redundant with structured 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?

With no output schema and no annotations, the description compensates by enumerating every returned field and the missing-data convention. The one gap is that all four parameters are optional, and the description never says what happens if no date arguments are passed.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: 'date' is defined as 'the morning you woke up' (a genuine disambiguation the schema does not make), and it explains that fromDate/toDate must be used as a pair. That goes beyond restating property 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 names a specific verb ('Sleep') and resource (Garmin sleep data) and splits the two operating modes: a single night via 'date', or a range via 'fromDate'/'toDate'. The resource is unique among siblings (getActivity, getBodyBattery, getHrvRange), so confusion is unlikely, though no sibling is named explicitly to route an agent away.

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 the condition for each mode: one night with 'date', up to 14 nights with 'fromDate' and 'toDate', and 'raw=true' for Garmin's JSON. It gives no exclusions or pointers to alternative tools, but the usage context is unambiguous.

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

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

With no annotations provided, the description carries the full disclosure burden and does well: it explains that each day's latest entry is returned, what extra scale metrics may accompany it, that an average and boundary weights are included, and the units used. It does not cover auth, rate limits, or no-data behavior, but it substantially describes the read behavior.

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

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

The description is front-loaded with the core purpose and then packs in the important return-shape details without filler. Despite being dense, every clause contributes either scope, output composition, includeAll behavior, or units.

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 and no annotations, so the description must explain the return values, and it does so thoroughly: per-day latest entries, optional body-composition metrics, range average, adjacent boundary weights, includeAll behavior, and units. That is sufficient for an agent to invoke and interpret 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 fromDate, toDate, and includeAll. The description reinforces the date format and includeAll effect and adds unit context, but it does not add much parameter semantics beyond what the schema already provides.

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 weight data over a date range and enumerates the returned components, so an agent can tell this is the weight-history tool. It lacks an explicit verb and does not explicitly contrast with siblings such as getDailySummary, but the resource-specific scope is still clear.

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

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

It gives useful context for the date range and explains when to set includeAll=true, but it does not say when to use this tool instead of related body-composition or daily-summary tools. Usage is implied rather than explicitly guided.

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

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

With no annotations, the description carries the full burden and does well on the read path: it discloses result ordering, the shape of the compact summary, that certain fields appear only "when Garmin has them" (conditional presence), and the date format. It omits pagination/continuation behavior beyond the limit, and says nothing about authentication, rate limits, or error behavior for large or unbounded limits.

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

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

Purpose and ordering are front-loaded, followed by return-content detail, so the reader gets the essential information immediately. The middle is a long semicolon-chained field list that is dense to read, but given the absence of an output schema those items largely earn their place.

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

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

With six optional parameters all covered by the schema and no output schema, the description's main remaining duty is explaining return content, which it does thoroughly, including conditional fields and the raw alternative. Only minor gaps remain (pagination beyond limit, auth expectations), which do not block correct invocation.

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

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

Schema description coverage is 100%, so all six parameters (raw, limit, names, startDate, endDate, activityType) are already documented in the schema. The description only restates the raw flag and the yyyy-MM-dd format, adding no filtering semantics or defaults beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb and resource ("List the user's Garmin activities"), plus ordering ("most recent first") and output form ("compact summary" versus raw JSON). It enumerates the summary fields and the raw escape hatch, which makes it distinguishable from the single-activity sibling getActivity without opening either schema.

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

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

Usage is only implied: an agent infers this is for enumerating multiple activities and that raw=true should be used when full Garmin JSON is needed. There is no explicit when-to-use versus getActivity/getActivityLaps guidance, and no statement of exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden and does so thoroughly: it discloses the underlying scheduler (launchd/cron/Task Scheduler), that it runs with no assistant open, that it destroys coach notes, that the computer must be on at that time, and what `last`/`next` report. These are the kinds of destructive side effects and constraints an agent needs before calling.

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

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

Purpose is front-loaded in the first sentence and the rest is organized from usage rules to side effects to parameter details. It is on the long side and a few clauses (e.g. the late-update note for `last`) are tangential, but almost every sentence adds operative 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?

There is no output schema, yet the description explains the reply shape (`next` with upcoming local-time runs and instruction to relay them), plus `last` diagnostics. Combined with the prerequisites and scheduling constraints, an agent has enough to call and report results correctly.

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

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

Schema coverage is 100%, so baseline would be 3, but the description goes well beyond the schema: it explains the 5-field cron format in local time, gives an example, requires a minimum 1-hour gap between runs, defines `path` defaulting to the main page, and specifies that `off` without `path` stops every page. Each parameter's interaction with the others is made explicit.

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

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

The first sentence gives a specific verb (enables/changes/stops) and resource (automatic refresh of a dashboard page), immediately distinguishing this from the sibling dashboard tools (writeDashboard, editDashboard, showDashboard, getDashboardData). An agent can select it without opening the schema.

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

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

It states an explicit precondition ('only when the user asks for it or says yes to the question of a dashboard prompt') and a prerequisite ('The page must exist (writeDashboard first)'). The `off` semantics and no-argument read-only mode are also spelled out, leaving no ambiguity about when to invoke it.

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

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

With no annotations, the description carries the burden well: it states 'Writes nothing and has no coach notes', defines the return payload (page path, data digest, page settings), and explains the preset-page fallback when no page exists. It does not mention any authentication or data-source prerequisites, which is the remaining gap.

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

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

Front-loads the core action ('Shows the training dashboard in the chat') before qualifications, and every sentence carries information (defaults, return values, sibling routing). It is dense but not padded, though the run-on parenthetical with backticks and line breaks makes it slightly harder to scan.

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

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

For a 2-parameter, no-output-schema tool, it explains the return values and both MCP-App and non-MCP-App behavior, which is close to complete. Only the lack of permission/auth prerequisites keeps it from being fully complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds light context (default page path under the data dir, relative paths inside the data dir, weeks of new data) but largely restates what the schema already documents, including the default of 12 and max of 52.

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?

Names a specific verb (shows) and resource (training dashboard) plus the precise rendering context (in the chat, in MCP Apps assistants). It also distinguishes itself from writeDashboard by noting that non-MCP-App assistants only see the reply and must use writeDashboard to persist a file.

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

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

Explicitly states the condition that selects this tool (assistants that show MCP Apps) and the alternative for the other case (writeDashboard writes the page as a file). The routing decision is fully spelled out rather than inferred.

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

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

With no annotations, the description carries the full burden and does so thoroughly: it discloses that existing page data is replaced while code/layout/widgets survive, that a different page code triggers an upgrade with `page: "upgraded"`/`previousServer`/`server` in the result, that the prior page is kept as `<file>.bak` except within a 15-minute window, that notes are escaped and capped at 5, and that preview writes nothing.

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

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

The purpose and return value are correctly front-loaded, and most sentences carry real information. However, the bulk arrives as a dense run-on with backticked identifiers interleaved mid-sentence and no segmentation, so the agent must parse carefully to extract the individual rules about upgrades, backups, and settings precedence.

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 mutation tool with 7 parameters, a nested settings object, no annotations, and no output schema, the description covers side effects, backup behavior, upgrade results, missing-language/widget-text signals, and preview mode. An agent could call it correctly and interpret the result without further information.

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

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

Schema coverage is 100%, so the baseline is 3; the description goes beyond it by specifying that `page` code must contain /* garmin-data:start */null/* garmin-data:end */, that `settings` fully replace the page's own settings, and that `layout` retains languages added via editDashboard. It adds meaningful semantics rather than restating 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 first sentence gives a specific verb (writes) and resource (the training dashboard page), names the default file path, and states what is returned (path plus digest). Sibling differentiation is only implicit — editDashboard and showDashboard are referenced in passing for language/widget text edits, but the description never says outright which sibling to use for which job.

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 establishes clear usage contexts: `layout` for a fresh template page, `page` for your own code, `settings` to replace page settings, and `preview: true` to inspect without writing. It also routes two tasks to the alternative (editDashboard `languages` and `widgetTexts`), though it never states when NOT to use this tool versus editDashboard or showDashboard.

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