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

The annotations already mark this as destructive and non-read-only, so the description adds valuable detail by disclosing that entries/sets are deleted alongside the session and that a boolean is returned. This exceeds the annotation baseline without contradicting it.

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

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

The description is two sentences with no filler. The first sentence communicates the action and scope, and the second states the return value. 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 one-parameter destructive tool with an output schema and safety annotations, this is nearly complete. The only notable gap is the lack of any note about how to obtain or supply session_id, but the low complexity keeps this minor.

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

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

Schema description coverage is 0%, so the description needed to compensate. It does refer to 'a session', which loosely maps to session_id, but it provides no format, provenance, or additional meaning beyond the schema's string type and parameter name.

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 verb 'Delete' and the resource 'a session', and further clarifies the scope by adding 'and all its entries/sets'. This makes it clearly distinct from sibling tools like update_session or get_session.

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

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

No guidance is given about when to use this tool versus alternatives, when not to use it, or what prerequisites exist. The description implies usage through its title, but it does not actually provide usage conditions or 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?

The readOnlyHint annotation already discloses that this is a safe read operation. The description adds one behavioral detail, 'newest first,' which is useful, but it does not mention pagination behavior or any other side effects. Given the strong annotation coverage, this is adequate but not exceptional.

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 five words long, front-loads the main verb and resource, and includes the most important behavioral modifier. Every word earns its place with no repetition or filler.

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

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

For a simple list tool with one optional parameter, a readOnlyHint annotation, and an output schema, the description is mostly complete. The only notable gap is the lack of explanation for the limit parameter, but the schema's name and default provide enough context for an agent to 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?

Schema description coverage is 0%, and the description does not explain the only parameter, 'limit.' While the name and default value in the schema provide some hint, the description fails to compensate for the low schema coverage by stating how the limit affects results.

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

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

The description states a clear verb and resource: 'List body measurements.' It also adds the ordering behavior 'newest first,' making the tool's purpose immediately identifiable. This differentiates it from sibling log_body_metric, which is clearly a write 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?

The description implies usage for reading body measurements through the verb 'list,' and the readOnlyHint annotation reinforces this. However, it does not explicitly mention when not to use it or point to a sibling alternative such as log_body_metric for logging measurements.

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 readOnlyHint annotation, the description reveals important behavior: if intake is incomplete it returns the intake flow instead with intake_required=true, and that constraints shape generation without touching the profile. This adds valuable context well beyond what annotations provide, and does not contradict the readOnlyHint.

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 yet covers all critical points in four sentences. It front-loads the main purpose, then gives usage timing, behavior nuance, and parameter clarification. Each sentence earns its place with no redundant filler.

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

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

Given the tool's simplicity (2 params, one enum) and the existence of an output schema, the description fully covers what an agent needs to know: what it returns, when to call it, how to handle incomplete intake, and what constraints affect. It even points to the sibling tool for durable facts. 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?

The description explains the `constraints` parameter in detail: 'TODAY-ONLY circumstances... shape this generation without touching the profile.' It does not explicitly describe the `task` parameter, but the schema's enum provides the allowed values. Since schema coverage is 0%, the description partially compensates, though it could be more explicit about the role of `task`: it only hints at it via 'for the task'.

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 exactly what the tool returns: 'Coaching instructions + this user's fresh training context for the task.' It uses a specific verb and resource, and explicitly distinguishes itself from update_coach_profile by noting durable facts go there instead. The agent can clearly tell this tool apart from siblings without opening the schema.

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

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

