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

Discloses that null values are omitted (not cleared) and 409 error for duplicates, adding context beyond annotations which already indicate non-read-only and non-idempotent.

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, no filler; front-loaded with purpose, followed by key behavioral notes.

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

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

Covers creation semantics, duplicate handling, and null behavior; missing return value mention but acceptable given no output schema.

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

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

Schema coverage is 100%, so baseline 3; description adds value by explaining that null values are treated as omitted, which is not in 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 'Create' and the resource 'a body measurement entry for a given date', and distinguishes from update-body-measurement.

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

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

Explicitly states when not to use (409 if entry exists) and provides alternative 'use update-body-measurement instead', plus guidance on null values.

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

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

The description does not disclose behavioral traits such as whether authentication is required, whether creation is idempotent, or what happens to the response. Annotations provide no hints (readOnlyHint=false, no other hints), so the description bears the full burden but fails to add context.

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

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

The description is a single sentence that is front-loaded and contains no unnecessary words. Every part earns its place.

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

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

Given 5 parameters (4 required) and no output schema, the description is too minimal. It lacks information about what a template is, the return format, error conditions, or how this fits into the broader exercise template workflow.

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

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

With schema description coverage at 0%, the description only names parameters (title, type, equipment, muscle groups) without adding semantics beyond the schema property names. It does not explain the meaning of each parameter, constraints beyond schema, or defaults like otherMuscles.

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 creates a custom exercise template and lists the key fields (title, type, equipment, muscle groups). This verb+resource combination distinguishes it from sibling tools that create other entities like workouts or routines.

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

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

No guidance is provided on when to use this tool versus alternatives such as searching for existing templates or updating templates. There is no mention of prerequisites or when not to use it.

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

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

Annotations set readOnlyHint=false and destructiveHint=false, so description must clarify behavior. Description explains it creates a new routine and returns full details with new routine ID, which is sufficient. No contradictions; no extra safety warnings needed.

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

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

Two concise sentences, no fluff. The first sentence states purpose and requirements; the second confirms return value. Efficiently 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 complex nested schema (exercises with many sub-properties) and no output schema, the description is high-level but incomplete. It misses details about notes, supersetId, restSeconds, and set sub-properties (distance, duration, etc.). The description covers only the essentials, leaving gaps for an AI agent.

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

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

Schema description coverage is 0%, so description must compensate. It mentions required title, exercises with sets, and optional folderId. However, it does not elaborate on other parameters like notes or nested set properties (reps, weight, type, etc.), which are in the schema but undocumented in the description. Only partial value added.

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 it creates a workout routine, specifies resource type (Hevy account), and differentiates from sibling tools like create-workout and create-routine-folder. The verb 'Create' and resource 'workout routine' are explicit.

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 usage context: requires title and at least one exercise with sets, and optional folder. It implies when to use this tool (when creating a routine) but does not explicitly exclude scenarios or mention alternatives. Sibling tools are distinct, so no confusion.

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

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

Annotations indicate mutation (readOnlyHint=false) but description adds context by stating it returns full folder details including the new ID. However, no discussion of side effects, permissions, or limits beyond what annotations imply.

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

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

Two concise sentences, no unnecessary words. Front-loaded with the purpose, then key requirement, then return value.

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

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

For a simple create tool with one parameter, the description covers purpose, input requirement, and output. The lack of an output schema is compensated by mentioning return of full folder details. Minor gap: no mention of potential errors or constraints.

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 describes name as a required string with minLength 1, but description merely restates that a name is needed without adding semantic details like naming conventions or uniqueness constraints. With 0% schema description coverage, the description should compensate but does not.

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 creates a new routine folder in Hevy, with a specific verb and resource. It distinguishes from sibling tools like create-routine and create-workout by focusing on folder creation.

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

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

No guidance on when to use this tool versus alternatives, such as creating a routine directly or when folders are needed. The description only mentions the required name parameter.

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

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

