anatome

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

Annotations provide minimal safety info (readOnlyHint=false, openWorldHint=true), but the description adds no context on whether the plan is persisted, side effects, or environmental dependencies. No contradiction exists, but the tool's behavioral footprint is under-disclosed.

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

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

The description is a single, front-loaded sentence with zero redundancy. It is concise and directly states the tool's purpose.

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

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

An output schema exists so return structure is covered, but parameter semantics are not, and usage guidance is absent. The description under-specifies a generation tool with 4 parameters and 0% schema coverage.

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 vaguely refers to 'goals + preferences' but does not explain individual parameters (days, goal, diet_type, daily_calories), formats, units, or allowed values.

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

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

The description clearly states the tool's function with a specific verb 'Generate' and resource 'multi-day meal plan'. It also indicates inputs ('goals + preferences') and distinguishes from sibling tools like ai_workout_plan (different domain) and meal logging 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?

Usage is implied from the description: use when you need a multi-day meal plan. However, there is no explicit guidance on when to use this versus alternatives (e.g., ai_workout_plan) or exclusions.

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

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

Annotations provide readOnlyHint=false, but the description clarifies the transformation behavior and output format. However, it does not disclose potential side effects, permissions, or failure modes. It adds some context beyond annotations but not rich behavioral detail.

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

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

The description is a single sentence with an illustrative example, making it concise and front-loaded. Every word contributes value without unnecessary verbosity.

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 the return structure is covered. The description conveys the core use case effectively with the example, but lacks guidance on locale handling and invalid input. For a simple tool, this is adequate.

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 only provides an example for the 'text' parameter ('2 eggs and toast with butter'). The 'locale' parameter is entirely unmentioned, leaving a significant gap in parameter understanding.

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

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

The description uses the specific verb 'Parse' with a concrete resource 'free-text meal description' and states the output 'structured items with grams + macros'. This clearly distinguishes it from sibling tools like ai_photo_macros (photo-based) and search_foods (search).

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

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

The description implies usage for free-text meal inputs with an example, but it does not explicitly state when to use this tool over alternatives or mention any exclusions. There is no reference to sibling tools, so guidance is limited to implied context.

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 provide readOnlyHint=false, destructiveHint=false, idempotentHint=false, but no budget or model info. The description adds valuable behavioral context: 'Vision model' clarifies the underlying model type, and 'capped separately from the text AI budget (free tier 1/mo)' discloses a rate limit not present in annotations. This goes beyond the structured data without contradicting it.

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

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

The description is two sentences: the first states the purpose, the second covers input requirements and budget. Every sentence earns its place with no wasted words. It is front-loaded with the main action and immediately explains the critical input constraint.

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

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

For a tool with 2 parameters and an output schema, the description covers the key aspects: purpose, input exclusivity, and a notable budget limitation. It does not mention potential edge cases (e.g., image size limits) but the output schema exists to describe return values, and annotations cover safety traits. The budget cap is a critical contextual detail that is included.

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 both parameters are already well-described in the schema (mutually exclusive, base64 no data prefix). The description's phrase 'exactly one' reinforces the oneOf constraint but adds no extra meaning beyond the schema. Per the rubric, baseline 3 is appropriate when the schema does the heavy lifting.

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: 'Analyze a meal image and estimate foods + macros.' This is a specific verb+resource (analyze meal image) that distinguishes it from siblings like ai_parse_meal (likely text-based) or ai_meal_plan (meal planning, not analysis).

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 clear input guidance ('Pass exactly one of image_url or image_base64') and notes the separate budget cap, implying this is for image-based analysis. However, it does not explicitly compare to alternatives (e.g., 'for text-based meal parsing, use ai_parse_meal'), so the when-to-use guidance remains implicit rather than 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 indicate readOnlyHint=false, so the description adds little behavioral context. It does not disclose whether the plan is persisted, returned, or has side effects, leaving the agent uncertain about the tool's operational profile.

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

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

The description is a single front-loaded sentence with no waste, but it is under-specified for the information needed. While concise, it sacrifices necessary detail, making it less useful than a slightly longer but more complete description.

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 3 parameters and 0% schema coverage, the description is incomplete. It does not explain all inputs or usage context, and the phrase 'goals + history' is ambiguous. The output schema exists, but input understanding remains insufficient.

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 minimally addresses parameters. It mentions 'goals' (matching goal) and possibly 'history' (matching experience) but omits days_per_week entirely. It fails to clarify parameter formats or purposes, providing no compensatory value.

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 the tool generates a workout plan, using a specific verb ('generate') and resource ('workout plan'). However, it mentions 'history' which is not a schema parameter, introducing ambiguity about inputs and not clearly distinguishing it from related routine 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?

No guidance is provided on when to use this tool versus alternatives like instantiate_routine or get_routine. It does not mention when to use or avoid this tool, nor any prerequisites.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds valuable behavioral context: 'soft delete, 30-day recovery window' and 'Requires X-App-User-Id'. This goes beyond annotations by explaining reversibility and authentication needs, though it does not mention other side effects or return values.

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

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

The description is one concise sentence, front-loaded with the action ('Delete a logged meal by id') followed by essential parenthetical details. Every word earns its place, with no fluff.

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

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

For a simple deletion tool with one parameter and an output schema present, the description covers purpose, behavior (soft delete), and auth (X-App-User-Id). It is complete enough for an agent to use correctly, though return values could be detailed if the output schema did not already exist.

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 must compensate. It explains that meal_id identifies the meal to delete ('Delete a logged meal by id'), but it does not provide format details or how to obtain the id (e.g., from get_meals). The meaning is clear enough for a single parameter but lacks depth.

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

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

The description clearly states 'Delete a logged meal by id', which is a specific verb and resource. It distinguishes from sibling tools like delete_workout and update_meal by focusing on meal deletion.

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 when to use this tool (when deleting a logged meal) and notes a prerequisite (requires X-App-User-Id), but it does not explicitly mention alternatives or exclusions, such as using update_meal for modifications. The 30-day recovery window hints at safe usage but does not replace 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 adds significant behavioral context beyond the annotations: it reveals the delete is a soft delete with a 30-day recovery window, and that sets are also affected. This provides the agent with important information about reversibility and cascading effects that annotations alone do not convey.

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

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