It explicitly instructs to 'Call at the start of any coaching conversation' and specifies when not to use it: 'durable facts go through update_coach_profile instead.' It also clarifies that constraints are only for today-only circumstances, which narrows the appropriate usage context. This leaves no ambiguity about when this tool should be selected.

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, which covers the safety profile. The description adds the valid status values (active, achieved, abandoned, revised, all) but does not disclose any other behavioral traits such as pagination, ordering, or whether it returns a list. With the output schema presumably documenting return structure, this is adequate for a simple read 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 a single sentence that front-loads the resource ('user's goals') and immediately provides the critical parameter options. There is no waste; every word contributes to the agent's understanding of the tool's purpose and the parameter's valid values.

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 tool with one optional parameter and an existing output schema, the description covers the essential aspect (status values). It does not mention any side effects or prerequisites, but given the readOnlyHint and the schema, nothing else seems necessary. The only minor gap is the lack of explicit statement about returning a collection, which is likely clear from the output schema.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining the 'status' parameter. It explicitly lists the allowed values (active|achieved|abandoned|revised|all), which is essential for correct invocation. It does not explain the meaning of each value, but the values are self-explanatory and the default 'active' is 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 identifies the resource as 'the user's goals' and lists the status filter options. It distinguishes from sibling write tool 'upsert_goal' by implying a read operation, and the title 'Get goals' reinforces the purpose. However, it does not explicitly use a verb like 'retrieve' or 'list', leaving the action slightly implied.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. While the read-only nature and sibling 'upsert_goal' make it obvious for reading goals, there is no mention of when to use it over other getters or any conditions. The usage context 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?

Annotations already declare readOnlyHint=true, and the description adds the key behavioral detail that the tool returns null when no active program exists. It also warns against inventing programs, which is valuable behavioral context beyond the annotation. However, it doesn't detail the exact structure of the returned day templates or targets, 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 compact and front-loaded: it states the primary purpose first, then the null behavior, then the fallback action, and finally the edit path. Every sentence 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 zero-parameter read-only tool with an output schema, the description covers the essential context: what it returns, what happens when there's no active program, and how to proceed in that case. The guidance to avoid inventing programs is critical for an AI agent and is clearly stated.

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 trivially complete. The description adds meaning by explaining what the returned data represents (day templates, planned blocks/supersets, per-exercise targets), which is more useful than the empty schema alone.

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

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

The description clearly states the tool retrieves the active training program including day templates and per-exercise targets, and explicitly notes it returns null when no active program exists. This distinguishes it from sibling tools like get_session or get_sessions, which focus on logged sessions rather than the program structure.

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 guidance: if no active program exists, the agent should call get_coaching_context(task='new_program') and follow it, and must never invent a program from generic knowledge. It also mentions editing via import_document, giving clear direction on when to use this tool versus alternatives.

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

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

Annotations already declare readOnlyHint: true, so the safety profile is known. The description adds value by disclosing what the response will contain (nested entries, sets, cardio, wearable metrics), which is behavioral information beyond the annotation. It does not mention error cases or side effects, but for a read-only fetch this is adequate.

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

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

The description is a single, focused sentence that front-loads the verb and resource, then adds the key detail about what is included. There is no wasted wording, and it is easy to parse quickly.

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

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

For a simple read-only tool with one parameter and an output schema, the description covers the core purpose and return content. It does not mention potential errors or the exact format of session_id, but these are minor given the simplicity. The presence of an output schema reduces the need to explain return values in detail.

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

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

Schema description coverage is 0%, so the description must compensate. It does not explicitly describe session_id, but the tool name and the phrase 'Get one session' imply the parameter identifies the session. The single parameter is simple and its purpose is obvious, so the minimal added semantics are acceptable but not enhanced.

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

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

The description clearly states the verb 'Get' and the resource 'one session', and specifies what is included ('full nested entries, sets, cardio and wearable metrics'). It distinguishes from the sibling get_sessions (plural) by emphasizing 'one session', 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 provides clear context for when to use this tool—when a single session's full details are needed—implicitly contrasting with get_sessions for listing. However, it does not explicitly mention alternatives or exclusions, 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?

The description mentions the ordering (newest first) and the optional date range, which adds some behavioral context. It does not disclose pagination behavior or any other side effects, but since the tool has readOnlyHint=true, the main missing context is whether the 'total volume' is computed or stored, and how the date range interacts with the ordering. The description is adequate but not detailed.

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

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

The description is concise and to the point, stating the verb, resource, key features (summary fields, total volume), and the ordering. The optional date range is mentioned, but the description is not front-loaded with the most critical information for an agent, though it is 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 that the tool has an output schema (which the description need not duplicate), the description covers the essential purpose and key parameters. It lacks explicit pagination information and the exact format of the date range, but these are minor for a read-only list tool. Overall, it is complete enough for an agent to understand the tool's function.

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

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

The input schema has 3 parameters with 0% coverage, and the description only mentions 'Optional date range' which partially maps to date_from and date_to. It does not explain the 'limit' parameter at all, and the date range parameters are not given specific format hints beyond what the schema already provides. Since the schema coverage is low, the description compensates somewhat but not fully.

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: listing workout sessions with summary fields and total volume, and it indicates that it returns sessions newest first, which distinguishes it from the sibling get_session (which likely returns a single session). However, it does not differentiate from other list-type siblings like get_body_metrics or list_exercises, though those clearly target different resources.

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

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

The description mentions an optional date range, which implies the tool can be used to retrieve sessions within a specific time period enfermedades, but it doesn't explicitly state when to use this tool versus alternatives like get_session or get_stats. The context of listing sessions is fairly clear, but no explicit exclusions or alternative routing is provided.

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

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

Annotations declare readOnlyHint=true, and the description reinforces this as a read-only statistics operation. It adds important behavioral nuance beyond the schema: the error condition for missing exercise_id, the fact that exercise_id is ignored for volume, and what each kind returns (top set, est-1RM, volume, PRs, trend %).

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 packed but not bloated; every sentence conveys a distinct requirement or routing rule. It front-loads the core purpose, then the critical exercise_id constraint, then kind semantics, then the alternative tool recommendation. 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?

With an output schema present and readOnly annotations, the description covers the essential operational context: parameter constraints, per-kind behavior, error handling, and when to choose a sibling tool. An agent has enough information to call this tool correctly and avoid common mistakes.

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

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

Schema description coverage is 0%, so the description must carry the semantic weight. It thoroughly explains kind's three enum options and the required/ignored behavior of exercise_id. However, date_from is not explicitly described as a filter or range, leaving one parameter partially underspecified.

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 precise statement: 'Statistics for ONE exercise, or for training as a whole,' and then enumerates the three kinds with distinct meanings. It clearly distinguishes this tool from its siblings, especially get_coaching_context, and from list_exercises which is referenced as a helper rather than a substitute.

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 exercise_id is required, when it is ignored, and what happens if the caller omits it for progression/prs. It also gives direct routing advice: use get_coaching_context for coaching decisions Finding the right alternative is fully supported.

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 state readOnlyHint=false and destructiveHint=false, giving minimal behavioral information. The description adds crucial details: active programs are validated server-side before anything is saved, and a response with ok=false and a violations list means nothing was written. This atomicity disclosure is valuable and goes beyond what annotations provide.

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

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

The description is three sentences long, with the purpose front-loaded in the first sentence, prerequisites in the second, and failure behavior in the third. Every sentence provides necessary information without repetition or filler, making it dense yet efficiently organized.

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

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

For a complex tool with a large nested schema, the description covers the most critical preconditions (program approval, validation) and failure atomicity, but it omits practical details like how ids are handled (existing vs new records), whether the import merges or replaces data, and what a successful response implies. Since an output schema exists, return values are covered, but the missing upsert semantics and id behavior leave an agent somewhat uncertain about side effects.

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

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

Schema description coverage is 0%, so the description must compensate for the single 'document' parameter. It lists only four of the seven top-level sections (exercises, sessions, body metrics, programs) and omits 'schema_version' (a required field), 'athletes', 'day_templates', and 'metadata'. This incomplete mapping leaves agents to infer the full document structure from the schema alone, with little guidance on key prerequisites like schema_version.

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 'Bulk-import a full workout document (exercises, sessions, body metrics, programs)', stating a specific verb, resource, and scope. This clearly differentiates it from sibling tools like log_session and log_body_metric, which handle single entities. The word 'full' signals the tool's bulk nature.

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 a concrete prerequisite: programs must be designed via get_coaching_context(task='new_program') and explicitly approved by the user before importing. It also names review_program_draft as the validation reference, providing context on when this is appropriate. It implies the bulk-vs-single distinction through its opening phrase, though it doesn't explicitly enumerate when to use alternatives.

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

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

Annotations already declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds useful context about the returned metadata (instructions / video_url / image_url / pool_slug) and the filtering behavior. However, it doesn't disclose pagination, ordering, or whether the returned list is exhaustive. With annotations covering the safety profile, a 3 is appropriate.

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: it states the core purpose first, then the filters, then the usage routing. Every sentence earns its place, and the sibling distinction is included without bloat.

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

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

The description covers the tool's purpose, scope, filters, and relationship to the sibling search_exercise_pool. An output schema exists, so return values need not be described. The only minor gap is the lack of detail on filter value formats, but the overall context is sufficient 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?

Schema description coverage is 0%, so the schema provides no parameter documentation. The description compensates by listing the four filter names and explaining that `query` is a substring of the name or id. However, it doesn't explain the expected format for `muscle`, `equipment`, or `movement_pattern` (e.g., exact values vs. free text), leaving some ambiguity. This is partial compensation for the schema gap.

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

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

The description states a specific verb ('List'), a specific resource ('THIS USER's own exercise catalog'), and the scope ('what they have actually trained'). It also names the sibling it is not ('use search_exercise_pool to choose a NEW exercise'), which distinguishes it from the closely related search_exercise_pool tool.

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 this tool ('Use this to reuse an id the user already has') and when to use the alternative ('use search_exercise_pool to choose a NEW exercise'). This is clear routing guidance that leaves nothing to inference.

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

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

Annotations only convey readOnlyHint=false and destructiveHint=false; the description carries the real behavioral load, and it does so richly: same-date recording ADDS to the entry, omitted fields keep their stored value, repeated keys are overwritten ("how a wrong number is corrected"), null clears a field, and "There is no delete." These merge semantics are exactly what an agent must know and are not derivable from the annotations. No contradiction — the write intent matches readOnlyHint=false and the overwrite/no-delete behavior is consistent with destructiveHint=false.

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 (~120 words) but every sentence carries a distinct, load-bearing fact — purpose, routing, data-flow consumer, merge semantics, null-clearing, return value, no-delete. It is front-loaded with purpose and routing before the dense behavioral rules. It forfeits a 5 only because it is a single unbroken paragraph; the density is justified by the genuinely complex merge 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?

For a nested, merge-semantics tool with an output schema present, the description covers everything an agent needs to call it correctly: when to use it, what it returns ("Returns the whole stored entry for that day"), the additive overwrite behavior, null-clearing, and the no-delete constraint. The return value is stated even though an output schema exists, and the id semantics are cross-referenced to import_document. 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?

The top-level `metric` parameter has no schema description (0% coverage), so the description must compensate, and it does by adding the behavioral layer absent from the schema: the date-keying rule, the merge-on-repeated-date behavior, null-clearing, and the id-vs-date distinction tied to import_document. The nested properties are already well described in the schema (units, ranges, field meanings), so the description need not repeat them; it adds genuine semantic value on top rather than restating 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?

Opens with a specific verb+resource: "Record the user's body weight, body-fat % or circumferences for one day." It then explicitly names the siblings it is not — "training goes to log_session, and reading measurements back is get_body_metrics" — so an agent can disambiguate without inspecting other definitions. The scope (one day, keyed by date) is stated up front.

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

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

Gives an explicit trigger — "Use it whenever the user states a current measurement" — and names the alternatives with their routing conditions: log_session for training, get_body_metrics for reading back, and import_document for id-copied entries. The when-not is fully specified and matches the sibling names, leaving nothing to inference.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the description doesn't need to restate mutation. It adds useful behavioral context: each call appends a new entry, the history is kept with the user's data export, no tool reads it back, and it does not replace saving facts through update_coach_profile or upsert_goal. It also discloses the return value ('Returns the stored event').

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 dense but well-organized: it front-loads the core action, then gives usage timing, exclusions, duplication warning, persistence context, and return value. Every sentence earns its place, though it is slightly long and could be tightened.

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

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

For a 2-parameter tool with 100% schema coverage, an output schema, and annotations, the description covers everything an agent needs: what to record, when to call it, when not to, how to avoid duplicates, what the payload should contain, and what the tool returns. No critical gap remains.

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 both parameters. The description adds value by explaining the payload's purpose in context ('the gist, in the user's language') and giving concrete examples for goal_review and deload_advised/red_flag_raised, which goes beyond the schema's generic 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 uses a specific verb ('Append a dated milestone') and names the exact resource ('the user's coaching history'), then enumerates the concrete event types it records. It also explicitly distinguishes itself from siblings like log_session and upsert_goal, so an agent can tell them apart without opening the schema.

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

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

