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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions checking and showing status, which implies a read-only operation, but does not disclose any behavioral traits such as authentication requirements, rate limits, error conditions, or what the status output includes (e.g., connected/disconnected, last sync time). For a tool with zero annotation coverage, this is a significant 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?

The description is two concise sentences that are front-loaded with the tool's purpose followed by usage guidance. Every sentence earns its place by providing essential information without any waste or redundancy.

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

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

Given the tool's simplicity (0 parameters, no annotations, no output schema), the description is adequate but has clear gaps. It explains what the tool does and when to use it, but lacks details on behavioral aspects (e.g., what the status output looks like, any prerequisites). For a status-check tool, this is minimally viable but could be more complete.

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

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

The tool has 0 parameters, and schema description coverage is 100%. With no parameters to document, the description does not need to add parameter semantics. The baseline for 0 parameters is 4, as there is nothing to compensate for, and the description appropriately focuses on the tool's purpose and usage.

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

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

The description clearly states the tool's purpose: 'Check if Strava is connected and show the current connection status.' It specifies the verb ('check') and resource ('Strava connection'), but does not explicitly differentiate from its siblings (e.g., connect-strava, disconnect-strava) beyond implying it's a read-only status check.

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

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

The description provides clear context for when to use it: 'Use this when the user asks about their connection status.' This gives explicit guidance on the triggering condition. However, it does not mention when not to use it or name specific alternatives (e.g., connect-strava for establishing a connection).

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 burden and does well by disclosing key behavioral traits: it opens a browser window for secure authentication and enables activity tracking. However, it doesn't mention potential side effects like overwriting existing connections or error handling, leaving some gaps.

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, followed by behavioral details and usage guidelines in two efficient sentences. Every sentence earns its place without redundancy or fluff.

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 tool's complexity (authentication with a browser interaction) and no annotations or output schema, the description is mostly complete but could improve by mentioning what happens after authentication (e.g., confirmation, error cases). It covers the essential purpose and behavior adequately.

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

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

The schema description coverage is 100%, so the baseline is 3. The description adds value by implying the authentication process but doesn't directly explain the 'force' parameter's semantics beyond what the schema provides. It compensates slightly by setting context, but not enough for a 5.

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

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

The description clearly states the specific action ('Connect your Strava account') and the resource ('Strava account'), distinguishing it from siblings like 'check-strava-connection' or 'disconnect-strava' by focusing on initial authentication rather than status checking or disconnection.

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

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

It explicitly states when to use this tool ('when the user asks to connect, link, or authenticate their Strava account') and provides an alternative context by mentioning the browser window for authentication, though it doesn't name specific sibling alternatives, the guidance is clear and actionable.

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

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

With no annotations provided, the description carries the full burden and effectively discloses key behavioral traits: it's a destructive operation ('remove stored credentials') and implies authentication needs ('your Strava account'). However, it doesn't mention potential side effects like data loss or rate 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?

The description is front-loaded with the core purpose in the first sentence and adds usage context in the second, with no wasted words. Every sentence earns its place by providing essential information.

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

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

For a destructive tool with no annotations and no output schema, the description is reasonably complete—it explains the action and usage context. However, it could be more thorough by detailing potential consequences (e.g., data deletion) or confirmation steps, given the tool's complexity.

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

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

The tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description adds no parameter information, which is appropriate given the lack of parameters, maintaining the baseline score.

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

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

The description clearly states the specific action ('Disconnect your Strava account and remove stored credentials') and distinguishes it from siblings like 'connect-strava' and 'check-strava-connection' by focusing on removal rather than connection or verification.

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

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