Annotations already indicate write operation (readOnlyHint=false), non-destructive, non-idempotent. Description confirms creation and return of details, adding that a workout ID is assigned. However, no discussion of auth requirements, rate limits, or side effects like overwriting or conflicts.

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, each serving a clear purpose: first states action and requirements, second states return value. No extraneous text. Efficient and well-structured.

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

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

Description covers creation intent and returns but omits error conditions, prerequisites (e.g., exercise template existence), or validation constraints. Moderate complexity with 6 parameters and nested exercises array warrants more guidance for safe invocation.

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

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

With 0% schema_description_coverage, description should compensate. It mentions required fields (title, startTime, endTime, exercises) but ignores all optional parameters like isPrivate, description, and lacks details on exercising input format (though schema provides structure). Incomplete coverage of 6 parameters.

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

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

Description clearly states 'Create a new workout' with specific verb and resource. Includes requirements (title, start/end times, exercises) and return value (workout ID). Clearly distinguishes from sibling tools like get-workout, update-workout, or create-routine.

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?

Description implies usage when creating a new workout but provides no explicit guidance on when to use vs alternatives. No mention of prerequisites (e.g., need for exercise templates) or when not to use (e.g., if editing an existing workout).

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

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

Annotations already provide readOnlyHint=true, and the description adds that it returns all measurement fields for the specified date. This adds useful context beyond the annotations.

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

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

Two sentences that are front-loaded and concise. Every sentence serves a purpose with no waste.

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, one parameter, and presence of an output schema, the description covers the core behavior. No additional information is needed.

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

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

Schema coverage is 100%, with the date parameter fully described. The description confirms 'by date' but does not add significant new meaning beyond the schema.

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

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

The description states the tool gets a single body measurement by date, using a specific verb and resource. It distinguishes from the sibling 'get-body-measurements' by explicitly saying 'single'.

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

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

The description implies when to use (when you need a measurement for a specific date) but does not explicitly mention alternatives or when not to use. The context is clear enough for a simple tool.

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

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

Annotations already declare readOnlyHint=true, so the description's mention of pagination adds useful context beyond the safety profile. However, it does not disclose other behavioral details like default ordering or response 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?

Two concise sentences front-load the action and resource, with no wasted words. It effectively communicates the core functionality.

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?

While an output schema exists, the description does not cover parameter semantics, which are essential for correct tool usage. The lack of parameter information makes the tool underspecified 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 description mentions pagination qualitatively but fails to explain the two parameters ('page' and 'pageSize') or their constraints (e.g., max pageSize=10). With 0% schema description coverage, this is a critical gap.

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

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

The description clearly states the tool retrieves a paginated list of body measurements for the authenticated user, specifying included metrics (weight, body fat, circumference). This distinguishes it from siblings like 'get-body-measurement' (singular) and mutation tools like 'create-body-measurement'.

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 use for listing measurements but provides no explicit guidance on when to use this versus alternative listing tools (e.g., no comparison to search tools). No when-not-to conditions 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?

The description does not reveal behavioral details beyond what annotations provide. The readOnlyHint=true annotation already indicates a safe read operation, so the description adds no extra context about pagination, ordering, authentication, or potential 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 a single sentence of 13 words, front-loading the core purpose. Every word is necessary, with no redundancy or filler.

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

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

Given the presence of an output schema (not shown), the description need not detail return values. For a simple query tool with a required parameter and two optional filters, the description is sufficiently complete. Minor improvement would be mentioning ordering or default range.

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 67% (startDate and endDate have descriptions, exerciseTemplateId has none). The description's phrase 'specific exercise template' implies exerciseTemplateId's role, but does not detail its format or source. Overall, marginal added value over 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 'Get' and the resource 'past sets for a specific exercise template', with optional date filtering. It distinguishes from sibling tools like 'get-exercise-template' which retrieves template metadata, and 'get-workout' which retrieves workout details, not set history.

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

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