It gives explicit when-to-call guidance ('at the end of the step the coaching prompt names'), gives concrete examples (type='checkin' after a check-in), and names exclusions ('not for ordinary chat, logged workouts (log_session) or goal edits themselves (upsert_goal)'). It also warns against duplicate calls ('do not repeat one').

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 reveals significant side effects and response traits beyond the sparse annotations: it auto-creates exercise catalog entries, returns a coach_hint with explicit handling guidance ('offer once, never push'), and exposes the rendering impact of missing duration. Since annotations only indicate readOnlyHint:false and destructiveHint:false, the description carries the full burden and does so well. 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?

Four sentences, each earning its place: purpose, return value, coach_hint behavior, routing to alternative, and a critical parameter instruction plus consequence. Information is front-loaded and no filler or repetition is present.

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 a complex nested session object, an output schema, and sparse annotations, the description covers the key operational aspects an agent needs to call this correctly: what to include, what returns, how to handle coach_hint, when to route elsewhere, and a crucial parameter prerequisite. The output schema handles return-value details, so the description is complete without over-explaining.

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

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

Schema description coverage is 0%, so the description must compensate. It adds a high-level structural map ('exercises → sets, cardio, wearable metrics') and specifically instructs setting duration_sec. However, it leaves the many nested fields (status, tags, metrics subfields, etc.) to the schema's names and types, which only partially suffice. It provides some added meaning but not a thorough semantic layer.

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 a completed workout session' followed by a clear enumeration of contents ('exercises → sets, cardio, wearable metrics'). It distinguishes itself from siblings by explicit routing to get_coaching_context for planning, clarifying this tool is for logging completed sessions. The return behavior (stored session, auto-created catalog entries) further sharpens the picture.

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 a different tool: 'If the conversation is about PLANNING training (not just logging), call get_coaching_context first.' It also provides a concrete pre-call instruction: ask for session duration or estimate it from set count, and warns about the consequence of omitting duration_sec. This gives an agent clear direction on both invocation and preparation.

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

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