It explicitly states when to use this tool ('when the user wants to logout, disconnect, or remove their Strava connection'), providing clear context and distinguishing it from alternatives like 'connect-strava' for establishing connections.

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 full burden but adds minimal behavioral context. It mentions 'popular segments' but doesn't define popularity metrics, disclose rate limits, authentication needs, or response format. For a search tool with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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 zero waste. It's front-loaded with the core purpose and avoids redundancy. Every word earns its place, making it easy for an agent to parse quickly.

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 4 parameters, 100% schema coverage, no output schema, and no annotations, the description is minimally adequate. It states what the tool does but lacks context on authentication, rate limits, return values, or sibling differentiation. For a search tool with filtering parameters, more guidance would improve completeness.

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 fully documents all parameters. The description adds no parameter-specific semantics beyond implying geographical filtering via 'geographical area.' It doesn't explain parameter interactions (e.g., minCat/maxCat requiring riding activityType) or provide examples, so it meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Searches for popular segments within a given geographical area.' It specifies the verb ('searches'), resource ('segments'), and scope ('geographical area'). However, it doesn't differentiate from sibling tools like 'list-starred-segments' or 'get-segment', which also retrieve segments but with different criteria.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., requiring Strava connection), exclusions, or compare it to siblings like 'list-starred-segments' (user-specific) or 'get-segment' (single segment by ID). The agent must infer usage from the name and parameters alone.

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 provided, so the description carries the full burden. It discloses that the tool saves files locally, which is a key behavioral trait. However, it lacks details on permissions, error handling, or file naming conventions, which are important for a file-export 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, well-structured sentence that efficiently conveys the tool's purpose and key behavior (saving to local directory). Every word earns its place, with no redundant or vague phrasing.

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 tool's moderate complexity (exporting a file), no annotations, and no output schema, the description is mostly complete but could improve by mentioning output details like file path or success indicators. It covers the core action and destination adequately for basic use.

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 the 'routeId' parameter. The description does not add any additional meaning or context beyond what the schema provides, such as format examples or source of the ID, resulting in a baseline score of 3.

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

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

The description clearly states the specific action ('Exports'), resource ('a specific Strava route'), and output format ('GPX format'), distinguishing it from sibling tools like 'export-route-tcx' which exports in TCX format. It provides complete information about what the tool does.

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

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

The description implies usage context by specifying 'saves it to a pre-configured local directory,' which suggests when to use this tool (for local GPX export). However, it does not explicitly state when not to use it or name alternatives like 'export-route-tcx' for different formats, leaving some guidance implicit.

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

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

With no annotations provided, the description carries full burden. It discloses key behavioral traits: it's a write operation (saves to local directory), requires a pre-configured destination, and outputs a file. However, it doesn't mention error conditions, file naming conventions, or what happens if the directory doesn't exist.

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 that contains all essential information: action, resource, format, and destination. Every word earns its place with zero 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 single-parameter tool with no output schema and no annotations, the description is reasonably complete. It explains what the tool does and where the output goes. However, it could benefit from mentioning error handling or file system implications.

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 the single 'routeId' parameter. The description doesn't add any additional parameter semantics beyond what the schema provides, maintaining the baseline score.

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

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

The description clearly states the specific action ('Exports'), resource ('a specific Strava route'), format ('in TCX format'), and destination ('saves it to a pre-configured local directory'). It distinguishes from sibling 'export-route-gpx' by specifying TCX format.

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

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

The description provides clear context for when to use this tool (exporting a route in TCX format to local storage). It doesn't explicitly mention when not to use it or name alternatives, but the TCX format specification naturally differentiates it from GPX export.

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 full burden for behavioral disclosure. It states this is a fetch operation but doesn't mention whether it requires authentication, has rate limits, returns structured data, or handles errors. For a read operation with zero annotation coverage, this leaves critical behavioral traits unspecified.

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

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

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a simple fetch operation and front-loads the essential information without unnecessary elaboration.

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

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

For a single-parameter read tool with no output schema, the description adequately covers the basic purpose but lacks context about authentication requirements, return format, or error handling. Given the sibling tools suggest this is part of a Strava API integration, more context about what 'detailed information' includes would be helpful for the agent.

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

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

Schema description coverage is 100%, so the schema already fully documents the single 'activityId' parameter. The description adds no additional parameter semantics beyond what's in the schema (e.g., format examples, constraints beyond exclusiveMinimum). This meets the baseline for high schema coverage but doesn't provide extra value.

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

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

