MONS Athletics

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds useful scope context by disclosing that the payload covers device requirements and starter links, but it says nothing about response format or size. With annotations carrying the burden, this is a reasonable 3.

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 subject ('What MONS Athletics is') and then lists the remaining content areas. It is efficient with no filler, though the comma-chained content list is slightly dense for one sentence.

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?

There is no output schema, so the description must convey what comes back — and it does, itemizing the informational sections an agent can expect. For a zero-parameter, read-only lookup, this is sufficiently complete; only a note on response shape or size would improve 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 zero parameters, so there is nothing for the description to disambiguate. Per the baseline for parameterless tools, a 4 is appropriate; the description correctly does not invent parameter guidance.

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

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

The description names a specific resource (MONS Athletics) and enumerates exactly what the tool surfaces: what it is, its training method, audience, device requirements, and getting-started links. That content inventory clearly separates it from action-oriented siblings like add_challenge, ask_coach, or edit_schedule. It stops short of a crisp verb+resource phrasing, but the retrieval scope is unambiguous.

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

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

Usage is only implied: the mention of 'links to get started' and device requirements signals an onboarding/informational call, but the description never states when to reach for this versus siblings such as my_profile or sign_up. No exclusions or prerequisites are given. Adequate for a trivial no-arg info tool, but not 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?

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, openWorldHint=false, so the mutation/non-idempotent profile is known. The description adds the 'after today' constraint, but does not explain what happens on a duplicate add or a rejected date, which matters given non-idempotence.

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, no filler, with the date constraint front-loaded before the parameter-sourcing note. Slightly terse grammar but nothing 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?

For a 2-parameter tool with annotations covering safety and no output schema, the description covers the essential constraint and ID provenance. It stops short of duplicate-handling or failure behavior, leaving a gap an agent would care about for a non-idempotent write.

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 only 50% — the date format lives in the schema but challenge_id has no schema description. The description compensates by telling the agent where challenge_id comes from ('as find_next_challenge and ladder give them'), which is real value beyond the structured fields.

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

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

States a specific verb+resource ('Puts a challenge on a date') and adds the timing constraint 'after today'. It is distinguishable from remove_challenge and find_next_challenge by the write action, though it never names those siblings as the contrasting 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?

Guidance is indirect: it routes the agent to find_next_challenge and ladder as the source of a challenge_id, and states the 'after today' constraint, but never says when to choose this tool over edit_schedule or schedule, nor what to do if the challenge is already on the calendar.

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 flag destructiveHint=true, which would be surprising for a chat tool; the description earns credit by explaining why ('The coach may adjust their workouts') and by noting the reply arrives in the same thread, implying conversation continuity. It does not mention non-idempotency (repeated calls post duplicate messages) or any rate/permission constraints, so it is not fully transparent.

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 with no filler: purpose and return value first, then usage triggers, then the side-effect caveat. Every sentence carries distinct information.

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

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

With no output schema, the description must cover the return, and it does ('returns the coach's reply'). It also warns about workout mutation via annotations being explained. Minor gaps: no guidance on formatting the message or what happens if 'today' is omitted, but nothing that blocks 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 coverage is 50%: the 'today' parameter carries a detailed description with format and the pre-05:00 local-date rule, while 'message' is undocumented apart from its maxLength. The description only implicitly conveys what 'message' is and adds no constraint detail (e.g., what content the coach can act on), so the 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 specific verb and resource ('Sends a message to their MONS coach'), plus the thread and return behavior ('in the same thread as the app, and returns the coach's reply'). No sibling tool does anything comparable, so it is trivially distinguishable from about_mons, check_readiness, or today.

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

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

Gives explicit trigger examples ('any training question: soreness, a missed session, how a session should feel'), which is clear positive guidance. It stops short of naming when NOT to use it (e.g., for app/account questions that belong to my_profile or about_mons), so it falls short of a 5.

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

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

Annotations already establish that this is a safe, read-only, idempotent operation. The description adds meaningful behavioral detail beyond that: it returns the next unanswered question first, then the challenge and verdict, and requires cumulative answers.

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

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

The description is tightly structured: purpose first, return behavior second, and the key invocation instruction last. Every sentence adds useful information without waste.

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

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

For a tool with no output schema and a nested answers object, the description adequately explains the response progression and the answer-accumulation requirement. It could say more about the shape of the next question or possible verdict values, but the core behavior is covered.

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 parameter meanings are already well documented. The description only reinforces the answers parameter by saying to send every answer so far each time, without adding syntax or format details beyond the schema.

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

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