The readOnlyHint annotation already signals no mutation; the description reinforces this with 'saves nothing' and discloses the return shape {ok, violations, warnings}. It also reveals what the tool checks (weights, equipment, session length, weekly days, injury conflicts), going beyond the annotation without contradicting it.

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 carry the full story: what it is, when/how to call it, what it checks, what it returns, and that it persists nothing. Every sentence earns its place and the most decision-relevant info is front-loaded.

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

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

For a complex nested-parameter tool with an output schema available, the description covers the essential workflow, return contract, and side-effect profile. The agent knows when to invoke it, what to pass, what to expect back, and what to do next — nothing critical is missing.

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

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

With 0% schema description coverage, the description compensates by explaining that the single 'document' parameter should be the same WorkoutDocument the agent intends to import. This adds real semantic guidance beyond the raw schema, though it does not detail the document's internal subfields — the nested schema itself covers those.

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

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

The description states a specific verb ('review'), a specific resource ('DRAFT training program'), and a concrete server-side behavior (checklist). It differentiates this from import_document by framing it as a pre-import validation step, and from get_program by making clear it operates on a draft, not an existing program.

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

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

It gives explicit when-to-use guidance: call it with the same WorkoutDocument intended for import, before presenting the draft to the user, and re-check after fixing violations. It does not explicitly list when-not-to-use scenarios or name alternatives, but the pre-import workflow is clear enough to route an agent correctly.

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 annotation readOnlyHint=true already indicates a safe read operation. The description adds value by specifying semantics like 'equipment' filtering (only fully covered exercises) and the meaning of 'in_user_catalog'. It also explains that slugs are canonical and should be reused, which is useful behavioral context. It doesn't contradict the annotation, and while it could mention pagination or rate limits, the current disclosure is strong for a read-only search.

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

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