The description clearly states the action ('fetches detailed information') and resource ('specific activity using its ID'), making the purpose immediately understandable. However, it doesn't distinguish this tool from similar siblings like 'get-activity-laps' or 'get-activity-streams' which also fetch activity-related data, missing an opportunity 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 provides no guidance on when to use this tool versus alternatives. With siblings like 'get-all-activities' (for listing) and 'get-activity-streams' (for specific data types), there's no indication of when detailed activity information is needed versus other activity-related queries, leaving the agent to guess based on context alone.

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 burden and does so well. It discloses important behavioral traits: authentication requirements ('Requires activity:read scope...'), data completeness ('Returns complete data... without omissions'), and precision handling ('All numeric values are preserved...'). It does not mention rate limits or error conditions, but covers key operational aspects.

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 well-structured with clear sections (Use Cases, Parameters, Output Format, Notes) and front-loaded purpose. It is appropriately sized for the tool's complexity, but could be slightly more concise by integrating some details (e.g., merging 'Output Format' bullet points). Every sentence adds value, with no redundant 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?

Given the tool's moderate complexity (1 parameter, no output schema, no annotations), the description is largely complete. It covers purpose, usage, parameters, output details, and behavioral notes. However, it lacks explicit error handling information or examples of the output format, which would enhance completeness for an agent.

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

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

The schema description coverage is 100%, with the single parameter 'id' documented as 'The identifier of the activity to fetch laps for.' The description adds minimal value beyond this, only restating it as 'The unique identifier of the Strava activity.' No additional syntax, format, or validation details are provided, so the baseline score 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 clearly states the tool's purpose with a specific verb ('Retrieves') and resource ('detailed lap data for a specific Strava activity'). It distinguishes itself from siblings like 'get-activity-details' or 'get-activity-streams' by focusing exclusively on lap data, not general activity information or raw sensor streams.

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

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

The description provides clear context for when to use this tool through the 'Use Cases' section, which outlines scenarios like detailed analysis, visualization, and metric comparison. However, it does not explicitly state when NOT to use it or name specific alternatives among the sibling tools (e.g., 'get-activity-details' for general info).

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 burden and excels by disclosing key behavioral traits: it specifies required OAuth scopes ('activity:read' vs 'activity:read_all'), notes data sources (Strava or Instagram), describes edge cases ('Returns empty array if activity has no photos'), and mentions output format details. This goes well beyond basic functionality.

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 well-structured with clear sections (Use Cases, Parameters, Output Format, Notes), front-loaded with the core purpose, and every sentence adds value without redundancy. It efficiently conveys necessary information in a readable format.

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 complexity of handling photos with authentication and data sources, no annotations, and no output schema, the description is highly complete. It covers purpose, usage, parameters, output details, authentication requirements, data sources, and edge cases, providing all needed context for effective tool use.

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 adequately. The description adds minimal value beyond the schema by clarifying the 'size' parameter's effect ('returns all available sizes' if unspecified) and providing example values, but does not significantly enhance understanding of parameter semantics.

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

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

The description clearly states the tool's purpose with a specific verb ('Retrieves') and resource ('photos associated with a specific Strava activity'), distinguishing it from sibling tools like 'get-activity-details' or 'get-activity-streams' that handle different aspects of activities. It precisely defines what is being fetched without ambiguity.

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

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

The description provides clear context for when to use this tool through 'Use Cases' (e.g., fetching photos, getting URLs, accessing metadata), but does not explicitly state when not to use it or name alternatives among siblings. It implies usage for photo-related needs without direct comparison to other 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?

With no annotations provided, the description carries full burden and excels at disclosing behavioral traits. It covers authentication requirements ('Requires activity:read scope'), data limitations ('Not all streams are available for all activities'), performance characteristics ('Large activities are automatically chunked to ~50KB per message'), and intelligent features like downsampling and pagination optimized for LLM context 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?

The description is well-structured with clear sections (Key Features, Format Options, Common Use Cases, Output Format, Notes) and front-loaded with the core purpose. While comprehensive, some sections could be more concise - the 'Key Features' list contains 6 items where 3-4 might suffice, and the description is longer than typical for a retrieval tool.

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

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

For a complex tool with 9 parameters, no annotations, and no output schema, the description provides excellent completeness. It covers authentication, data availability, performance considerations, pagination behavior, format options, common use cases, and output structure. The 'Notes' section addresses important edge cases and limitations that an agent needs to know.

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

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

