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

Annotations cover the safety profile (destructive, non-idempotent, openWorld), and the description adds substantial context beyond them: rechecks of account/gym/membership/date/ownership/content, exactly one DELETE to a fixed verified endpoint, post-delete calendar read, and the warning that a reference or boolean alone is not proof of consent. It also flags that an absent row does not prove permanent deletion or RM-history effects.

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?

Dense but every clause earns its place, with the core confirmation requirement front-loaded before the recheck/retry caveats. Slightly long for a single tool, but 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?

For a destructive, non-idempotent write with an output schema (so return values need not be explained), the description covers prerequisites, consent, verification scope, single-attempt semantics, and read-back. Nothing an agent needs to invoke it safely 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 description coverage is 0%, so the description must carry parameter meaning. It explains actionReference must come fresh from prepare_activity_deletion and that confirmed: true accompanies the call, but it never defines sourceActivityId's role in matching the previewed entry, nor gymId, which the schema presents only as an opaque pattern. Partial compensation.

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 specific verb (delete) plus the exact resource/scope ('one exact own activity entry') and names the required precursor tool prepare_activity_deletion, cleanly separating it from the prepare_* siblings. An agent can identify the operation 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?

Explicitly requires a fresh prepare_activity_deletion reference, mandates showing the full preview and obtaining separate human confirmation of the exact entry before calling with confirmed: true, and states the retry prohibition ('an uncertain attempt must never be retried automatically'). It effectively defines when and when-not to call.

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?