The description is a single paragraph but is reasonably concise, with key information front-loaded ('Search the curated global exercise pool'). It packs many details without redundancy. However, it is somewhat dense and might be slightly overlong given the complexity, but each sentence contributes value (filter criteria, slug reuse, exclusion).

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 (7 optional parameters, output schema exists) and the readOnlyHint annotation, the description covers the essential aspects: filter semantics, output fields (slug, localized name, muscles, defaults), and usage context. The output schema presumably details return values, so the description doesn't need to. It also includes the important instruction about reusing slugs, which is critical for downstream tools.

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

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

The input schema has zero descriptions, so the description must clarify parameters. It covers each parameter with concrete examples ('muscle' e.g. 'lats', 'side_delts'), clarifies that equipment is a list of what the user has with the 'fully covered' semantic, and explains the 'query' parameter (name in any supported language). This adds significant meaning beyond the raw schema, though 'limit', 'locale', and 'movement_pattern' are not individually detailed, but the overall guidance compensates.

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: searching the curated global exercise pool for building programs or workouts. It specifies the resource (exercise pool), the action (search), and the context (the place to pick exercises from). It distinguishes itself from siblings like list_exercises by emphasizing the curated global pool and the reuse of canonical slugs.

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 tells the agent when to use this tool ('THE place to pick exercises from when building a program or a workout') and even provides an exclusion criterion ('Invent your own exercise only when nothing here fits'). This gives clear routing guidance, especially given the presence of sibling tools like list_exercises and upsert_exercise.

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, the description discloses important side-effect behavior: null fields are CLEARED while omitted fields are untouched, and the write is persisted and feeds the app's UI. It also explains what is returned (updated profile, changed fields, ui_impact) and instructs the agent to confirm to the user that the answer was saved. This is consistent with readOnlyHint=false and idempotentHint=true.

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 dense but every sentence carries essential guidance: when to invoke, how to batch, how to handle injuries, patch semantics, return value, and required user confirmation. It is front-loaded with the core purpose and action trigger.

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

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