No guidance on when to use this tool versus alternatives, such as when to fetch sets from a workout versus historical data. No exclusions or prerequisites mentioned, leaving the agent to infer usage from sibling tool names.

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

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

Annotations already declare readOnlyHint=true. Description adds that it returns 'complete details' with specific fields. No contradictions. Additional behavioral context like error handling or ID format not provided, but acceptable given 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?

Single sentence, front-loaded with purpose, lists included fields concisely. No wasted words.

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

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

For a simple get-by-ID tool with output schema present, description covers purpose and returned fields. Lacks details like error behavior or ID format, but these are secondary.

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 has 0% description coverage for the single parameter exerciseTemplateId. Description does not explain its meaning beyond the name and the fact it's an ID. No format, example, or additional context.

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

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

Description states verb 'get', resource 'exercise template', scope 'by its ID', and lists specific fields returned (name, category, equipment, muscle groups, notes). Clearly distinguishes from siblings like get-exercise-templates (list) and search-exercise-templates.

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?

Implicitly clear: use when you have an ID and need full details. No explicit when-not-to-use or alternatives, but context from siblings and name makes it obvious.

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

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

The readOnlyHint annotation is already present, and the description adds context about pagination but does not elaborate on behavioral details like authorization or rate limits. Given annotations cover the safety profile, the description provides adequate but not exceptional transparency.

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

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

The description is concise with two sentences, front-loading the main action. It efficiently conveys the tool's purpose without unnecessary verbiage.

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

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

The description covers the basic purpose and result, but lacks details on pagination behavior or error handling. Since an output schema exists, return values are documented elsewhere, yet some operational context is missing.

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

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

With 0% schema description coverage, the description must compensate but only mentions 'paginated list' without explaining page and pageSize parameters. It does not add meaning beyond the schema, leaving agents to infer parameter semantics from names alone.

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 retrieves a paginated list of exercise templates, specifying types (default/custom) and example details. It distinguishes itself from sibling tools like get-exercise-template (singular) and search-exercise-templates by focusing on browsing a list.

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

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

The description indicates it's useful for browsing or searching, providing clear usage context. However, it does not explicitly mention when not to use it or compare with search-exercise-templates, lacking full guidance on alternatives.

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

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

Annotations already declare readOnlyHint=true, so the description's mention of 'Returns all details' adds some context. However, it does not disclose any additional behavioral traits such as authentication requirements or response structure beyond 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.

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

Two concise sentences with no wasted words. The purpose is front-loaded, making it easy to scan.

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

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

For a simple get-by-ID tool with one parameter and an output schema, the description is largely complete. It could mention that the output schema documents the returned details, but this is not necessary given the context.

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

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

Schema description coverage is 0%, and the description only refers to 'by its ID' without elaborating on the routineId parameter's format, example values, or source. This provides minimal value beyond the schema's type and minLength.

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 'Get' and the resource 'routine by its ID', and specifies that it returns all details. This accurately distinguishes it from sibling tools like 'get-routines' (plural) and 'get-routine-folder'.

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 a specific routine ID is known, but does not explicitly mention when not to use it or suggest alternatives like 'get-routines' for listing. The context is clear but lacks exclusions.

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

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

Annotations already declare readOnlyHint=true, indicating a safe read operation. The description adds value by specifying the returned data (name, creation date, associated routines), going beyond annotations. No behavioral contradictions.

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 immediately states the tool's purpose. It is concise with no redundant words or unnecessary details.

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 (one parameter, no nested objects) and the presence of an output schema, the description is fairly complete. It mentions key return fields, though it could elaborate on the structure of 'associated routines'.

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 one parameter (folderId) with 0% documentation. The description only says 'by its ID', adding minimal meaning. It fails to explain parameter constraints (e.g., expected format, example values) or how it relates to folder ID 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 it retrieves complete details of a specific routine folder by ID, listing included fields (name, creation date, associated routines). This distinguishes it from sibling tools like 'get-routine-folders' (which lists all folders) and 'get-routine' (which retrieves a routine).

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 you have a folder ID and need details, but it does not explicitly state when to use this tool versus alternatives, nor does it provide conditions or exclusions. No mention of prerequisites or when not to use.

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

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

