Wellness Project

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

Annotations already declare destructiveHint=true and readOnlyHint=false, indicating a destructive mutation. The description adds context by framing it as an undo operation, which helps the agent understand the user's intent. It also discloses the inference behavior for the date parameter. However, it does not mention what happens if the date is not a declared rest day or if the operation fails, though this is minor for such a simple tool.

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

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

The description is extremely concise: two sentences plus a short instruction block. It front-loads the core purpose, immediately gives the trigger scenario, and then provides the parameter handling rule. No word is wasted, and the structure flows logically from what to why to how.

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

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

For a tool with a single optional parameter, full schema coverage, and an output schema, the description covers all essential aspects: what it does, when to use it, and how to handle the only parameter. The presence of an output schema means return values need not be described. The description is complete for 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?

Schema coverage is 100% and the schema describes the date format and default. The description adds value beyond the schema by instructing the agent to 'parse the user's reference' rather than asking, which is critical for natural-language understanding. This guidance is not present in the input schema, so it earns credit.

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 function: 'Remove a previously declared rest day.' It specifies the resource (rest day) and action (remove/cancel), distinguishing it from sibling tools like log_rest_day and list_rest_days. The added usage example ('scratch that, I'm going to lift today after all') reinforces the purpose.

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 defines when to use the tool: 'Use when the user changes their mind or wants to undo a mistaken declaration.' It also provides a clear behavioral guideline for parameter handling: 'INFER — do not ask: date: parse the user's reference; default to today.' This gives the agent both the trigger context and how to handle the input.

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, so the destructive nature is disclosed. The description adds valuable behavioral context: the requirement for explicit user request and the caution against using delete as a fix, which goes beyond the annotations.

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

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

The description is concise, front-loaded with the main action, and every sentence provides necessary information. 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?

Given the simple one-parameter tool and the presence of an output schema, the description fully covers prerequisites (list_cycle), usage conditions (explicit ask), and alternatives (update_cycle), making it complete for the tool's 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 coverage is 100% with the id parameter described as 'Record ID from list_cycle. Required.' The description reinforces this by mentioning 'by ID' and confirming the record first, but does not add new parameter semantics 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 tool's function: 'Delete a period record by ID.' It specifies the resource (period record) and the action (delete), and distinguishes from sibling tools by referencing update_cycle as an alternative for fixing records.

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?

Explicit guidance is provided: use list_cycle first to confirm the record, only delete when the user explicitly asks to remove a specific record, and use update_cycle instead of deleting to fix. This clearly defines when to use and when not to use the 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?

The description discloses the cascading effect ('Also removes all severity history for that injury') and irreversibility ('Permanently'), adding behavioral context beyond the annotations (readOnlyHint, destructiveHint). It accurately complements the destructiveHint without contradiction.

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

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

The description is mostly concise, with clear front-loading of the core purpose. However, the instruction to 'looked up via list_injuries first' appears twice (in the main body and the INFER block), introducing minor redundancy.

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

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

For a simple delete operation, the description covers purpose, prerequisite, side effects, and how to obtain the ID. With an output schema present, return-value details are unnecessary, leaving no significant 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?

The input schema already fully describes the 'id' parameter, and the description adds the useful note that the ID may need to be looked up via list_injuries first. This goes beyond the schema's basic description.

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

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

The description explicitly states the action ('Permanently delete an injury entry by ID'), specifies the resource ('injury entry'), and notes the permanent nature. It clearly distinguishes from sibling tools like list_injuries, log_injury, and update_injury.

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 prerequisite (use list_injuries first to confirm the ID) and instructs the agent to infer the ID rather than ask. It lacks explicit 'when not to use' phrasing, but the context is sufficient for selection against 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 indicate destructiveHint=true, but the description goes further by stating 'Permanently delete' and 'This action is irreversible,' adding critical context about consequences. It also clarifies the need to confirm before deleting when ambiguous, which is not covered by annotations.

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

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

Every sentence earns its place: purpose, when to use, required workflow, and irreversibility warning. The text is front-loaded with the primary action and remains succinct without 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?

For a simple one-parameter delete tool with existing annotations and output schema, the description fully covers purpose, workflow, irreversibility, and ambiguity handling. No critical information is missing.

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

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

Schema coverage is 100% and the description of the 'id' parameter is already explicit. However, the description reinforces the meaning by saying 'Meal ID from list_meals' and emphasizes the prerequisite workflow, adding value beyond the schema.

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

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

The description explicitly states 'Permanently delete a meal entry,' which is a specific verb plus resource. It clearly distinguishes this from sibling delete tools for other entities (e.g., delete_workout) by specifying 'meal entry.'

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 explicit when-to-use guidance: 'Use when the user explicitly asks to remove or delete a logged meal.' It also outlines a required workflow (call list_meals first) and instructs to confirm ambiguity, which is strong contextual guidance beyond basic purpose.

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 include destructiveHint=true and readOnlyHint=false, but the description adds value by emphasizing 'This action is irreversible' and requiring confirmation before deletion. This goes beyond the structured annotations and helps the agent understand the gravitas of the 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 extremely concise—two sentences—with the key action front-loaded. Each sentence earns its place: the first states the irreversible action, the second delivers the required safety workflow. No 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?

For a simple delete operation with one required parameter, full schema coverage, and an output schema, the description sufficiently covers the action, irreversibility, and the required confirmation workflow. Nothing important is missing 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 schema covers 100% of parameter details with a clear description for 'id' ('Recovery session ID. Required — do not proceed without it.'). The description restates the need to confirm the ID but does not add substantial new semantic meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description clearly states 'Permanently delete a recovery session log entry' with a specific verb and resource, distinguishing it from sibling delete tools by the unique resource type. The wording is explicit and avoids tautology.

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 usage context: 'REQUIRED WORKFLOW: confirm the session ID before deleting. If the user's intent is ambiguous, ask which session to remove.' This tells the agent when to proceed and how to handle ambiguity, though it does not explicitly mention alternatives or when not to use the 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 destructiveHint=true and readOnlyHint=false, so the baseline safety profile is known. The description adds workflow behavior (list_runs first) and a confirmation requirement, which goes beyond the annotations. It does not describe cascade effects or error handling, but annotations cover the key destructiveness signal.

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 extremely concise, front-loaded with the core action, and every sentence provides operational value. The confirmation instruction is an essential addition without being verbose.

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

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

For a simple one-parameter delete tool, the description covers the essential use case, prerequisite ID lookup, and safety confirmation. Output schema exists, so return-value explanation is unnecessary. Annotations provide the destructive/idempotent context, making this complete.

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

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

Schema coverage is 100%, with the id parameter described as 'Run UUID from list_runs. Required.' The description reinforces this by mentioning list_runs but adds no new parameter-level detail beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states 'Delete a run by ID' with a specific verb and resource, and distinguishes it from sibling delete tools for other entity types. It unambiguously identifies the tool's function.

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 to use ('when the user wants to remove a run entry'), provides a prerequisite workflow ('Call list_runs first to find the correct ID'), and instructs to ask for confirmation on ambiguous intent. This is strong usage 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 destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is covered. The description adds the word 'Permanently' which reinforces irreversibility, and the note to confirm the ID before deleting provides a cautionary behavior. However, it does not disclose return values, error handling, or side effects beyond deletion, and the 'Permanently' is somewhat redundant with destructiveHint.

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 brief with two short paragraphs, and the purpose is front-loaded. However, there is redundancy between 'Use list_wellbeing first to confirm the entry ID before deleting' and the INFER line 'id: must be provided or looked up via list_wellbeing first', which repeats the same instruction. Still, it is compact and readable.

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

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

For a simple single-parameter delete tool with an output schema and annotations, the description covers the key operational need: how to obtain the ID. It also signals permanence and the prerequisite of confirmation. It stops short of explaining potential error cases or response structure, but those are partially covered by the output schema and annotations, making it reasonably complete.

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

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

The schema already documents the single parameter 'id' with 100% coverage, so the baseline is 3. The description adds value by explaining that the ID 'must be provided or looked up via list_wellbeing first', giving the agent a clear fallback strategy for obtaining the parameter. This goes beyond the schema's simple 'Required' note.

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

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

The description explicitly states 'Permanently delete a wellbeing entry by ID', using a specific verb and resource, and clearly distinguishes this from sibling delete_* tools by specifying 'wellbeing entry'. It also clarifies the operation's scope (by ID), leaving no ambiguity about what the tool does.

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

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

The description instructs to 'Use list_wellbeing first to confirm the entry ID before deleting', providing a clear prerequisite and explicit guidance for obtaining the required ID. It also includes an 'INFER — do not ask' directive, indicating the agent should look up the ID rather than asking the user. However, it does not explicitly contrast with alternatives like update_wellbeing, so it falls slightly short of full usage differentiation.

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

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

Beyond annotations (destructiveHint=true, readOnlyHint=false), the description specifies the irreversible nature and exactly what gets destroyed: session, supersets, and sets. This adds crucial behavioral context beyond the structured metadata.

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 somewhat verbose with two paragraphs, but each section earns its place: purpose, usage condition, required workflow, and danger warning. It is well-structured and front-loaded, though slightly longer than strictly necessary.

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

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

Given the simple single-parameter tool, the description fully covers the necessary context: irreversible deletion, cascade effects, and mandatory pre-workflow. The presence of an output schema and complete parameter schema further reduce gaps, making this description 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 schema already has 100% parameter coverage with a description for session_id. The tool description adds workflow context ('never guess it', 'confirm which session'), reinforcing the meaning and proper sourcing of the parameter beyond the schema.

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

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

The description uses the specific verb 'permanently delete' with the resource 'workout session' and scope 'all its exercises and sets'. This clearly distinguishes it from sibling delete tools for other resources and states exactly what action is performed.

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 to use it ('when the user wants to remove a logged workout entirely') and provides a required workflow: call list_workouts first to confirm the session ID. It also gives guidance for ambiguous intent, making usage conditions very clear.

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

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

Annotations already declare readOnly, idempotent, and non-destructive, but the description adds return format (Markdown plus guardrail preamble), the one-topic-per-call constraint, and the repeat-call strategy for multi-topic questions. This goes beyond what annotations provide, fully disclosing 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 well structured: a clear first sentence states purpose, followed by when-to-use, exclusions, examples, and return/constraint details. No redundancy or filler; the length is justified by the need to cover 11 distinct topics.

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 the detailed schema and annotations, the description covers purpose, usage conditions, exclusions, return format, and handling of multi-topic queries. The presence of an output schema means return-value details need not be in the description. It is fully complete for this tool's complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by mapping user questions to enum values (e.g., 'where do I see my PRs?'→pages_training), which materially helps correct topic selection beyond the schema's already detailed enum descriptions.

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

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

The description opens with 'Look up how this app works' and specifies features, settings, navigation, and troubleshooting, giving a clear verb+resource. It distinguishes itself from sibling data tools by focusing on product documentation rather than user 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?

It explicitly states when to call ('Call when the user asks where something lives, how a feature works...') and when not to ('Do NOT call for advice about the user's body or data'). Concrete examples map user questions to specific topics, providing unambiguous usage 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?

Beyond the annotations (readOnly, idempotent, non-destructive), the description discloses detailed behavior: returns PR with exact set details, side-by-side banded/unbanded PRs, recent sessions formatted like get_workout, one-line trend delta vs 30-90 days ago, and how exercise_name resolution works when never logged. No contradiction with annotations.

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

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

The description is well-structured with clear sections (USE FOR, NOT for, INFER) and front-loaded with the core purpose. Every sentence earns its place; despite length, it remains highly scannable 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 the tool's complexity (PRs, recent sessions, trends, exercise canonicalization), the description covers all aspects: what it does, when to use, behavioral details, and inference rules. The output schema handles return values, so no need to describe them here. The description fully equips an agent to choose and invoke the tool correctly.

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

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

The input schema already has 100% coverage with full descriptions, including defaults and the PR-always-all-time caveat. The description adds the 'INFER — do not ask' instruction, which is valuable guidance but mostly restates schema semantics rather than introducing new meaning.

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 immediately states the tool looks up everything for ONE exercise, including all-time PR and recent performance. It clearly distinguishes from siblings by explicitly saying NOT for full sessions (use get_workout) or date-window lists (use list_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?

Provides explicit USE FOR categories with example questions, and a NOT for section naming the correct alternative tools (get_workout, list_workouts). Also includes INFER instructions telling the agent not to ask the user for parameters, which is clear 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?

Beyond readOnlyHint, the description discloses that a missing or wrong equipment tag can 'silently halve or double its NSI score,' and instructs how to fix it via update_workout. It also details the NSI scoring hierarchy at session, exercise, and set level, providing behavioral transparency not inferable from 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 structured into clear sections with bold headers, front-loads the primary action, and each sentence conveys unique operational detail. Despite length, it avoids redundancy and stays focused.

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 need not list return fields, but it explains the structure of NSI scoring, the equipment caveat, and the required workflow. This covers the tool's complexity well.

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

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

The schema already documents session_id as 'Session ID from list_workouts. Required.' The description reinforces this connection and adds the warning 'never guess it,' giving the agent actionable guidance on sourcing the parameter. Given the 100% schema coverage, the added value is complementary.

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

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

The description opens with 'Retrieve full detail of a workout session' and enumerates specific data elements (exercises, sets, reps, weights, superset groupings, heart points, notes, NSI scoring), making the tool's purpose unmistakable. This is specific and distinct from generic operations.

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 explicit use cases: 'Use for detailed questions about a past workout, reviewing training before recommendations, confirming what was logged, or comparing a session to population strength standards.' It also mandates the prerequisite workflow: 'call list_workouts first.' However, it does not explicitly mention when not to use it or name alternative tools.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds useful behavioral context: the blog is 'public', posts are 'advisor-authored daily', and results include specific fields (slug, title, summary, advisor name, date). It also discloses the linking pattern (/blog/<slug>). The only minor gap is not explicitly stating that the tool never mutates data, but the annotations already cover that, so the description adds sufficient 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?

The description is two concise sentences with a return-value note, all front-loaded. The first sentence states the core purpose, the second gives usage guidelines, and the final line lists return fields and linking format. 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 has 3 optional parameters, a rich schema, and output schema exists, the description is complete. It explains what the tool does, when to use it, what it returns, and how to link results. There are no significant gaps: the public nature, advisor filter, and inline linking are all covered. The description fully complements the structured annotations and 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?

The input schema already covers all three parameters (limit, query, advisor_slug) with descriptions, achieving 100% schema coverage. The description does not add additional parameter semantics beyond the schema; it merely restates the substring filter concept via 'search'. Since schema coverage is high, a baseline of 3 is appropriate, and the description does not need to compensate.

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 function: 'Search the public Crew Blog at /blog for advisor-authored daily posts.' It specifies the resource (Crew Blog), the action (search), and the scope (advisor-authored daily posts), distinguishing it from sibling tools that deal with health metrics and workouts. The verb 'search' plus the specific resource makes the purpose unambiguous.

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

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

The description provides explicit usage boundaries: 'Only call when the user explicitly asks about the blog or what an advisor has written; don't volunteer posts in normal conversation.' This clearly states when to use and when not to use the tool, which is strong guidance beyond what annotations offer. It effectively prevents misuse by instructing not to volunteer posts in unrelated contexts.

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, idempotentHint, and destructiveHint, so the bar is lower. The description adds valuable behavioral context by disclosing the INFER rules (defaulting start_date to 30 days ago and end_date to today), which indicates the tool will automatically apply defaults and the agent should not ask.

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: two sentences plus a directive block. Purpose is front-loaded, and every sentence earns its place, especially the INFER instruction which provides actionable guidance.

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

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

For a simple read-only list tool with 2 optional parameters, an existing output schema, and full parameter documentation, the description covers purpose, usage context, and inference behavior. It is sufficiently complete for an agent to select and invoke correctly.

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

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

Schema description coverage is 100%, so both parameters are fully documented with formats and defaults. The description's INFER section essentially repeats the schema defaults without adding new semantic meaning, so the baseline 3 applies.

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

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

The description uses a specific verb ('List') with a clear resource ('body composition entries') and scope ('within a date range'). It distinguishes from sibling list_* tools by focusing on body metrics and explicitly mentions weight history and body fat trend.

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 when to use the tool: 'Use when the user asks about their weight history, body fat trend, or any body metrics over time.' It provides clear context but does not mention when not to use or alternative tools, so it lacks explicit 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 and destructiveHint=false. The description adds value by clarifying the date-range scope, the user-specific nature ('the user's logged period records'), and the INFER rule that defaults should be applied without asking. No contradictions with annotations.

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

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

Two succinct sentences cover purpose and usage, followed by a clean two-item INFER list. Every sentence is purposeful, front-loaded, and free of 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?

For a simple list tool with two optional parameters and an output schema, this description fully covers purpose, usage context, default behavior, and parameter inference. No gaps are apparent 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?

Schema coverage is 100%, but the description goes beyond by explicitly instructing 'INFER — do not ask' for both start_date and end_date, reinforcing the defaults. This behavioral directive is not present in the schema, adding significant meaning for 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 begins with 'List the user's logged period records within a date range', which clearly identifies the verb, resource, and scope. It distinguishes this tool from sibling list tools by focusing on period/cycle records, and the mention of 'cycle history' reinforces the specific domain.

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 to use: 'Use to look up period history before updating or deleting a record, or when the user asks about their cycle history.' Also provides clear INFER instructions to not ask for defaults, which is an effective usage guideline for parameter handling.

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 the tool is read-only, idempotent, and non-destructive. The description adds meaningful behavioral context beyond annotations: results are grouped by muscle group, and canonical names are tied to proper exercise tracking and NSI score calculation. This provides useful expectations for the agent.

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

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

The description is two sentences, front-loaded with the primary function, and every clause adds value: what it returns, how it's grouped, when to call it, and why canonical names matter. No filler or redundancy.

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

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

Given the tool has zero parameters and an output schema exists, the description sufficiently covers purpose, grouping, usage context, and downstream impact. It completely addresses the agent's need to know what this tool does and when to invoke it.

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

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

The tool has no parameters, so per the rubric the baseline is 4. The description appropriately avoids inventing parameter details and correctly focuses on the output and usage context.

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

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

The description clearly states the tool returns all canonical exercise names from the exercise library, grouped by muscle group. It uses a specific verb ('Returns') and resource, and distinguishes itself from sibling tools by its explicit focus on the exercise library and its role in logging/updating 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 gives explicit usage context: call this before log_workout or update_workout to match user-described exercise names to canonical ones. It does not mention when not to use it or name alternatives, so it falls short of a 5, but 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds behavioral context beyond these: default filtering to Active and Monitoring, the meaning of 'all' and 'Resolved', and the fact that the tool returns entry IDs needed for update/delete tools. No contradictions with annotations.

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

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

The description is concise and well-structured. The first sentence states the core purpose, followed by typical use cases and a valuable note about returned IDs. The 'INFER — do not ask' section is clearly formatted and adds necessary parameter guidance without fluff. Every sentence earns its place.

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

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

Given the tool's simplicity (one optional parameter, output schema provided, read-only per annotations), the description fully covers the necessary context: when to use it, how to interpret the status parameter, and why its return value matters. The output schema handles return-value details, so no further explanation 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% (status enum with a description), so baseline is 3. The description significantly enriches the parameter semantics by explaining the default behavior, how to include Resolved ('all'), and how to get history only ('Resolved'). This goes well beyond the schema's simple 'Filter by status' and provides actionable guidance.

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 function: 'List injuries from the injury log.' It specifies the resource (injury log) and provides context for use cases ('injury history, current injuries, or rehab progress'). This distinguishes it from sibling list tools by domain and by noting it returns entry IDs for update_injury and delete_injury.

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 to use the tool: 'Use when the user asks about their injury history, current injuries, or rehab progress.' It also provides inference guidance for parameter selection ('INFER — do not ask'), which clarifies how to handle status. However, it does not mention when not to use it or name alternative tools, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds context about the tool being a canonical reference lookup and explains its role in preventing name drift and ensuring trending consistency, which is useful beyond the annotations.

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

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

The description is two sentences: the first states the output, the second gives usage guidance and rationale. 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 zero-parameter read-only list tool with an output schema, the description fully covers what the tool returns, when to use it, and why. The reference to list_exercises and the mention of trending add 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 tool has zero parameters, so there are no parameter semantics to describe. The schema coverage is 100% (vacuously), and the description requires no parameter explanation. Baseline for zero parameters is 4.

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

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

The description clearly states the tool returns all LOINC-coded markers from the reference library and enumerates the fields (canonical name, LOINC code, panel, typical unit, common aliases). It distinguishes itself from list_lab_results by specifying 'reference library' and the canonical nature of the 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?

Explicitly instructs to call this BEFORE log_lab_results to match user-provided marker names, and references list_exercises as a similar pattern. This provides clear when-to-use guidance and indirectly indicates not to use it for retrieving logged results.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering the safety profile. The description adds valuable behavioral context: it states that start_date should default to 365 days ago because "labs are infrequent," and explicitly instructs the agent to "INFER — do not ask" for default parameters. This goes beyond annotations without contradicting them.

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

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

The description is compact: three sentences and a two-item bullet list. Every sentence earns its place, with the main purpose front-loaded and the inference rules neatly structured. No redundant or filler content.

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

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

The tool has only four optional parameters, an output schema is present, and annotations convey safety. The description covers purpose, usage triggers, filtering options, and default inference rules. For a simple read-only listing tool, this is complete enough for an agent to select and invoke correctly without ambiguity.

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

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

Input schema coverage is 100% with each parameter already described, so baseline is 3. The description adds incremental value by reinforcing defaults and providing the rationale for the 365-day default, plus a clear directive to infer rather than interrogate the user. It also clarifies that panel_name and marker_name are optional filters, which is implicit 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 opens with "List lab/biomarker results within a date range," a specific verb+resource+scope statement. It clearly distinguishes from siblings like list_lab_markers (which lists available markers) and log_lab_results (which adds entries). The added use case "lab history, blood work trends, or specific marker values" further reinforces the purpose.

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 when to use: "Use when the user asks about their lab history, blood work trends, or specific marker values over time." It also gives practical inference rules for default date values to avoid unnecessary questions. However, it does not explicitly mention alternative tools or when not to use, so it falls short of a 5 but is clearly better than vague 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 mark the tool as readOnly, idempotent, and non-destructive. The description adds valuable behavioral context: the 31-day maximum range, the need for multiple calls for longer periods, and the specific data fields returned (meal ID, date, type, macros). No contradictions with annotations.

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

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

Well-structured: main purpose first, then usage guidance, then parameter inference. Every sentence contributes, and the INFER section uses bullet-like formatting for clarity. The length is justified given the complexity of date-range handling.

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 correctly focuses on behavior rather than return format. It covers the tool's purpose, when to use it, limits (31 days), and parameter resolution. It is complete for the tool's complexity and 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?

Although the schema covers 100% of parameters, the description enriches both parameters with inference rules: date defaults to today, end_date should be set based on user phrasing ('this week' → date=Monday, end_date=today; 'last 7 days' → date=7 days ago). It clarifies that end_date is omitted for single-day lookups, adding meaning beyond the schema descriptions.

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

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

The description opens with a specific verb and resource: 'List all meals logged for a date or date range', and lists the returned fields (ID, date, type, food description, macros). It also distinguishes itself from sibling tools by explicitly recommending its use before update_meal or delete_meal.

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 explicit when-to-use guidance: 'Use this before update_meal or delete_meal to find the correct meal ID' and for answering questions like 'what did I eat today/this week/yesterday?'. It also gives clear instructions for longer periods ('Maximum range: 31 days... make multiple calls') and detailed inference rules for date/end_date with examples.

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, idempotentHint=true, and destructiveHint=false, so safety is well covered. The description adds valuable behavioral details beyond annotations, such as the default filter, the INFER directive (do not ask), and the returned fields, which helps the agent understand exactly what to expect.

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 tightly packed with useful information: purpose, usage triggers, parameter guidance, and return fields. Each sentence adds value with no fluff or repetition of structured data.

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 optional parameter, no required fields) and the presence of an output schema plus return-field listing, the description is fully sufficient. It covers the filter semantics, the return structure, and the behavioral context needed for correct invocation.

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

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

The schema covers 100% of parameter descriptions with an enum, but the description enriches this by clarifying the practical meanings: 'active' is the default, 'all' is for history, and 'historical' is for ended strategies only. This adds meaningful guidance over the raw schema.

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

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

The description identifies a specific verb ('List') and resource ('user's recovery and mindfulness strategies'), making the tool's purpose immediately clear. It distinguishes itself from sibling tools like manage_recovery_strategy and log_recovery_session by framing this as the read-only listing operation.

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

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

It provides explicit use cases: when the user asks about recovery practices or mindfulness routines, and when strategy IDs are needed before logging a session. It does not explicitly state when not to use this tool or name alternatives, but the context is sufficiently clear to guide 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, reducing the burden on the description. The description adds valuable behavioral guidance via the 'INFER — do not ask' defaults, explaining how to handle missing parameters without prompting the user. No contradiction with annotations.

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

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

The description is concise and well-structured: one purpose statement, example queries, and a clear INFER section. Every sentence adds value, with no 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?

For a simple read-only list tool with two optional parameters, the description fully covers usage context, defaults, and intent. An output schema is present, so return values need not be described. No gaps remain.

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

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

The input schema already provides complete descriptions (100% coverage) with defaults for both parameters. The description adds meaning beyond the schema by instructing the agent to infer these defaults rather than ask the user, which is useful for invocation behavior.

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

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

The description uses a specific verb ('List') and resource ('rest days') with clear scope ('within a range'), and differentiates itself from sibling tools like log_rest_day and cancel_rest_day by its read-only, listing nature. Example user queries further clarify the intended use.

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 when to use the tool ('Use when the user asks about their rest pattern') with concrete example queries. It does not mention when not to use it or name alternatives, but the context is sufficiently clear for a listing 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 and idempotentHint=true, covering the safety profile. The description adds meaningful behavioral context beyond annotations: the run-vs-workout distinction (imported cardio becomes workout sessions with session IDs, never run IDs), which is crucial behavior not conveyed by structured fields. It also discloses the 31-day cap. Minor gap: doesn't mention return format/pagination, though an output schema exists.

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

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

The description is well-structured with brief, front-loaded paragraphs: return fields, use-case examples, the workout/exclusion caveat, and the range limit. Each sentence earns its place. It's slightly longer than minimal due to the detailed run-vs-workout clarification, but that content is genuinely valuable and not redundant.

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

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

This is a read-only list tool with excellent annotations (readOnly, idempotent) and a full output schema. The description covers purpose, return fields, exclusions, range limits, and default behavior—nothing essential is missing. The run-vs-workout boundary and multi-call strategy fully address the complexity of this listing 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 both parameters already document format (YYYY-MM-DD) and defaults. The description reinforces the defaults via the INFER directive and adds max-range context for the date parameters, but since the schema carries the full descriptive load, the added semantic value is marginal and the baseline-3 applies.

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

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

The description clearly states the tool lists runs within a date range and enumerates the exact return fields (ID, date, distance, duration, pace, type). It explicitly differentiates from siblings like list_workouts and delete_run by clarifying that wearable-imported cardio sessions are handled elsewhere, and even provides example queries that make its purpose unmistakable.

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

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

The description gives explicit usage context: example user questions, use-before-delete_run guidance, and clear alternative tool routing (update_workout/delete_workout for workouts, never delete_run). It also states the 31-day maximum range and instructs sequential multi-call for longer periods, plus an INFER directive for defaults. This is comprehensive when-to-use guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds a valuable behavioral trait: 'INFER — do not ask' with automatic defaults for start_date and end_date. This clarifies that the tool will use 14 days ago and today when parameters are omitted, a detail not fully captured in the schema or annotations. This goes beyond basic read-only disclosure.

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 extremely concise: two sentences plus a short bullet list. The purpose is front-loaded, and every sentence provides critical information—what the tool does, when to use it, and how defaults are handled. No wasteful or repetitive wording exists.

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

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

This is a simple filtered-list tool with an output schema and strong annotations. The description covers the tool's purpose, usage context, and default-handling behavior. Given the availability of the output schema to explain return values, no additional behavioral details are needed for correct invocation. The description is complete for its complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning by specifying the exact default values (14 days ago and today) and the instruction to infer rather than ask the user. This enriches the parameter understanding beyond the schema's formulaic 'Default: 14 days ago' by clarifying the agent's behavior regarding missing 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 opens with a specific action and resource: 'List sleep log entries within a date range.' This clearly defines the tool's purpose and distinguishes it from sibling tools such as log_sleep or show_week_sleep by adding a usage context about history, trends, and quality over time. The verb 'List' and resource 'sleep log entries' leave no ambiguity about what the tool does.

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

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

The description includes an explicit 'Use when' clause: 'Use when the user asks about their sleep history, trends, or quality over time.' This provides clear guidance on when to invoke the tool. However, it does not explicitly name alternative tools or state when not to use it, though the read-only annotation and the context about history/trends imply differentiation from logging and summary tools.

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

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

Although annotations indicate read-only and idempotent behavior, the description adds significant behavioral context: the 'INFER — do not ask' guidance, default filter behavior, and the meaning of each filter/category option. This goes well beyond what annotations convey, and no contradiction exists.

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

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

The description is well-structured: a one-sentence purpose, a clearly labeled 'INFER' section with concise bullet-like guidance, and a brief list of return fields. Every sentence serves a purpose, with no 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 simplicity (two optional enum params), the description covers all essential aspects: purpose, usage, parameter inference, and return fields. The presence of an output schema means return value details need not be exhaustively repeated, making this description complete for an agent to select and invoke the tool correctly.

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

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

The input schema already describes each parameter, but the description enriches this by explaining when to use each value (e.g., filter defaults to 'active', use 'all' for history, 'historical' for ended items) and how to interpret category omission. This adds actionable meaning beyond the enum descriptions.

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

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

The description opens with a clear verb+resource: 'List the user's medications and supplements.' It explicitly distinguishes itself from the sibling manage_supplement by noting it provides IDs needed before calling that tool, and the overall purpose is unambiguous.

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

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

It explicitly states when to use the tool: 'Use when the user asks what medications or supplements they're taking, asks to review their stack, or you need IDs before calling manage_supplement.' This provides clear context and implies when not to use it (e.g., when managing rather than listing).

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds valuable behavioral context: the INFER rule for start_date/end_date defaults and the detailed explanation of how Zone Minutes are split into moderate and vigorous zones, which is not obvious from the schema.

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

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

The description is concise, front-loaded with the core purpose, and each section has a purpose. The Zone Minutes explanation is a bit detailed but serves to clarify the data representation. The INFER rule is a separate block that is easy to parse. Overall, it is well-structured and not padded.

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

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

The description covers what data is listed, when to use it, and the inference behavior for defaults. Given that an output schema exists, return values need not be described. No significant gaps are apparent for a read-only list tool, and the Zone Minutes breakdown adds necessary context for 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?

Schema coverage is 100% with both parameters described. The description adds the 'INFER — do not ask' directive, telling the agent to use defaults without asking the user, which is extra semantic guidance beyond the schema. It also explains the meaning and format of these date parameters implicitly through the default values.

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

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

The description uses a specific verb ('List') and resource ('daily wearable data') with an enumerated set of metrics (steps, RHR, HRV, Zone Minutes, VO2max, calories, stress). It clearly distinguishes the tool from siblings by naming the wearable-focused metrics and explicitly stating when to use it for step count, heart rate, HRV trends, etc.

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 explicit context for when to use the tool ('Use when the user asks about their step count, heart rate, HRV trends...'). It does not explicitly mention alternatives, but the usage triggers are clear enough to differentiate from list_body_metrics or show_week_steps, and the INFER instructions give behavioral guidance for defaults.

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 read-only and non-destructive behavior, lowering the bar. The description adds value by stating that it returns entry IDs needed for update/delete, and it provides an explicit inference rule ('INFER — do not ask') with defaults for the date range, which is behavioral guidance beyond the schema and 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 compact and front-loaded: first sentence states the action and purpose, second gives the key return-value tie-in, and the 'INFER' section is bulleted for clarity. No redundant text; every sentence earns its place.

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

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

For a simple read-only list tool with only two optional parameters and an output schema, the description covers purpose, usage triggers, return-value relevance, and parameter inference defaults. The existing output schema handles return format, so no further explanation 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% as both parameters include descriptions with format and defaults. The description goes further by instructing the agent to infer defaults silently rather than asking the user, which adds operational meaning beyond the schema's plain parameter descriptions.

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

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

The description uses a specific verb and resource: 'List wellbeing log entries within a date range.' It specifies the scope (date range) and distinguishes the tool from siblings by naming the relevant topics (mood, energy, stress, soreness) and explicitly ties it to update_wellbeing and delete_wellbeing via returned entry IDs.

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

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

It provides clear trigger context: 'Use when the user asks about their mood, energy, stress, or soreness trends over time.' It also explains why you'd use this tool (to obtain entry IDs for update/delete). It lacks an explicit 'do not use for' statement, but the guidance is specific enough to direct selection among the many sibling list 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?

Adds substantial behavioral context beyond the readOnlyHint/idempotentHint annotations: NSI calculation methodology, rating bands, 90-day call limit, and the need to chain calls for longer periods. This is valuable operational detail.

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

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

The description is front-loaded with the core purpose in the first sentence. Each subsequent paragraph adds distinct value: usage examples, NSI explanation, range/limitation handling, and defaults. No redundant or filler content.

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

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

Given the tool's complexity and the presence of an output schema, the description covers all necessary aspects: purpose, parameter usage, edge cases (longer ranges), and query patterns. It is sufficient for an agent to use the tool correctly without additional information.

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

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

Schema coverage is 100%, so baseline is 3. The description adds useful context beyond the schema: the 90-day maximum range and the inference to widen up to 90 days for trend questions. It also implicitly clarifies the behavior when parameters are omitted.

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 lists workout sessions in a date range with specific fields (ID, date, focus type, location, NSI). It distinguishes itself from siblings like get_workout by explicitly saying 'Use before get_workout to find a session ID'.

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 explicit usage instructions including example questions, guidance to use before get_workout, and a detailed strategy for handling ranges longer than 90 days with sequential calls. It also gives inference rules for defaulting dates.

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 only provide false flags, so the description carries the behavioral burden. It discloses the upsert behavior ('Calling this tool twice on the same date updates the existing entry'), unit conversion expectations, and partial-logging capability. These are essential behaviors not captured in 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?

Though longer than typical descriptions, it is well-structured with clear sections (purpose, usage, inference rules, data behavior). Every sentence earns its place—no fluff or repetition. The proactive data collection guidance is necessary for correct agent behavior.

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 all critical aspects for a 10-parameter mutation tool: units, inference, partial updates, upsert behavior, and even how to handle missing user data. With an output schema present, not explaining return values is acceptable; the description is complete enough for an agent to invoke correctly.

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

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

The schema descriptions are comprehensive (100% coverage), so baseline is 3. However, the description adds significant value by providing formulas for derived fields (lean = weight × (1 - bf%/100), fat = weight × bf%/100), explicit unit conversion instructions, and the rule to infer the date. This goes far beyond the schema's per-param descriptions.

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

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

The description clearly states the tool logs or updates body composition metrics, with a specific verb and resource. It distinguishes itself from sibling tools like list_body_metrics by focusing on writing data and provides usage context (e.g., 'Use when the user shares weight, body fat percentage...').

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 when to use the tool ('Use when the user shares...') and gives detailed guidance on proactive data collection, inference rules, and allowed subsets of fields. It also implies when not to use it by naming read-only siblings, making usage 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 only provide generic hints, so the description carries the burden. It discloses key behavioral traits: inference of dates without asking, consent prerequisite, reopening a period previously marked ended, and the default-to-today rule. These add substantial context beyond the structured fields and do not contradict any annotations.

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

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

The description is front-loaded with a clear one-sentence purpose, then uses concise bullet points for cases and inference rules. Every sentence earns its place—there is no fluff or repetition, and the structure aids scannability.

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 fully covers the tool's complexity: consent check, inference behavior, future-date restriction, and resume logic. With an output schema present, return values need not be described. It leaves no significant gaps for an agent to understand when and how to invoke the tool.

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

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

Although schema coverage is 100%, the description enriches parameter meaning significantly. It explains how to derive started_on (default today) and ended_on (omit unless explicitly stated, with an example of inferring from '5-day period'). This natural-language mapping is far more valuable than the schema's basic date format descriptions.

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

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

The description opens with a specific verb+resource: 'Log a period to the user's cycle log.' It enumerates distinct use cases (starting today, backfilling, resuming, logging start only) and clearly distinguishes from sibling tools like update_cycle, list_cycle, and delete_cycle by focusing on the logging action.

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

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

The description gives explicit when-to-use scenarios (starting, backfilling, resuming) and a clear when-not-to-use ('Do NOT use this tool to log future dates'). However, it does not explicitly name alternative tools (e.g., update_cycle for modifications), so alternative guidance is implied rather than stated.

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

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

Beyond annotations (which only indicate readOnly=false, etc.), the description discloses critical behavior: injuries are date ranges with ongoing status until end_date is set, and it provides detailed inference rules for start_date, severity, status, affected_movements, and side. This adds substantial context about how the tool operates and what the agent should expect, with 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?

The description is well-structured with a clear opening sentence, a concise date-range explanation, and a bulleted 'INFER' section that saves space. Every sentence adds value; there is no repetition of schema details or fluff. The format is easily scannable for an agent.

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 9 parameters, 3 required, and an output schema, the description covers all essential behavioral aspects: when to use, how to infer defaults, what to ask, and the date-range model. It is complete for the agent to successfully invoke the tool without further clarification.

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?

Although schema coverage is 100%, the description adds meaningful semantic guidance for parameters: defaults (start_date=today, status=Active), severity estimation scale (minor=2-3, moderate=5-6, severe=8-9), and inference for affected_movements and side. This goes far beyond the schema's basic descriptions, helping the agent populate values 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 opens with 'Log a new injury or aggravation,' which clearly states the action and resource. It distinguishes from siblings like update_injury and delete_injury by emphasizing 'new' and provides specific trigger examples (hurt, pain, strain). This is a specific verb+resource with clear 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?

Explicitly states when to use: 'Use when the user mentions getting hurt, feeling pain, straining something, or describes an injury.' It also gives practical guidance to infer rather than ask, and specifies the only case to ask (unclear body_part). It doesn't explicitly name alternatives (e.g., update_injury for existing injuries), but the 'new' keyword and sibling context make this clear 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 are minimal (all hints false), so the description carries the burden of behavioral disclosure. It thoroughly explains inference rules for date, panel, flag, reference ranges, and lab name, as well as fallback behavior for unmatched markers and the requirement to submit all markers in one call. This goes well beyond the structured 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 structured and front-loaded, starting with purpose and usage, then workflow and inference rules. Every sentence provides necessary guidance without fluff, and the length is appropriate for a tool with a complex array input.

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, the description covers all necessary aspects: prerequisite lookup, inference rules, fallback handling, batching, and prompting for missing data. Since an output schema exists, return values need not be described, making the description complete for effective 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?

Although schema coverage is 100%, the description adds significant meaning by explaining how to derive each parameter: canonical names and LOINC codes from list_lab_markers, date inference, flag extraction, and reference range parsing. It also clarifies conditional behavior for loinc_code and marker_name when no match exists, 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 tool logs one or more blood test or biomarker results, using the specific verb 'Log'. It distinguishes itself from sibling tools like list_lab_results and list_lab_markers by describing the action and context, making its purpose unambiguous.

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

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

The description explicitly states when to use the tool: when the user shares lab values from PDFs, reports, or photos. It also provides a prerequisite workflow referencing list_lab_markers, an alternative action when the user hasn't shared results (prompt them), and a clear batching requirement.

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

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

Beyond annotations (readOnlyHint=false, destructiveHint=false), the description discloses key behaviors: it infers date/meal_type/macros from context, estimates macros aggressively, handles fasting days with a zero-calorie entry, and manages duplicate errors via a defined protocol. It even explains the rationale for fasting logging related to TDEE math. This is rich behavioral context that annotations alone would not 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?

The description is long but every section earns its place: INFER rules, BRAND NAMES, ASK, FASTING, DUPLICATES. It is front-loaded with the primary use case and then organized by decision logic. No fluff, no repetition of schema 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 complexity (9 params, 6 required, enum, output schema), the description covers every aspect an agent needs: inference, estimation, edge cases, error recovery, and special fasting behavior. It leaves no obvious gap in 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 already 100%, but the description adds substantial meaning: it defines meal_type time windows, mandates macro estimation, gives brand-name lookup instructions, and explains when to set force=true. It transforms raw parameter names into actionable guidance, far exceeding the baseline.

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

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

The description opens with a specific verb+resource pair: "Log a meal to the user's food diary." It clearly distinguishes this tool from siblings like update_meal, delete_meal, and list_meals by focusing on the act of logging a new meal. The subsequent usage trigger "when the user mentions eating, describes a meal, or asks to log food" further sharpens the purpose.

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 to use: "Use when the user mentions eating, describes a meal, or asks to log food." It also provides when-not-to-use guidance by referencing update_meal for updates and describing the duplicate-handling workflow with force=true. This gives the agent clear decision criteria relative to sibling tools.

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

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

The description extensively discloses inference behavior: date defaults to today, category inferred from practice name, duration_minutes omitted for skipped sessions, quality only included if rated, and skipped inferred from user wording. It also prescribes a workflow dependency on list_recovery_strategies. These details go well beyond the basic annotations (readOnlyHint=false, etc.) and add significant behavioral context.

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

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

The description is well-structured with a clear opening line, a bullet-like INFER section, and a PREFERRED WORKFLOW. Each section efficiently carries necessary information without redundancy. The length is justified by the complexity of inference rules, and the text is 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?

For a tool with 8 parameters (2 required) and an output schema, the description covers all necessary aspects: usage triggers, parameter inference, workflow, and standalone vs strategy-linked cases. Return values are not explained, but the output schema exists, so that is appropriate. The description fully equips an agent to select and invoke the tool correctly.

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

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

Although the schema has 100% parameter coverage, the description adds substantial semantic guidance: it explains how to infer required fields like category and strategy_name, when to omit duration_minutes and strategy_id, and how to handle quality and skipped. This transforms raw schema definitions into actionable usage rules, adding value beyond structured fields.

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

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

The description opens with 'Log a completed or skipped recovery/mindfulness session', clearly identifying the action and resource. It provides a concrete list of practices (breathing, meditation, cold plunge, sauna, stretching) and distinguishes this tool from other log_* siblings by focusing on recovery/mindfulness sessions, including standalone vs strategy-linked cases.

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?

Explicit trigger conditions are given: 'Use when the user says they did (or skipped) a breathing exercise, meditation, cold plunge, sauna, stretching, or any recovery practice.' A preferred workflow instructs calling list_recovery_strategies first for adherence tracking, with a fallback to standalone logging. It lacks an explicit 'when-not' or named alternative tools, so not full marks.

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 explicitly states 'Idempotent — calling twice on the same date is a no-op,' but the annotations declare idempotentHint: false. This is a direct contradiction; according to the rules, a contradiction warrants a score of 1. Other behavioral details like suppressing workout-prompt nudges are useful but overridden by the contradiction.

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

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

The description is well-structured: purpose, usage, inference guidance, idempotency, and alternative tool. Each section is clearly labeled and every sentence provides necessary information. Appropriate length for the tool's complexity.

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

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

For a mutation tool with one optional parameter, the description fully covers behavior, triggers, side effects (nudge suppression), idempotency, and how to undo. An output schema exists, so return value explanation is not required. The only issue is the annotation contradiction, which is already penalized in behavioral transparency.

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 already covers the parameter with format and default (100% coverage), but the description adds inference rules (e.g., 'today' = today, 'yesterday' = today - 1) and instructs the agent to infer rather than ask. This adds meaningful value beyond the schema.

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

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

The description opens with 'Mark a date as an intentional rest day,' a specific verb and resource. It clearly distinguishes from sibling tools like cancel_rest_day and list_rest_days by contrasting removal and listing.

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 to use: 'Use when the user says they took a rest day, are taking one today, or wants to mark a past day as rest after the fact.' Also points to cancel_rest_day for removal, providing both positive and negative 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 mark this as a write operation (readOnlyHint=false). The description adds meaningful behavioral context: conversion rules for duration (minutes, h:mm:ss), distance unit conversion (km ÷ 1.609344), inference defaults for date/run_type/surface, and a clear ask-only-if-necessary policy. It does not contradict any 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 structured with clear headings (REQUIRED, INFER, DURATION, ASK) and is front-loaded with the purpose sentence. Every section earns its place—no fluff or repetition. The length is justified by the tool's complexity (7 params, conversions, inference rules).

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 (7 params, 3 required, output schema present), the description covers all essential aspects: required vs optional fields, inference behavior, conversion formats, and the ask policy. The output schema handles return-value documentation, so the description is complete without needing to explain 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?

Schema coverage is 100%, so baseline is 3, but the description substantially enriches the schema. It provides concrete examples for duration_sec ('28 minutes' → 1680), gives the exact conversion formula for distance_mi, and details inference heuristics for date, run_type, and surface—adding value far beyond the schema's property descriptions.

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

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

The description opens with 'Log a run to the user's running tracker'—a specific verb+resource that clearly defines the action. It distinguishes itself from siblings like log_workout by scoping to 'running activity' (run, jogging, jog).

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 ('Use when the user mentions going for a run, jogging, or any running activity') and provides a clear exclusion for when to ask instead of infer. However, it does not explicitly name alternatives (e.g., log_workout for non-running activities), so it lacks full alternative differentiation.

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 key behavioral traits beyond annotations: it is an upsert (calling twice on same date updates), allows logging any subset of fields, enforces one row per day, and tags entries as manual. It also explains the date inference rule. Annotations only state basic hints, so this description adds substantial 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 organized with a clear intro, a bold PROACTIVE DATA COLLECTION section, and a bulleted INFER section. Every sentence provides actionable guidance—no filler. It is longer than average but all content is necessary 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?

Given the tool's moderate complexity (7 parameters, write operation, multiple source types), the description covers all essential aspects: when to use it, how to handle missing data, date semantics, upsert behavior, and manual tagging. The presence of an output schema further reduces the need to document return values, making this description complete.

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

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

Schema coverage is 100%, so the schema already documents each parameter. The description adds meaningful extra semantics, notably the sleep_score conversion rule ('For a 1-10 self-rating, multiply by 10 first') and the flexible date interpretation. This goes beyond the baseline, though it does not add detail for every parameter.

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

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

The description opens with a specific verb+resource ('Log a sleep entry') and clearly defines the tool's scope: accepting sleep data from Fitbit, Oura, Whoop, Apple Health, or manual recall. It also distinguishes itself from sibling tools by noting that entries are always tagged as manual and that wearable-provider sources are reserved for auto-sync pipelines, preventing confusion with log_wearable or list_sleep.

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

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

The description gives explicit guidance on when to use the tool ('Use when the user shares sleep data...') and includes proactive data collection instructions for incomplete input. It implies exclusion of auto-synced wearable data by reserving those sources for auto-sync pipelines, but it does not explicitly name an alternative tool, so it falls just short of a 5.

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

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

Annotations indicate readOnlyHint=false, destructiveHint=false, and idempotentHint=false, but the description adds valuable behavioral context beyond these flags: date and taken defaults, an explicit "INFER — do not ask" policy, and the requirement to call list_supplements first. It does not contradict the annotations, and the added context clarifies expected behavior without being redundant.

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 and concise, using short paragraphs and bullet-like sections. Every sentence adds value: the purpose, the inference rules, and the required workflow. There is no fluff or repetition of the tool name.

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

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

Given the tool's moderate complexity, the presence of an output schema, and rich annotations, the description covers all key aspects: what it does, when to use it, how to handle parameters, and what prerequisite step is needed. The agent has enough information to invoke the tool confidently without requiring additional clarification.

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

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

The input schema already provides full descriptions for all four parameters (100% coverage), so the baseline is 3. The description adds extra meaning by specifying that supplement_id should come from list_supplements, and it reiterates the defaults for date and taken in an actionable way, which helps an agent use the parameters correctly.

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

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

The description clearly states the tool's function with a specific verb and resource: "Mark a medication or supplement as taken or not taken for a specific date." This distinguishes it from sibling logging tools, which focus on different domain entities, and also clarifies the daily-tracking context.

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 says when to use the tool: "Only relevant when the user has daily tracking mode enabled" and "Use when the user says they took (or missed) a medication or supplement on a particular day." It also provides a required workflow calling list_supplements first, which gives concrete procedural guidance and avoids ambiguity.

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

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

Beyond the annotations (which only set readOnly=false, destructive=false, idempotent=false), the description reveals critical behaviors: step_count is additive, other fields replace existing manual values, and the operation is idempotent when values already exist (returns no-op success). It also discloses that date defaults to today, reducing assumptions. This goes well beyond what annotations convey.

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 longer than average but uses clear section headers (STEPS, INFER, IDEMPOTENT) and front-loads the primary purpose. Each section adds necessary operational detail; however, the step_count guidance is repeated in both the description and schema, and the text could be tightened slightly without losing meaning.

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

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

Given the 10-parameter complexity and the presence of an output schema, the description is thorough: it covers default behavior, edge cases (device sync issues, double counting), correction semantics, idempotency, and when to seek confirmation. The agent has enough context to use the tool safely without additional assumptions.

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

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

The schema already provides 100% parameter descriptions, so the baseline is 3. The description adds meaningful semantic value by explaining the additive behavior of step_count versus the replacement behavior of other fields, and by noting that confirm_supplemental must only be true after explicit user confirmation. This clarifies interaction between parameters that the schema doesn't fully convey.

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

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

The description opens with a clear action: 'Log daily wearable metrics' and enumerates specific metrics (RHR, HRV, Zone Minutes/AZM, VO2max, calories, stress, supplemental steps), making the tool's scope unambiguous. It also distinguishes itself from sibling log_* tools by focusing on wearable device metrics rather than body metrics, meals, or sleep.

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 explicit when-to-use guidance, particularly for step_count: 'Only use it when the user explicitly says they walked steps their device did NOT capture' and when NOT to use it ('If the user says sync is wrong… do NOT pass step_count'), directing the agent to investigate device-level sync issues instead. It also clarifies that other fields are safe for corrections, giving clear alternative actions.

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

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

Beyond annotations (which only indicate non-read-only, non-idempotent, non-destructive), the description discloses key behaviors: conflict detection with warning and required user action, inference of dates and ratings without asking, and flexibility to log a subset of rating fields. This is valuable context not available in structured fields.

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 a clear purpose statement upfront, followed by usage triggers, conflict behavior, and inference rules. Each section earns its place, and the formatting (line breaks, dashes) improves readability without 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 has an output schema (not shown but noted), the description need not detail return values. It covers all essential runtime aspects: period handling, conflict resolution, inference guidance, and parameter flexibility. For a logging tool with this complexity, the description is 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?

Although the schema already covers all seven parameters with descriptions, the description adds significant semantic enrichment: defaults for period_start/end, concrete rating inference examples ('exhausted'=2, 'great energy'=8), and explicit permission to log any subset. This goes well beyond the schema's field descriptions.

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

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

The description opens with a specific verb and resource: 'Log subjective wellbeing ratings for a day, week, month, or custom date range.' It clearly distinguishes from sibling tools by focusing on subjective feelings (energy, mood, stress, soreness) and supporting both single-day and period entries.

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 to use: 'Use when the user describes how they feel.' It also provides detailed inference rules ('INFER — do not ask') and explains the conflict behavior, giving clear guidance on handling overlapping entries by updating/deleting first.

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

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

Beyond the annotations (readOnlyHint false, idempotent false), the description discloses key behaviors: it matches exercise names silently ('Don't ask before logging, match silently and log'), explains literal_name skips resolver and 'gets no NSI score', reveals that equipment mistakes 'silently halves or doubles NSI', describes parsing shorthand like '3 sets of 15 reps', and states that it returns the new session ID. It also exposes inference logic (date, focus_type, is_bodyweight, superset_group, slot_type) and RPE scale interpretation.

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 lengthy but well-structured with clear sections (EXERCISE NAMES, EQUIPMENT, SETS, INFER, RPE, ASK, RETURNS) and front-loaded with the main purpose. Each section holds necessary domain rules, but some content is redundant with the schema (e.g., RPE scale is repeated in both the description and schema). The length is justified by the tool's complexity, so it earns a 4 rather than a lower score.

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 (8 parameters, rich nested sets array, no output schema beyond the returned ID), the description covers all necessary context: how to call list_exercises, inference rules, ask behavior, RPE semantics, return of '[ID NN]', and follow-up tool routing. It addresses edge cases like isometric holds and loaded carries, making it complete for an agent to invoke correctly.

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

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

Despite 100% schema description coverage, the description adds substantial meaning beyond the schema. For example, for 'equipment' it elaborates dumbbell_pair vs dumbbell_single laterality semantics; for 'sets' it clarifies isometric holds (hold_length_sec), tempo/pause, loaded carries (per hand vs total weight), and distance goes in notes; for 'literal_name' it explains when to set it ('call it exactly X'); for 'weight_lb' it mandates pounds even if user gives kg. These enrich the skeletal property descriptions.

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

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

The description opens with 'Log a complete workout session: exercises, sets, reps, weights, and session metadata.' This is a specific verb+resource statement that clearly distinguishes it from sibling tools like log_run, list_workouts, and update_workout. It also states concrete use cases: 'Use when the user describes finishing a workout, lists exercises performed, or asks to log training.'

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

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

The description gives explicit when-to-use guidance ('Use when the user describes finishing a workout...') and provides inference/ask rules: 'INFER — do not ask' lists fields to infer, while 'ASK (single batched question) only if missing and not inferable' specifies when to ask. It also mentions follow-up tools: 'Pass it to update_workout / delete_workout / get_workout / add_exercises for follow-ups in this conversation,' which implicitly differentiates this logging tool from update/delete 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?

Beyond the destructiveHint annotation, the description discloses key behaviors: inference of category and schedule, defaulting of start_date, the requirement to ask only if name is missing, and the detailed follow-up confirmation flow after an add. It even mandates a second tool call for corrections. The description adds substantial behavioral context beyond 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?

While the description is longer than typical, every sentence provides necessary operational guidance. The structure is logical: first usage scope, then parameter defaults, then prerequisites, then detailed post-add interaction. No filler or redundancy, and the embedded example makes the expected behavior concrete.

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 11 parameters, three enums, a destructive annotation, and an output schema, the description covers all essential operational aspects: when to use, prerequisites, inference defaults, and required follow-up actions. It is fully complete for an AI agent to select and invoke correctly.

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

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

Although the schema already covers 100% of parameters, the description enriches semantics with inference rules: 'Infer category from name, start_date defaults to today, infer schedule from context.' It also clarifies that id is required for non-add actions and explains the defaulting behavior for schedule fields in the post-add restatement. This goes well 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 opens with a specific verb set ('Add, update, end, or delete a recovery/mindfulness strategy') and clearly identifies the resource. It distinguishes from siblings like list_recovery_strategies by focusing on mutating actions, and the scope matches the tool name.

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

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

It provides explicit when-to-use guidance: 'Use when the user describes a new practice, changes a schedule, stops a practice, or removes one.' It also gives a clear alternative/precondition: 'For update/end/delete call list_recovery_strategies first.' This is exemplary usage 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 indicate destructiveHint=true, but the description goes further by explaining the nuanced behaviors: the difference between 'end' (set end_date) and 'delete' (remove record), default values for start_date/end_date, and the workflow of calling list_supplements before any mutation. This contextualizes the mutation semantics and inference logic, adding substantial value beyond the annotation flags.

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 structured into clear sections (purpose, use-when, INFER, ASK, REQUIRED), with each section serving a distinct purpose. It is detailed yet focused; every sentence adds operational value without redundancy. The front-loaded summary and subsequent rules make it easy to parse.

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

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

Given the tool's complexity (17 parameters, 4 actions, multiple inference rules), this description is remarkably complete. It covers when and how to use the tool, default behaviors, ambiguity handling, and prerequisite calls. The presence of an output schema means return-value details don't need to be in the description, so the context provided is sufficient for correct invocation.

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

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

The input schema already provides 100% parameter coverage, but the description adds high-value semantic guidance: how to infer the 'action' parameter, default category to 'supplement', default date handling, and the requirement that 'id' comes from list_supplements. This goes well beyond the schema descriptions, turning raw parameters into actionable rules.

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

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

The description opens with a specific verb and resource: 'Add, update, end, or delete a medication or supplement.' This clearly states the tool's function and distinguishes it from sibling tools like log_supplement_taken, which logs an intake event rather than managing the supplement record. The purpose is unambiguous and directly aligned with the tool name.

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

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

The description gives explicit when-to-use conditions: 'Use when the user describes their stack, adds a new item, changes a dose or schedule, says they stopped taking something, or wants to remove an entry.' It also provides inference rules (INFER section) and tells the agent when to ask the user, plus a required prerequisite for update/end/delete: call list_supplements first. This is thorough guidance with no ambiguity about alternatives.

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

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

The description adds meaningful behavioral detail beyond the readOnly and idempotent annotations, such as 'Interactive: 7d/30d/90d/1y range toggle and hover tooltips; returns a short text summary alongside the chart.' However, it contains an inconsistent range list ('30/90-day/1-year' vs '7d/30d/90d/1y'), which slightly muddies the 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 repeats range-toggle information twice: 'with a 30/90-day/1-year range toggle' and 'Interactive: 7d/30d/90d/1y range toggle'. It also uses the vague phrase 'when the user asks about this', making it less concise than it could be.

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 and annotations covering safety, the description adds value by explaining the chart output, interaction, and text summary. The inconsistent range list is a gap, but overall the description is complete for a display-focused 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?

The input schema fully documents the sole parameter 'range' with an enum and a description ('Time window. One of 7d, 30d, 90d, 1y.'), so schema coverage is 100%. The description only mentions 'range toggle' and does not add default or additional formatting semantics 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 'Show the user their body weight (and body-fat %) trend over time as an interactive line chart', making the tool's specific verb, resource, and output format clear. It also distinguishes from text-based responses by saying 'prefer calling this tool and rendering the chart over describing the numbers in text.'

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

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

The description gives explicit usage guidance: 'When the user asks about this, prefer calling this tool and rendering the chart over describing the numbers in text.' It does not explicitly name or exclude sibling tools like list_body_metrics, so it lacks a direct alternative comparison.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, while the description adds valuable behavioral details beyond that: it is interactive (hover tooltips, range toggle), returns a short text summary alongside the chart, and defaults to the most-logged lift. This gives the agent a richer model of the tool's runtime 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 three sentences, front-loaded with the core purpose and then providing usage guidance and behavioral characteristics. Every sentence earns its place, and the structure is clear. The only minor issue is a redundant/inconsistent mention of date ranges ('30/90-day/1-year' vs. '7d/30d/90d/1y'), but this does not significantly harm clarity.

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 3 optional parameters, a rich output schema, and strong annotations, the description covers the essential contexts: purpose, when to use, interactivity, and output. It does not discuss data source limits or explicitly exclude sibling tools, but for a read-only visualization tool, it is sufficiently complete for correct agent invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions filters for date range and muscle group and an exercise picker, but the schema already documents each parameter thoroughly, including the default for exercise. The description adds little beyond rephrasing; it even omits the '7d' range when listing date options, a slight inconsistency.

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 function with a specific verb and resource: 'Show the user's estimated 1-rep-max progression for a lift over time as an interactive line chart.' This is distinct from list-type siblings. However, it does not explicitly differentiate from the close sibling get_exercise_history, instead relying on the chart/interactive language to imply the difference.

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

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

The description gives an explicit use case: 'Use when the user asks about progress on a specific lift (e.g. "how's my bench progressing").' It also states a preference to render the chart over text. However, it does not mention when-not-to-use or name alternative tools, so it falls short of a 5.

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

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

The description adds behavioral details beyond the annotations: it renders an interactive chart with range toggle and hover tooltips, and returns a text summary alongside the chart. Annotations already establish read-only and idempotent safety, so the description enhances transparency without contradicting them.

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

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

Two sentences with clear front-loading: the first sentence states the core function and components, the second adds usage preference and interactive features. Every word earns its place with no redundancy.

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

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

For a simple zero-parameter tool with annotations and an output schema, the description covers the essential aspects: what, when, and interactive behavior. The range toggle (7d/30d/90d/1y) creates slight ambiguity given the opening 'today's', but overall it is sufficiently 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 zero parameters, so the schema is empty. The description provides meaningful context about the chart output and components, but there are no parameters to elaborate on. Baseline 4 applies 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 tool shows today's Fit Score breakdown across six named components (Train, Sleep, Fuel, Recovery, Steps, Wellbeing) as an inline donut/radial chart. It uses a specific verb ('show') and resource, and distinguishes from the weekly sibling by specifying 'today's'.

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 says when the user asks about this, prefer calling this tool and rendering the chart over describing numbers in text, providing clear context for use. However, it does not explicitly mention alternatives like show_week_fit_score for weekly breakdowns, so no exclusions are stated.

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

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

Key behaviors are disclosed: interactive dual-line chart, range toggle, hover tooltips, and a returned text summary. These details go beyond the read-only, idempotent, and non-destructive annotations, providing actionable expectations for the agent.

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-load the core purpose and then add interaction/return details. No filler or repetition; every sentence earns its place.

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

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

For a simple tool with one optional parameter, the description covers purpose, usage guideline, interaction behavior, and return summary. Combined with comprehensive annotations and an existing output schema, nothing 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?

The single optional 'range' parameter is fully covered by the schema with an enum and description. The tool description reinforces the range options ('30/90-day/1-year range toggle') but does not add new semantic meaning. Baseline 3 applies due to the 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 it shows resting heart rate and HRV recovery trend as an interactive dual-line chart. It distinguishes itself from sibling show/list tools by specifying the recovery metrics and chart 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 explicitly advises using this tool when the user asks about recovery trends and prefers chart rendering over text. It does not name specific alternative tools, but the context is clear among the sibling tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds behavioral context about the interactive chart (range toggle, hover tooltips) and the accompanying text summary, complementing the annotations without contradiction.

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

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

The description is concise, using only two sentences to convey the core function, usage preference, and interactive features. It front-loads the primary purpose and avoids extraneous information.

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

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

The description covers purpose, usage, and output format, which is largely sufficient given the simple one-parameter schema and output schema. However, the '14 days' vs '30d' default mismatch leaves a gap in understanding the actual default view, slightly undermining 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 schema already fully documents the 'range' parameter with enum and default (30d). However, the description says 'over the last 14 days,' which is not an enum option and contradicts the schema's default of 30d. This creates confusion about the initial time window and misleads the agent regarding parameter behavior.

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: 'Show the user their running mileage over the last 14 days as an inline bar chart.' This specifies the verb (show), resource (running mileage), and output format (inline bar chart), distinguishing it from sibling tools like list_runs which likely provide textual listings.

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 explicit usage guidance: 'When the user asks about this, prefer calling this tool and rendering the chart over describing the numbers in text.' This tells the agent when to use the tool and offers an alternative (describing in text), though it does not name specific sibling tools or exclusion conditions.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the tool's safety is known. The description adds valuable behavioral details beyond annotations: it mentions the interactive range toggle, hover tooltips, and that it returns a short text summary alongside the chart. No contradiction with annotations.

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

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

The description is three concise sentences, front-loaded with the core purpose, followed by usage guidance and behavioral detail. Every sentence adds value with no 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?

This simple tool has one optional parameter, clear annotations, and an output schema. The description fully covers what the tool does, how to present it, the interactive behaviors, and the accompanying summary. No critical information is missing for an agent to invoke it correctly.

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

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

Schema coverage is 100% and the parameter 'range' has a clear description in the schema (time window with enum values and default). The description adds minimal extra meaning by referencing the range toggle, but does not clarify semantics beyond what the schema already provides.

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

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

The description clearly states the tool shows the user's past 7 days of daily Fit Score as an inline chart, with a specific verb ('show'), resource ('daily Fit Score'), and format ('inline chart'). It distinguishes from siblings by mentioning the 0-100 composite and chart rendering, and the name aligns with show_week_fit_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?

Provides explicit guidance to prefer this tool over describing numbers in text, which is a clear usage directive. It does not explicitly mention alternatives like show_fit_score_breakdown, but the 'prefer calling this tool' statement gives context for when to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral context beyond annotations: the chart is interactive with range toggle (7d/30d/90d/1y) and hover tooltips, and it returns a text summary alongside the chart. No contradiction with annotations.

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

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

Three sentences, front-loaded with the main purpose, then usage guidance, then interactive details. Every sentence adds value with no 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?

Tool is simple (1 optional parameter, output schema exists). Description explains the output (chart + text summary), interactivity, and default range. Nothing crucial is missing that isn't covered by schema or annotations.

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

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

Schema description coverage is 100% for the single parameter 'range', which has an enum and a clear description. The description mentions a range toggle but does not add extra meaning beyond what the schema already provides, so baseline 3 is appropriate.

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

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

Description clearly states the tool shows the user their past 7 days of calories and macros (protein, carbs, fat) vs targets as an inline chart. The verb 'show' and specific resource (macros/calories) distinguish it from sibling tools like show_week_sleep or show_week_steps.

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 explicit guidance to prefer this tool and rendering the chart over text description when the user asks about this. It does not name alternative tools, but the context of comparing to text is clear. No exclusions or alternative tool names given, so not a full 5.

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

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

Annotations already declare read-only/idempotent/non-destructive, so the bar is lower. The description adds valuable behavioral context: an interactive chart with '7d/30d/90d/1y range toggle and hover tooltips' and a 'short text summary alongside the chart', which exceeds the 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?

Three sentences, each earning its place: purpose, usage preference, and behavioral details. No redundancy or filler, well-structured for quick parsing.

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

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

For a simple one-parameter tool with output schema and robust annotations, the description provides complete context: what it shows, how to present it, interactive behavior, and output summary. Nothing essential is missing.

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

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

Schema coverage is 100% with range described as 'Time window. One of 7d, 30d, 90d, 1y. Default 7d.' The description mentions the range toggle, which adds minor context about interactivity, but does not significantly enhance the schema's parameter documentation.

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