For a complex tool with a large nested schema and an output schema, the description covers invocation timing, field-level semantics, special injury routing, return information, and expected user-facing confirmation. Nothing critical is missing for an agent to call this 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 schema coverage is 100%, the description adds crucial semantics the schema cannot express: null means clear, omitted means untouched, and the patch should contain only the facts confirmed in the current turn. It also clarifies that injuries are handled through specific sub-fields rather than generic profile 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 states a specific verb ('Persist facts the user confirmed') and a clear resource (coaching profile), enumerating the fact types (goal, experience, schedule, equipment, injuries, preferences). It distinguishes itself from sibling update/upsert tools by clearly scoping to the coaching profile and its confirmed-facts use case.

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-call guidance: 'Call as soon as a fact is confirmed', with one fact per call, no batching, and mid-workout support. It also routes injury updates explicitly via add_injuries versus resolve_injury_areas, and clarifies patch semantics with null-clearing versus omission.

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 the operation is not read-only, is idempotent, and is not destructive, so the description does not need to restate these. It adds a field-scoping constraint by listing allowed keys, which is useful, but it does not explain patch semantics such as merge vs replace or whether unknown keys are rejected.

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 one lean sentence followed by the allowed-key list, with no filler. The core action is front-loaded and every element 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?

The required session_id + patch shape and allowed keys are enough to construct a basic call, and an output schema exists to describe results. However, the description omits patch-merge semantics and any usage exclusions, which are meaningful for an update operation and are not covered by annotations or 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?

With 0% schema description coverage, the description must compensate for the generic patch/additionalProperties schema. Listing the allowed keys (date, duration_sec, status, etc.) gives real meaning to the patch parameter. It does not detail value formats or constraints for individual keys, and session_id is left to inference from its name.

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

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

The description names a specific verb ('Fix') and resource ('session-level fields'), and enumerates the exact keys that can be updated, so an agent can immediately recognize what the tool does. It also contrasts with the sibling update_set by scoping to session-level rather than set-level data.

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

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

The phrase 'session-level fields' implies the tool is for correcting/updating session data rather than logging a new session or updating sets, but there is no explicit when-to-use or when-not-to-use guidance and no sibling alternatives are named. Usage must be inferred from the field list.

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

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

Annotations already signal non-read-only, idempotent, non-destructive behavior. The description adds useful behavioral context beyond annotations: the exact patch key whitelist, the 1-based occurrence semantics for repeated exercises, and the return behavior ('updated set, or null if none'). 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 dense sentences with no filler. The purpose is front-loaded, allowed keys are compactly listed, and the non-obvious occurrence parameter is explained. 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?