Annotations already declare readOnlyHint=true, so the read-only behavior is covered. The description adds pagination context but does not disclose other traits like rate limits or response format beyond what the output schema provides.

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 consists of two concise sentences, front-loading the primary function and adding a brief usage note with no redundant or unnecessary words.

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

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

With an output schema present, the description adequately covers the tool's purpose. It mentions default and custom folders and pagination, but lacks details on parameter usage and edge cases like empty results, which 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 0%, yet the description does not explain the 'page' and 'pageSize' parameters, leaving their purpose and behavior undocumented. Common pagination parameters may be inferred, but the description should add value here.

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 ('Get a paginated list') and resource ('your routine folders'), and distinguishes from siblings like 'get-routine-folder' (singular) and 'create-routine-folder' by specifying it returns both default and custom folders.

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 organizing and browsing routines but does not explicitly state when to use this tool versus alternatives like 'get-routine-folder' or provide exclusions. No when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, indicating a safe read operation. The description adds that the list is paginated and includes custom and default routines, which is useful context. However, it does not disclose pagination details (e.g., page numbering, sorting) or authentication requirements. Given the annotations, the description adds moderate value but could say more about 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 two sentences: the first states the function, the second adds a use case. Every word is necessary; no repetition or fluff. It is appropriately sized and front-loaded with the core purpose.

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

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

Given the tool's simplicity (two optional parameters, output schema exists, annotations present), the description covers the main purpose and usage context. It mentions that custom and default routines are included. While it could mention sorting or folder context, the output schema likely provides return value details, so completeness is high but not maximal.

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 0%, but the description does not explain the parameters 'page' and 'pageSize' at all. It only mentions 'paginated list' without linking to the parameters. The description fails to compensate for the lack of schema descriptions, leaving the agent to infer parameter usage from the schema defaults and constraints alone.

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 'Get a paginated list of your workout routines, including custom and default routines.' It uses a specific verb ('Get'), resource ('routines'), and scope ('paginated list, including custom and default'). It distinguishes itself from siblings like 'get-routine' (singular) and 'get-routine-folders' by focusing on listing all routines.

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 says 'Useful for browsing or searching your available routines,' which provides a clear use case. While it does not explicitly state when not to use it (e.g., for a specific routine, use get-routine), the context is clear and the sibling tools imply alternatives. No exclusions are given, but the guidance is sufficient.

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

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

Annotations already set readOnlyHint=true. The description reinforces this by describing a read operation and adds context about returned fields and purpose. No additional behavioral traits needed; no contradictions.

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

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

Two sentences with no wasted words. The first sentence states the core action and outputs; the second provides a concrete use case. Well-structured 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 simplicity of the tool (zero parameters, output schema exists), the description covers everything needed: purpose, output fields, and use case. It is complete and leaves no gaps.

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?

No parameters exist, and schema coverage is 100%. The description does not need to add parameter details; it correctly focuses on the output. Baseline score of 4 for zero-parameter tools 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 'Get the authenticated user's account info' and lists specific fields (user ID, display name, public profile URL). It is unambiguous and distinct from sibling tools, which are all about body measurements, exercises, routines, and workouts.

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 a clear use case: 'Useful for verifying which account the API key belongs to.' While it does not explicitly mention when not to use or alternatives, the context makes it obvious as there are no sibling tools for user 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?

Annotations already provide readOnlyHint=true, so description adds limited behavioral context beyond stating what data is returned. No mention of error handling, auth, or other constraints, but with annotations this is acceptable.

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 core action, no fluff. Efficiently states purpose and return contents.

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

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