Goes well beyond annotations (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false) by disclosing the full behavioral contract: rechecks source and preferences, sends at most one POST, reads back the calendar and detail, and treats a timeout or unverified read-back as uncertain and never retried automatically. This is exactly the kind of non-idempotent, side-effecting detail an agent needs.

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 dense sentences that are front-loaded with the core action and sequencing, and no filler. Slightly packed – the consent/precondition clause could be separated – but every phrase carries load.

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 non-idempotent open-world mutation with an output schema (so return values needn't be explained) and zero schema parameter coverage, it covers consent, sequencing, retry semantics and uncertainty well. It omits the meaning of confirmed and acknowledgePossibleDuplicate, which is a real gap for a write tool.

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

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

Schema description coverage is 0%, so the description must compensate, and it partly does – it references the preview's gym, source, date, variant, audience, WOD TV setting, results and the action reference. However, it does not explain the confirmed boolean const, or acknowledgePossibleDuplicate, leaving two parameters without meaning. Good but incomplete compensation.

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 specific verb (Publish) and resource (the fresh prepare_activity_publication preview), and explicitly ties it to the sibling prepare_activity_publication, distinguishing it from all other execute_* and get_* siblings. An agent can tell exactly what this does without opening other schemas.

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?

Clearly states the precondition (only after the MCP client shows the preview and obtains action-specific account-holder confirmation; a reference alone is insufficient consent). It does not explicitly name when-not to use it versus e.g. execute_booking_creation, but the dependence on a fresh prepare_activity_publication preview implies the alternative path.

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 (destructiveHint=true, idempotentHint=false), the description discloses meaningful behavior: it rechecks the reservation, sends at most one cancellation request, reconciles with fresh reads, and never retries automatically. It also transparently notes that only one standard cancellation branch was observed live and that late/other branches remain unverified, which is valuable cautionary 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 front-loaded with the core purpose and then adds only high-value safety and behavioral details. Each sentence earns its place, including the consent requirement, no-retry rule, and live-verification caveat, without padding 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 destructive, non-idempotent tool with an output schema, the description covers the essential operational context: consent proof, rechecking, single request, reconciliation, and the unresolved late-credit-loss branch. The presence of an output schema means return values need not be described, and nothing critical for correct invocation is missing.

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

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

With 0% schema description coverage, the description must compensate, and it does add meaning for confirmed (must be true and backed by explicit consent) and actionReference (a reference alone does not prove consent). However, it leaves gymId unexplained and does not clarify the actionReference format beyond what the schema pattern already provides, so the compensation is incomplete.

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, 'Cancel one exact prepared booking,' which clearly states the tool's function. It also distinguishes itself from siblings like execute_late_booking_cancellation by referring to a 'standard cancellation request' and an exact prepared booking, so an agent can tell it apart without opening schemas.

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 preconditions: the MCP client must show the preview and obtain explicit account-holder confirmation before calling with confirmed: true, and it warns never to retry automatically. It does not explicitly name alternatives or state when to prefer execute_late_booking_cancellation, but the context strongly implies the standard-cancellation path.

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 (write, non-idempotent, open-world), the description discloses meaningful operational traits: it 'sends at most one standard write, then reconciles with fresh reads,' and honestly flags its verification status ('One standard creation was observed at 9NBC; other response branches remain unverified live'). This is exactly the kind of trust calibration context annotations cannot convey, and 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 dense but efficient: the safety-critical consent precondition is front-loaded, and each sentence after it adds a distinct operational fact (fresh reference, one write, reconciliation, verification status, uncertainty handling). The only minor redundancy is the consent point appearing in both sentence two and sentence three, but that repetition serves to emphasize the highest-risk failure mode.

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 consequential mutating tool with an output schema present (so return values need no explanation), the description covers the full decision path: consent gate, fresh-reference requirement, at-most-one-write guarantee, live verification status, and the mandated post-condition of manual inspection on uncertain results. The sole missing element is undocumented gymId semantics, which prevents a 5.

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

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

With 0% schema coverage, the description must carry parameter meaning, and it does for the two required fields: actionReference is defined as a fresh prepare_booking_creation reference, and confirmed is explained as requiring prior explicit account-holder consent (const: true). However, gymId is never mentioned anywhere, so an agent cannot infer why the optional gymId parameter exists or when to supply it — a genuine gap in an otherwise strong definition.

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 first sentence states a specific verb + resource + constraint: 'Create exactly one booking from a fresh prepare_booking_creation reference.' This simultaneously distinguishes the tool from the cancellation siblings and from the prepare step, so an agent knows precisely what this tool does and which sibling pairing it belongs to.

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 routing conditions: it must follow a fresh prepare_booking_creation reference, must be preceded by showing the user the exact gym/class/time/credit uncertainty and obtaining explicit confirmation, and 'A reference alone does not prove consent.' It also states when NOT to proceed ('An uncertain result requires manual inspection before a new action'), leaving no ambiguity about the required precondition.

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 (destructiveHint:true, idempotentHint:false) are already present, but the description adds crucial context: it requires a UI confirmation step, sends at most one request, reconciles by reading, and explicitly states it does not verify refund or balance. This goes beyond the annotations and tells the agent what side effects 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?

Every sentence adds value: it front-loads the mandatory confirmation step, then the call condition, then the behavior after the call. It is dense but not verbose, with no filler. The structure logically guides the agent through the required sequence.

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 mutation tool with an output schema, the description covers the entire workflow: what to do before calling, what parameters to pass, what the tool does (rechecks, sends once, reconciles), and what it doesn't verify. An agent has all the information needed to invoke it 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?

Schema description coverage is 0%, so the description carries the burden. It explains the meaning of the two required parameters: actionReference must be the NEW one from the prior call, and confirmedCreditLoss must be true. It does not explain gymId, which is optional, but for the essential parameters it adds useful semantics beyond the schema's raw constraints.

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 defines the tool as the follow-up to a normal cancellation when credit loss is pending. It names the sibling execute_booking_cancellation and specifies the exact condition ('reports pending-credit-loss') that triggers this tool, distinguishing it from other cancellation tools.

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 the precondition: 'After execute_booking_cancellation reports pending-credit-loss'. It mandates a separate explicit confirmation and instructs to 'Only then call with the NEW actionReference and confirmedCreditLoss: true'. Also prohibits automatic retries, giving clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare readOnly, idempotent, openWorld, non-destructive, so the safety profile is covered. The description adds real behavioral context beyond that: search coverage is 'limited,' candidates 'do not prove personal records,' and 'no member selector is accepted.' These are useful scoping caveats rather than restated hints.

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 compact sentences, front-loaded with the search action and followed by the ambiguity rule and limits. Slightly jargon-heavy ('read for this account,' 'member selector') but nothing is wasted.

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?

An output schema exists, so return shape need not be explained. The description covers the resolution flow, the ambiguity fallback, and coverage limits — enough for an agent to call this correctly, though the gymId scoping semantics remain unaddressed.

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% across three parameters, so the description must compensate. It clarifies 'name' as the search key and 'exerciseId' as an ID selected from returned candidates, but says nothing about how gymId scopes the search (only the oblique 'no member selector' line). Partial coverage justifies a mid score.

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

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

States a specific verb and resource: 'Search bounded exercise candidates by name,' which an agent can distinguish from get_exercise_1rm and get_exercise_rm_progression (those read results, this resolves candidates). The tie to 1RM is only implied by the tool name, not the description, so the intent is slightly opaque.

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 the workflow — resolve a name to a candidate, and if ambiguous, supply 'an explicit source exercise ID from these candidates' — which is genuine routing guidance. However, it never names a sibling tool or states when to skip this step, so the agent must infer the handoff to get_exercise_1rm.

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 the safety profile is covered. The description adds valuable behavioral context: it authenticates the account, selects a gym, assumes Europe/Madrid timezone if not configured, and warns that source gym names are untrusted external content. This 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?

Four sentences, each carrying distinct information: authentication/discovery, selection logic, timezone assumption, and trust warning. No fluff, no repetition of schema or annotations. The most important operational detail (gym selection) 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?

The tool has an output schema, so return values are documented elsewhere. The description covers the key behavioral aspects: authentication, gym selection, timezone handling, and trust boundary. It doesn't mention error cases or what happens if no gym is accessible, but for a read-only discovery tool with an output schema, this is 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?

Schema description coverage is 0%, so the description must compensate. It does: it explains that gymId overrides the default gym selection for this query. The schema only provides the pattern, so the description adds the semantic meaning of the parameter. It could be more detailed (e.g., what happens if gymId is invalid), but it covers the key 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: authenticate the configured account and discover accessible gyms. It also explains the gym selection logic (only gym, configured default, or gymId override), which distinguishes it from the sibling tools that all focus on retrieving specific data types (sessions, bookings, workouts, activity).

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 explains when to use this tool: to authenticate and discover accessible gyms, and how gymId overrides the default selection. It doesn't explicitly name alternatives or state when not to use it, but the context is clear enough given the sibling tools are all data-retrieval tools for specific domains.

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?

Even though readOnlyHint, openWorldHint, idempotentHint, and destructiveHint already cover the safety profile, the description adds substantial behavioral context: the reported gym zone may be assumed, history availability is not exhaustive, labels never establish attendance, and source names are untrusted. This meaningfully 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?

Each of the four sentences carries a distinct, necessary piece of information: action/ordering, zone assumption, availability limitation, and source trust caveat. It is dense but free of filler, and the core purpose 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?

The description covers ordering, limitations, and trust semantics, and an output schema exists so return values do not need explanation. However, it does not state what happens when the optional gymId is omitted, and it never explicitly ties the 'reported gym zone' to the gymId parameter, leaving a small but real gap.

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

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

Schema description coverage is 0%, and the description never names or explains gymId. The phrase 'reported gym zone' only indirectly relates to the input, so the agent gets little help beyond the schema's field name and pattern. With only one optional parameter, a direct link between the behavior and gymId was needed.

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 specific verb ('Read') and a specific resource ('the account holder's available historical booking view'), with ordering ('newest first') and scope ('at a verified gym'). The 'historical' framing also clearly separates it from sibling tools like get_upcoming_bookings.

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 the tool is for historical booking views and provides useful context about verified gyms and the reported gym zone, but it never names alternatives or states when not to use this tool. Selection logic is left to inference rather than explicit 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?

The description goes well beyond the readOnly/idempotent/destructive annotations by detailing the IANA time zone assumption, the precise meaning of occupancy ('occupied places, not attendance or booking eligibility'), the untrusted nature of source names, and the all-or-nothing failure behavior ('All days must succeed; errors return no schedule'). This is rich, non-annotation 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?

Six sentences, each carrying a distinct fact, and the purpose is front-loaded. There is no filler or repetition; everything 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 output schema exists, so return values need no explanation. The description covers all essential behavioral and semantic aspects for a 5-parameter read-only tool: date range, time zone, filter semantics, occupancy definition, trust boundary, and error behavior. An agent has enough to call 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?

With schema description coverage at 0%, the description compensates meaningfully: it explains the inclusive interval for startDate/endDate, the exact-match className filter, and the HH:mm format for startTime. The gymId parameter is only indirectly referenced via 'verified gym,' leaving some ambiguity, but the most important parameters are semantically clarified.

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 statement, 'Query an inclusive interval of gym-local calendar dates,' which clearly identifies the tool's function and sets it apart from sibling tools about bookings, account context, and personal activity. The scope (gym, dates, sessions) is concrete and instantly distinguishes it from alternatives.

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

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

No explicit guidance is given on when to use this tool versus the sibling tools. There is no mention of alternatives, preconditions, or exclusions. The functionality is described, but the agent must infer when this is the appropriate choice.

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 cover the safety profile (readOnly, idempotent, non-destructive, openWorld), and the description adds genuinely new behavior: the account ID is derived internally, units require corroborating history text, and source names are untrusted. These caveats go well beyond the structured fields and warn the agent about data interpretation pitfalls.

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 core read action is front-loaded, but the middle sentences are dense and cryptic ('the chart field named lbs alone is not a unit', 'limited exercise-detail coverage') without context, which dilutes rather than sharpens the message.

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?

An output schema exists, so return values need not be explained, and the description still adds auth derivation, unit-handling, return-context, and trust caveats. Coverage is solid for a two-param read tool, though the cryptic unit and coverage phrasing leaves some 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?

Schema description coverage is 0%, so the description must carry parameter meaning. It does semantically identify both params ('one known source exercise ID' for exerciseId, 'an accessible gym' for gymId), but adds no format, range, or ID-sourcing detail beyond that conceptual mapping.

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 specific verb ('Read') and resource ('latest dated 1RM for one known source exercise ID'), which is concrete enough to distinguish from find_exercise_1rm and get_exercise_rm_progression. It stops short of naming those siblings, so the differentiation is inferable rather than explicit.

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

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

The phrase 'one known source exercise ID' implies a precondition (you must already have an ID), and 'at an accessible gym' hints at scope, but there is no explicit when-to-use/when-not guidance and no pointer to the sibling tools that would be chosen instead.

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 cover the safety profile (readOnly, idempotent, non-destructive), so the description earns credit for going beyond that: it explains that source-marked new RM events are labeled separately, that optional WOD entries are kept distinct, and that the view is limited to the own account rather than complete history. That is meaningful output-shaping context an agent could not infer 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?

Three compact sentences, front-loaded with the verb and resource, then the labeling behavior, then the scope limitation. Dense but each sentence carries information; minor jargon ('source-marked') slightly slows 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?

An output schema exists so return shape need not be described, and the description supplies the scope limitation, labeling semantics, and WOD handling an agent needs to interpret results. Only gymId's role remains unexplained, which is a small residual gap.

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

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

Schema description coverage is 0% across three parameters, so the description must compensate. It addresses exerciseId ('known source exercise ID') and indirectly includeWod via the WOD-context sentence, but gymId is never explained in either place, leaving a real 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 gives a specific verb (Read) and resource (separate 1/3/5/10RM series) keyed to a source exercise ID, which clearly separates it from get_published_workouts and the booking tools. It stops short of naming get_exercise_1rm/find_exercise_1rm as siblings, so it is clear but not fully differentiated.

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?

'Known source exercise ID' implies the ID must be obtained elsewhere, and the closing sentence excludes it from being a full lifetime history, which is a scope caveat. However, no explicit when-to-use/when-not or alternative tool (e.g. get_exercise_1rm) is named, leaving usage only implied.

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?

Goes well beyond the readOnly/idempotent/openWorld annotations by disclosing that the gym zone may be assumed, that results carry recorded block results in source encodings and explicit completed-date coverage, that partial results never establish a session count or verified attendance, and that source content is untrusted data. These are non-obvious behavioral caveats an agent cannot derive from 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?

Front-loaded with the purpose and date bound, then layered caveats. Dense but each sentence carries distinct information; it is slightly overpacked into one paragraph rather than under- or over-explained.

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?

An output schema exists, so return format need not be spelled out, yet the description still characterizes the payload and its trust/coverage limits. The main remaining gap is gymId semantics, which neither schema nor description resolves.

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 conveys meaningful semantics for startDate/endDate (calendar dates, gym-local, 1–31 day bound, completed-date coverage), but gymId is only obliquely referenced via the gym zone and its meaning/format is never explained.

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 specific verb (Retrieve) and resource (personal activity) with an explicit scope: 1 to 31 inclusive gym-local calendar dates. This clearly separates it from the booking, publication, and 1RM siblings, though it never names an alternative tool explicitly.

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 implied usage constraints (date range bounded to 31 days, gym-local zone that may be assumed) but no when-to-use versus siblings and no prerequisites or exclusions. An agent can infer this is the read path for personal activity but gets no routing 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?

The annotations already declare read-only, idempotent, open-world, non-destructive behavior, yet the description adds substantial value: it explains load calculation for today/future, per-exercise unavailable status for missing RM/unit/identity/read failures, that past dates have no present-day load, and that feed and personal history coverage are limited with untrusted source content. These are meaningful behavioral traits beyond structured annotations and help the agent anticipate response semantics.

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 primary action and then layers behavioral details in separate sentences. Most content earns its place, though the sentence 'Original values, all publications and labeled variants remain' is somewhat cryptic and could be clearer without losing essential 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 existing output schema and rich annotations, the description covers purpose, load behavior, failure modes, and data limitations well. It stops short of explaining the optional 'gymId' parameter, which is a minor but real gap for an agent invoking the tool with that argument.

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 clarifies that 'date' is gym-local and 'className' must be exact, adding useful meaning for two required parameters, but it never explains the optional 'gymId' parameter or its default behavior, leaving a 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 and resource: 'Retrieve published workout alternatives by gym-local date and exact className.' It distinguishes the scope well, but does not explicitly name or contrast with any sibling tool, leaving the agent to infer differentiation from the broader tool list.

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

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

The description gives detailed behavioral context but no clear when-to-use or when-not-to-use guidance relative to alternatives. It does not point to any sibling tool or condition under which a different 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?

The description substantially enriches the annotations: it explains time-zone assumptions, state distinctions, that reservations do not establish attendance, that coverage has no verified date horizon, that source names are untrusted, and that failures return errors rather than empty views. These details go far beyond readOnlyHint and openWorldHint alone.

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?

Each sentence earns its place: the action is front-loaded, and the following sentences cover time-zone handling, state semantics, coverage limits, trust boundaries, and error behavior. The description is dense but not bloated, and every clause addresses a decision or interpretation an agent would otherwise lack.

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 output schema exists and the annotations already cover read-only, idempotent, and open-world behavior, the description completes the remaining picture: how to interpret states, what absence means, how time zones are handled, and what failure looks like. Nothing critical is missing for correct invocation and interpretation.

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 description coverage is 0%, the description adds meaningful context for the single gymId parameter: the gym must be verified, and its reported time zone may be assumed. This is useful beyond the schema's pattern constraint, even though it does not explicitly name the 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 and resource: "Read the account holder’s upcoming booking view at a verified gym." The word "upcoming" clearly distinguishes this from siblings like get_booking_history and get_class_sessions, so an agent can infer its scope even 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?

The tool's intended use is clearly implied: use it to read the account holder's upcoming booking view, including distinguishing booked, waitlisted, and unknown states. It does not explicitly name alternatives or exclusion conditions, but the scope is precise enough that an agent can select it appropriately among the listed siblings.

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, and the description's 'never sends DELETE' and 'short-lived reference is not confirmation' statements are consistent and add real context. It goes further with the preview contents (exact content, incomplete coverage, possible irreversible loss, no backup or undo, unknown RM-history effects) and eligibility rules, which is strong disclosure for a preview 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?

Front-loads the core purpose and the non-destructive guarantee, then layers preconditions and caveats. It is fairly dense but every sentence carries distinct information; only the rapid-fire caveat list 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?

An output schema exists so return values need not be described, and the description still covers preconditions, eligibility, safety caveats and the non-confirmation semantics. For a preview tool feeding an execute sibling, 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 description coverage is 0%, so the description must compensate, and it does: it explains date as gym-local, tells where to obtain sourceActivityId (get_personal_activity), and states the ID must occur in the authenticated account calendar and verify owner/gym/date. gymId is only implied via 'selected gym', leaving a small 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?

States a specific verb and resource ('Prepare a read-only preview for deleting one exact own activity entry') and clearly distinguishes itself from execute_activity_deletion by emphasizing that it never sends DELETE. An agent can identify the tool's role without opening any 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?

Explicitly says when to use it (before deletion, for an exact own entry) and prescribes the prerequisites: a gym-local date and a sourceActivityId obtained from get_personal_activity. It also rules out misuse by stating the reference is not confirmation and no DELETE is sent, implicitly routing confirmation to the execute sibling.

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 meaningful behavior beyond the annotations: the two-phase draft/execute flow, that a draft has no action reference, that historical kilogram suggestions are read-only, and that audience and WOD TV settings are pulled from account preferences and rechecked before execution. None of this is inferable from readOnlyHint/openWorldHint, and nothing contradicts 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 single dense paragraph is front-loaded with the core action, but sentences are long and stack multiple conditions (draft mode, load confirmation, preference recheck, preview/confirm) without structure. Every clause carries information, yet a bulleted or sequenced layout would cost less effort 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?

An output schema exists, so return values need no explanation, and the description covers the workflow, preconditions, and confirmation gate sufficiently to call the tool correctly. The remaining shortfall is the undocumented parameters, which is a schema/description gap rather than a missing concept.

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% across 7 parameters, so the description is the only guidance and it covers only part of the surface: sourceActivityId (source ID), variantLabel (difficulty label), actualLoads (actual kilograms), and blockResults ('supported result'). gymId, comment, activityDate, and the sourceAlternative enum are never explained, leaving a real documentation 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?

States a specific verb+resource: reads a selected gym workout in the current publication view and prepares one own activity entry, and names the upstream source (get_published_workouts). It distinguishes itself from execute_activity_publication through the 'prepare' framing and the confirmation gate, though the phrasing ('own activity entry', 'supported publication view') is dense enough that the exact artifact being produced takes a second read.

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 real when-to-use guidance: supply the source ID from get_published_workouts, resolve the difficulty label when several variants exist, and re-run the call with a supported result or explicitly confirmed kilograms when the first pass returns a draft. It does not explicitly name execute_activity_publication as the tool that consumes the prepared draft, so the hand-off 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 destructiveHint=false, so the description adds value by detailing behavior: it matches the schedule reservation internally, accepts no reservation ID or family selector, returns no executable reference for ambiguous/missing/cancelled/waitlisted/unsupported targets, and explicitly says 'This preview sends no cancellation POST.' It also mentions showing credit-loss risk at 9NBC, providing richer behavioral 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 moderately long but every sentence adds value: it states the purpose, prerequisites, matching constraints, conditional behavior (credit-loss risk), required confirmation flow, and non-mutation guarantee. It is front-loaded with the core purpose and maintains a logical structure. No redundant or filler sentences.

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 output schema exists (not shown here) and annotations cover safety, the description provides sufficient context: it explains the tool's role in the cancellation workflow, prerequisites, behavioral limitations, and the confirmation requirement. It does not mention return value details, but that is likely covered by the output schema. The only minor gap is the lack of explicit per-parameter explanation, but that is a smaller concern because the schema patterns and names are clear.

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

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

Schema coverage is 0%—the properties have no descriptions—so the description must compensate. It explains that the tool matches the schedule reservation based on date, className, startTime, and endTime, and that no reservation ID or family selector is accepted, implying these four required fields are how the class is identified. However, it does not explain each parameter individually or mention the optional gymId, leaving some ambiguity for agents. The parameter names are self-explanatory, but the description could be more explicit about what gymId means (likely the gym identifier related to the IANA zone).

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 and resource: 'read the configured account’s fresh daily schedule and prepare cancellation of one exact booked class.' It clearly distinguishes itself from execute_booking_cancellation by emphasizing that this is a preview step that sends no cancellation POST, and it names the sibling execute_booking_cancellation as the next step. This makes the tool's role 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 instructs to obtain explicit account-holder confirmation before execute_booking_cancellation and notes that this preview sends no cancellation POST, establishing the correct order of operations. It also specifies a prerequisite (user-confirmed gym IANA zone) and mentions a condition at 9NBC (show credit-loss risk). However, it does not explicitly state when to use this over other prepare tools like prepare_booking_creation, though the focus on cancellation is 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 already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds valuable behavioral context: 'The short-lived reference does not book a class' and 'Possible credit use and the unverified balance are disclosed.' These go beyond the annotations by explaining the temporal nature of the reference and the disclosure of side effects (credit usage), which is not communicated by 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 concise and front-loaded: the first sentence states the purpose and scope, followed by prerequisites, exclusions, and the required confirmation flow. Each sentence adds a distinct, non-redundant piece of information. It is not bloated but packs a lot of essential context into a short paragraph.

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 preparation tool that is part of a two-step booking flow, the description covers the core requirements: what it does, what data it needs, what it does not do (no booking, no action on ambiguous targets), and the required confirmation step before calling the sibling. The output schema exists, so explaining the return structure is unnecessary. The only minor gap is no explicit mention of error handling for invalid inputs, but the statement about ambiguous targets receiving no action covers the most likely failure mode.

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

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

With schema description coverage at 0%, the description carries the burden of explaining parameters. It maps the required parameters to their roles: 'class name, date, start and end time' and 'user-confirmed gym IANA zone' for the gymId. It also emphasizes the need for exact and unambiguous values, which is essential for correct invocation. While it does not detail formats (covered by schema patterns), it does provide the semantic meaning behind each parameter, compensating for the lack of schema descriptions.

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

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

The description clearly states the tool's purpose: 'Read the current daily schedule and prepare one exact class booking for the configured account.' It distinguishes itself from the sibling execute_booking_creation by explicitly stating it does not book, and it names the exact target parameters (class name, date, start/end time). This is a specific verb+resource that tells an agent exactly what the tool does.

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

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

The description gives explicit usage context: it requires a user-confirmed gym IANA zone and exact class details, and it states that ambiguous/missing/already booked/waitlisted/unsupported targets receive no action reference. It further instructs to 'Show the full preview and obtain explicit account-holder confirmation before execute_booking_creation,' which routes the agent to the correct sibling for the actual booking. This is clear when/when-not guidance with an explicit alternative.

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