The description covers the locating key, the mutation scope, allowed patch keys, duplicate-exercise handling, and return behavior. An output schema is present, so the absence of detailed return-field documentation is not a gap. An agent has enough to invoke this tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the patch object via an explicit allowed-key list and defines the 'occurrence' parameter precisely. The remaining parameters (session_id, exercise_id, set_number) are self-descriptive from their names, though the description does not elaborate on value formats.

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

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

The description states a specific verb ('Fix'), a clear resource ('a single set'), and an unambiguous locator ('session + exercise + set_number'). It also enumerates the allowed fields, which distinguishes it from session-level siblings like update_session.

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 clearly implies when to use the tool: when correcting a logged set's metrics. It does not explicitly name alternatives or list when-not conditions, but the scoping by session/exercise/set_number and the allowed patch keys give the agent sufficient context for selection.

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

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

Annotations already signal idempotentHint=true and destructiveHint=false, and the description adds genuinely new behavioral context: omitted fields are preserved, pool exercises keep one identity/history, and hand-written exercises leave the UI blank unless certain fields are provided. 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 focused sentences, each earning its place: the core upsert behavior, the pool-first workflow, and the required fields plus partial-update safety. Critical guidance is front-loaded before less common constraints.

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

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

For a complex nested-object tool, the description covers creation, update semantics, pool integration, required metadata, and partial-update behavior. An output schema is present, so the description does not need to explain return values, and the workflow guidance is sufficient for an agent to call this tool correctly alongside its siblings.

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

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

Schema description coverage is 0%, so the description must compensate, and it does for the most important fields: it explains the role of id and pool_slug, and mandates instructions, primary_muscles, category, and equipment for hand-written exercises. It does not explain every nested property, but the remaining property names are largely self-descriptive against the enum schemas.

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

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

States a clear action ('Create or update an exercise') on a specific resource ('the user's catalog'), and explains the keying mechanism ('by its id/name'). It also differentiates itself from search_exercise_pool by naming that sibling explicitly and positioning this tool as the write-side counterpart.

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

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

Gives explicit routing guidance: prefer the pool by calling search_exercise_pool first, pass the pool slug as id plus pool_slug, and only hand-write when the pool has nothing. It also states when full metadata is required and that partial updates are safe.

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, destructiveHint=false), the description discloses important side effects: setting featured=true automatically un-features any other active goal, the server rejects featured frequency goals, and unknown exercise IDs are rejected to avoid splitting exercise history. It also outlines the non-silent milestone transition workflow and the policy that goals are superseded rather than deleted. 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 long, but every section earns its place given the tool's complexity: create-vs-update distinction, goal_type shapes, validation rules, featured-goal side effects, lifecycle transitions, and coach-proposal handling. It is front-loaded with the most essential action and structured so an agent can quickly find the relevant constraint.

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

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

For a complex upsert tool with a nested target object, the description is complete: it covers field-level semantics, allowed values, server-enforced constraints, side effects, workflow sequencing, and domain heuristics like review_date cadence and milestone calibration. An output schema exists, so the lack of explicit return-value discussion is not a gap. An agent has enough context to invoke this tool correctly without additional probing.

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 0% schema description coverage, the description thoroughly explains the nested goal.target semantics: each goal_type variant (milestone, weekly_volume, trend, maintenance, frequency, and omitted goal_type), which fields each requires, and what values mean (e.g., mev|mev_mav|mav bands, tolerance_pct, supersedes_goal_id, featured, ratified). It adds meaning far beyond the raw schema enum names.

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: 'Create or update a training goal (pass `id` to update).' It clearly differentiates the tool from siblings like get_goals and upsert_exercise, and further disambiguates the many goal shapes via target.goal_type. The purpose is unmistakable and immediately actionable.

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 and when-not-to-use guidance: it tells the agent to check list_exercises and use upsert_exercise for genuinely new exercises, never to set featured on frequency goals, never to delete goals, and to call upsert_goal twice when transitioning an achieved milestone. It also specifies when to set review_date, featured, ratified, and supersedes_goal_id, making correct invocation conditions concrete.

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