The description clearly states a specific purpose: pick a challenge from training, assess readiness, and say what is still needed. It distinguishes this from simply listing challenges, but it does not explicitly name or contrast with the sibling find_next_challenge.

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 useful invocation guidance for the iterative flow, especially 'Send every answer so far each time,' but it does not explain when to use this tool instead of alternatives such as find_next_challenge or add_challenge.

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 this a destructive, non-idempotent write. The description goes beyond them by disambiguating focus=none (hands the date back to the coach) from focus=null (clears), and by stating the 'only one weekday can be the long run' constraint. It still doesn't spell out what existing entries are overwritten.

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 in the first clause and follows with two tight clarifying sentences. The none/null clause is dense but earns its place; little 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?

For a 3-parameter destructive mutation with no output schema, the description covers both operating modes, the key enum edge cases, and a validation constraint. It leaves minor gaps (overwrite semantics, permission needs) but is largely sufficient to call correctly.

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

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

Schema description coverage is only 33% (only today is documented), so the description must compensate. It explains what days and weekly each set and clarifies the subtle none-vs-null distinction for focus, adding real meaning the schema leaves silent.

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 (Sets) and resource (a coming day's focus, or a weekday's recurring focus), and cleanly splits the two modes by naming the days and weekly parameters. It does not, however, differentiate itself from the sibling schedule tool, which an agent could easily confuse it with.

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 days-vs-weekly split implicitly tells the agent which parameter to reach for in which scenario, and the none/null note gives conditional behavior. But there is no explicit when-to-use vs the sibling schedule tool, no prerequisites, and no stated exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so the safety profile is fully covered and the description need not repeat it. The description adds the practical behavior of what it returns and the hand-off to check_readiness, which is useful, but it doesn't address pagination, ordering, or how the challenge list is scoped beyond sport.

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

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

Two sentences, no filler, and the core action is front-loaded before the check_readiness hand-off. Slightly compressed phrasing ('the furthest a person has run, ridden or swum') costs a little readability but the structure is efficient.

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

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

With no output schema, the description appropriately explains what comes back (the first training question and every challenge in the sport) and what the caller does next. For a read-only query with fully documented parameters, this is nearly complete; it could still clarify what identifying inputs the tool has already or how results are ordered.

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 schema documents sport (with enum), furthest_km, and the optional challenge_id in detail. The description only loosely gestures at the input ('the furthest a person has run, ridden or swum') and says nothing about challenge_id, so it neither adds nor detracts much beyond the schema baseline of 3.

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 action: it takes the furthest distance per sport and returns the first training question plus all challenges in that sport. It clearly separates itself from the sibling check_readiness by naming it. The only ambiguity is the somewhat vague phrase 'the first question about their training', but the operation and result are recognizable.

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 sketches a workflow: this tool surfaces the questions and the challenge list, then 'check_readiness picks the challenge once the questions are answered'. This gives the agent a clear sense of when this tool is the entry point versus the follow-up. It doesn't cover other siblings like add_challenge or ladder, so it stops short of full when/when-not 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 establish readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds genuine value by disclosing the returned structure (ordered ladder stages: collected, next, ready, readiness) and the presence of removal-ready ids. It says nothing about ordering of calendar items, filtering, or empty states, so it stays at a solid-but-not-rich 3.

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 sentence that front-loads the primary payload (the ordered ladder) before the secondary calendar content. Every clause carries information, though the parenthetical stage list and trailing clause make it slightly run-on for a single sentence.

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, zero-required-parameter tool with full schema coverage and annotations, the description conveys what comes back and the ordering semantics, which is what an agent needs to invoke it correctly. Missing only edge cases such as what an empty ladder or calendar looks like.

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

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

Schema coverage is 100% and the single optional 'today' parameter is fully documented in the schema, including the 05:00 cutoff rule and the 'omit if unknown' guidance. The description never mentions the parameter, so it adds no meaning beyond the schema — the baseline 3 applies.

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

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

The description names the specific resource (the challenge ladder, plus the calendar challenges) and enumerates the ladder stages in order, which lets an agent distinguish it from find_next_challenge and check_readiness. It never states an explicit verb ('returns'/'lists'), so the read intent is inferred rather than declared, but the scope is concrete.

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?