Schema description coverage is 100%, so the schema already documents all 9 parameters thoroughly. The description adds some context about parameter interactions (e.g., 'Use max_points parameter to downsample very large activities intelligently') and format implications, but doesn't provide significant additional semantic meaning beyond what's in the schema. Baseline 3 is appropriate when schema does heavy lifting.

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

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

The description clearly states the tool's purpose with specific verbs ('retrieves detailed time-series data streams') and resources ('from a Strava activity'), distinguishing it from siblings like get-activity-details or get-activity-laps. It explicitly focuses on data streams rather than summary information or other activity aspects.

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

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

The description provides clear context for when to use this tool through 'Common Use Cases' (e.g., analyzing workout intensity, calculating power metrics) and 'Notes' section (e.g., requires activity:read scope, not all streams available for all activities). However, it doesn't explicitly state when NOT to use it or name specific alternative tools for different needs.

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 burden of behavioral disclosure. It mentions pagination and optional filtering, but doesn't cover critical aspects like authentication requirements, rate limits, error handling, or what 'complete activity history' entails (e.g., all-time vs. limited period). The description is insufficient for a tool with 7 parameters and no safety annotations.

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

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

The description is efficiently structured in two sentences that cover the core functionality and key features (filtering, pagination). There's no wasted verbiage, though it could be slightly more front-loaded with the primary purpose.

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

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

For a tool with 7 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what 'complete activity history' means, how pagination works in practice, what the response format looks like, or any error conditions. The agent would struggle to use this tool effectively without trial and error.

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 parameters are well-documented in the schema itself. The description adds minimal value beyond the schema by mentioning date range and activity type filtering, but doesn't provide additional context about parameter interactions or usage patterns. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose as fetching complete activity history with optional filtering, which is specific (verb+resource). However, it doesn't explicitly differentiate from sibling tools like 'get-recent-activities' or 'get-activity-details', leaving some ambiguity about when to choose this over alternatives.

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

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

The description mentions optional filtering and pagination but provides no guidance on when to use this tool versus alternatives like 'get-recent-activities' or 'get-activity-details'. There's no mention of prerequisites, use cases, or exclusions, leaving the agent 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.

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

With no annotations provided, the description carries the full burden. It discloses that it fetches profile information and the ID, which is useful context, but lacks details on behavioral traits such as authentication requirements, rate limits, error handling, or response format. It adequately describes the core function but misses deeper behavioral insights.

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 that front-loads the main purpose and includes essential context about the ID's utility. Every word earns its place with no waste, making it highly concise and well-structured for quick understanding.

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

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

Given the tool's complexity (simple fetch with no parameters) and lack of annotations and output schema, the description is minimally complete. It covers the purpose and a key output detail (the ID), but for a tool with no structured output documentation, it should ideally explain return values or error cases more fully to be fully helpful.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the inputs. The description adds value by explaining the purpose (fetching profile info and ID) beyond the empty schema, but since there are no parameters to elaborate on, it naturally compensates well, earning a high baseline score.

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

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

The description clearly states the specific action ('fetches') and resource ('profile information for the authenticated athlete'), distinguishing it from siblings like get-athlete-stats or get-athlete-zones by focusing on profile data. It explicitly mentions the inclusion of the unique numeric ID, which is a key differentiator.

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

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

The description provides clear context by specifying it fetches data 'for the authenticated athlete' and notes the ID is 'needed for other tools like get-athlete-stats,' implying usage as a prerequisite for those tools. However, it does not explicitly state when not to use it or name direct alternatives, keeping it from a perfect score.

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 full burden but lacks behavioral details. It doesn't disclose whether this is a read-only operation, if it requires specific permissions, rate limits, or how data is returned (e.g., pagination, format). The mention of 'authenticated athlete' hints at auth needs but is vague.

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, well-structured sentence that front-loads the core action and includes key details (resource, source, data included) without any wasted words, making it highly efficient and easy to parse.

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

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

For a tool with 0 parameters and no output schema, the description is adequate but incomplete. It specifies what data is fetched but not the return format or behavioral traits. Given the lack of annotations, more context on auth requirements or data structure would improve completeness.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately adds no parameter details, maintaining focus on tool purpose without redundancy, earning a baseline score above 3 for efficiency.

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

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