For a simple single-parameter tool with an output schema, the description covers the main return fields. Could mention error behavior (e.g., 404 if ID not found) but overall adequate given low complexity.

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

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

Schema coverage is 0%, yet description only says 'by ID' without explaining format, source, or constraints for workoutId. The parameter name is somewhat self-explanatory but description should compensate more.

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

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

The description uses a specific verb 'Get' and resource 'workout', specifying retrieval by ID. It clearly distinguishes from siblings like 'get-workouts' (plural) which lists workouts, not a single one.

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?

Implies usage when needing full details of a specific workout, but lacks explicit when-not-to-use or mention of alternatives like 'get-workouts' or 'get-workout-count'.

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

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

Annotations already declare readOnlyHint=true, making the safe read nature clear. The description adds that it returns a count, but no further behavioral context (e.g., response format, pagination details) beyond what annotations provide.

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

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

A single sentence that perfectly conveys the purpose and use cases with zero waste. Front-loaded and efficient.

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 parameters, an output schema existing, and annotations covering safety, the description is fully complete for an agent. It adds the needed context for pagination/statistics use cases.

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

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

No parameters exist, so baseline is 4. The description doesn't add parameter info (unnecessary) and remains clear about the tool's function.

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?

Clearly states it returns the total number of workouts on the account, distinguishing from sibling tools like get-workouts (list) and get-workout (single). The verb 'get' and noun 'total number of workouts' specify exactly 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?

Explicitly mentions usefulness for pagination or statistics, providing clear context for when to use. Does not explicitly exclude other scenarios or compare to siblings, but the guidance is helpful enough.

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

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

Annotations provide readOnlyHint=true, and the description confirms it is a read operation. The description adds ordering (newest to oldest) and paging behavior, which is valuable beyond the annotation.

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

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

The description is concise with three sentences. The first sentence states the core function, the second adds ordering, and the third explains the intent. No unnecessary words.

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

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

Given the existence of an output schema and the context of sibling tools, the description adequately explains the tool's purpose and behavior for cache synchronization. It could include more parameter details but is complete for the intended 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 0%, and the description does not detail individual parameters. It implicitly references 'since' and paging but lacks specifics on defaults, formats, or constraints that would help the agent.

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 retrieves a paged list of workout events (updates or deletes) since a given date, ordered newest to oldest. It differentiates from siblings like get-workout and get-workouts by focusing on incremental cache updates.

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

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

The description explicitly states the intended use case: allow clients to keep their local cache up to date without fetching entire list. It does not explicitly exclude other uses, but the guidance is clear and contextually appropriate.

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

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

Annotations already indicate readOnlyHint=true (safe read). The description adds context about pagination behavior and ordering (newest first), which goes beyond annotations and helps the agent understand the tool's behavior. However, it does not mention potential edge cases like empty lists or error handling.

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 main purpose. No wasted words, but could be slightly more concise by merging the second and third parts. Overall well-structured.

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

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