The description is a single, well-structured sentence that front-loads the core action and includes a concise parenthetical with key behavioral details. Every word adds value, with no redundancy or filler.

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

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

For a simple delete tool with one parameter, an output schema, and annotations already declaring destructive intent, the description covers the essential context: what is deleted, how it is identified, the soft-delete behavior, the recovery window, and the cascading effect on sets. No critical information is missing.

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

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

The schema has no property descriptions (0% coverage), and the description only says 'by id', which adds marginal value beyond the parameter name 'workout_id'. Since there is only one simple parameter, the name is mostly self-explanatory, but the description does not offer additional details like ID format or source, so it meets the baseline but does not exceed it.

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 action ('Delete'), the resource ('a logged workout'), and the scope ('and its sets'), with 'by id' specifying the identification method. This distinguishes it from sibling tools like delete_meal and provides a precise, unambiguous purpose.

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

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

The description implies when to use this tool: when you need to delete a workout and its sets. It also adds useful context about the soft-delete and 30-day recovery window, which informs usage decisions. However, it does not explicitly discuss alternatives or when not to use it, so it falls short of full 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 provide readOnlyHint=true and idempotentHint=true, and the description adds meaningful context about the data scope (list of domains), the GDPR rationale, and the security property that caller-supplied user ids are ignored. No contradictions with annotations.

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

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

Two sentences carry all essential information: the first states the action and scope, the second adds legal context and security. No filler, front-loaded with the most critical detail.

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 is complete for an export operation: covers purpose, data scope, auth, and legal basis. An output schema exists (not shown), so return value details are not required. It could mention large-payload handling or rate limits, but these are not critical for this tool's core usage, especially with read-only/idempotent annotations.

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

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