The description clearly states the specific action ('fetches'), resource ('authenticated athlete's shoes from Strava'), and scope ('including usage distance and primary flag'), distinguishing it from sibling tools like get-athlete-profile or get-athlete-stats that focus on different athlete 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?

The description provides no guidance on when to use this tool versus alternatives, such as whether it's for viewing shoe inventory versus activity-specific gear, or prerequisites like needing Strava authentication. It mentions 'authenticated athlete' but doesn't clarify if this requires prior connection steps.

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 provided, so the description carries the full burden. It discloses the prerequisite (ID from another tool) but lacks details on rate limits, authentication needs, error handling, or what the statistics output includes (e.g., format, units). This is a moderate gap for a tool with no annotation coverage.

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

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

Two sentences, front-loaded with the core purpose, no redundant information. Every sentence earns its place by specifying the tool's function and prerequisite.

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 no annotations and no output schema, the description is incomplete. It covers the purpose and prerequisite well but lacks behavioral details (e.g., response format, error cases) and output information, which is needed for a tool with no structured output documentation.

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 the athleteId parameter. The description adds minimal value by reiterating the need to obtain the ID from get-athlete-profile, but doesn't provide additional syntax or format details beyond the schema.

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

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

The description clearly states the verb ('fetches') and resource ('activity statistics for a specific athlete'), specifying the scope ('recent, YTD, all-time') and distinguishing it from sibling tools like get-athlete-profile (which provides profile data, not stats).

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

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

It explicitly states when to use this tool ('for a specific athlete using their ID') and provides a prerequisite ('Requires the athleteId obtained from the get-athlete-profile tool'), naming the alternative tool for obtaining the ID.

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 provided, so the description carries the full burden of behavioral disclosure. It mentions the output includes a formatted summary and raw JSON, which adds some value, but fails to cover critical aspects like authentication requirements (implied by 'authenticated athlete' but not explicit), rate limits, error handling, or whether it's a read-only operation. For a tool with zero annotation coverage, this is a significant 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?

The description is two sentences with zero waste: the first states the purpose clearly, and the second adds crucial output details. It's front-loaded with the core function and efficiently conveys necessary information without fluff or repetition.

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 tool has no parameters, no annotations, and no output schema, the description provides basic purpose and output format, which is adequate for a simple retrieval tool. However, it lacks details on authentication, error cases, or behavioral traits that would make it more complete. It meets the minimum viable threshold but has clear gaps in context.

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

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

The input schema has 0 parameters with 100% coverage, meaning no parameters are documented in the schema. The description doesn't need to compensate for missing param info, as there are none to explain. It appropriately focuses on output details instead. A baseline of 4 is given since it adds context about output without redundant parameter explanations.

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

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

The description clearly states the verb ('Retrieves') and resource ('authenticated athlete's configured heart rate and power zones'), making the purpose specific and understandable. It distinguishes itself from siblings like get-athlete-profile or get-athlete-stats by focusing on zones data. However, it doesn't explicitly contrast with all potential siblings, keeping it from a perfect 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing authentication via connect-strava), exclusions, or comparisons to other tools like get-athlete-stats that might overlap. This leaves the agent with minimal context for decision-making.

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 full burden for behavioral disclosure. It states it 'fetches' data (implying read-only) but doesn't mention authentication requirements, rate limits, pagination behavior, or what 'most recent' means (e.g., time window, ordering). This leaves significant gaps for an agent to understand operational constraints.

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 that immediately conveys the core purpose without unnecessary words. It's appropriately sized for a simple retrieval tool and front-loads the essential 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?

Given the lack of annotations and output schema, the description should provide more context about what 'most recent activities' means, how results are structured, and how this differs from sibling activity tools. The current description is insufficient for an agent to fully understand the tool's behavior and appropriate usage context.

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

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

Schema description coverage is 100%, so the input schema fully documents the single parameter 'perPage'. The description adds no additional parameter semantics beyond what's already in the schema (which defines type, constraints, and default). This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('fetches') and resource ('most recent activities for the authenticated athlete'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get-all-activities' or 'get-activity-details', which would require more specific scope clarification.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get-all-activities' or 'get-activity-details'. It mentions 'most recent activities' but doesn't specify if this is paginated, limited by date, or how it differs from other activity retrieval tools in the sibling list.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a fetch operation (implying read-only), but doesn't mention authentication requirements, rate limits, error conditions, or what 'detailed information' includes. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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 that gets straight to the point with zero wasted words. It's appropriately sized for a simple fetch operation and front-loads the essential 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 fetch tool with no output schema, the description is minimally adequate but could be more complete. It doesn't explain what 'detailed information' includes or provide context about the response format. Given the lack of annotations and output schema, more behavioral and response context would be helpful.

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

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

The schema has 100% description coverage, with the single parameter 'routeId' well-documented in the schema itself. The description adds no additional parameter semantics beyond what's already in the structured schema, so the baseline score 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 clearly states the action ('fetches detailed information') and resource ('a specific route using its ID'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from similar siblings like 'get-segment' or 'get-activity-details' beyond mentioning 'route' specifically.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (like needing a route ID from 'list-athlete-routes'), nor does it clarify when this tool is appropriate compared to other get-* tools for different resource types.

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 burden of behavioral disclosure. It states this is a fetch operation, implying it's likely read-only, but doesn't confirm safety aspects like whether it requires authentication, has rate limits, or what happens if the ID is invalid. This leaves significant gaps for a tool that interacts with external data.

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

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

The description is a single, efficient sentence that directly states the tool's function without any fluff. It's front-loaded with the core action and resource, making it easy to parse quickly.

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 lack of annotations and output schema, the description is incomplete. It doesn't explain what 'detailed information' includes (e.g., fields returned), error conditions, or authentication needs. For a tool fetching data from an external service like Strava, this leaves the agent under-informed about behavioral expectations.

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

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

The input schema has 100% description coverage, with the 'segmentId' parameter well-documented in the schema itself. The description adds no additional meaning beyond implying the ID is used to fetch details, which is already clear from the schema. This meets the baseline for high schema coverage.

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

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

The description clearly states the verb ('fetches') and resource ('detailed information about a specific segment'), making the purpose understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'get-segment-leaderboard' or 'get-segment-effort', which also fetch segment-related data, so it doesn't reach the highest score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'explore-segments' or 'list-starred-segments'. It mentions using a segment ID but doesn't specify prerequisites (e.g., needing an ID from another operation) or exclusions, leaving the agent with minimal context for 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 are provided, so the description carries the full burden of behavioral disclosure. It states 'fetches' (implying a read operation) but doesn't cover critical aspects like authentication requirements, rate limits, error conditions (e.g., invalid ID), or response format. For a tool with no annotation coverage, this leaves significant gaps in understanding how it behaves.

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 that front-loads the core action ('fetches detailed information') and resource ('specific segment effort'). There is no wasted verbiage, repetition, or unnecessary elaboration, making it easy to parse quickly.

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 lack of annotations and output schema, the description is incomplete for effective tool use. It doesn't explain what 'detailed information' includes (e.g., effort time, power data), authentication needs, or error handling. For a tool that likely returns structured data (implied by 'detailed information'), more context is needed to guide an agent in interpreting results.

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

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

The schema description coverage is 100%, with the single parameter 'effortId' fully documented in the schema as 'The unique identifier of the segment effort to fetch.' The description adds no additional semantic context beyond implying the ID is used to fetch details. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't detract either.

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

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

The description clearly states the verb 'fetches' and the resource 'detailed information about a specific segment effort using its ID', making the purpose unambiguous. It distinguishes from siblings like 'get-segment' (which fetches segment metadata) and 'list-segment-efforts' (which lists multiple efforts) by specifying retrieval of a single effort by ID. However, it doesn't explicitly mention what 'detailed information' includes, leaving some ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid effort ID from another operation), contrast with 'list-segment-efforts' for multiple efforts, or specify use cases like analyzing performance on a segment. Without such context, an agent might struggle to select this tool appropriately.

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 provided, so the description carries the full burden. It mentions filtering capabilities and pagination ('per_page', 'page'), which are useful behavioral details. However, it lacks information on authentication requirements, rate limits, error conditions, or whether this is a read-only operation (though 'retrieves' implies it). The description doesn't contradict any annotations since none exist.

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 a clear purpose statement, followed by a bulleted list of use cases. Every sentence earns its place by adding value—the first sentence defines the tool, and the bullets provide practical guidance without redundancy. It's appropriately sized for a tool with multiple parameters and use cases.

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 complexity (9 parameters, no output schema, no annotations), the description is fairly complete. It covers the tool's purpose, filtering options, and use cases. However, it lacks details on the output structure (e.g., what fields are returned in leaderboard entries) and behavioral aspects like authentication, which would be helpful for an agent. Without an output schema, the description could do more to explain return values.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds marginal value by summarizing the filtering options ('gender, age group, weight class, club, date range, and followed athletes') and implying the leaderboard structure, but it doesn't provide additional syntax or format details beyond what the schema specifies. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the specific action ('retrieves the leaderboard'), resource ('for a specific Strava segment'), and scope ('shows top performances with times, power, and heart rate data'). It distinguishes this tool from siblings like 'get-segment' (which likely returns segment metadata) and 'list-segment-efforts' (which might list efforts without leaderboard ranking).

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

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

The 'Use this to:' section provides clear context for when to use this tool (e.g., 'See top performances on a segment', 'Compare your efforts against others'), but it does not explicitly state when NOT to use it or name specific alternatives. For example, it doesn't contrast with 'list-segment-efforts' for unfiltered efforts or 'get-segment' for basic segment info.

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 provided, so the description carries the full burden. It states the tool returns version and metadata but doesn't disclose behavioral traits like whether it requires authentication, has rate limits, returns structured JSON, or what 'related metadata' includes. This leaves significant gaps for a tool with zero annotation coverage.

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 zero waste—it directly states the tool's function without unnecessary words or fluff, making it easy to parse and front-loaded.

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

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

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but incomplete. It lacks details on authentication needs, return format, or metadata specifics, which could hinder an agent's ability to use it effectively in complex scenarios.

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

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

The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description appropriately focuses on the tool's purpose without redundant parameter details, meeting the baseline for zero-parameter tools.

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

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

The description clearly states the specific action ('Returns') and resource ('Strava MCP server version and related metadata'), distinguishing it from all sibling tools which focus on athlete data, activities, segments, or connections rather than server metadata.

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

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

The description implies usage for retrieving server metadata, but provides no explicit guidance on when to use this tool versus alternatives (e.g., for diagnostics, compatibility checks, or monitoring). 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 provided, the description carries the full burden of behavioral disclosure. It mentions 'authenticated athlete', implying an authentication requirement, but does not specify permissions, rate limits, or response format. This leaves gaps in understanding the tool's 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 a single, clear sentence with no wasted words. It is front-loaded with the core action and resource, making it efficient and easy to parse.

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

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

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but minimal. It covers the basic purpose but lacks details on authentication, output format, or usage context, which could be helpful for an agent.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately adds no parameter details, aligning with the schema. A baseline of 4 is applied since it avoids redundancy.

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

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

The description clearly states the verb ('Lists') and resource ('clubs the authenticated athlete is a member of'), making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'list-athlete-routes' or 'list-starred-segments', which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as other list tools or related athlete data tools. It lacks context about prerequisites or typical scenarios for retrieving club memberships.

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 burden of behavioral disclosure. It usefully mentions pagination behavior, which isn't obvious from the schema alone. However, it doesn't describe other important traits like rate limits, authentication requirements beyond 'authenticated athlete', error conditions, or what the return format looks like (e.g., array of route objects).

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 that front-loads the core purpose ('Lists the routes') and includes essential behavioral context ('with pagination'). There's no wasted verbiage or redundant 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 read-only list tool with full schema coverage but no output schema, the description is minimally adequate. It covers the basic purpose and pagination, but lacks details on authentication requirements, rate limits, return format, or error handling that would help an agent use it correctly in complex scenarios.

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

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

The schema description coverage is 100%, with both parameters well-documented in the schema. The description adds no additional parameter semantics beyond mentioning pagination generally, which is already covered by the schema's parameter descriptions. This meets the baseline expectation when schema coverage is complete.

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

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

The description clearly states the action ('Lists') and resource ('routes created by the authenticated athlete'), making the purpose immediately understandable. It distinguishes from siblings like 'get-route' (single route) and 'explore-segments' (public segments), though it doesn't explicitly name these alternatives.

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

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

The description implies usage context by specifying 'authenticated athlete' routes, suggesting it's for personal route retrieval rather than public exploration. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'get-all-activities' or 'list-starred-segments', nor does it mention prerequisites like authentication.

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

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

No annotations are provided, so the description carries the full burden. It mentions authentication ('authenticated athlete's') and optional filtering, but lacks details on pagination behavior (implied by 'perPage' parameter), rate limits, error conditions, or response format. This is inadequate for a tool with multiple parameters and no 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.

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

The description is a single, clear sentence with zero wasted words. It front-loads the core purpose and efficiently notes the optional filtering feature, making it easy to parse and understand quickly.

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

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

For a tool with 4 parameters, no annotations, and no output schema, the description is incomplete. It lacks details on authentication requirements, pagination handling, error scenarios, and what the returned efforts data includes. This leaves significant gaps for an AI agent to use the tool effectively.

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 fully documents all parameters. The description adds minimal value by implying date filtering ('optionally filtering by date'), but does not elaborate on parameter interactions or semantics beyond what the schema provides. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the tool's purpose: 'Lists the authenticated athlete's efforts on a specific segment, optionally filtering by date.' It specifies the verb ('Lists'), resource ('efforts'), and scope ('authenticated athlete's', 'specific segment'), but does not explicitly differentiate it from sibling tools like 'get-segment-effort' (singular) or 'get-segment-leaderboard'.

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

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

The description provides minimal guidance: it mentions optional date filtering but does not explain when to use this tool versus alternatives like 'get-segment-effort' (for a single effort) or 'get-segment-leaderboard' (for rankings). No context on prerequisites, exclusions, or typical use cases is given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool lists starred segments but does not describe return format, pagination, rate limits, or authentication requirements beyond implying an authenticated athlete. This leaves significant gaps for a tool that likely involves API calls.

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 zero waste. It is front-loaded with the core purpose and appropriately sized for a tool with no parameters, making it easy to parse quickly.

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 no annotations and no output schema, the description is incomplete. It lacks details on return values, error handling, or behavioral traits like rate limits, which are crucial for an API-based tool. The description does not compensate for these gaps, making it inadequate for full contextual understanding.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds value by specifying the resource scope ('starred by the authenticated athlete'), which is not captured in the schema, justifying a score above the baseline of 3.

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

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

The description clearly states the specific action ('Lists') and resource ('segments starred by the authenticated athlete'), distinguishing it from siblings like 'explore-segments' (browse) and 'star-segment' (modify). It precisely communicates what the tool does without ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'explore-segments' or 'get-segment'. It mentions the authenticated athlete, implying a prerequisite, but does not explicitly state when-not-to-use or compare with sibling tools, leaving usage context unclear.

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 provided, so the description carries the full burden. It mentions 'authenticated athlete' (implying authentication needs) and the star/unstar action (a mutation), but doesn't disclose other behavioral traits like rate limits, error conditions, or what happens if the segment doesn't exist. For a mutation tool with zero annotation coverage, this leaves significant gaps.

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 zero waste. It front-loads the core action and resource, making it easy to parse. Every word earns its place without redundancy.

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

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

Given the tool's complexity (a mutation with authentication), lack of annotations, and no output schema, the description is minimally adequate. It covers the basic purpose and authentication context but misses details like return values, error handling, or side effects, which are important for a mutation tool.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters. The description doesn't add meaning beyond what the schema provides (e.g., no extra context about segmentId format or starred implications). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Stars or unstars'), specifies the resource ('a specific segment'), and identifies the subject ('for the authenticated athlete'). It uses specific verbs and distinguishes this tool from siblings like 'list-starred-segments' or 'get-segment' by focusing on modification rather than retrieval.

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 when an athlete wants to star or unstar a segment, but it doesn't explicitly state when to use this tool versus alternatives (e.g., no comparison to sibling tools). It mentions 'authenticated athlete' as a prerequisite, providing some context, but lacks guidance on exclusions or specific scenarios.

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