Given the presence of an output schema (which describes return values), the description provides sufficient context about what the workout details include (title, description, times, exercises). It does not mention pagination metadata, but the output schema likely covers that. Missing any mention of scope (e.g., all user's workouts) is a minor gap.

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

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

Schema description coverage is 0% (no parameter descriptions in schema). The description only says 'paginated list', implying page and pageSize parameters, but does not explain their constraints (e.g., page is a positive integer, pageSize max 10). The agent must infer from schema defaults and constraints, which is insufficient for a 0% 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 it returns a paginated list of workouts with ordering from newest to oldest. This distinguishes it from sibling tools like 'get-workout' (single workout) and 'get-workout-count' (count only). The verb 'Get' and resource 'list of workouts' are specific and clear.

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

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

No explicit guidance on when to use this tool vs alternatives (e.g., get-workout for a single workout, get-workout-count for counts). The context is implied by tool names, but the description does not explicitly state usage boundaries.

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

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

The description discloses caching behavior: first call fetches all templates, caches with bounded TTL, and reuse. It also explains the refresh parameter. This adds value beyond annotations (readOnlyHint). However, it does not specify TTL duration or cache 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 three sentences, front-loaded with the core purpose, and every sentence adds value. No wasted words 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 schema covers all parameters, annotations provide readOnlyHint, and an output schema exists, the description provides sufficient context about caching behavior and refresh mechanism. No obvious gaps for a search tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds minimal value: it mentions the muscle group filter and refresh behavior, but these are also described in the schema. No new parameter semantics are introduced.

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 purpose: 'Search exercise templates by name with optional muscle group filter.' It uses a specific verb (search) and resource (exercise templates), and distinguishes from sibling tools that fetch by ID or list all.

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 through context (search by name, optional filter) but does not explicitly advise when to use this tool over siblings like get-exercise-templates. 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.

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

Adds context beyond annotations: the API doesn't support clearing fields, so null values are omitted. This explains the idempotent behavior (sending same fields multiple times yields same result) and potential destructive nature (updating fields). The 404 response is also disclosed.

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

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

The description is concise, with three sentences that cover purpose, behavior, and caveats. No unnecessary words or repetition. Well-structured 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 18 parameters and no output schema, the description covers the essential behavioral aspects: partial update semantics, null handling, required date, and 404 error. Missing success response format, but this is acceptable without an output schema. Adequate for agent decision-making.

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

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

Schema coverage is 100%, so every parameter is described. The description adds valuable overall behavior: only provided fields are sent and updated, and at least one measurement field must be provided (not enforced in schema beyond date). This clarifies how to construct requests correctly.

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

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

The description clearly states it updates an existing body measurement entry for a given date, specifying the resource and action. It implicitly distinguishes from sibling tools like create-body-measurement by emphasizing 'existing' but does not explicitly contrast.

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

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

Provides clear guidance: null values are treated as omitted (cannot clear fields), requires at least one measurement field, and returns 404 if date doesn't exist. This tells the agent how to use the tool correctly and what to expect.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true; the description adds the return value but no additional behavioral context (e.g., partial vs full update, authorization needs, 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?

Two sentences with no filler; first sentence states purpose, second sentence clarifies return value. Efficient 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 complex nested 'exercises' parameter and no output schema, the description provides only the most basic field names. It does not guide the agent on constructing the exercise array, leaving gaps for a tool with high parameter 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?

With 0% schema coverage, the description only names 'title, notes, and exercise configurations' but fails to explain the complex nested structure of the 'exercises' parameter or mention the required 'routineId' parameter explicitly.

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?

Clearly states the action ('Update an existing routine by ID'), the resource ('routine'), and the modifiable fields, distinguishing it from sibling tools like create-routine and get-routine.

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?

Implies use for modifying existing routines, but lacks explicit when-not-to-use or alternatives among siblings. However, the tool name and description make the context clear.

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

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

Annotations indicate destructiveHint=true and idempotentHint=true. The description mentions returns but does not elaborate on side effects, required permissions, or partial update behavior. It neither contradicts nor significantly extends the annotations.

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

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

Two concise sentences, front-loaded with action, no filler. Every sentence adds value.

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

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

Given no output schema, the description includes return value info. It adequately covers parameters and behavior for a straightforward update tool. Lacks error handling or prerequisite details, but sufficient for typical 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?

With 0% schema description coverage, the description adds meaning by enumerating modifiable fields (title, description, start/end times, privacy, exercises). It helps the agent understand what each parameter group does, though it does not detail subfields like exercise parameters.

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

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

The description clearly states the action ("Update an existing workout"), the resource (workout), and lists the modifiable fields. It distinguishes from siblings like create-workout (create vs update) and get-workout (read vs write).

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 use when modifying an existing workout but does not explicitly state when to use alternatives (e.g., update-routine) or any prerequisites. No guidance on when not to use this tool.

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