The schema describes 'domains' with an example, but the main description enriches parameter semantics by listing all supported domain values ('meals, water, workouts, sets, cardio, body metrics, goals, notes, supplements, profile'), which is beyond the schema's example. This helps the agent understand valid inputs without additional lookups.

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 verb ('Export') and resource ('the signed-in user's complete data as JSON') and enumerates the data types included. It distinguishes from sibling get_* tools by emphasizing the complete-data scope and GDPR portability purpose.

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

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

The description explicitly ties usage to the GDPR Art. 20 portability right and clarifies identity is derived from the OAuth token or bound key, never a caller-supplied user id. It does not explicitly say 'use get_* for single-domain queries,' but the 'complete data' framing implies this is for full export, not focused retrieval.

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 provide basic safety indicators (readOnlyHint: false, destructiveHint: false, idempotentHint: false). The description adds the behavioral detail of 'arbitrary colors' and the return format 'Returns SVG.' However, it does not disclose why readOnlyHint is false or any potential side effects, though there is no contradiction. Given the annotations carry most of the burden, the description adds modest value.

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

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

The description is a single concise sentence (plus a short return statement). It front-loads the primary purpose and adds only essential information about the output. Every word earns its place; there is no filler or redundancy.

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

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

The tool has three parameters, one required ('layers'), yet the description does not explain what 'layers' should contain or how the parameters influence the output. With no schema descriptions and no meaningful clues in the description, an agent cannot correctly invoke this tool without guessing. The return format is stated, but the input semantics are entirely missing, making the description insufficient for a usable 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 schema has 0% description coverage for its three parameters. The description does not explain the meaning of 'view,' 'gender,' or 'layers,' especially the crucial 'layers' parameter which is an array with no item type. The mention of 'arbitrary colors' could relate to layers but is not tied to any parameter. The description fails to compensate for the schema's lack of 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 description clearly states the tool's function: 'Render an SVG diagram of the human body with muscles highlighted in arbitrary colors.' It uses a specific verb ('Render') and a specific resource (SVG human body diagram), and further clarifies the output by stating 'Returns SVG.' This distinguishes it from sibling tools, none of which generate such images.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not state any prerequisites, exclusions, or contexts where it would be preferred. The sibling tools include list_muscles and get_muscle_recovery, but the description gives no comparative advice. There is no explicit or implied usage context beyond the basic function.

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 openWorldHint=false. The description adds valuable behavioral context beyond annotations, such as 'most recent first' ordering and the requirement for an app user context. No contradictions with annotations.

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

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

The description is two sentences, front-loaded with the main action, and every phrase adds value. No redundant information or fluff.

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

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

The description covers the tool's core purpose, filters, ordering, and context requirement. An output schema exists, so return values are presumably documented there. While pagination via 'limit' is not described, overall the description is sufficient for the tool's simplicity.

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

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

Schema description coverage is 0%, so the description must carry the burden. It explains metric_type (with examples 'weight', 'bicep') and the date range (from/to) as filters. However, the 'limit' parameter is not mentioned, leaving its meaning to be inferred from the schema.

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

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

The description clearly states the tool's purpose: to list the current app user's body metrics/measurements, with examples (weight, height, bicep, body fat) and ordering (most recent first). This distinguishes it from sibling tools like log_body_metric (which writes) and other getters focused on different resources.

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

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

The description implies usage for reading body metrics and mentions filtering options, but does not explicitly state when to use this tool over alternatives or provide exclusions. It gives context (requires app user context) but lacks direct comparison with sibling tools.

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

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

The readOnlyHint and idempotentHint annotations already establish the safety profile. The description adds the behavioral detail of 'most recent first' ordering, which is useful. It doesn't mention pagination or date range behavior, but with strong annotations, this is sufficient.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently conveys the core action, scope, and ordering, earning the highest conciseness score.

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

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

The tool has an output schema and annotations, reducing the need to describe return values or safety. However, the description omits key context around the optional date range and limit parameters, leaving the agent uncertain about how to use them. It's adequate for a simple list tool but lacks full operational detail.

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

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

The input schema lists three optional parameters (limit, date_to, date_from) with no descriptions, and the description does not explain their semantics. At 0% schema description coverage, the burden falls on the description, which fails to describe how date filtering works or the default limit. The parameter names are intuitive but not 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?

The description clearly states the tool lists the current user's cardio activities, most recent first. It specifies a verb ('List'), a resource ('cardio activities'), and the ordering, making the purpose unambiguous. It doesn't explicitly differentiate from sibling tools like get_workouts, but the resource name is specific enough.

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_workouts or log_cardio. It lacks any context about prerequisites, typical use cases, or exclusions, leaving the agent to infer appropriate usage from the name alone.

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

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

Beyond the readOnlyHint and idempotentHint annotations, the description reveals key behavior: it returns a sequence of events with {seq, entity, id, action}, includes deletes, and uses a cursor-based pagination model. This significantly helps an agent understand what to expect and how to maintain state across calls.

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

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

The description is two sentences long, front-loads the core purpose, and every clause adds value. It packs the return format, cursor protocol, and first-sync behavior without any fluff 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?

Given the tool has an output schema and only three optional parameters, the description covers the essential usage: what it returns, how to page, and when to use it. The sync protocol is fully explained, making the tool self-contained for an agent. No major gaps remain.

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

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

The description adds critical semantics for `since` by explaining to pass the last seq back, and notes the behavior when omitted. The schema already covers `since` and `entities`, but `limit` remains undocumented in both schema and description. With 67% coverage, the description compensates for the key parameter but not fully for `limit`.

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 starts with 'What changed since a cursor', clearly identifying the tool as a change-feed/event log. It explicitly mentions 'including DELETES, which a list read cannot show', distinguishing it from list-style siblings like get_meals or get_workouts. The verb+resource is specific and 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 indicates when to use the tool: for incremental sync or when deletions need to be captured, which list reads cannot show. It also provides concrete protocol advice ('omit `since` for a first sync'), but it does not name specific sibling alternatives, leaving room for more explicit 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?

The description adds the three lookup modes, going slightly beyond annotations, but it does not disclose behavior when multiple parameters are supplied, whether random takes precedence, or what happens on no match. Annotations declare read-only, and there is no contradiction.

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

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

One concise, front-loaded sentence with no fluff; every word contributes 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?

The description is minimal and misses important context: relationships with sibling tools, parameter interaction rules (e.g., if multiple fields are set), and error behavior. While the output schema covers return values, input semantics are underspecified.

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

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

The description associates the three parameters with their roles (name, id, random), but does not elaborate on expected formats, mutual exclusivity, or precedence. Since schema description coverage is 0%, this is partial compensation but 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 clearly states the tool fetches a single exercise and specifies three access modes (name, id, random), which distinguishes it from sibling tools like search_exercises that likely return multiple results.

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?

Implied usage is provided via 'by name, id, or random', but there is no explicit guidance on when to prefer this over sibling tools like resolve_exercise or search_exercises, nor any exclusions or alternative recommendations.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, which cover the safety profile. The description adds that it's scoped to the current user and filtered by date range, which is useful context. However, it does not disclose edge cases like omitted parameters or return format, but with output schema present, that's partially mitigated. The description does not contradict 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 a single, focused sentence with no filler. It is front-loaded with the action and resource, making it immediately clear what the tool does. Every word contributes 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?

The tool is simple with two optional string parameters and an output schema, so the description need not explain return values. However, the description says 'for a date range' while the schema marks parameters as optional, creating ambiguity about what happens when no range is provided. This is a meaningful gap for a complete context, but the output schema and annotations help 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?

Schema description coverage is 0%, so the description must compensate for parameter meaning. It only says 'for a date range' which hints that date_to and date_from form a range, but does not explain which is which, optionality, format, or behavior when omitted. The property names in the schema are self-explanatory, so the description adds minimal value beyond what the schema already implies.

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 action (List), a specific resource (the current app user's meals), and a parameter scope (for a date range). This distinguishes it from sibling tools like get_nutrition_daily or get_workouts, which target different data types. The verb-resource pair 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?

The description implies when to use this tool: whenever you need to retrieve meals for the current user within a date range. It does not explicitly name alternatives or exclusions, but the context is clear enough that an agent would not confuse it with related tools like get_nutrition_daily. There is no misleading 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 (readOnlyHint, idempotentHint) already convey the safe, read-only nature, so the description doesn't need to repeat that. It adds value by explaining the optional parameter's effect: including bodyweight makes recovery reflect 'real load.' This is honest and provides context beyond the annotations. No contradiction with annotations.

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

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

Two punchy sentences plus a dash-separated fragment deliver the core idea, usage context, and parameter guidance without waste. The most important information is front-loaded, and every phrase contributes 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?

For a simple read-only tool with one parameter, the description is complete. It explains what the tool returns (7-day recovery per muscle), recommends fresh muscles, and clarifies the optional bodyweight flag. The presence of a full output schema further covers return structure. 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?

The input schema already fully documents the single boolean parameter at 100% coverage, including its meaning and requirement about logged weight. The description adds a brief 'so recovery reflects real load' rationale, but this is marginal. Since schema carries the full burden, 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?

The description clearly states the resource: 'Per-muscle 7-day recovery %' and the action: 'Recommends fresh muscles.' It distinguishes itself from sibling tools like get_body_metrics or get_ppl_day by framing it as the 'what should I train today?' input. The mention of 'Fitbod parity' also adds specificity.

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 clear usage context—this is the tool for deciding what to train based on muscle recovery. It doesn't explicitly name alternative tools or exclusions, but the 'what should I train today?' framing implies when to use it. A brief note on avoiding it for other purposes would make it a 5.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the description adds the X-App-User-Id auth requirement and the default last-7-days behavior. This goes beyond the structured fields and gives actionable context without contradicting 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 consists of three short, information-dense sentences: a listing of the tool's output, a usage heuristic, and an auth requirement. No filler or redundancy.

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

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

With an output schema and only two optional, well-documented parameters, the description covers the essential context: daily aggregation, default range, and auth requirement. It does not need to explain return values because the output schema exists.

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 fully documents both date parameters, but the description adds the default date-range behavior ('last 7 days'), which is not explicitly stated in the parameter descriptions. This clarifies what happens when parameters are omitted, adding value beyond the schema.

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

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

The description clearly identifies the tool as a daily nutrition aggregator, listing specific metrics (calories, macros, fiber/sugar/sodium/alcohol, water, targets, adherence %) and the date range. The 'per-day' and 'how am I tracking today?' phrasing distinguishes it from weekly alternatives like get_nutrition_weekly.

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 offers a clear use case ('how am I tracking today?') and a default date range, which helps the agent decide when to invoke it. However, it does not explicitly state when not to use it or name alternatives such as get_nutrition_weekly, 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 declare readOnlyHint and idempotentHint, so the safety profile is known. The description adds meaningful behavioral context: it requires X-App-User-Id and clarifies the aggregation behavior (rollup, average daily calories) beyond what annotations state.

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

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

The description is compact and front-loaded, stating the core rollup first, then the use-case, then the auth requirement. Every sentence contributes distinct information; 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 a simple 2-parameter schema and an output schema present, the description covers purpose, use-case, and auth. However, it omits details like date format (e.g., ISO 8601), behavior when parameters are omitted, or how the rollup handles partial ranges. These gaps could lead to incorrect tool invocation.

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

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

The schema has 0% description coverage for its two parameters (date_from, date_to), and the description provides no additional guidance about their formats, meaning, or optionality. The names are self-explanatory, but the description fails to compensate for the empty schema and does not mention how the date range works.

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 verb+resource+scope: 'Per-week rollup of calories, macros, nutrients, water and days-logged' with 'average daily calories'. This distinguishes it from similar tools like get_nutrition_daily, and the explicit use-case 'how was my last month?' reinforces its purpose.

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

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

The description gives a clear context for when to use the tool via the quoted user intent, though it does not explicitly mention alternatives or exclusions. The presence of sibling get_nutrition_daily makes the weekly-vs-daily contrast implicit but not 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 declare readOnlyHint=true and idempotentHint=true, so the read-only behavior is already disclosed. The description adds that the output is 'canonical' slots, indicating a fixed, standard template rather than user-specific data, and the constraint on 'day' values. This is consistent with the closed-world hint.

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

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

The description is one compact sentence that front-loads the tool's purpose with 'Push/pull/legs shortcut' and avoids redundant wording. The parenthetical adds a useful real-world usage example without verbosity. Every phrase serves a purpose.

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

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

Given the tool's simplicity (one parameter, output schema present, read-only), the description sufficiently covers the domain, input constraint, and intended output. It does not need to detail the return structure since an output schema exists, and the annotations already cover safety and idempotency.

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 no parameter descriptions (0% coverage), so the description carries the full burden for the single 'day' parameter. It explicitly enumerates valid values ('push, pull, or legs') and explains the semantic meaning: which PPL day's exercise slots to return. The colloquial example ('give me a push workout') reinforces the 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?

The description clearly states the tool returns the exercise slots for a canonical push/pull/legs day, using the active verb 'returns' and specifying the resource ('canonical PPL day's exercise slots'). It distinguishes from sibling get_* tools by framing itself as a PPL-specific shortcut ('the give me a push workout wedge').

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

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

The description provides a clear use case: when a user asks for a push/pull/legs workout ('the give me a push workout wedge'), and sets the parameter constraint ('day must be push, pull, or legs'). It does not explicitly name alternative tools or exclusions, but the 'shortcut' label implies a special-purpose choice over broader workout retrieval tools.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description's 'Get' is consistent. It adds context about the required app user context and the specific profile fields, though it does not detail auth, errors, or return behavior beyond annotations.

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

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

Single sentence, front-loaded with the verb and resource, no redundant content. Every word contributes to understanding the tool's purpose.

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

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

For a parameterless read-only profile getter with an output schema and read-only annotations, the description adequately captures purpose, scope, and prerequisite. It does not need to explain return values because an output schema exists.

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 zero parameters, the schema covers all inputs trivially (100% coverage). The description adds no parameter semantics because none are needed; the baseline of 4 applies.

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

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

The description uses the specific verb 'Get' and identifies a clear resource: the current app user's fitness profile, enumerating contents (height, weight, goals, diet, sports). This distinguishes it from sibling getters focused on metrics, nutrition, water, or progress.

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 states a clear prerequisite ('Requires an app user context'), which helps determine when this tool is appropriate. It does not name alternatives or exclusions, but the scope is clear enough to guide a natural fit alongside sibling getters.

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 tool as read-only and idempotent, so the description does not need to restate that. It adds valuable behavioral details beyond annotations, such as 'Only completed sets count' and the interpretation of training_load values (acute:chronic ratio with >1.5 and <0.8 thresholds). These nuances help the agent understand what data is included and how to interpret results, going beyond the structured 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?

The description is extremely concise, consisting of two sentences. It front-loads the core purpose ('Any progression metric for the current user') and then efficiently lists all metric options with inline clarifications. No redundant words or fluff—every part earns its place, making it easy to scan and understand.

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

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

Given the tool's complexity (14 params, output schema exists) and the rich annotations, the description is fairly complete. It covers all metric options and adds important behavioral filters (completed sets, training_load thresholds, per-muscle freshness). However, it lacks explicit guidance on when to choose this tool over sibling getters, which is a notable gap for contextual completeness.

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

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

Schema description coverage is high at 86%, so the baseline is 3. The description does add some contextual meaning for metric-specific parameters (e.g., correlate uses metric_a vs metric_b, training_load supports windows), but it does not elaborate on parameters beyond what the schema already provides. Overall, it does not significantly compensate for the few undocumented parameters, but the schema covers most of the burden.

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

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

The description clearly states the tool returns 'any progression metric for the current user' and enumerates the specific metrics, giving a precise sense of scope. It distinguishes itself from siblings through unique metrics like 'correlate' and 'compare_periods', but does not explicitly differentiate from overlapping getters like get_muscle_recovery. Overall, it is specific and useful, but could more firmly contrast with sibling 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?

The description implies usage by listing metrics and includes contextual notes like training_load thresholds and 'only completed sets count', but it never explicitly states when to use this tool versus alternatives such as get_muscle_recovery or get_body_metrics. No exclusions or alternative tool references are provided, leaving the agent to infer the intended use case.

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 idempotentHint, and the description adds value by disclosing the expansion behavior: all days, slots, exercises, sets, reps ranges, rest, and superset groupings. This richer detail about output composition goes beyond the structured hints, though it does not cover error cases or auth requirements.

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

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

The description is two sentences, front-loads the primary action, and avoids redundancy. The second sentence is a memorable shorthand that reinforces the tool's purpose without wasting words.

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

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

For a single-parameter, read-only tool with an output schema and safety annotations, the description is largely complete: it states what is fetched and how much detail is included. It could mention how to find the slug (e.g., via list_routines), but the sibling tool context makes this omission acceptable.

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 carries the burden for explaining the 'slug' parameter, but it only repeats the word 'slug' without defining its format, provenance, or how to discover valid values. The phrase 'by slug' adds little beyond the schema's property name and type.

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

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

The description uses a specific verb 'Fetch' and identifies the resource as 'a single curated routine by slug', clearly distinguishing it from list_routines (list) and get_ppl_day (single day). It also enumerates the expanded contents, leaving no ambiguity about what the tool returns.

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 when to use this tool via 'The give me a full program tool', indicating it is for retrieving a complete routine rather than a list or a single day. It does not explicitly name alternative tools or state exclusions, but the context is clear enough among 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 and idempotentHint, covering safety. The description adds useful behavioral context: the requirement of X-App-User-Id and that it is scoped to the 'current app user'. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence that covers the purpose and an essential auth requirement. Every word adds value; there's no redundancy or filler.

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

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

While annotations and output schema cover safety and return values, the description leaves the relationship between the three optional date parameters ambiguous. Given the tool's simplicity, the description is minimally adequate but has a notable gap in guiding request construction.

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 only mentions 'date range' without explaining the roles of 'date', 'date_from', and 'date_to'. It does not clarify whether 'date' is a single date or alias, or whether the range params are required together. The description fails to compensate for the missing schema details.

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 verb ('List'), resource ('water intake entries'), and scope ('current app user' and 'date range'). It distinguishes itself from sibling tools like log_water, which is for creating entries.

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

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

It provides clear context for when to use this tool (listing water intake for the authenticated user over a range) and includes a required auth header (X-App-User-Id). It doesn't explicitly exclude alternatives, but the read-only nature and sibling names make the use case 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 indicate read-only and idempotent behavior. The description adds context by listing the contents of the response, which is useful. However, it does not disclose how 'recent' is defined, pagination behavior, or whether ordering is applied, leaving some behavioral ambiguity.

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

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

The description is a single, information-dense sentence that front-loads the resource name and lists the key data fields. It is concise and free of filler, though it could be slightly more explicit about the action (e.g., 'Retrieves').

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

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

The description covers the core purpose and return contents, but it omits parameter semantics and usage context. The vagueness of 'Recent' and the lack of filtering details leave significant gaps, especially given that the schema provides no parameter descriptions.

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

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

Schema description coverage is 0%, and the description does not explain either 'limit' or 'status'. The agent has no way to know what values status accepts or how limit affects the results; the default of 8 appears only in the schema, making this parameter poorly specified.

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

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

The description clearly identifies the resource ('weekly progress check-ins') and enumerates the data fields returned (bodyweight, energy, sleep, adherence, wins, blockers, coach reply). The name reinforces the retrieval action, and it is easily distinguishable from siblings like log_weekly_checkin and other data-retrieval 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?

The description provides no guidance on when to use this tool versus alternatives such as get_progress or get_body_metrics. It also fails to mention the write counterpart log_weekly_checkin. Usage context must be inferred entirely from the sibling list.

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

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

Annotations already mark it read-only and idempotent, so the agent knows it's safe. The description adds valuable context about the data scope ('current app user') and ordering ('most recent first'), which are not in the annotations. 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?

A single sentence of 11 words delivers the core purpose with no filler. It is front-loaded with the action verb and resource, making it highly scannable.

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

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

The description covers the essential purpose, scope, and ordering, and the output schema likely explains return values. However, it lacks any explanation of the three optional input parameters, which is a gap for a tool with 0% schema description coverage. Still, given the simple list operation and strong annotations, it's serviceable.

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 zero schema description coverage, the description needed to compensate but doesn't mention the `limit`, `date_from`, or `date_to` parameters. While parameter names are somewhat self-explanatory, the description provides no semantics for how filtering or limiting works, leaving the agent to guess.

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 'List' as the verb, identifies the resource as 'current app user's workouts', and adds an ordering constraint ('most recent first'). This distinguishes it from sibling tools like log_workout (creating) and delete_workout (deleting), making purpose unmistakable.

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

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

The description implies this is the go-to tool for viewing workouts but does not explicitly state when to use it over alternatives (e.g., for a single workout or routine). Sibling names provide some context, but the description itself offers no exclusions or alternative 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 adds auth requirement (X-App-User-Id) and behavioral details like skipping rest days and stepping by cadence_days, which go beyond the annotations. Annotations already indicate a non-read-only operation, and the description confirms it without contradiction.

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

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

Two sentences, packed with essential information and no redundancy. The description is efficiently structured and front-loaded with the primary action.

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

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

The description covers the core purpose, key parameters, and auth requirement. Output schema exists for return values, so not describing them is acceptable. Minor gaps like error handling or idempotency behavior are not critical given the simplicity.

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 40% schema coverage, the description compensates by explaining the roles of start_date and cadence_days in the scheduling logic. target_external_user_id is described in the schema, but routine_id and idempotency_key remain underdocumented; however, routine_id is self-explanatory given the tool name and idempotency_key's purpose is common.

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

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

The description clearly states the tool's function: scheduling a user's routine into planned workouts, with specific details about start date and cadence. It distinguishes itself from sibling tools by focusing on the routine-to-calendar instantiation, not logging or reading.

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 'Bridges the routine library into the user's calendar' gives clear context for when to use this tool. It doesn't explicitly name alternatives or exclusions, but the purpose is sufficiently distinct from siblings like log_workout or get_routine.

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 idempotentHint, and the description does not contradict them. The description adds useful behavioral context by stating the fixed count of 23 and the inclusion of anatomical names, which goes beyond the annotations.

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

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

The description is a single, tightly scoped sentence that front-loads the verb and immediately specifies the subject and scope. No filler, repetition, or redundant information exists.

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

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

Given zero parameters, a rich output schema, and annotations covering safety and mutability, the description is fully sufficient. It clearly communicates the exact content (all 23 slugs with anatomical names) and no further context is needed.

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

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

The tool has zero parameters, so the description carries no parameter burden. The baseline of 4 applies because there is nothing to explain beyond what the schema already shows.

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

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

The description uses the specific verb 'List' and clearly identifies the resource (supported muscle slugs) and the output content (anatomical names). It also specifies the exact cardinality (23), which distinguishes it from sibling tools like get_muscle_recovery or generate_muscle_image.

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 this is the canonical reference for muscle identifiers, which is a clear use case. However, it does not explicitly state when to prefer this over alternatives or mention any exclusions, so it lacks explicit usage guidance.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds that it 'Returns minimal list,' which is a behavioral trait not in the annotations. It does not disclose pagination or other limitations, but with annotations handling the core safety, this is adequate.

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

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

The description is three concise sentences, front-loaded with the main purpose. Every sentence adds value: what it does, how to filter, and what to expect in return. No wasted words or redundant statements.

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

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

Given the tool's complexity (5 optional params) and the presence of an output schema, the description is sufficiently complete. It covers the purpose, filter criteria, and return type. It could mention alternative tools for detailed views, but the 'minimal list' phrase and sibling names like 'get_routine' provide enough context. The annotation coverage also reduces 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?

Schema description coverage is 0%, so the description must compensate. It lists the filterable parameters: 'difficulty, goal, split_type, days_per_week,' which adds meaning beyond the raw schema by indicating they are filters. However, it omits the 'limit' parameter and does not explain enum semantics, 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 clearly states the tool's purpose: 'Browse the curated workout routine library' with specific examples (PPL, upper/lower, full-body, 5x5). This uses a specific verb ('Browse') and resource ('workout routine library'), and distinguishes it from siblings like 'get_routine' which retrieves a single routine.

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

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

The description implies usage context (browsing a library, filtering by criteria) but does not explicitly mention alternatives or when not to use this tool. There is no exclusion of 'get_routine' for detailed views, though 'Returns minimal list' hints at a trade-off. This is implied guidance rather than 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 indicate a non-read-only write operation. The description adds the consequence that logging weight enables bodyweight-inclusive volume analytics, but it does not disclose other behavioral details such as idempotency behavior, despite the presence of an idempotency_key parameter. No contradiction with annotations.

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

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

The description is concise and front-loaded with the action ('Log a body measurement'). The list of metric types is efficiently packed into a single sentence, and the note about weight analytics is a valuable addition without unnecessary fluff.

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

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

Given the output schema and annotations, the description covers the most critical parameter semantics (metric_type and unit) and provides a use-case for weight logging. Minor gaps remain for date format, value constraints, and idempotency handling, but these are partly addressed by the schema's basic type 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?

With zero schema description coverage, the description compensates by enumerating all metric_type options with their corresponding units, which is essential for correct invocation. However, parameters like date, value, notes, and idempotency_key are not elaborated beyond their schema types, leaving some gaps.

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 'Log a body measurement' and enumerates the supported metric types with their units, making it distinct from sibling tools like log_meal and log_workout. It leaves no doubt about the resource and action.

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

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

The description implies use for recording body metrics and provides a specific benefit for logging weight, but it does not explicitly state when to use this tool over alternatives or mention any exclusions. The domain is clear, but there is no direct 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 adds no behavioral context beyond what the annotations provide. It does not disclose what happens after logging (e.g., returns the created activity), any side effects, or validation behavior. The annotations already indicate it is a non-read-only, non-destructive operation, but the description contributes no further transparency.

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

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

The description is brief and front-loaded: the first sentence states the purpose, and the second lists capabilities. It is appropriately sized, though the inclusion of 'power' is inaccurate and slightly undermines clarity.

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

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

For a tool with 9 parameters and no schema descriptions, this description is incomplete. It does not explain the date format, valid sport values, or required fields. The presence of an output schema means return values need not be described, but the parameter semantics are too sparse for reliable 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 0%, so the description must compensate, but it only mentions a few fields (duration, distance, HR, calories) and incorrectly includes 'power', which is not in the schema. It does not explain the required parameters (date, sport) or other optional fields like notes, title, or idempotency_key.

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

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

The description clearly states the tool's function: 'Log a cardio activity (run/bike/swim/etc.) for the current app user.' It uses a specific verb and resource, and the parenthetical examples distinguish it from strength workout logging tools like log_workout.

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 clear context by specifying the action (logging cardio) and scope (current app user), but it does not mention when to prefer this tool over alternatives or any exclusions. The distinction from log_workout is implicit through the term 'cardio'.

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

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

The description adds minimal behavioral context beyond the annotations. It scopes the operation to the current app user, but does not explain side effects, idempotency behavior, or what happens on duplicate entries. The mention of 'optional ingredients' is not supported by any schema parameter, which could mislead. However, it does not contradict 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 a single, succinct sentence that front-loads the main action and key details. Every word earns its place, and it is appropriately concise without padding.

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?

Despite having 8 parameters and an output schema, the description is incomplete for a logging tool. It does not explain parameter meanings, required fields, or constraints like date format or meal_type values. The output schema exists, so return values are covered, but the overall context for effective use is severely lacking.

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 carries the parameter-documentation burden, but it only mentions 'calories' and 'macros' (which maps to protein/carbs/fats). It omits required parameters like date and name, and misunderstands the schema by referring to 'optional ingredients' when no ingredients field exists. This provides insufficient parameter clarity.

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 with a specific verb ('Log') and resource ('a meal'), and distinguishes it from sibling tools like update_meal and delete_meal by indicating creation. It also specifies the key content (calories + macros + optional ingredients), making the action 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?

No guidance is provided on when to use this tool versus alternatives such as ai_parse_meal or log_water. The description only states that it logs a meal for the current user, but lacks any when/when-not instructions or alternatives.

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

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

Annotations already indicate readOnlyHint=false (write operation) and idempotentHint=false. The description adds that it logs for the current app user but does not disclose behavior like appending records or the role of idempotency_key. With annotations covering the safety profile, a mid-range score is appropriate.

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

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

The description is a single concise sentence that is front-loaded with the verb and resource. Every word earns its place with no redundancy.

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

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

This is a simple logging tool with an output schema and annotations providing safety hints. The description states the essential action and scope. It is complete enough for expected usage, though it could benefit from a note about idempotency or typical call patterns.

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 provides minimal parameter meaning beyond the unit 'ml'. It does not explain the date format, the expected range or type of amount_ml, or the purpose of idempotency_key, leaving the agent to rely on param names only.

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

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

The description uses a specific verb (Log), names the resource (water intake), specifies the unit (ml), and identifies the scope (current app user). It clearly distinguishes from sibling tools like get_water (read) and other log_* 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?

The description provides clear context by indicating the action and scope, making it obvious when to use this tool. However, it does not explicitly mention alternatives or when not to use it, though this is less critical for a simple logging tool.

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

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

The annotations only mark readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the description carries some burden. It adds helpful context about date formatting and free-form payload fields, but it does not disclose behavior around status (draft/submitted), idempotency, or whether this creates or updates an existing record. There is no contradiction with annotations.

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

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

The description is two sentences long, with the action front-loaded in the first sentence. Every sentence adds value: the first states the purpose, the second provides parameter detail. No waste words.

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

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

Given the tool's complexity (5 params, nested payload, output schema), the description covers the core purpose, date constraints, and payload structure, but misses important context about status semantics, idempotency behavior, and when to use the tool relative to siblings. Since an output schema exists, return values are not required in the description, but the missing status/idempotency explanation leaves notable gaps.

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

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

With 0% schema description coverage, the description compensates by explaining week_start/week_end format (YYYY-MM-DD, Monday start) and listing payload fields (energy, sleep_quality, etc.). However, it leaves status and idempotency_key unexplained, so the compensation is only partial.

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 'Record a weekly check-in', which is a specific verb+resource phrase that clearly indicates the tool's action and target. It also differentiates from sibling tools like get_weekly_checkins (retrieve vs. record) and other log_* tools by specifying the unique weekly check-in domain.

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

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

The description implies usage context (when you need to log a weekly check-in) but provides no explicit guidance on when to prefer this tool over alternatives, nor any exclusions. It does not mention related tools like get_weekly_checkins or other logging tools, so the 'when' is only implicit.

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 disclose the write nature (readOnlyHint=false), non-destructiveness (destructiveHint=false), and non-idempotency (idempotentHint=false). The description adds meaningful context beyond these by stating that an app user context is required and that the workout consists of exercise sets unified across strength/cardio. It does not contradict any annotation and enriches agent understanding of operational requirements.

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

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

The description is a single, front-loaded sentence that conveys the core purpose and a key requirement in 11 words. There is no wasted verbiage or redundant information; every word earns its place. The structure is ideal for quick consumption by an agent.

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

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

With 5 parameters, 0% schema coverage, and a modest description, the tool is under-specified. While an output schema exists (so return values are not needed), the lack of detail on required 'date', the 'sets' array structure, and optional fields like 'idempotency_key' leaves the agent with insufficient guidance. The description is too terse to be considered complete for a tool of this complexity.

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

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

Schema description coverage is 0% for 5 parameters, so the description must compensate but does not. It mentions 'exercise sets' which hints at the 'sets' parameter but does not explain its structure, the meaning of 'date', 'title', 'primary_sport', or 'idempotency_key'. No additional parameter-level detail is provided, making it impossible for an agent to construct a valid request without external knowledge.

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

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

The description uses the specific verb 'Log' with the resource 'a workout' and specifies the scope ('with exercise sets (strength or cardio unified)'). This clearly distinguishes it from sibling tools like 'log_cardio' (which likely handles cardio-only activities) and 'get_workouts' (which reads workouts). The phrase 'unified' explicitly clarifies that this tool covers both strength and cardio, adding precision.

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

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

The description provides clear context: it is for logging workouts with sets, and the 'strength or cardio unified' wording indicates it is the intended tool for both types, implicitly guiding against using separate tools for strength vs. cardio. It also states a prerequisite ('Requires an app user context'), which is essential for invocation. However, it does not explicitly name alternatives or exclusion criteria, so it falls short of a 5.

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

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

The annotations already declare readOnlyHint, idempotentHint, and openWorldHint, covering the safety profile. The description adds that the lookup is for food products via barcode but does not disclose behaviors like not-found handling or data source limitations. Since annotations handle primary safety traits, a mid-range score is appropriate.

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

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

The description is a single concise sentence that front-loads the action ('Lookup') and target ('food product'), with no wasted words or redundancy.

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

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

Given the simple single-parameter nature and the presence of an output schema plus read-only annotations, the description is complete enough. It defines the input scope and purpose without needing to explain return values since the output schema covers that.

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 provides no description for the 'barcode' parameter (0% coverage), so the description must compensate. It does so by specifying the barcode format as EAN/UPC, which gives the agent meaningful input expectations beyond the parameter name alone. This is valuable but lacks detail on exact format 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 states the tool's purpose with a specific verb 'lookup' and a well-defined resource 'food product' plus a specific key type 'EAN/UPC barcode'. This distinguishes it from sibling tools like search_foods, which would search by text, making the purpose unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives such as search_foods. The description only states what it does, not the appropriate context for using it or when to prefer another tool.

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

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

The description discloses a critical behavioral trait: identity comes from the OAuth token or bound key, not from a caller-supplied user id, which prevents misuse. Since annotations already provide readOnlyHint and idempotentHint, the description adds context about authentication and the combined-response nature, though it does not mention response size, pagination, 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?

The description is two sentences: the first states the primary purpose and lists contents, the second covers subsetting and authentication. It is front-loaded, free of fluff, and every sentence adds 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?

The description covers the essential aspects: what data is returned, how to subset it, and how identity is determined. The presence of an output schema reduces the need to explain return values. Minor gaps include not defining the meaning of 'recent' or the effect of `workout_limit`, but these are not critical for an initial understanding.

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 provides good coverage for `domains` with accepted values and default, and the description adds a brief usage note. However, `workout_limit` lacks a schema description and is not mentioned in the tool description, leaving its semantics partially ambiguous. With 50% schema coverage, the description compensates for `domains` but not for `workout_limit`.

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

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

The description clearly states the tool returns multiple aspects of the signed-in user's training context in one response, listing specific data types (workouts, nutrition, check-in, notes, profile, targets). It distinguishes itself from sibling tools like get_workouts and get_profile by emphasizing 'in one response' and the use of a `domains` parameter to request a subset.

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 when to use this tool by stating it returns multiple domains in one response and supports the `domains` parameter for subsetting, but it does not explicitly say when not to use it or name alternatives like individual getter tools. The context is clear, but exclusions and explicit alternative guidance are missing.

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`, and `idempotentHint`, covering the safety profile. The description adds minimal behavioral context by naming the output ('primary/secondary muscle layers') but not disclosing edge cases like unknown exercise names or normalization behavior. Since the annotation coverage is strong, the description's limited addition is acceptable but not outstanding.

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

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

The description is a single, clear sentence that immediately states the purpose and output. There is no unnecessary verbiage or redundancy. It is perfectly front-loaded and concise.

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

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

Given the tool has one simple string parameter and an output schema (which likely documents the return structure), the description is fairly complete for the tool's complexity. It explains the core function and output layers. However, it omits any note about handling unknown exercises or whether the output is a flat list, but the output schema presumably covers that. This is sufficient for a simple mapping tool.

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

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

The input schema has one string parameter 'exercise' with no description (0% coverage). The description clarifies that this is an 'exercise name', which adds meaning beyond the bare schema. However, it does not provide examples, valid formats, or handling of unmatched names. This is a moderate improvement over the schema.

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

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

The description uses a specific verb ('resolve') and clearly states the resource ('exercise name') and outcome ('into primary/secondary muscle layers for rendering'). This distinguishes it from siblings like `search_exercises` or `get_exercise`, which likely have different purposes. The mention of 'for rendering' further clarifies its niche.

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

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

The description gives a clear context ('for rendering') implying when to use this tool, but it does not explicitly mention alternatives or when not to use it. Since it provides a distinct use case without exclusions, it earns a 4 rather than a 5.

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

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

The annotations already declare readOnlyHint=true, openWorldHint=true, and idempotentHint=true, so the safety profile is covered. The description adds value by disclosing the enriched result format (anatome_imageSrc URLs) and pagination behavior (pass next_cursor as cursor). 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?

The description is three sentences, each conveying a distinct piece of information: purpose/scope, enriched returns, and pagination. There is no fluff or redundancy, and the most important info (what it does) 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 there. The description covers the essential operational aspects: search filters, enriched results, and pagination. Given the complexity (6 parameters), it is sufficiently complete for an agent to select and invoke correctly.

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

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

Schema description coverage is very low (17%), but the description compensates by explicitly naming the key filter parameters: q (name), muscle, equipment, and level. It also explains the cursor parameter and pagination. It does not mention the limit parameter, but its default in the schema provides some context.

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

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

The description starts with 'Search 873 exercises by name with muscle/equipment/level filters,' which clearly specifies the action (search), resource (exercises), and scope (filtering). This distinguishes it from sibling tools like get_exercise and resolve_exercise, as search is 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 description clearly implies when to use the tool: when searching for exercises by name with optional filters. It does not explicitly mention alternatives or exclusions, but the context of 'search' makes the usage evident. A minor gap is lack of direct comparison to get_exercise or resolve_exercise.

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

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

Annotations already declare readOnlyHint, openWorldHint, and idempotentHint. The description adds value by disclosing data sources and the per-100g macro return format, which are not covered by annotations. It does not discuss pagination or locale behavior, but with annotations present, this is sufficient.

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

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

The description is a single, well-structured sentence that concisely states the purpose, data sources, and return format without extraneous words.

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

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

With a simple tool and an output schema present, the description covers the core function and return format but lacks usage guidance and parameter explanations. It is adequate for a straightforward search but leaves some gaps in context for the agent.

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 the 'q' parameter as a name search but provides no semantics for 'locale' or 'page_size'. The names are self-explanatory to some degree, but the description does not explicitly explain them, leaving ambiguity for the agent.

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

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

The description clearly states 'Search food products by name' with a specific verb and resource, and identifies data sources (Open Food Facts + USDA) and the return format (macros per 100g). This distinguishes it from sibling tools like search_exercises and lookup_barcode.

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

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

The description implies usage by name but does not explicitly state when to use this tool versus alternatives such as lookup_barcode for barcode queries. No exclusions or alternative recommendations are provided, leaving the agent to infer context from sibling names.

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

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

The description adds useful behavioral context beyond the annotations: it reveals the partial-update semantics and the required X-App-User-Id header. It does not mention side effects or error behavior, but the added context is meaningful and non-contradictory.

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

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

The description is two sentences, front-loads the core purpose, and provides actionable usage instructions without waste. Every word earns its place, making it highly concise and well-structured.

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

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

For a tool with 14 parameters and low schema coverage, the description is incomplete. It omits the required meal_id, does not explain unit conventions for macros, and misleadingly references non-existent fields. The output schema may cover return values, but the input side has significant gaps.

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

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

Schema description coverage is very low (14%), and the description fails to compensate. It lists 'portion' and 'nutrients' as editable, but those are not actual parameters in the schema, creating confusion. It also does not clarify units or allowed meal_type values, leaving the agent under-informed about the parameter semantics.

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

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

The description clearly states the verb 'correct' (update) and the resource 'previously logged meal', distinguishing it from create, delete, or get operations. The explicit mention of editable fields reinforces its purpose.

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

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

The instruction 'Pass only the fields you want to change' gives clear usage guidance, and 'previously logged' implies it is for existing meals. It does not explicitly name alternatives, but the context is sufficiently clear for an AI agent to differentiate from log_meal or delete_meal.

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

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

Beyond annotations, the description explains meaningful side effects: timezone affects daily bucketing and defaults to UTC, and weight acts as a fallback for bodyweight-inclusive volume. These are behavioral traits not captured by readonly/idempotent hints, adding genuine transparency.

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

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

The description is only two sentences, with the first sentence stating the core purpose and the second delivering critical usage nuances. Every word earns its place, with no redundancy or fluff.

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

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

Given the 17-parameter complexity and low schema coverage, the description covers the most behaviorally significant parameters and notes the tool's scope ('current app user'). The existence of an output schema and annotations helps fill gaps. It omits partial-update semantics (e.g., whether unspecified fields are preserved or reset), but overall it is sufficiently complete.

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

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

Schema description coverage is low (35%), and the description compensates for `timezone` and `weight` with important semantics (e.g., weight doubles as fallback bodyweight). However, many other parameters (goal, diet_type, active_sports) remain ambiguous and are not clarified by the description, so compensation is only partial.

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 'Upsert the current app user's fitness profile', clearly stating the action (upsert) and the resource (profile). It also adds distinguishing details about timezone and weight that clarify its specific scope, setting it apart from sibling tools like get_profile or log_meal.

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

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

The description gives explicit usage guidance: 'Set `timezone` first' and explains why it matters (bucketing of daily totals, streaks, adherence windows). It does not mention alternatives or exclusions, but the context is clear for when this tool is relevant.

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