garmin-connect-mcp
Server Quality Checklist
Latest release: v1.0.0
- Disambiguation5/5
Each tool targets a distinct health metric or activity aspect. The daily summary and individual metric tools are clearly separated by description, and activity tools (list, details, splits, last, on day) have distinct purposes. No two tools overlap in functionality.
Naming Consistency5/5All tool names follow a consistent verb_noun pattern using snake_case. Read operations use 'get_', 'list_', or 'show_', and write operations use 'log_', 'create_', or 'schedule_'. The pattern is predictable and easy to understand.
Tool Count4/525 tools is on the higher end, but each covers a distinct aspect of Garmin Connect's health and fitness data. The count is justified by the breadth of metrics (daily summary, sleep, steps, HR, HRV, stress, body battery, etc.) and activity/workout management. A slight reduction could be possible if some convenience tools were merged, but they each earn their place.
Completeness4/5The tool set covers the main user needs: viewing daily health metrics, activity history, workout planning, and logging weight and hydration. Missing are update/delete operations for activities or workouts, but these may be limited by the Garmin API. Overall, the surface is well-rounded and leaves few obvious gaps for typical queries.
Average 3.7/5 across 25 of 25 tools scored. Lowest: 2.4/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 2 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add
glama.jsonto the root of your repository:{ "$schema": "https://glama.ai/mcp/schemas/server.json", "maintainers": [ "your-github-username" ] }Then . Browse examples.
Add related servers to improve discoverability.
How to sync the server with GitHub?
Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.
To manually sync the server, click the "Sync Server" button in the MCP server admin interface.
How is the quality score calculated?
The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).
Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.
Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).
Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.
Tool Scores
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It does not disclose whether this operation is read-only, whether it requires specific user permissions, or what side effects occur (e.g., data is not modified). The format of the returned data (e.g., JSON object with specific fields) is also not described beyond the initial list.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief (two lines plus a simple argument list), but the summary line could be rephrased to be more complete. It wastes no words but lacks a clear verb.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has only one parameter with a default and an output schema, the description covers the basic purpose. However, it does not explain the relationship between the returned fields (e.g., fitness age vs. training status) or how this differs from other health tools like get_hrv or get_daily_summary.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning the schema provides no description for the 'day' parameter. The description adds only an example ('today' or '2026-08-18'), but does not clarify the default behavior (default='today'), timezone handling, or date format requirements. This is insufficient to compensate for the missing schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states 'VO2 max (aerobic fitness), fitness age and training status' as the returned data. However, it does not clearly state that the tool *gets* or *retrieves* this data, and among siblings like get_daily_summary, the distinction is unclear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No usage guidelines are provided. The description does not specify when to use this tool versus alternatives like get_daily_summary or get_training_readiness, nor does it mention any prerequisites or contraindications.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility for disclosing behavioral traits. It does not state that the operation is read-only, whether authentication is required, or the structure of the response (e.g., pagination). The description adds little beyond the name.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short but includes an unnecessary 'Args' section that merely echoes the schema. While not verbose, it is not optimally structured (e.g., missing a clear purpose statement beyond the first line). It could be more front-loaded and concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema (not shown), but the description does not mention what the list contains (e.g., workout names, IDs) or any ordering, sorting, or filtering behavior beyond the limit. For a list tool with only one parameter, completeness is minimal; an agent would lack key context for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning the description should compensate by explaining the `limit` parameter's meaning, constraints, or behavior. It merely restates the schema defaults with 'Most workouts to list. Defaults to 25.' – no additional semantics or constraints are provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does 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 ('saved workout plans in Garmin Connect'). It distinguishes itself from sibling tools like `get_workout` and `get_scheduled_workouts` by specifying 'plans' (plural) and the scope 'saved'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as `get_scheduled_workouts` or `get_workout`. There is no mention of prerequisites, default behavior, or limitations, leaving the agent without context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully convey behavioral traits. It mentions the unit 'kilograms' (helpful) but fails to disclose side effects (e.g., whether it overwrites an existing entry for the same day), required authentication context, or rate limits. The description is overly minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and front-loaded with the main purpose. The Args section is clearly structured. However, it could be trimmed further by merging the first sentence with the example; still, no significant waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low schema coverage and no annotations, the description lacks essential details like date format, valid range for kilograms, and whether updates are allowed. The output schema exists but isn't leveraged to clarify return behavior. The tool involves a write operation that could have side effects, but nothing is disclosed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5Does 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 schema's lack of meaningful property descriptions. It does add the example format for 'kilograms' (e.g., 74.5) and clarifies that 'day' defaults to today. However, it does not specify the date format expected (e.g., ISO 8601, YYYY-MM-DD) or any bounds on 'kilograms'. This is insufficient for a zero-coverage schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Record' and the resource 'body weight measurement in Garmin Connect'. It distinguishes from the sibling 'get_weight_history' which is a read operation, though it doesn't explicitly contrast them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'get_weight_history' for viewing past weights. There is no mention of prerequisites or restrictions (e.g., can only be logged once per day? Does it support future dates?).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden, but it only notes that the 'period' parameter is informational—it does not disclose whether the tool is read-only, destructive, requires authentication, or what happens to the data. The lack of behavioral context leaves an agent uncertain about side effects or access needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short at two lines plus an Args section, which is concise. It is front-loaded with the purpose and then adds the parameter note. However, the 'Args' section could be more integrated, and the brevity sacrifices necessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has only one parameter, no annotations, and an output schema (which may document return values), the description is still incomplete. It fails to explain what 'upcoming scheduled workouts' means relative to the training calendar, how results are ordered, or any limitations. The substantive output schema reduces the need to describe returns, but behavioral and parameter gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning the description must compensate, but it only marginally addresses the single parameter 'period' by calling it informational. It does not explain valid values, format, or how the parameter affects results beyond the default of 'next 30 days'. This is insufficient for an agent to use the parameter correctly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the verb 'Show' with the resource 'workouts scheduled on the Garmin training calendar', which clearly states the tool's purpose. It is distinguishable from siblings like 'list_workouts' (which likely lists available workout templates) and 'schedule_workout' (which schedules a new one).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions the 'period' argument is currently informational and all upcoming scheduled workouts are returned, giving some context on usage. However, it does not explicitly state when to use this tool versus alternatives like 'list_workouts' or 'get_activities_on_day', nor does it provide any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility for behavioral disclosure. It mentions the data source (Garmin) and the outputs (status, baseline range), but does not disclose critical behavioral traits such as read-only nature, authentication requirements, data freshness, or what happens when no data exists for a given day. The description is insufficient for safe autonomous use.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at two sentences plus an Args line. It front-loads the core purpose and parameter guidance without extraneous information. Every part serves a clear function, though it could be slightly more structured for readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the existence of an output schema, the description need not detail return values. However, it creates confusion by stating 'for one night' while the parameter is named 'day'. It does not explain what 'Garmin's status' or 'personal baseline range' entail. With siblings like get_sleep and get_stress, the description could better tie the tool to overall health analysis. It is adequate but has notable gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must supplement. The 'Args' section provides examples for the 'day' parameter ('today', 'yesterday', '2026-08-18'), adding format and possible values beyond the schema's bare type and default. However, it does not explain edge cases like future dates or missing data, so compensation is partial.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns 'Heart rate variability (HRV) for one night, with Garmin's status and the personal baseline range.' This specifies the verb (get), resource (HRV), and scope (single night, with status and baseline). It distinguishes from siblings like get_heart_rate and get_stress by focusing on a specific recovery metric with contextual data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use get_hrv versus alternative tools such as get_stress or get_body_battery. It explains that HRV is a recovery and stress indicator, which implies usage context, but does not state when to prefer this tool over others 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.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must carry full burden. It only describes return content (levels, charge/drain) but omits behavioral details: authentication needs, read-only nature, rate limits, error handling for invalid periods, or whether data is aggregated daily. The presence of an output schema partially offsets the need to describe return format, but behavioral context is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences plus a short Args block. Every word adds value. The main purpose is front-loaded, and the parameter explanation is immediately appended. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter and an output schema, the description provides a basic understanding: what the metric is and how to specify the period. However, it lacks units (e.g., is it a percentage?), range, and explicit documentation of returned fields. The output schema likely covers structure, but an agent could still be uncertain about interpreting results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% (no parameter description in schema). The description compensates well with concrete examples: 'last 7 days', 'this week', '2026-08-01 to 2026-08-18'. This adds explicit format guidance beyond the schema's type and default. However, it could further clarify timezone handling or accepted date formats.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves 'Body Battery energy levels' and explains what it shows (charged and drained each day) and what higher values mean. This specific verb+resource combination distinguishes it from sibling tools like get_heart_rate or get_sleep, which cover different metrics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides an example for the period parameter but gives no guidance on when to choose this tool over alternatives, no prerequisites, and no context like 'use this for daily energy trend analysis'. An agent would lack direction for appropriate invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full responsibility for behavioral disclosure. It indicates that the tool returns recorded body weight with a computed change metric, implying a read operation. However, it does not mention safety (e.g., read-only nature), authentication needs, rate limits, or what happens if the period is invalid. The output format is left to the output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: one sentence for the core purpose, followed by a brief parameter description with examples. Every sentence adds value, and the structure is front-loaded. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter and an existing output schema, the description adequately explains the parameter and the high-level return value (weight history with change). It does not cover edge cases or limitations, but given the low complexity and presence of output schema, it is nearly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema only provides a title and default for `period`. The description adds concrete examples ('last 30 days', 'this month', '2026-01-01 to 2026-08-18') and hints at allowed formats (relative phrases or absolute dates). Given 0% schema description coverage, this significantly enhances understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Recorded body weight over a period, with the change from first to last,' clearly specifying the verb (get/retrieve) and resource (body weight history) including a specific metric (change). It is distinct from sibling tools like `log_weight` (logging) and `get_daily_summary` (aggregate data), but does not explicitly differentiate from them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For example, when to prefer `get_weight_history` over `get_daily_summary` or `log_weight` is not mentioned. No exclusions or prerequisites are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavioral traits. It only states a read-like operation ('list') but does not clarify return format, pagination, error handling, or whether the tool is idempotent. Key details like what happens for invalid dates or empty results 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.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences plus a well-structured Args block. Every word adds value, with no redundancy or filler. It front-loads the core purpose effectively.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has a single parameter and an output schema (not shown), the description covers the input sufficiently. However, it lacks usage context relative to the large set of sibling tools, and does not address edge cases like missing or malformed dates. It is complete for basic invocation but not for nuanced decision-making.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description adds significant value by explaining the 'day' parameter with concrete examples ('today', 'yesterday', '2026-08-18'). This goes beyond the schema's title and default, though a more precise format specification (e.g., 'YYYY-MM-DD') would improve it further.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'List', the resource 'activities', and the scope 'on one specific day'. This distinguishes it from siblings like 'list_activities' (which likely lists across days) and 'get_daily_summary' (which aggregates stats).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus its many siblings (e.g., list_activities, get_activity_details, get_last_activity). The description does not mention when not to use it or alternatives, leaving the agent without contextual decision support.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. It only states it lists devices and last-use times, but omits details like whether it shows all devices regardless of status, if it requires authentication, or if it has any side effects. The description is minimal and relies on the tool name for implied behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the verb and resource, and contains no extraneous information. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with no parameters and an output schema (as indicated in context signals), the description adequately explains what is returned (devices and last used time). It is complete enough for an agent to understand its basic purpose, though it could hint at the output structure more explicitly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters. With no parameters, the baseline is 4. The description does not need to add parameter meaning, and it correctly matches the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List the Garmin devices on this account and when each was last used.' It uses a specific verb (List) and resource (Garmin devices on this account), and the sibling tools focus on activities, health data, or workouts, so this tool is well-differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. There is no mention of exclusions, prerequisites, or context such as 'use this to see all devices before performing device-specific operations.'
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states 'full detail' which hints at a rich response but does not disclose traits like return format (e.g., list vs. object) or whether it requires authentication. It's adequate but not detailed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: one sentence with no extra words. It front-loads the key promise ('Full detail') and specifies the scope ('most recently recorded'). Could be improved by slightly restructuring for even quicker scanning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given there are zero parameters, an output schema exists (though not detailed here), and no annotations, the description is fairly complete. It tells the agent exactly what it will get: full details for the most recent activity. It doesn't explain what 'activity' encompasses vs. siblings, but the scope is narrow enough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, and schema description coverage is 100% (no params to document). The description adds value by promising 'Full detail' which implies the no-parameter call returns a comprehensive object. This is clear and useful.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns 'Full detail for the most recently recorded activity.' The verb 'get' is implied and the resource is 'activity'. However, it doesn't explicitly distinguish what 'activity' means compared to siblings like 'get_daily_summary' or 'get_activity_details', but the focus on 'most recently recorded' separates it from listing or detail-by-ID tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool: to get the latest activity with full detail. However, there is no guidance on when not to use it or alternatives (e.g., for a specific date, use get_activity_details; for a range, use list_activities). The sibling tools are numerous and related, making explicit guidance valuable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden. It discloses the tool returns a score and factors, but does not specify whether this is a read-only operation, whether it requires authentication, rate limits, or the scope of data (e.g., today only vs historical). The description is adequate but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by clear parameter documentation. It's concise at two sentences plus a parameter block, but the parameter documentation could be more integrated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (so return values are documented elsewhere) and a single optional parameter, the description sufficiently covers the main purpose and usage. It does not explain edge cases like missing data for a selected day, but overall meets the needs of an information retrieval tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context for the 'day' parameter beyond the schema (which only provides a default and type). It clarifies accepted formats like 'today', 'yesterday', or a date string '2026-08-18'. Given 0% schema description coverage and 1 parameter, this is helpful guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves Garmin's training readiness score and identifies contributing factors. It distinguishes itself from sibling tools like get_hrv, get_sleep, or get_daily_summary by focusing specifically on readiness assessment.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the primary use case (assessing training readiness) but provides no guidance on when to prefer this over siblings like get_body_battery or get_daily_summary for similar recovery/readiness questions. No exclusions or alternatives are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavioral traits. It only states the action (putting on calendar) without mentioning side effects, permissions, overwrite behavior, error handling, or idempotency. For a mutation tool, this is insufficient transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with three sentences, including a clear purpose statement and parameter explanations. Every sentence earns its place without any fluff, making it easy to scan and understand.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema, return values are covered. However, the description lacks details on error conditions (e.g., scheduling an already occupied day), overwriting behavior, or prerequisites beyond the workout_id. It is adequate but not fully complete for a scheduling mutation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description adds valuable context: workout_id is explained as 'The numeric id, from list_workouts or create_workout,' and day includes usage examples ('tomorrow' or '2026-08-20'). This compensates well for the lack of schema descriptions, providing meaning beyond the raw types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Put an existing workout plan on the Garmin training calendar,' using a specific verb (Put) and resource (existing workout plan onto calendar). It distinguishes from sibling tools like create_workout (creates plans) and get_scheduled_workouts (lists scheduled), establishing a unique purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly suggests when to use the tool by referencing where to get the workout_id (list_workouts or create_workout), but it does not explicitly state when to use vs alternatives, nor does it provide exclusions or context for when not to use it. This leaves the agent needing to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden of behavioral disclosure. It does not state whether the tool is read-only, requires authentication, has rate limits, or what happens if no data exists for the requested day. The description implies a safe read operation but does not confirm it.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and front-loaded with the tool's output. Every sentence adds value, but the 'Args:' section is somewhat redundant with the schema, though it provides useful examples. Could be slightly tighter by integrating examples into the main text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema, the description need not detail return fields, but it does list key returned metrics. However, it omits behavioral context (e.g., error handling, no-data cases) and usage guidance for alternative tools. Overall adequate for a simple retrieval tool but not fully comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain the parameter. It does this effectively by giving concrete example values for the 'day' parameter (today, yesterday, date format), adding meaning beyond the schema's default value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns heart rate data for one day, including resting, lowest, highest, and a seven-day average. This is specific and distinct from sibling tools like get_hrv, get_steps, or get_sleep, which focus on different health metrics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides examples for the 'day' parameter ('today', 'yesterday', '2026-08-18'), which guides usage. However, it does not explicitly exclude cases where broader date ranges are needed (e.g., via get_date_range_summary) or clarify when not to use this tool versus alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description provides moderate behavioral insight: it explains the output includes average, highest, and a stress-level split. However, it does not disclose potential limitations (e.g., no data for a day), required permissions, or any side effects. The behavioral transparency is adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences of purpose followed by a minimal args section. No redundant words, and the key information is front-loaded. Every sentence adds value, and the structure is clean.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the single parameter and the existence of an output schema, the description covers the main aspects: what the tool returns (average, highest, split) and how to specify the day. It lacks handling of edge cases (e.g., missing data, invalid date formats) but is mostly complete for a straightforward read tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage for the single parameter 'day', but the description adds concrete examples ('today', 'yesterday', '2026-08-18'), clarifying the expected format. This compensates well, though additional details like timezone handling or date range restrictions would elevate it further.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states what the tool does: it returns stress levels for a given day, including average, highest, and the split between rest, low, medium, and high stress. The verb 'get' with the resource 'stress levels' is specific, and the output details distinguish it from sibling tools like get_hrv or get_body_battery.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. While the description explains the day parameter, it does not mention prerequisites, context (e.g., requires a wearable device), or situations where this tool is preferable over other health metric tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It only states 'Show the steps' without disclosing side effects, authentication needs, rate limits, or any behavioral traits beyond a simple read operation. The presence of an output schema is not mentioned nor is its content summarized.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of one purpose sentence and one parameter line, with no wasted words. The most important information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple retrieval tool with a single parameter and an output schema present, the description is largely complete. It could mention that the output schema will contain the detailed steps, but overall it provides enough to use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The parameter description adds meaning beyond the schema by specifying 'The numeric id, from list_workouts,' clarifying both the type and source. At 0% schema coverage, this is valuable context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Show the steps of one saved workout plan,' using a specific verb and resource. It distinguishes itself from siblings like list_workouts (list plans) and create_workout (create plans).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage requires a workout_id from list_workouts, but does not explicitly state when to use this tool versus alternatives (e.g., get_activity_details). No when-not or alternative guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that the tool returns totals over a period and accepts a period string with examples, but it does not state whether the data is read-only, if there are rate limits, or what happens when no data exists. The behavior is reasonably transparent for a summary query.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (two sentences plus parameter descriptions) and front-loaded with the core purpose. Every sentence adds value, though the parameter descriptions could be folded into the initial sentence for even tighter structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, 2 parameters, and an output schema (which likely describes return fields), the description sufficiently covers what the tool does and its inputs. The sibling context suggests this is a summary tool among many activity-specific ones. It is complete enough for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% coverage, so the description must compensate. It adds meaning for the 'period' parameter with examples ('last 30 days', 'this month', 'last week') and for 'sport' as an optional filter with examples ('running', 'cycling'). However, it does not specify allowed values or formats beyond the examples, leaving ambiguity for the agent.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool aggregates totals (activities, distance, time, calories) over a period, with an explicit example ('how much did I run last month'). It distinguishes itself from siblings like 'get_activity_details' or 'list_activities' by focusing on summary across 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.
Usage Guidelines4/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear when-to-use guidance with the example and optional sport filter. However, it does not explicitly say when NOT to use this tool (e.g., for detailed activity breakdowns) or suggest alternatives like 'get_activity_details' for granular data.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full burden. It indicates a read operation ('recorded by Garmin') with no side effects, but does not mention data freshness, caching, or whether all records are always returned. This is adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence efficiently conveys the tool's purpose and provides relevant examples without any redundant words. It is front-loaded and every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless tool with an output schema, the description is complete: it explains what is retrieved and gives concrete examples. No additional context about return format is needed given the output schema existence.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the description adds value by listing example record types, compensating for the lack of param details. Schema coverage is trivially 100%, earning a baseline of 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves personal bests from Garmin, with concrete examples like fastest 5K and longest run. This distinguishes it from sibling tools such as get_activity_splits or get_vo2max_and_fitness, which focus on different data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives is provided. Given many sibling tools for health and activity data, the agent receives no hints about appropriate selection or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral traits. It correctly hints at a write operation ('Add') and adds context about milliliters (e.g., '250 is a glass') and day defaults. However, it does not disclose what happens on success/failure, authentication needs (likely required for Garmin), rate limits, or side effects (e.g., overwriting existing entries on the same day). 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.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise—two short sentences plus an Args block with two parameters. Every sentence adds value (purpose, measurement context, default behavior). No wasted words. The structure is front-loaded and easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given low complexity (2 params, no nested objects), the description is fairly complete. However, it lacks any info about the output schema (which exists), such as what the tool returns (confirmation, updated log, error). It also omits behavioral details like idempotency or whether the same day can be updated multiple times. An output schema exists, so return value details are partially excused, but the description could still mention what a successful response looks like.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate fully. It explains 'milliliters' with a helpful real-world equivalence ('250 is a glass') and clarifies 'day' defaults to today. These add substantial meaning beyond the raw schema fields (which only provide types and a default string). Both parameters are well-explained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Add drunk water'), the resource ('hydration log'), and the platform ('Garmin Connect'). It is specific and distinct from siblings, which mostly deal with reading or logging other types of data (e.g., log_weight, get_daily_summary, create_workout).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear use context (logging water to Garmin) but provides no explicit when-to-use or when-not-to-use guidance, nor does it compare with alternative tools (e.g., log_weight for weight or other logging tools). Some guidance can be inferred from sibling names but is not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are not provided, so the description carries the full burden. It correctly indicates this is a read operation (retrieves data) and specifies the return structure (per distance unit splits with pace and heart rate changes). However, it doesn't disclose whether splits are calculated automatically, what happens if the activity lacks GPS data, or if there are rate limits. A score of 3 reflects basic transparency without deeper behavioral insight.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with one introductory sentence and a single parameter definition. Every sentence is necessary and adds value. No filler or redundancy. There is no structural issue.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (single parameter, clear output schema implied by the description, no nested objects), the description is nearly complete. It covers the tool's purpose, parameter semantics, and basic output. The only minor gap is not specifying what happens if the activity_id does not exist or if splits are unavailable, but with an output schema present, return values need not be fully explained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does 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 provides a clear, human-readable definition for the single parameter 'activity_id' as 'The numeric id of the activity.' This adds meaning beyond the schema, which only states type and title. With only one parameter, this is sufficient, earning a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states it returns 'per-kilometre or per-mile splits for one activity, showing how pace and heart rate changed through the effort,' clearly specifying the verb (get), resource (splits), and scope (one activity, per distance unit). This distinguishes it from siblings like get_activity_details, which would provide overall activity summary, and get_heart_rate, which is broader.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide explicit guidance on when to use this tool versus alternatives like get_activity_details or list_activities. Usage is implied by the semantics of the tool name and description (i.e., to examine splits), but no exclusions or prerequisites are given. A score of 3 is appropriate as it is minimally adequate but lacks clear context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description states the tool returns step counts with total and average, implying a read operation. However, with no annotations provided, it omits details such as whether data sync is required, if values are automatically gathered, or any rate limits. It covers the basic behavior but not the full operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief and front-loaded: two sentences for purpose and summary, then a clear args section. Every sentence adds value, and there is no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 optional parameter) and presence of an output schema, the description covers the essential input semantics. It could add a note about data source or units, but overall it is sufficiently complete for safe use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5Does 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 providing explicit examples for 'period' like 'last 7 days' or date ranges, adding significant meaning beyond the schema's bare type and default. This enables an agent to construct valid calls.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns 'daily step counts over a period, with the total and daily average.' The verb 'get' and resource 'steps' are unambiguous, and the purpose distinguishes it from siblings like 'get_daily_summary' or 'get_activity_splits' which cover different metrics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides examples for the 'period' argument but does not explicitly advise when to use this tool over others (e.g., when needing raw steps vs. a summary). It is adequate for a simple tool but lacks guidance on prerequisites or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden for behavioral disclosure. It describes the expected behavior of constructing a workout with warm-up, intervals, and cool-down, and notes the effect of setting interval/repeats to zero. However, it does not disclose side effects (e.g., data saved to user's account), required permissions, rate limits, or error handling, which are important for a creation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured: a concise opening sentence, a bullet list of the workout structure, a note about steady sessions, and a clear Args list. Every sentence serves a purpose, and the information is front-loaded with the most important details first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, 1 required) and the presence of an output schema, the description covers input semantics thoroughly. It does not explain the return value, but the output schema likely handles that. Missing is guidance on error states (e.g., invalid sport value) or validation, but overall it is sufficiently complete for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description includes a detailed Args section that explains the meaning, example values, and defaults for each parameter (e.g., 'name: What to call the workout, for example "Tuesday intervals"'). This adds significant value beyond the schema's bare titles and types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates a 'time-based workout plan' in Garmin Connect, specifying the structure (warm-up, optional interval+recovery, cool-down). This distinguishes it from sibling tools like list_workouts, get_workout, and schedule_workout, which are for reading or scheduling existing workouts, not creating new ones.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit guidance on when to use certain parameter values, e.g., 'Set interval_minutes and repeats to 0 for a steady session.' It also explains the optional nature of intervals. However, it does not explicitly state when not to use this tool versus alternatives, or mention prerequisites like existing user authentication.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes the tool as a summary aggregation, which is a read-only operation. However, it does not disclose potential edge cases (e.g., missing data for a day) or any authentication requirements. For a simple read tool, this is adequate but not exceptionally transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: three sentences plus a parameter list. It is front-loaded with the most important information (purpose and metrics), and every sentence is necessary. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter with default, no required params, no nested objects) and the presence of an output schema, the description is complete. It covers what the tool does, when to use it, and how to invoke it. The agent can confidently select and use this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, but the tool description includes an 'Args' section that explains the 'day' parameter with examples ('today', 'yesterday', '3 days ago', '2026-08-18'). This adds significant meaning beyond the schema's type and default, compensating for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns an 'overall summary of one day' and lists the specific metrics included (steps, calories, heart rate, etc.). This specific verb+resource combination distinguishes it from sibling tools like get_steps, get_sleep, which return individual metrics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance: 'Start here when the user asks "how was my day" or "how am I doing today".' This tells the agent exactly when to use this tool. While it doesn't explicitly state when not to use, the sibling list implies alternatives for specific metrics or date ranges.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description implies a read-only operation by listing what data is returned, which is consistent with the tool name. However, since no annotations are provided, the description could better disclose any behavioral traits like idempotency, rate limits, or that the activity must belong to the authenticated user. The current description is adequate but leaves some transparency gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with three sentences and a docstring-style parameter listing. It is front-loaded with the most critical information (what the tool does) and then provides usage guidance. No unnecessary words or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the low complexity (single integer parameter), no nested objects, and an existing output schema, the description is complete. It explains the purpose, lists key return fields, states how to obtain the required ID, and documents the parameter. There is no missing information needed for the agent to successfully invoke this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5Does 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 explicitly documents the sole parameter activity_id with a clear description ('The numeric id of the activity'), adding meaning beyond the schema. The description of what data the tool returns also helps the agent understand the parameter's role.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves full details for one activity and lists specific metrics (distance, time, pace, etc.). It uses a specific verb ('get') and resource ('activity details'), and distinguishes itself from siblings like list_activities, get_last_activity, and get_activity_splits.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs the agent to first get the activity ID from list_activities or get_last_activity, providing a clear usage prerequisite. It also lists the required parameter activity_id, guiding the agent on what to provide.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It clarifies the scope ('for one night'), the time interpretation ('last night' and 'today' both mean the most recent night), and lists the fields returned. A minor gap: it does not state whether the tool is read-only (implied by 'get') or if it modifies data, but the description is otherwise transparent. No contradiction since there are no annotations to contradict.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at two sentences plus a bulleted Arg section. The main sentence front-loads the purpose. The Arg section is clear. However, the bullet list under 'Args' could be tightened—'day:' followed by a newline and explanatory text feels slightly less structured than ideal, but overall it's efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 1 optional parameter, high output schema (covers return fields), and no required parameters, the description is quite complete. It explains the parameter, the tool's scope, and what data is returned. It might benefit from stating that it returns the most recent available sleep data if 'day' is omitted, but the default 'last night' hints at this. No significant gaps remain for the agent's selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must fully explain the parameter. It does: 'day' is described as 'The night's date', with example values including 'last night', 'today' (both meaning most recent night), 'yesterday', and a specific date format '2026-08-18'. This adds rich meaning beyond the schema's minimal type and default.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('get') and resource ('sleep for one night'), and clearly lists the exact breakdown of data returned (total time, deep/light/REM/awake breakdown, sleep score, resting heart rate, breathing). It also implicitly distinguishes from sibling tools like get_daily_summary and get_hrv by focusing on sleep-specific metrics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear guidance on when to use this tool (for retrieving sleep data for a specific night) and includes helpful details on date input formats ('last night', 'today', 'yesterday', '2026-08-18'). However, it does not explicitly tell when not to use it or mention alternatives among siblings for broader summaries or other metrics.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
- Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It describes the tool as listing activities, which is a read operation, and does not mention destructive actions or side effects. It adds context on the default limit and optional sport filter, but it does not disclose response pagination or latency implications. However, given the output schema exists, the return format is inferred.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured, with a clear introductory sentence followed by parameter documentation in a bullet-point style (Args section). Every sentence serves a purpose: the first defines the tool, the second guides usage, and the Args section provides parameter details without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 3 parameters (all optional), an output schema, and no nested objects, the description is complete enough. It covers all parameters, usage context, and a clear purpose. The output schema likely documents return fields, so this need not be in the description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant meaning beyond the input schema, which has 0% schema description coverage and only provides types and defaults. It explains the period parameter with examples like 'last 30 days' and a date range format, details the sport parameter with a list of valid values, and clarifies the limit parameter's default and purpose. This fully compensates for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists recorded activities with specific examples (runs, rides, swims, walks) and a period filter. It distinguishes itself from sibling tools by explicitly noting 'Use this to find an activity before asking for its details,' which sets it apart from tools like get_activity_details or get_last_activity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: 'Use this to find an activity before asking for its details.' This implies it is a precursor to other activity-related tools, and it effectively excludes usage for getting detailed data, sleep, heart rate, etc., which are covered by sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
GitHub Badge
Glama performs regular codebase and documentation scans to:
- Confirm that the MCP server is working as expected.
- Confirm that there are no obvious security issues.
- Evaluate tool definition quality.
Our badge communicates server capabilities, safety, and installation instructions.
Card Badge
Copy to your README.md:
Score Badge
Copy to your README.md:
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/jharkebusch/garmin-connect-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server