Mobela

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

Annotations only declare readOnlyHint=false/openWorldHint=false/destructiveHint=false, which is a thin safety profile. The description adds genuinely new behavioral context: the write is immediately persisted and visible ('will immediately appear in the user's Mobela app') and that IDs must come from another tool. Permissions and failure behavior are still unstated.

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 short sentences, action first, prerequisite second, side effect third. No filler, no repetition of schema content.

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

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

For a mutation tool with a rich 100%-covered schema and no output schema, the description covers purpose, prerequisite, and the key side effect. It notably omits what the call returns (e.g. the new template's ID), which an agent may want for follow-up calls.

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 baseline is 3 and the schema carries field-level detail. The description still adds meaning beyond the schema by establishing the provenance/validity constraint for the required exercises IDs ('valid exercise IDs' from get_exercise_library).

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 ('Create and save a new routine') plus the destination surface ('the user's Routines tab'), which no sibling offers since all siblings are get_* readers. An agent can immediately tell this is the single creation path for routines.

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

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

Gives an explicit prerequisite and ordering rule: 'Always call get_exercise_library first to get valid exercise IDs.' It does not name when NOT to use it (e.g. use get_my_templates to view existing routines), so it stops short of full alternative coverage.

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, covering the safety profile, and the description adds genuine extra context: the default lookback/lookahead window and the fact that empty days are surfaced. It still omits pagination or ordering behavior, but it meaningfully supplements 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?

A single compact sentence that front-loads the resource and packs scope, contents, defaults, and the empty-day detail with no 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 zero-required-parameter read tool with no output schema, the description adequately conveys what comes back (planned workouts and to-dos per day plus empty days). It could say more about return shape or ordering, but 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?

Schema coverage is 100% — both days_back and days_ahead already carry 'Default 7/14, max 60' descriptions. The description only restates those defaults, adding no semantics beyond the schema, so the baseline of 3 applies.

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

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

States a specific resource ('the user's training calendar') and its contents ('planned workouts and to-dos per day'), plus the default time window. It is clearly distinguishable in content from history-oriented siblings like get_workout_history, but it does not explicitly contrast itself with them.

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 default window and the mention of empty days imply the scenario (looking at the current planning horizon), but there is no explicit when-to-use guidance and no named alternative among the many get_* siblings. Usage is inferable 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, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds genuinely useful behavioral scope: it aggregates "all synced and logged sessions" (not just logged ones) and defines the week boundary ("weeks start Monday"), which the annotations cannot convey.

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

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

One dense but front-loaded sentence delivers the data content first and the usage trigger last, with no filler. Every enumerated metric and the week-boundary parenthetical earns its place by describing what an agent will actually get back.

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 no output schema, the description usefully enumerates the return payload (per-session metrics plus weekly and current-week totals) and the aggregation scope, so an agent can call it correctly with zero required params. Minor gaps remain: no mention of units beyond km/mi or of behavior when no sessions exist in the window.

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

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

The single parameter has 100% schema description coverage including default (28) and max (365), so the schema does the work. The description adds no syntax or interpretation for `days` beyond what is already structured; baseline 3 applies.

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

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

States a specific resource (running/riding/walking volume) and enumerates the exact metrics returned: per-session distance, moving time, pace, heart rate, plus weekly totals. This is clearly distinguishable from siblings like get_recent_runs (individual runs) and get_workout_stats (broader workout stats) 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?

"Use for mileage, volume and pace questions" gives an explicit positive trigger that maps to the metric set. However, it names no alternatives and gives no exclusions (e.g., when to prefer get_recent_runs or get_workout_stats), so routing between overlapping siblings is still partly left 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 cover the safety profile (readOnly, non-destructive, closed-world), and the description adds genuinely new behavioral context: the precedence rule that user-typed notes are "the last word" and the instruction to respect the content. It does not describe freshness, pagination, or the shape of returned notes, but it contributes meaning beyond the annotations.

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

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

Two sentences, front-loaded with what the resource contains and closing with the authoritative precedence rule and call-site guidance. No filler, no restatement of the name.

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

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

For a zero-parameter, read-only retrieval tool with no output schema, the description supplies everything needed: the content categories an agent should expect, the semantic weight of the notes, and the moment in the workflow to call it.

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

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

The tool takes no parameters, so there is nothing to disambiguate; the description correctly spends no space on input semantics. Baseline 4 applies for a zero-parameter tool.

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?

Names a specific resource (coach notes about the user) and enumerates its contents: injuries, race dates, goals, constraints, refused exercises. The scope is distinguishable from siblings like get_user_profile or get_workout_history because it is explicitly framed as coach-authored observations.

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?

"Call this alongside get_user_profile before building a plan" gives explicit timing and a companion tool, which is strong routing guidance. It stops short of stating when not to use it or how it relates to the other 12 siblings, but the primary workflow context is unambiguous.

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 safety is covered. The description adds genuinely useful behavioral context beyond that: the library size (1000+) and the fact that unfiltered calls are wasteful. It still omits return-format/pagination detail, but that gap is minor for a read-only list 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?

It is front-loaded with the core purpose in the first sentence and then layers the filtering imperative. The repeated emphasis on filtering is slightly redundant but each sentence carries distinct guidance (filter rule, multi-call workflow, clarifying question).

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

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

For a read-only catalog tool with a fully documented schema and no output schema, the description covers usage conditions, filtering expectations, and the disambiguation step. It leaves minor gaps around return shape and default behavior, but nothing essential for correct invocation.

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

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

Schema description coverage is 100% with enums on muscle, category and equipment, so the schema already carries the load. The description only adds illustrative usage (muscle="chest" for push, muscle="quads" for legs) rather than new syntax or format semantics. Baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: "Get exercises from the library." The word "library" implicitly separates it from siblings like get_exercise_records (the user's logged history) or get_personal_records, but it never explicitly names a sibling to disambiguate.

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 states a hard when-to-use rule ("ALWAYS filter before calling — never fetch without at least one filter"), a workflow context ("Before building a routine, call this multiple times"), and a prerequisite ("If you do not know what muscles/equipment the user wants, ask them first"). When-not and prerequisite conditions are both explicit.

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 and non-destructive, so safety is covered; the description adds the useful behavioral point that results are the user's own logged data, newest first, with a stated unit (lb). It doesn't cover empty-result behavior, so not a 5.

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

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

Two sentences, both front-loaded with the return shape first and the call condition second. No redundant restatement of the tool name or schema.

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 no output schema, the description compensates by naming the returned fields and ordering. Minor gaps remain: behavior when an exercise has no logged sets, and whether results are truncated.

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

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

Schema coverage is 100% with the 1–20 id bound already documented, so the baseline is 3. The description adds genuine value by saying where the ids should come from (get_exercise_library or get_workout_history), which the schema does not convey.

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

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

States a specific retrieval: the user's last logged sets with weight in lb, reps, and RPE, ordered newest first, for given exercises. That is concrete enough to distinguish it from get_personal_records or get_workout_history, though it does not explicitly contrast itself with those siblings.

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?

"Before suggesting loads" gives an explicit usage context, and it names the two sibling tools that supply the required exercise ids, establishing a dependency order. It lacks an explicit when-not-to-use clause, keeping it just short of a 5.

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

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

Annotations already establish the read-only, non-destructive safety profile; the description usefully adds that data spans multiple device sources and can be stale because device data only syncs when the user opens the app, and it points to latest_date. It does not cover authorization requirements, rate limits, or how missing metrics are represented.

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 returned metric set, then the intended use, then source compatibility and sync caveat. Every sentence adds operational value, with no 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 read-only summary tool with no output schema, the description lists the metrics and notes period averages and latest_date, giving the agent enough to interpret the return. It remains slightly underspecified on response structure and missing-data behavior, but annotations and the simple one-parameter schema reduce the burden.

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 sole parameter (days) is fully documented in the schema with default and maximum, so the description need not restate it. The description's mention of period averages is contextual but does not add syntax or constraints beyond the schema.

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

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

The description names a specific resource (daily health from the user's watch) and enumerates the metrics it returns, so the agent knows exactly what the tool produces. It stops short of differentiating from siblings such as get_cardio_summary or get_workout_stats, which also cover fitness/activity data.

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

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

It gives a clear use case (recovery, readiness and fitness questions) and a freshness precondition. It does not name when to prefer it over sibling summary/stat tools, so routing among overlapping health and workout tools remains partly ambiguous.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds no behavioral detail beyond that — no return shape, no pagination, no indication of what a template object contains. It adds purpose context but nothing behaviorally new.

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 short sentences, front-loaded with the action and followed by the decision context. No filler, no restatement of the tool name.

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

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

For a zero-param read tool with read-only annotations, this is nearly sufficient. Since no output schema exists, a brief note on what a returned template contains would help, and the wording drifts between 'templates', 'routines', and 'programs', which slightly muddies what is actually returned.

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 takes zero parameters, so per the baseline rule a 4 applies. There is nothing for the description to clarify beyond confirming this returns the calling user's own templates rather than a global set.

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: retrieving the user's saved routines/templates. This is clear enough to distinguish it from read tools like get_workout_history or get_exercise_library, though it never explicitly names the sibling create_workout_template that it is meant to complement.

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 concrete usage context — check before creating to avoid duplicates, and to learn what programs the user already has. No explicit exclusions or named alternatives, but the when-to-use intent is unambiguous.

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 establish readOnly/openWorld=false/destructive=false, so the safety profile is covered. The description adds genuinely useful behavior: that results are computed by Mobela by merging Garmin, Apple Watch, Health Connect, Strava and in-app GPS, and that the scope is all-time. It stops short of noting latency or edge cases (e.g., missing data sources), which keeps it from a 5.

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, purpose and scope front-loaded before the sibling reference. The distance enumeration and source list are dense but informative rather than filler; still, the sentence could compress slightly without losing value.

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

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

With no output schema, the description carries the burden of describing returns and does so (time, seconds, session id, date). Combined with the aggregation-source and scope notes, an agent has everything needed to call and interpret this parameterless read tool.

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

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

The tool takes zero parameters, so the baseline is 4; there is nothing the description could add on parameter semantics. It correctly does not invent filtering options, keeping expectations aligned with the empty 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?

States a specific verb+resource ('the user's all-time running bests') with the exact distances covered, the sources aggregated, and the returned fields. It also distinguishes itself from sibling get_session_details, so an agent can select it 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 says 'Use for PR and race-time questions' and routes the per-session case to get_session_details with the condition ('a single run's own best efforts and any PRs it set'). Both the when-to-use and the alternative are named.

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, openWorldHint=false, and destructiveHint=false, so the safety profile is covered. The description adds valuable return-shape context (fields per run) and source coverage, though it does not mention authentication or rate limits.

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

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

Front-loads the purpose, then provides a dense but useful list of returned fields, and closes with sibling routing. Every sentence contributes to correct invocation; no 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?

With no output schema, the description compensates by listing all returned fields. Annotations cover safety, schema covers parameters, and sibling alternatives are named. Nothing essential is missing for correct use.

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

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

Schema description coverage is 100%, so the schema already documents days and limit. The description adds no parameter-level detail beyond what the schema provides, which is the baseline 3 for high coverage.

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

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

The description states a specific verb and resource: retrieves the user's recent runs from enumerated sources. It lists the exact fields returned per run, distinguishing it from siblings like get_session_details and get_user_profile.

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 routes the agent to get_session_details for laps, intervals, or heart-rate zones of a single run, and to get_user_profile for distance unit preferences. This gives clear conditions for when to use those alternatives instead of this tool.

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

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

Annotations already establish readOnly/non-destructive/closed-world, so the safety profile is covered. The description adds genuine behavioral value on the output side: the granularity of data returned (laps, splits, best efforts, PRs, HR zones, totals) and the platform compatibility, which is important since no 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?

Front-loads what the tool returns, then closes with two short, actionable sentences about platform support and id sourcing. The long content enumeration is dense but every item is informative; no 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?

With no output schema and a single required param, the description carries the burden of describing return content and does so thoroughly, plus names the id sources. Minor gaps remain: no mention of behavior when the id is invalid or not found, and no pagination-size caveats, but these are small for a read-only detail fetch.

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?

Only one parameter with 100% schema description coverage, so the schema already defines session_id and its provenance. The description restates the same sourcing hint ('Use the `id` from get_workout_history or get_cardio_summary'), adding no syntax or format detail beyond the schema. Baseline 3 is appropriate.

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

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

States a precise verb+resource (fetch one logged session in full) and enumerates the returned detail: per-lap distance/time/pace/HR, km and mile splits, best efforts, PRs, HR-zone minutes, totals. It also names the sibling sources that supply the id (get_workout_history, get_cardio_summary), so an agent can route between this and the summary/history tools 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?

Explicitly tells the agent where the required id comes from (get_workout_history or get_cardio_summary) and notes the platforms it works for (Garmin, Apple Watch, in-app GPS). It gives clear when-to-use context but stops short of stating when to prefer a sibling such as get_cardio_summary or get_recent_runs 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 declare readOnlyHint=true, destructiveHint=false and a closed-world scope, so the safety profile is covered. The description's added behavioral value is the sequencing requirement and the fact that it returns a composite profile rather than a single metric, but it says nothing about freshness, caching, or what happens when no profile 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?

Two sentences, zero filler. The content enumeration comes first and the imperative precondition is placed at the end where it is most likely to be acted on.

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 no input schema, no output schema, and annotations covering the safety profile, the description supplies exactly the missing pieces: what the profile contains and when it must be called. An agent can invoke it correctly with no further information.

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

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

The tool takes zero parameters, so the baseline is 4 — there is no parameter semantics to clarify. The description's field enumeration describes the return shape rather than inputs, which is helpful but belongs to a different dimension.

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?

Names a specific verb and resource ("Get the user's fitness profile") and enumerates the exact contents — experience level, equipment, frequency, duration, location — which distinguishes it from sibling getters like get_health_summary or get_workout_stats. It does not name a sibling explicitly, so it falls short of a 5.

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

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

"Always call this first before generating a workout plan" gives an explicit precondition and ordering rule, which is unusually actionable. It stops short of a 5 because it names no alternative or when-not-to-use case (e.g., what to do if the profile is empty or already cached).

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered without description help. The description adds value by disclosing the shape of the response (session type, exercises, duration, RPE, date), which is meaningful given there is no output schema, but it says nothing about ordering, recency window, or pagination behavior beyond what the schema already states.

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

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

Two sentences, zero filler: the first states what is returned, the second states why it is useful. The resource and payload are front-loaded before the rationale.

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 no output schema, the description usefully compensates by listing the returned fields, and the annotations cover the read-only safety profile for a zero-required-parameter tool. The remaining gap is operational detail — default ordering and what 'recent' means in practice — which is minor but not fully closed.

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

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

Schema description coverage is 100% — both 'limit' (default 30, max 100) and 'category' (enum of five values) are fully documented in the schema. The description adds no parameter-level detail, so the baseline of 3 is appropriate.

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

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

States a specific verb and resource ('Get the user's recent workout sessions') and enumerates the returned fields, so the agent knows exactly what this retrieves. It does not, however, distinguish itself from adjacent siblings such as get_session_details or get_workout_stats, which an agent could easily confuse with it.

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 second sentence gives an implied purpose ('understand training patterns, volume, frequency, and muscle group balance'), which signals when the tool is useful. There is no explicit when-not guidance and no named alternative (e.g. use get_session_details for a single session, get_workout_stats for aggregates), so the agent must infer the boundary.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description contributes the content scope (what is aggregated) but says nothing about window semantics, grouping, or timezone handling that the annotations cannot express.

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?

One front-loaded sentence with a colon-separated list; every item earns its place because there is no output schema to convey return shape. No filler or repetition.

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

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

With no output schema, the metric list carries the return-value burden reasonably well, and annotations cover safety. It stops short of clarifying how the 'days' window interacts with the aggregates or what a streak counts as, which is the only meaningful 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 100% and the single 'days' parameter already carries its meaning and default (30). The description adds nothing beyond the schema, so the baseline 3 applies.

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

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

States a specific verb ('Get') and resource ('aggregated workout statistics') and enumerates the exact metrics produced: sessions, duration, average RPE, sessions/week, muscle groups, streak. The word 'aggregated' implicitly separates it from raw-log siblings like get_workout_history, though no sibling is named.

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 when-to-use guidance and no alternatives named. An agent must infer that this is the summary view versus get_workout_history or get_session_details, but the definition never says so explicitly.

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