There is no explicit when-to-use or when-not-to-use statement versus siblings like find_next_challenge or today. The only usage signal is implicit: it notes the output carries 'the id remove_challenge takes', which tells an agent this is the lookup step before removal. Adequate but thin.

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

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

Annotations declare destructiveHint=true, and the description is consistent, explaining that today's sessions are planned 'again' around the new constraints, so existing plans are regenerated. It also adds information annotations do not carry: the call 'Takes up to a minute', and that it returns the re-planned sessions. It omits whether the change is reversible or requires an existing plan.

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 with the trigger stated first and useful facts (latency, return) appended. The fragment 'Returns them' has an unclear antecedent, which is a small structural flaw but not bloat.

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

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

For a mutation tool with full schema coverage and annotations covering the safety profile, the description covers the trigger, the replanning effect, latency and a vague return note. With no output schema, 'Returns them' is too thin to tell the agent what comes back, and nothing is said about permissions or preconditions.

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 minutes, cannot_do and the date handling (including the before-05:00 rule). The description only restates minutes and cannot_do in prose and says nothing about the optional 'today' parameter, so the baseline 3 applies.

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

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

The description conveys a specific effect: given today's available minutes and what the athlete cannot do, today's sessions are re-planned. The verb is indirect ('this tells the coach... the coach plans...'), but an agent can identify the resource (today's plan) and the outcome. It does not explicitly separate itself from edit_schedule or today, which keeps it out of 5 territory.

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 clear trigger condition — 'When the athlete's day is different' — which tells the agent when this tool applies rather than a manual schedule edit. It names no alternatives (edit_schedule, schedule) and gives no exclusions, so it stops short of 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and a closed world, so the safety profile is fully covered externally. The description does add value the annotations cannot: it enumerates the data the profile contains (subscription state, endurance mix, kettlebells, DOB, max heart rate), though it omits anything about return format or units.

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 short and wastes no words, but it is a sentence fragment beginning with 'Whether' and reads as an unordered dump of fields rather than a front-loaded statement of purpose. Brevity here is a symptom of under-specification as much as economy.

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 field list is genuinely load-bearing because it is the only signal of what comes back. However, a zero-parameter read tool that is the read half of update_profile should state its action and its relationship to that sibling; the definition leaves that to inference.

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 rubric's baseline of 4 applies. Nothing in the description is needed to explain inputs, and the field names it lists are informational rather than parameter documentation.

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 text is a noun-phrase field list rather than a statement of action: no verb such as 'retrieve' or 'get' tells the agent what the tool does. The name 'my_profile' combined with the field enumeration lets an agent infer it reads the user's profile, but the definition itself only restates content, which is close to a tautology of the title 'My MONS 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?

No when-to-use guidance, no prerequisites, and no mention of the obvious alternative sibling update_profile for changing these values. The agent must infer that this is the read counterpart to update_profile entirely on its own.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false and readOnlyHint=false, so the safety profile is covered structurally. The description usefully adds the precondition that the challenge must not yet have occurred, but says nothing about irreversibility, error behavior, or what exactly is deleted from the calendar.

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 front-loaded sentence with no filler. The trailing phrase "by its id from ladder on_the_calendar" is slightly awkward and would read better restructured, 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?

For a simple single-parameter destructive mutation with annotations covering the safety profile and no output schema, the description covers purpose and a key precondition. It leaves gaps around failure modes, reversibility, and where exactly to obtain the id.

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

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

The schema has 0% description coverage on the single required id parameter (string, maxLength 64). The description partially compensates by indicating the id originates from the ladder/on_the_calendar context, but gives no format, source-lookup, or example guidance.

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

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

States a specific verb ("Removes") and resource ("challenge"), and adds a scoping constraint ("that has not happened yet"). It implicitly contrasts with add_challenge but never names a sibling or alternative 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?

The phrase "that has not happened yet" implies a precondition (only future/upcoming challenges are removable), but there is no explicit when-to-use guidance or reference to alternatives like edit_schedule or find_next_challenge.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is fully covered by structured data. The description adds that output spans both future plans and past sessions, which is useful scope context, but leaves the ambiguous phrase 'sessions so far' unexplained and says nothing about ordering, limits, or response shape.

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 with the payload front-loaded; every clause carries content (planned days, weekly rules, logged sessions). Slight loss for the vague phrasing 'the weekly rules' and 'the sessions so far', which costs precision without saving much space.

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 must carry the return-value burden, and it does sketch the three content areas. It still omits how many days are returned, what the weekly rules look like, and whether 'sessions so far' means completed activities or future entries, leaving gaps for a zero-required-parameter 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 100%: the single optional 'today' parameter already documents its YYYY-MM-DD format, the pre-05:00 rollback rule, and that omission is allowed. The description adds nothing about this parameter, so the schema baseline of 3 applies.

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

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

The description names the resource clearly: the training schedule covering planned days (rest, long run, sport), the weekly rules, and sessions logged so far. It reads as a retrieval of the person's plan. However, it never distinguishes itself from the closely related sibling edit_schedule or today, so an agent cannot tell from the text alone whereas this is the read path.

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?

There is no when-to-use guidance: nothing says to pick this instead of edit_schedule (to modify) or today (for today's view). Usage must be inferred entirely from the noun phrase. This is a missed opportunity given three plausible sibling overlaps.

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

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

Annotations already declare the write/idempotent/non-destructive profile, and the description adds real value on top: it mirrors the app's onboarding flow and explicitly does nothing to an account that is already set up. It omits auth/session requirements and what state results after setup, but the annotation bar is met and exceeded.

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, zero filler, with the core action front-loaded and the no-op caveat last. Every sentence carries information the agent needs.

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

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

For a nested, multi-parameter mutation with no output schema, the description covers purpose, input provenance, and idempotent behavior adequately. It could say more about what the account gains after setup (schedule, challenge), but nothing critical to 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?

Schema description coverage is 100%, so the schema already explains all six parameters in detail, including the enum, kettlebell weight classes, and challenge_id sourcing. The description only gestures at 'the challenge and answers from check_readiness', which adds little and slightly blurs that challenge_id actually comes from find_next_challenge. 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 specific verb and resource ('Sets up the signed-in person's MONS account') and anchors it to onboarding behavior, so an agent can tell it apart from update_profile/my_profile. It stops short of naming a sibling tool explicitly, which is what a 5 would require.

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 clear usage context: pass challenge/answers sourced from check_readiness when they exist, and it is a no-op on an already-configured account. It does not explicitly say when to prefer this over update_profile, so it is short of full alternative routing.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description does add one genuinely useful behavioral fact: the result may indicate that today has not been designed yet, which is an empty-state the agent should anticipate. It says nothing about pagination, freshness, or return shape beyond that.

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 compact sentence with no filler, and the two possible outcomes are stated up front. Slightly awkward grammar ('or that today is not designed yet') 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?

With no output schema and a read-only annotation profile, the description does just enough by flagging the not-yet-designed case. It still leaves the shape of a returned session unspecified, which an agent selecting and parsing this tool would benefit from knowing.

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

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

Schema coverage is 100% and the single optional `today` parameter is fully documented in the schema, including the 05:00 cutoff rule and the omit-if-unknown instruction. The description contributes no parameter meaning at all, so the baseline 3 applies.

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

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

The description identifies the resource (today's training sessions as the coach designed them) but is phrased as a noun fragment with no verb, so it reads more like a title restatement than a defined action. It also does not differentiate itself from nearby siblings such as schedule, edit_schedule, or morning_check_in.

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?

There is no explicit when-to-use guidance and no named alternative. An agent must infer on its own whether this is the right tool versus schedule or morning_check_in, and no prerequisites or exclusions are given.

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 a mutating, idempotent, destructive operation, so the safety profile is covered structurally. The description adds the partial-update contract ('Send only what changes'), usefully implying omitted fields are left alone, but it never explains what destructiveHint actually means here or whether an omitted field resets.

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 the partial-update rule; nothing is wasted. The pronoun 'they' is slightly ambiguous (the user), which keeps it from a 5.

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?

No output schema exists, but with 100% schema coverage and annotations covering the mutation profile, the description supplies the one thing not in structured data: the partial-update contract. Minor gaps remain around omitted-field behavior.

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 schema fully documents the 'mix' enum values and the kettlebells weight classes and counts. The description merely names the same fields without adding format or constraint detail, 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 ('Changes') and resource (profile), naming the two updatable fields (mix/endurance, kettlebells). It does not explicitly differentiate itself from the sibling 'my_profile' read tool, so it is clear but not fully sibling-differentiating.

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?

'Send only what changes' gives a partial-update instruction, which is a usage hint, but there is no guidance on when to use this versus 'my_profile' or when not to call it. Usage 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.