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

With no annotations provided, the description carries the burden of behavioral disclosure. It does state the core behavior — logging an interaction is an additive write — and clarifies the scope of interaction types. But it does not disclose validations, required pre-existing person/type IDs, or what the tool returns, so it only meets the minimum bar.

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

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

A single front-loaded sentence states the action, the object, and representative subtypes with no filler. The parenthetical earns its place by clarifying what counts as an interaction.

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 create/log tool, the high-level description plus 100% schema coverage is nearly complete: the agent can identify the tool, see the required fields, and invoke it. The only missing context is how to source valid personId/typeId values, but the sibling list includes list_people and the schema already provides type examples.

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

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

Schema description coverage is 100%, so the input schema already documents every parameter. The parenthetical examples (meeting, call, message) loosely map to the typeId values but add no semantic detail beyond what the schema already provides, so the score stays at the baseline of 3.

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

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

The description uses a specific verb ('Log') and a specific resource ('interaction with a person'), with concrete examples (meeting, call, message). There are no sibling interaction tools, so an agent can unambiguously identify this as the tool for recording a social or business interaction.

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 intended usage is clear: use this tool whenever an interaction with a person needs to be logged. No sibling tool offers the same function, so an alternative/exclusion rule is not strictly necessary; however, the description does not state prerequisites such as the person needing to already exist in the system.

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 clearly indicates a mutating action and a default volume of 250ml, which is useful since no annotations are provided. However, it does not disclose whether the amount is appended to existing intake or replaces it, nor any other side effects or response behavior.

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 wasted words. It communicates the core action, the date scope, and the default amount efficiently.

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 two-parameter tool with no output schema, the description is mostly adequate for calling it correctly. However, it misses an opportunity to distinguish itself from set_water_intake and does not explain whether calling it adds to or overwrites existing water intake.

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 covers both parameters with descriptions (dateString and amountMl), and schema description coverage is 100%. The description adds the 'glass' framing and default 250ml, but this mostly duplicates what the schema's amountMl description already states.

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 ('Add') and resource ('a glass of water') with a date scope, making the operation immediately clear. It also differentiates from siblings like get_water_intake and set_water_intake by signaling an incremental add rather than a read or a set operation.

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

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

The phrase 'for a specific date' implies this is for logging water consumption on a given day, but there is no explicit guidance on when to use this tool versus the closely related set_water_intake sibling. Usage is implied rather than stated.

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

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

No annotations are provided, so the description carries the full disclosure burden, but it only says a definition is created. It does not cover duplicate handling, privacy or sharing scope, permission requirements, or what the tool returns. For a write operation, this is a meaningful gap.

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 with the action and subject front-loaded. It contains no filler and does not restate the parameter schema.

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

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

The fully described schema makes parameter semantics clear, but with no annotations and no output schema, the description leaves return behavior and edge cases like duplicate names or existing food definitions unaddressed. It is minimally viable for a straightforward create operation, but not rich enough for fully autonomous context.

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

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

Schema description coverage is 100%, so the schema already documents all 14 parameters and their units. The description adds only a high-level 'per serving' framing and no parameter-specific detail, so the baseline score 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 uses a specific verb ('Create') and resource ('custom food definition') and adds 'with nutritional info per serving,' making the action clear. The 'custom' qualifier also distinguishes this from lookup, search, update, and delete siblings.

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

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

No guidance explains when to use this tool instead of alternatives like lookup_barcode, search_foods, list_food_definitions, or update_food_definition. The description simply restates the operation and leaves all usage context to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'Create a new habit' without mentioning persistence, return value, duplicate handling, default behavior, or constraints. For a mutation tool with zero annotation coverage, this is a meaningful transparency gap.

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 no filler, front-loading the action and resource. It avoids redundantly repeating optional parameter details and earns its place as concise, efficient guidance.

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 schema fully covers parameter semantics and defaults, which makes the definition sufficient for invoking the tool with the three required fields. However, there is no output schema and no annotations, and the description does not state what the successful response contains or any creation-side constraints, leaving some contextual 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?

The input schema has 100% description coverage, so the schema already documents all 8 parameters. The description adds little beyond restating 'goal frequency' and does not clarify the relationship between goalFrequency and goalPeriod, so the baseline 3 is appropriate.

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

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

The description uses the specific verb 'Create' with the resource 'habit' and highlights the key 'goal frequency' concept, so an agent can clearly tell this operation adds a new habit. It does not explicitly distinguish itself from sibling tools like update_habit or list_habits, but the verb and resource are unambiguous 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?

Usage context is implied by the verb 'Create' — an agent can infer this tool is for introducing a new habit rather than updating or toggling an existing one. There is no explicit when-to-use or when-not-to-use guidance, and no alternatives are named, so it falls short of strong routing guidance.

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

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

No annotations are provided, so the description carries full burden. It correctly implies a write operation, but doesn't disclose duplication behavior, required authentication, or whether amount should be positive. The tool is described only as 'record,' which is minimal beyond the title.

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

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

Two short sentences, no wasted words. The prerequisite hint is placed after the main action, which is effective and front-loaded enough.

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 create operation with fully described parameters, this is adequate. However, no output schema exists, and without annotations the description doesn't mention what the tool returns or any side effects. Given the low complexity, it's a passable but not rich definition.

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

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

Schema description coverage is 100%, so parameters are already documented (date, name, income, sourceId, description). The description adds value by pointing to list_spending_sources for sourceId, but doesn't explain 'income' formatting or required constraints beyond what the schema offers. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Record') and resource ('new income entry'), so the purpose is clear. It doesn't explicitly distinguish itself from the sibling create_spending, but the name and resource differ enough to infer intent.

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

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

It gives a direct usage hint: 'Use list_spending_sources to get valid source IDs.' This tells the agent what prerequisite to call before invoking. However, it doesn't explicitly say when not to use this tool or compare to alternatives, so it's a clear but partial guideline.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it says almost nothing: it does not state that a persistent record is created, whether duplicate names are allowed, what the default status behavior is, or what happens on success. 'Track' obliquely implies creation but gives no side effects, auth requirements, or error semantics.

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

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

The description is a single efficient sentence with zero waste and the purpose front-loaded. It is slightly terser than ideal for an 8-param create tool with no annotations, but it does not ramble or repeat schema content.

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

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

For an 8-parameter create operation with no annotations and no output schema, a one-sentence description is incomplete: the agent gets no sense of what a successful call returns, whether the item becomes visible via list_items, or how this relates to the spending tracker. The strong schema covers inputs but not operational context.

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

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

Schema description coverage is 100%, so the baseline of 3 applies even though the description adds no parameter details. The schema itself is genuinely helpful, including a date format (YYYY-MM-DD) and a cross-tool pointer for categoryId, so the agent can build a correct call without the description.

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

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

The description states a specific verb and resource ('Track a new item/product purchase'), and the schema makes it clear this records an inventory item with purchase date and price, which separates it from the financial create_spending/create_income siblings. However, it does not explicitly name any sibling or state what it is not, so it stops short of full differentiation.

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

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

No guidance is given on when to use this tool versus alternatives. The close sibling create_spending is never referenced, and the only cross-tool hint ('use list_item_categories to find IDs') lives in the schema, not the description. The agent must infer entirely from the name and schema that this tool is for cataloging purchases rather than recording spending.

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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It honestly states that this creates a new journal entry, making the mutating nature clear. It does not mention response behavior, potential duplicates, or other side effects, but for a straightforward create operation this is a reasonable but not thorough disclosure.

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 with no filler words. It front-loads the action and the object, making it immediately scannable and useful for 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?

The tool is simple: four flat parameters, no enums, no nested objects, and no output schema. The schema fully documents inputs, and the description clearly identifies the operation. The only minor gap is that no return value or success behavior is described, but this is not critical for invoking the tool correctly.

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

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

Schema description coverage is 100%, so the schema fully documents all four parameters and their meanings. The description adds only 'rich text content,' which aligns with the content parameter but does not materially improve parameter understanding beyond what the schema already provides.

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 ('create') and resource ('journal entry') and adds the content mode ('rich text content'). This clearly identifies the tool's function and distinguishes it from the sibling journal tools like list_journal_entries, get_day_entry, and toggle_journal_todo.

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 intended usage is implied by the verb 'create' and the resource 'journal entry', so an agent can infer when to use this tool. However, there is no explicit guidance about when not to use it or how it relates to other journal tools, though no competing create tool exists among the 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?

No annotations are provided, so the description carries the full burden of disclosing side effects and behavior. It only restates the core operation and the quick-add option, both already reflected in the schema, and omits consequences such as whether this cnanges daily nutrition summaries, whether foodDefinitionId is validated, or whether required fields still apply for quick-adds.

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

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

Two short sentences, no filler, and the central operation is fron-loaded. Every sentence contributes a distinct piece of information: what the tool does and the two modes it supports.

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 14 parameters and no annotations or output schema, the description is arguably too thin. The schema covers parameter names, but the description's 'quick-add with just calories' could mislead an agent into ignoring the five required fields. It is adequate for a simple create operation but lacks caveats around validation and side effects.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's reference to quick-add 'just calories' adds a small layer of intent, but the schema already documents isQuickAdd and foodDefinitionId clearly. It does not meaningfully clarify required-field relationships or the date/mealType constraints beyond the schema.

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

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

The description clearly states the operation ('Log a meal entry') and the resource, and immediately distinguishes two supported modes: referencing a food definition or quick-adding with calories. This is specific enough to separate it from siblings like create_food_definition, list_meal_entries, and update_meal_entry.

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

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

There is no explicit when-to-use guidance or mention of alternatives. The description implies it is for logging meals but does not differentiate it from log_meal_template or explain when quick-add vs food-definition reference should be chosen. The phrase about quick-adds gives some context, but not enough directional 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It only states that a template is created, with no mention of return values, duplicate handling, validation behavior, or side effects.

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

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

One sentence, no filler, with the action and resource front-loaded. 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?

The schema covers the inputs well, but with no annotations and no output schema, the description omits practical behavior details such as what happens after creation or how the template can be used subsequently. It is minimally viable but leaves room for confusion.

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

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

Schema description coverage is 100%, so the schema already documents both 'name' and 'items' thoroughly with examples and per-field units. The description adds no new parameter detail, which matches the baseline for full schema coverage.

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

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

The description states a clear verb ('Create'), a specific resource ('reusable meal template'), and the input source ('from a list of foods'). This cleanly distinguishes it from siblings like update_meal_template, delete_meal_template, and create_meal_entry.

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 'reusable meal template' implies this is for saving a template rather than logging a one-time meal entry, giving some contextual guidance. However, it does not explicitly name alternatives or state when not to use this tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Add' signals mutation, but nothing is said about duplicate handling, whether linked friend parameters create graph relationships, side effects, or expected response behavior. The description discloses only the bare operation type, nothing beyond 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?

A single clean sentence with zero filler. The action verb and resource are front-loaded, and nothing in the description is redundant with the schema.

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

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

With 10 parameters, linked-friend logic, no output schema, and no annotations, a one-sentence description is inadequate. The agent gets no sense of success/failure semantics, return value, or duplicate behavior. The schema mitigates parameter understanding but leaves the operational context unexplained.

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

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

Schema description coverage is 100%, so all 10 parameters are already documented with meaningful detail (priority default of 3, relationshipTypeId examples, and the hint to use list_friends for linkedFriendUserId). The description adds no parameter info, but the baseline of 3 applies because 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?

'Add a new person to your CRM' uses a specific verb (add) and resource (person in CRM), clearly conveying a create operation. It distinguishes from the sibling update_person via 'new', though it doesn't explicitly call out any sibling by name.

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 on when to use this tool versus alternatives. With siblings like update_person and add_interaction present, there is no routing advice, no conditions, and no exclusions — the agent must infer 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?

With no annotations and no output schema, the description carries the full behavioral burden. It discloses that the tool records a new expense and implies foreign-key validation by requiring valid IDs from the list endpoints. However, it does not state what is returned on success, how invalid IDs fail, or whether duplicates are rejected — material gaps for a write operation with zero annotation coverage.

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 with zero filler. The purpose is front-loaded in the first sentence and the prerequisite workflow in the second. Every word earns its place.

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

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

For a simple five-scalar-parameter create tool with full schema documentation, the description covers the purpose and the key prerequisite workflow. The only meaningful gap is the absence of return-value behavior, which matters more because neither annotations nor an output schema exist to fill it.

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

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

Schema coverage is 100%, setting the baseline at 3. The description adds real meaning beyond the schema by revealing that categoryId and sourceId are not arbitrary strings but foreign keys obtainable from list_spending_categories and list_spending_sources. This provenance information is genuinely useful and slightly exceeds the baseline.

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

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

The description opens with a specific verb and resource — "Record a new expense" — which clearly unambiguously separates this creation tool from sibling mutations like update_spending and delete_spending, and the word "expense" distinguishes it from create_income. It stops short of explicitly naming the sibling alternatives, so it is clear but not maximally differentiating.

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

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

The description gives an explicit precondition and workflow: call list_spending_categories and list_spending_sources first to obtain valid IDs, telling the agent exactly what setup is required before invocation. It does not state when to prefer alternatives such as create_income for income recording, so it misses the exclusion half of strong 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates a write operation by saying 'Create', but does not disclose side effects, return behavior, whether defaults are applied, idempotency, or any required authentication/context.

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

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

The description is a single, front-loaded sentence with zero wasted words. It is concise and easy to parse, though it could have used the brevity to add a small amount of usage or behavioral context.

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

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

For a mutation tool with six parameters, no annotations, and no output schema, this description is too thin. It does not mention return values, default behaviors, or the rich HTML/description format constraints, leaving the agent without important execution context that the schema alone does not convey.

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

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

Schema description coverage is 100%, so the schema fully documents all six parameters. The description adds no parameter-level meaning, but this is acceptable under the baseline since the schema already handles 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 states a specific verb ('Create') and resource ('a new task in a project'), which clearly identifies the operation. It differentiates from read/update tools like get_task, list_tasks, and update_task by the create verb, though it does not otherwise elaborate on scope.

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

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

No guidance is given on when to use this tool versus alternatives such as update_task, list_tasks, or the many other create_* siblings. The usage is only implied by the word 'Create', not explicitly scoped with conditions or exclusions.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. 'Log' implies a creation operation, but the description does not state that a new record is created, whether any existing data is modified, or what prerequisites exist (e.g., valid exerciseDefinitionId). It mostly restates the tool name's action.

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 redundant phrases. It front-loads the verb and object, and every word contributes to the 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?

Despite rich schema descriptions, the tool has a complex nested exercises structure and no output schema. The description does not explain the effect of the operation, how to handle superset grouping, or what response to expect. With no annotations, these gaps make the description incomplete for a mutation tool.

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

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

Schema description coverage is 100%, with each property already well documented (date format, exerciseDefinitionId lookup, weight in kg, etc.). The description adds no additional parameter information beyond what the schema provides, so the baseline 3 is appropriate.

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

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

The description uses a specific verb ('Log') and resource ('workout session'), and specifies the payload scope ('exercises and sets'). This clearly differentiates it from read-only siblings like list_workout_sessions and list_exercises.

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

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

The description implies the tool is for recording a workout session but provides no explicit guidance on when to use it versus alternatives, nor does it name any exclusions. The usage context is implied rather than stated.

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

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

No annotations are provided, so the description carries the full disclosure burden. It usefully reveals that only custom food definitions can be deleted, but it does not mention permissions, reversibility, failure behavior, or result format. The essential destructive scope is clear, but behavioral detail is minimal.

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 that front-loads the verb and resource, with the key constraint placed immediately in parentheses. Every word earns its place and there is no filler.

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

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

For a one-parameter destructive operation, the description plus schema is nearly sufficient: the agent knows what action to take, what target is allowed, and what input is required. The only real gap is lack of behavioral context such as whether deletion is permanent or requires specific permissions, but this is minor given 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?

The input schema already provides 100% description coverage for the single foodId parameter. The description adds no extra meaning about how foodId is resolved or what format it should take, so it neither improves nor detracts from the schema baseline.

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

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

The description states a specific verb ('Delete') and resource ('custom food definition'), and adds the important scoping detail that system foods cannot be deleted. This clearly distinguishes the tool from siblings like delete_meal_entry and update_food_definition.

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 parenthetical '(cannot delete system foods)' gives an explicit applicability boundary, telling the agent when this tool should not be used. It does not explicitly name alternative tools, but the resource is unique enough among siblings that routing is still 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?

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It clearly states the major side effect: the friend is also removed from any shared projects, which is essential for understanding the destructive impact. It does not mention permanence or undoing, but the disclosed side effect is significant and goes beyond what the tool name alone would 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 sentence with the primary action front-loaded and the side effect in a concise parenthetical. Every word earns its place, and there is no redundant information. This is an ideal level of conciseness for a simple tool.

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

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

For a one-parameter delete operation with no output schema and no annotations, the description is nearly complete: it states the action and the critical side effect. It could optionally mention that the friendship must exist or that the operation is irreversible, but for a straightforward delete, the current description gives an agent enough context to call it correctly.

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

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

Schema description coverage is 100% for the single 'friendshipId' parameter, so the schema already documents the parameter. The description adds no additional contextual meaning about the parameter, such as where to obtain a valid friendship ID or the format expectation. Baseline 3 applies because the schema does the heavy lifting and the description doesn't conflict or add 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 uses a specific verb and resource ('Remove a friend') and adds a key side effect (removes from shared projects), making the operation clear. It distinguishes this tool from listing friends, sending requests, or responding to requests, though it doesn't explicitly name those siblings. The added side-effect detail further disambiguates the tool's impact.

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: use this tool when you want to remove an existing friend. However, there is no explicit guidance on when not to use it, such as distinguishing between removing a friend and declining/unsharing a pending request. No alternatives are named, leaving some ambiguity for an agent choosing among friend-related operations.

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?

With no annotations provided, the description must carry behavioral disclosure, and 'permanently' at least signals irreversibility and destructive intent. However, it does not mention side effects, authorization requirements, or whether related data is affected, leaving part of the burden unmet.

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

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

The description is five words, front-loaded with the verb and object, and contains zero filler. Every word earns its place, especially 'permanently,' which adds an important behavioral qualifier.

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?

Although the API surface is simple with one required parameter and no output schema, the description leaves unstated what qualifies as a tracked item, whether deletion cascades to associated records, and what success or error responses look like. It is adequate for basic invocation but not fully self-sufficient.

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

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

Schema coverage is 100%, so the single parameter itemId is already documented as 'Item ID.' The description adds only that the target is a 'tracked item,' providing light domain context but no additional syntax, format, or relationship 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 uses a specific verb ('Delete') plus a clear resource ('a tracked item'), making the operation unambiguous. It distinguishes from sibling item tools like create_item and update_item, as well as from delete_* tools targeting other 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?

There is no guidance about when to use delete_item versus alternatives, nor any exclusion criteria or prerequisites. The intended use is only implied by the verb and resource name.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Delete a meal entry' conveys that the operation is destructive, but it does not state whether deletion is permanent, whether it cascades to related data, what happens if the entry does not exist, or whether any confirmation or special permissions are required.

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

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

The description is a single focused sentence that immediately communicates the operation. It is efficient and readable, though it borders on under-specification rather than being merely 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?

For a simple single-parameter delete operation, the description plus the schema may be enough for an agent to make the call, but it lacks any detail about return values, error behavior, or side effects. Given there is no output schema and no annotations, the description is minimally adequate but not fully informative.

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 covers 100% of parameters, and the single param 'entryId' already has a clear description ('Meal entry ID'). The tool description adds no additional parameter semantics beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a clear verb ('Delete') and a specific resource ('a meal entry'), which distinguishes it from related tools like delete_meal_template. It is slightly generic because the same pattern is used across many sibling delete tools, but the resource is unambiguous enough for selection.

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 usage guidance is provided. The description does not specify when to use this tool versus delete_meal_template, delete_food_definition, or other delete operations, nor does it mention any prerequisites or conditions.

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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It merely states the action without explaining irreversibility, cascading effects on related meal entries, authentication requirements, or what happens after deletion.

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 with no filler or redundant information. It is appropriately sized for a simple one-parameter delete operation.

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 well-documented parameter, the description is minimally adequate. However, with no annotations and no output schema, it lacks critical behavioral context such as irreversibility and effects on associated data.

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

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

Schema description coverage is 100%, so the 'id' parameter is already documented as 'Template ID'. The description adds no additional meaning beyond the schema, which is acceptable given the high coverage.

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

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

The description 'Delete a meal template' uses a specific verb and resource, making the operation immediately clear. It also distinguishes this tool from related siblings like create_meal_template, update_meal_template, and log_meal_template.

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 mention prerequisites, conditions, or scenarios where deletion should be avoided, leaving the agent to infer usage solely from the verb 'Delete'.

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?

With no annotations provided, the description carries the full disclosure burden. The word 'permanently' is a genuine behavioral signal indicating irreversibility, which is the most critical trait for a destructive operation. However, it omits side effects (e.g., impact on spending analytics or categories), authorization requirements, and what happens on success or failure.

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?

Five words, zero waste, and the action verb plus resource are front-loaded. Every word contributes meaning, including 'permanently', which carries the irreversibility signal. This is an appropriately minimal description for a simple tool.

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 (one required parameter, no nested objects, no output schema), and the description covers the core action and its irreversibility. But with zero annotations, the description alone must cover behavioral context — it does not mention side effects, error conditions, or return behavior, leaving the agent to guess at the operational contract of a destructive call.

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

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

Schema description coverage is 100% — the schema already documents 'spendingId' as 'Spending ID', so the baseline is 3. The description adds nothing about the parameter itself, which is acceptable given the parameter's self-evident purpose from the tool name.

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

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

The description names a specific verb ('Delete'), a specific resource ('expense record'), and a scope qualifier ('permanently') that distinguishes it from soft-delete variants. It differentiates the tool from its siblings create_spending, update_spending, and list_spendings with no ambiguity.

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 offers no when-to-use guidance, no exclusions, and no mention of alternatives such as update_spending for toggling status or list_spendings for verification. An agent must infer entirely from the verb that this is for removing a spending record; no context distinguishes when deletion is appropriate vs. when an update would suffice.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only restates the operation and gives no insight into response format, data granularity, ordering, default date range behavior, or handling of missing data points.

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 with no filler, and the core action is front-loaded. While it sacrifices detail, it is appropriately compact for a simple data-retrieval tool.

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

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

For a tool with no output schema and no annotations, the description is too sparse to be fully complete. An agent cannot determine the shape of the returned price history, how limit is applied, or how from/to defaults behave, leaving important 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?

All four parameters have schema descriptions covering 100% of the parameters, so the baseline of 3 applies. The description itself adds no additional parameter semantics beyond what the schema already provides.

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

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

The description clearly states the verb 'Get' and the resource 'historical price data for an asset', making the core purpose immediately understandable. However, it does not explicitly differentiate this tool from sibling tools, though no sibling appears to offer the same exact function.

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 like get_portfolio_summary or list_assets. The description does not mention typical use cases, prerequisites, 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?

No annotations are provided, so the description carries the full burden. It clearly signals a read-only retrieval for a single date, but it does not disclose what happens when no day entry exists, what fields are returned, or any non-obvious side effects. Basic transparency is present, but richer behavioral context is missing.

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 with no wasted words. It front-loads the action and resource, then specifies the date scope. This is appropriately sized and easy to parse.

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

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

The tool is simple with one parameter, but there is no output schema, no annotations, and no sibling differentiation. The description identifies the resource and date well, but does not describe the return shape, absence behavior, or when this tool is the right choice among many similar date-based getters. It is adequate for a basic retrieval but not fully 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 100% and the only parameter, dateString, is already fully documented with its YYYY-MM-DD format. The description adds no additional parameter meaning beyond 'specific date', so a baseline 3 is appropriate.

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

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

The description states a specific verb ('get'), a resource ('day entry' / 'daily notes'), and the key parameter (specific date). It is clear about what the tool returns, though it does not differentiate it from date-scoped sibling getters such as get_diet_daily_summary or get_water_intake.

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, and no exclusions or conditions are provided. With many sibling tools that retrieve date-specific data, an agent receives no basis for selecting get_day_entry over them.

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?

No annotations are provided, so the description carries the full behavioral burden. It does disclose that the response contains totals and meals grouped by type, which goes beyond the tool name. However, it does not specify what the totals measure, what 'type' means, whether water is included, or how the date window is interpreted, leaving key output behavior ambiguous.

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

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

A single front-loaded sentence states the action and the main output characteristics with no filler or redundancy. Every phrase contributes directly to understanding what the tool does.

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?

Although the tool is simple with one well-documented parameter, there is no output schema and no annotations, so the description must explain return values more fully. It only says 'totals and meals grouped by type', leaving the agent uncertain about exact response fields, which totals are included, and how grouping works.

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

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

Schema description coverage is 100%, and the only parameter, date, already has a format description (YYYY-MM-DD). The tool description adds no parameter-level meaning beyond what the schema provides, so the baseline 3 applies.

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

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

The description uses a specific verb 'Get' and a specific resource 'daily diet summary', and it adds useful return-structure detail: 'totals and meals grouped by type'. This distinguishes it from sibling tools like list_meal_entries, get_diet_profile, and get_water_intake, so an agent can tell it apart without inspecting their schemas.

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

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

The description implies aggregate, date-based use through 'daily summary' and 'totals', but it does not explicitly state when to prefer this over list_meal_entries or get_day_entry, and it names no alternatives or exclusions. The intended use is reasonably clear, but the guidance 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?

No annotations are provided, so the description carries the behavioral transparency burden. It clearly indicates a read operation and lists the fields contained in the profile, but it does not mention authentication needs, behavior when no profile exists, or whether defaults are applied.

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 states the action, resource, and key contents without filler. 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?

For a zero-argument getter with no output schema, the field list provides enough understanding of the return content. It is slightly incomplete because it does not state what happens if no diet profile has been set or point to sibling operations for modifying the profile.

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 baseline is 4. The parenthetical describes profile fields rather than invocation arguments, which is appropriate for a call with no inputs.

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 and resource ('Get user diet profile') and immediately clarifies what the profile contains: TDEE inputs such as sex, DOB, height, activity, goal, and macro preset. This differentiates it from siblings like set_diet_profile (write operation) and get_nutrition_goals (goals retrieval).

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 verb 'Get' and the parenthetical about TDEE calculation inputs imply this is the retrieval tool for the user's diet profile settings. However, it does not explicitly contrast this tool with close siblings like set_diet_profile, get_diet_daily_summary, or get_nutrition_goals, leaving usage context implied rather than stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. The word 'Get' strongly implies a read-only operation, and the listed analytics give some sense of output. However, it does not mention behavior such as the time window used for monthly/yearly completions, how invalid or missing habit IDs are handled, or whether any side effects occur.

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 with no filler. It front-loads the verb and resource, then lists the key analytics categories in a compact, scannable format. Every part of the 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?

For a simple one-parameter read operation without an output schema, the description covers the essential selection and invocation information: what the tool does and what high-level metrics it returns. It is slightly incomplete in not describing the exact return shape or error behavior, but the low complexity keeps this gap minor.

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

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

Schema description coverage is 100% and the only parameter, habitId, is described as 'Habit ID.' The description adds little beyond that—'for a habit' merely restates the parameter's role. Since the schema already carries the parameter meaning, the baseline of 3 applies.

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

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

The description clearly states the verb 'Get' and the resource 'analytics for a habit,' then enumerates the returned metrics: streaks, completion rate, monthly/yearly completions. This distinguishes it well from siblings like list_habits, which retrieves raw habit data, and toggle_habit_entry, which is a write operation.

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

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

The usage context is implied rather than explicit: an agent can infer this tool is for analytical summaries of a habit rather than raw listing or editing. However, the description does not state when to prefer this over alternatives or provide any exclusion/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?

With no annotations, the description carries the transparency burden. 'Get' clearly signals a read-only operation, and the parenthetical explains what data is returned. It does not detail default values, units, or behavior if goals are unset, but for a zero-parameter getter the behavior is sufficiently 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, compact sentence that front-loads the action and resource, then adds a useful clarifying parenthetical. Every word contributes value with no redundancy.

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

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

For a simple zero-parameter getter, the description adequately states what will be returned. It does not describe the exact response shape or units, but no output schema exists and the description covers the essential retrieval intent well enough for an agent to invoke it correctly.

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

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

The tool takes zero parameters, so the input schema is trivially complete. Per the rubric, zero params baseline is 4; the description adds no parameter details because none are needed.

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

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

The description uses a specific verb ('Get') and identifies a precise resource ('the user's daily nutrition goals') with clarifying content ('calories and macros'). This clearly distinguishes it from sibling tools like set_nutrition_goals and get_diet_daily_summary.

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 the tool — when the user's current daily nutrition goals are needed — but it does not explicitly state when not to use it or mention alternatives. Usage is reasonably clear from the 'Get' verb and the resource name, but there is no 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?

With no annotations, the description must carry the behavioral burden. It clearly indicates a read operation and that filtering is optional, but it does not disclose output format, pagination, ordering, or error behavior. This is acceptable but not rich.

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

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

A single, front-loaded sentence conveys the action, resource, and optionality without wasted words. The parenthetical expansion of 'PRs' adds clarity without bloat.

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

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

For a simple tool with one optional parameter and no output schema, the description is sufficient to invoke correctly: it explains what is returned and when the filter applies. It could add return-shape details, but none are strictly required for correct use.

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

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

Schema coverage is 100% and the exerciseId parameter is already described as 'Exercise definition ID to filter by.' The description's 'filtered by exercise' adds no meaningful detail beyond the schema, so it sits at the baseline.

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

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

The description names a specific verb ('Get') and a distinct resource ('personal records') and clarifies the optional exercise filter. No sibling tool targets personal records, so the tool is unambiguously distinguishable from the rest of the API.

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 'optionally filtered by exercise' gives clear context: call this when retrieving PRs, with or without an exercise restriction. It does not mention exclusions or alternatives, but none are needed given no similar sibling 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?

With no annotations, the description carries the full behavioral disclosure burden. It clearly indicates this is a read-only overview by using 'Get' and listing the returned data categories, but it does not mention details like whether P&L is absolute or percentage-based, the reporting period, currency, or potential performance implications of fetching all holdings.

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. The main action and resource appear first, followed by a compact colon-delimited list of what the summary contains. Every word earns its place and there is no filler.

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

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

For a zero-input read tool without an output schema, the description adequately names the principal return categories. It is missing minor but useful context such as currency, P&L period, and whether allocation is by asset class or individual holding, but it is sufficiently complete for an agent to invoke the tool correctly.

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

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

The tool has zero parameters, so there is nothing for the description to explain beyond what the schema already shows. The baseline for a no-parameter tool is 4, and the description appropriately focuses on the output rather than inputs.

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 ('Get') and a clear resource ('portfolio summary'), then enumerates the key contents: total value, P&L, allocation, and all holdings. This distinguishes it from related siblings like get_asset_price_history, list_assets, and list_investment_transactions, which focus on narrower or different data.

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

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

The description implies when to use the tool: whenever a portfolio-level overview is needed. However, it provides no explicit guidance about when to choose this over related investment siblings, such as get_asset_price_history or list_assets, or what scenarios would favor those 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the output concept (total spend and income) but does not reveal aggregation behavior, whether the result is read-only, how income is combined with spending, or whether the calculation includes/excludes any transaction types. 'Get' implies read-only, but richer detail is needed for full 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 a single efficient sentence with the core purpose front-loaded and the return scope immediately clarified in parentheses. Every word earns its place, with no redundancy or unnecessary 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 tool has one simple parameter and no output schema, so the description does need to explain what is returned; it does say 'total spend & income for a month.' Still, it omits useful details like whether the response contains separate spend and income fields or a net value, and the absence of any sibling alternatives guidance makes the context slightly incomplete.

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

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

Schema description coverage is 100%, so the yearMonth parameter is already well-documented with format and example. The description's 'for a month' aligns conceptually with yearMonth but adds no substantive meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Get') and resource ('monthly spending analytics') and clarifies the return concept: 'total spend & income for a month.' This differentiates it from sibling list tools like list_spendings and list_incomes by signaling an aggregated analytics view rather than raw item listings.

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 'for a month' gives clear temporal context, and the analytics framing implies it should be used for aggregated monthly totals rather than detailed transactions. However, the description does not explicitly state when to use this tool over alternatives like list_spendings or create_spending, leaving some selection logic to inference.

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

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

With no annotations, the description carries the burden of disclosing behavior. The verb 'Get' clearly indicates a non-mutating read operation, and 'full details' suggests the response will be comprehensive. However, it does not describe error behavior, missing-task handling, or the actual response structure.

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 short, clear sentence with no wasted words. It is front-loaded with the action and resource, making it instantly 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?

For a single-parameter getter with no output schema, the description is largely sufficient: it tells the agent the operation is a read and that the response contains full task details. It does not enumerate exact fields, but the context of sibling tools and the simplicity of the operation make this an acceptable level of completion.

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

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

Schema description coverage is 100%, and the schema already defines taskId as a string with the description 'Task ID'. The tool description adds no additional parameter semantics beyond implying the task is identified by ID, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb (Get) and resource (specific task), and 'full details' distinguishes it from the sibling list_tasks tool. The agent can tell this is a single-task retrieval by ID rather than a listing operation.

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

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

The phrase 'specific task' implies that this tool is for retrieving one task by ID, which provides some guidance. However, it does not explicitly state when to use this instead of list_tasks, create_task, or update_task, nor does it mention any 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?

With no annotations provided, the description itself must convey behavioral traits. 'Get' implies a read-only operation and 'for a specific date' sets the query scope, but it does not disclose what happens when no record exists, what units are returned, or any permissions needed. This is a modest but not comprehensive disclosure.

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 eight-word sentence with no filler or redundancy. It front-loads the verb and resource, earning the maximum score for conciseness.

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 a simple single-parameter getter with no output schema and no annotations. The description identifies the input and resource, but leaves out return format (e.g., units, null vs zero behavior) and any date-handling caveats. For such a simple tool this is a minor gap, so completeness is adequate but not outstanding.

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

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

The single parameter 'date' is fully documented in the schema with format 'YYYY-MM-DD', so the description adds no additional meaning beyond what the schema provides. Baseline 3 applies due to 100% schema coverage.

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

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

The description uses a specific verb ('Get'), names the resource ('water intake'), and scopes it to a specific date. This makes the operation clear and distinguishes it from sibling mutation tools like set_water_intake and add_water.

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

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

The description implies the tool is for retrieving a water intake value for a single date, which is enough to signal the common use case, but it does not explicitly mention alternatives or when not to use it (e.g., versus get_diet_daily_summary). Therefore usage guidance is only implied.

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

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

No annotations are provided, so the description must carry the behavioral disclosure. 'List' conveys a read-only operation and 'with current prices' indicates what the result contains. However, it does not clarify whether prices are real-time/delayed, whether results are paginated, or whether the asset list is exhaustive or filtered by user context.

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

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

A single, front-loaded sentence with no filler. Every phrase ('List', 'available assets', asset examples, 'with current prices') contributes useful information.

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

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

The tool is simple and the schema is fully documented, but there is no output schema or annotations and the description leaves the scope of 'available' slightly ambiguous. It also omits practical expectations such as pagination, sort order, or how this differs from portfolio/history tools.

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

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

Schema description coverage is 100%, so both parameters (search, assetType) are already documented. The description adds asset-class examples that loosely echo assetType, but no additional search-syntax, filtering behavior, or format details beyond the schema.

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

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

States a specific action ('List') and resource ('available assets'), with examples of asset classes and the output ('current prices'). The word 'available' plus the examples positions it as a market/catalog listing rather than the user-holding tools like get_portfolio_summary or list_investment_transactions.

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 offers no explicit guidance on when to choose this over alternatives, no prerequisites, and no exclusions. Sibling tools such as get_asset_price_history and get_portfolio_summary are not mentioned, so an agent must infer the correct context 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?

There are no annotations, so the description carries the behavioral burden. It adds useful scope ('system + custom') and 'list' implies a read-only operation, but it does not disclose return format, ordering, pagination, or whether custom definitions are user-editable. Acceptable for a simple list tool, but not richly transparent.

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

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

A single compact sentence that front-loads the verb and resource, then adds the valuable 'system + custom' distinction. 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?

For a zero-parameter read-only list tool, the description is nearly complete. The only mild gap is that it does not describe what an exercise definition entry contains or how results are ordered, but this is not essential for correct invocation.

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

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

The tool has zero parameters, so the baseline is 4. There are no parameter semantics to clarify, and the description correctly focuses entirely on the operation rather than on inputs.

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

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

States a specific verb ('List') and resource ('exercise definitions') plus scope ('system + custom'). This clearly differentiates from sibling tools like list_workout_templates or list_food_definitions while remaining 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 usage: call this when you need the available exercise definitions. It does not explicitly mention alternatives or when not to use it, but the tool is self-contained and distinct enough that the lack of explicit routing is only a minor gap.

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?

With no annotations, the description carries the behavioral burden. It does add useful scope information: 'system + custom' and the optional search/filter behavior, and the verb clearly implies a read-only operation. However, it does not disclose response shape, pagination, or behavior when no parameters are supplied.

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 conveys the purpose, scope, and optional parameters with no filler. The essential information is front-loaded and nothing extraneous is included.

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 adequate for a simple list tool with two optional params, but multiple gaps remain: no output schema, no mention of response format, no pagination note, and no relationship to search_foods. An agent would have to infer several operational details.

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 params already have descriptive text in the schema. The description's 'search by name or filter by category' largely paraphrases the schema and does not add format, exact-match, or interplay 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 the operation ('List'), the resource ('food definitions'), and the scope ('system + custom'), with optional search and category filtering mentioned. It is not a tautology, but it does not explicitly contrast with sibling search_foods, so it lacks full sibling differentiation.

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 search_foods or search_community_foods. The optional search/filter wording describes how to narrow results within the tool, but not the decision context that would route an agent to this tool instead of a sibling.

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

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

The description adds useful behavioral context by specifying 'pending' and 'sent and received', narrowing the scope beyond what the tool name alone conveys. However, with no annotations provided, the description carries the full burden and does not explicitly state that this is a read-only operation or what data is returned.

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 immediately states the action, resource, and scope. There is no filler or redundant information.

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

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

For a zero-parameter list tool, the description is sufficiently complete: it tells the agent exactly what will be listed. No output schema exists, but the simple nature of the operation means no additional invocation guidance 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 there is nothing for the description to clarify about arguments. The schema already fully covers the empty parameter set, and the baseline of 4 for parameterless tools 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 a specific verb ('List') and a specific resource ('pending friend requests') with an explicit scope ('sent and received'). It clearly distinguishes this tool from siblings like list_friends, which presumably lists established friends rather than pending requests.

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

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

The description implies the tool is used when the agent needs to retrieve pending friend requests, including both sent and received. However, it does not explicitly state when to use this over sibling tools like list_friends, or mention any filtering or response behavior.

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?

With no annotations, the description carries the transparency burden. It discloses personal scope ('your') and the accepted-friend filter, but says nothing about return format, ordering, pagination, or potential empty results. This is adequate for a simple read-only list but not rich.

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. Every word earns its place and directly conveys the tool's function.

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 no-parameter list operation, the description is functionally complete: it states the resource and scope. It does not detail output or pagination, but those are less critical given the simplicity and the absence of an output schema.

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

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

The tool has zero parameters and the schema shows an empty properties object with 100% coverage. The description correctly implies no inputs are needed, so there is nothing missing for 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 is specific: verb 'List' plus resource 'your accepted friends.' The qualifier 'accepted' semantically distinguishes this from sibling list_friend_requests, making the tool's 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?

Usage context is implied rather than explicit: the word 'accepted' suggests this tool is for confirmed friendships, not pending requests. However, it does not explicitly state when to use this tool versus alternatives like list_friend_requests or list_people.

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?

With no annotations provided, the description carries the behavioral burden. It discloses that this is a listing operation with an optional filter and specifies the return fields, which is helpful. It does not mention pagination or ordering, but for a simple read-only list tool this is reasonably transparent.

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

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

The description is a single sentence that front-loads the core action, includes the optional filter, and lists the return fields. Every word adds value with no redundancy.

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

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

For a tool with one optional parameter, no output schema, and no annotations, the description provides sufficient context: what it lists, the filter behavior, and what fields are returned. An agent can correctly invoke this tool without additional information.

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

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

The schema provides 100% coverage for the single parameter, including the meaning of true, false, and omit. The description adds no new parameter information beyond what the schema already states, so the baseline score 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 verb 'List', the resource 'habits', the optional filter on active status, and the returned fields. It is readily distinguishable from sibling tools like create_habit, update_habit, and get_habit_analytics, which have different purposes.

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 the tool: whenever you need to list habits, optionally filtered by active status. However, it does not explicitly name alternatives or state when not to use this tool versus sibling tools like get_habit_analytics.

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?

With no annotations, the description must carry the behavioral burden; it does disclose the core trait of an optional date range filter and implies a read-only listing operation. It omits ordering, inclusive date handling, pagination, and response shape, so the disclosure is only partial.

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

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

A single front-loaded sentence states the operation and the only meaningful option. Every word earns its place, and there is no redundant or vague 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 two-optional-parameter read tool with no output schema, the description covers the core behavior: it lists incomes and may be date-filtered. The schema fills in parameter details; minor omissions such as ordering and default range behavior keep it from maximum 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?

Both parameters are fully documented in the schema with types and formats, so the description adds little beyond the 'optional' filtering intent. Baseline 3 is appropriate because the schema does the heavy lifting for parameter documentation.

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

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

The description uses the specific verb 'list' with the resource 'income records', making the operation unmistakable. It clearly differentiates from siblings like create_income and list_spendings by naming the exact resource.

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 'optionally filtered by date range' implies a usage context and signals when the date parameters may be relevant. However, there is no explicit guidance about when to prefer this tool over related list tools or when not to use it.

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?

No annotations are provided, so the description carries full behavioral burden. It only restates the action and optional filtering; it does not disclose pagination behavior, date-range handling, sorting, return shape, or any side-effect profile beyond the implied read-only nature of 'List'.

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 with zero wasted words. The verb and resource are front-loaded, and the parenthetical efficiently clarifies the transaction scope.

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 schema covers all parameter meanings, and the description names the resource clearly. However, with no output schema or annotations, the tool leaves gaps around return format, pagination, and when it is preferable to sibling investment tools like get_portfolio_summary.

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

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

Schema description coverage is 100%, so the baseline is 3. The phrase 'optionally filtered' maps to the filter parameters but adds no specific meaning beyond what the schema already documents for to, from, assetId, and assetType.

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

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

The description states a clear verb and resource: 'List investment transactions' with a parenthetical clarifying buys/sells. It is unambiguous about what the tool does, though it does not explicitly contrast with siblings like get_portfolio_summary or get_asset_price_history.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention that get_portfolio_summary provides a higher-level view or that get_asset_price_history tracks prices, leaving the agent to infer appropriate usage.

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?

No annotations are provided, so the description carries the burden of behavioral disclosure. 'List all' clearly signals a read-only, non-destructive operation with no filtering or side effects, which is sufficient for a zero-parameter list tool. It does not mention pagination or return format, but those are minor for this simple resource.

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 sentence with the core operation front-loaded and only one useful parenthetical explaining why the tool matters. Every word earns its place and no filler is present.

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

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

For a simple, zero-parameter list operation without an output schema, the description is complete: it states the operation, the scope ('all'), and the downstream purpose (creating items). An agent can select and invoke this tool correctly based on the description alone.

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

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

The input schema has zero properties and 100% schema description coverage, so there are no parameters requiring documentation. This matches the baseline of 4 for a zero-parameter tool; the description appropriately adds no redundant parameter detail.

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 ('List') and a precise resource ('all item categories'), immediately distinguishing it from item CRUD siblings like list_items and create_item. The added purpose clause ('needed for creating items') further clarifies its role and value.

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 noting this tool is needed before creating items, which implies the correct usage scenario. It does not explicitly name alternatives or say when not to use it, but there is no obvious competing sibling for item categories specifically.

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?

No annotations are present, so the description carries the burden. The verb 'List' accurately implies a read-only operation, but the description does not disclose default behavior, ordering, pagination, or whether all statuses are returned when no filter is applied. It is correct but minimal.

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

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

A single, front-loaded sentence with no filler or redundancy. It states the core operation and optional filters efficiently.

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

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

For a simple list tool with two optional parameters and full schema coverage, the description plus schema is sufficient for a correct call. It does not describe the output shape, but the verb 'List' implies a collection, and no output schema exists to define it further.

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

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

Schema description coverage is 100%, so the parameters are already documented. The description only repeats the idea of filtering by status or category and adds no additional meaning beyond what the schema provides.

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 and resource: 'List tracked items/products', and notes the optional status/category filters. This clearly identifies the operation and differentiates it from sibling tools like create_item, update_item, delete_item, and list_item_categories.

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 naming the resource, but it does not explicitly compare with alternatives such as list_item_categories or explain when to prefer list_items over other list_* tools. No exclusions or alternative routing are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'List journal entries, optionally filtered by date range' without mentioning ordering, pagination, the default limit, read-only nature, or date-boundary semantics. This adds little beyond what the tool name already implies.

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 no filler. The verb and object are front-loaded, and the optional filter is stated efficiently.

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 schema covers parameter definitions well, and the core operation is clear. However, with no annotations and no output schema, behavioral details like sorting, pagination, and what fields are returned are left unspecified, which makes the description adequate rather than fully 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 100%, so the baseline is 3. The description adds the 'date range' framing for from/to but provides no additional meaning for the limit parameter or any important formatting details beyond what the schema already documents.

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 ('List') and resource ('journal entries'), and notes the optional date-range scope. It is clear at a glance, though it doesn't explicitly contrast with sibling tools like list_journal_todos or get_day_entry.

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

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

No guidance is given for when to use this tool versus alternatives such as get_day_entry or list_journal_todos. There are no exclusions, conditions, or references to sibling tools, so the agent receives no routing help beyond the obvious reading intent.

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?

No annotations are provided, so the description carries the burden of conveying behavior. 'List' signals a read-only operation, and the optional completion-status filter communicates the key behavioral variation. It does not describe return shape or pagination, but for a simple one-parameter list tool 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 one short sentence with the core verb and resource front-loaded. The parenthetical definition and optional-filter clause each add value without repetition 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?

For a tool with one optional parameter and no output schema, the description plus schema cover the main usage and filtering semantics. Return-field details are not specified, but the simple read-only nature of the tool makes this a minor gap rather than a critical omission.

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

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

Schema coverage is 100% and the schema already explains the completed parameter fully, including behavior when omitted. The description's mention of optional filtering adds no new semantic detail beyond the schema, so the baseline score 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 states a specific verb ('List'), a clear resource ('journal todos'), and adds a clarifying parenthetical ('task items') that distinguishes these from journal entries or general tasks. The optional completion-status filter further specifies the operation's scope.

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 establishes when to use the tool: when journal todos need to be retrieved, with an optional filter. It does not explicitly name alternative tools or exclusion conditions, but the journal-todo resource is distinct enough among siblings that usage is unambiguous.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It clearly indicates a read-only listing operation and mentions the available filters, but it does not disclose ordering, pagination, the default limit (aside from schema), or what entry fields will be returned. These are meaningful gaps, but the core non-mutating behavior is transparent.

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

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

The description is two short sentences with the main action front-loaded. Every word earns its place: the resource is named, and the filters are summarized without redundant 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?

For a list tool with five optional, fully documented parameters, the description is adequate but not complete. Since there is no output schema, the description could usefully explain what an entry contains or the default sort/return behavior. Still, an agent can likely invoke it correctly based on the schema alone.

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

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

Schema description coverage is 100%, so the schema already documents each parameter meaningfully. The description adds a high-level grouping of filters (date, date range, meal type) but does not add detail beyond the schema. The 'limit' parameter is not mentioned in the description, but the schema covers 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 states a specific verb ('List'), a distinct resource ('logged meal entries'), and the key filtering dimensions (date, date range, meal type). It clearly differentiates from sibling tools like list_meal_templates, create_meal_entry, and get_diet_daily_summary by specifying logged entries rather than templates, writing, or summaries.

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 retrieving historical food logs, but it does not explicitly state when to prefer this over related tools such as list_meal_templates or get_diet_daily_summary. It provides no exclusions or alternative routing, leaving the agent to infer the appropriate 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?

With no annotations, the description carries the transparency burden. 'List all saved...' clearly indicates a read-only operation and broad scope, which is helpful. It does not mention sorting, pagination, or whether shared/community templates are excluded, but for a zero-parameter listing tool this is a reasonable level of 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 one concise sentence with no filler. The parenthetical definition 'reusable food combinations' adds value without bloating the text. Every word earns its place.

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

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

For a no-parameter listing tool, the description is nearly complete: it covers the operation, resource, and scope. It could be slightly more explicit about excluding community templates or describing the response shape, but given the trivial input surface and simple read behavior, this is a minor gap.

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

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

There are zero parameters and schema description coverage is 100%, so no parameter documentation is needed. The description adds semantic clarity about what 'meal templates' are, which indirectly supports the empty schema. Baseline for zero parameters is 4.

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 ('List') and a clear resource ('saved meal templates'), and defines the concept with 'reusable food combinations.' This distinguishes it from sibling tools like list_meal_entries (entries vs templates) and search_community_templates (saved vs community). The scope is immediately clear.

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 usage context is implied: use this when you need all of the user's saved meal templates. However, it does not explicitly state when not to use it or mention alternatives such as search_community_templates for community templates. The guidance is adequate but not 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?

No annotations are provided, so the description carries the full burden. The verb 'List' implies a read-only operation, but the description does not disclose the default archived behavior (omitted means non-archived only), pagination, or result semantics. This is a meaningful gap for a data-retrieval tool.

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

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

The description is a single sentence with no filler. It front-loads the verb and resource, then states the optional filters compactly and readably.

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 list operation with no required parameters and a schema covering all parameters, so the description is close to adequate. However, it leaves out the archived filter and offers no guidance on result scope or defaults, leaving some ambiguity for agents.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description restates 'search' and 'relationship type' but adds no extra meaning and does not mention the `archived` parameter or its default behavior.

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

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

The description states a clear action ('List'), a specific resource ('people in your CRM'), and two optional filters ('search or relationship type'). However, it omits the archived filter and does not explicitly distinguish this from the sibling `list_friends` tool.

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

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

There is no guidance on when to use this tool versus alternatives like `list_friends` or `create_person`. No context, conditions, or exclusions are provided to help an agent choose it correctly.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It implies a read-only list operation and hints at return content via 'task counts and metadata'. However, it does not explicitly state side-effect-free behavior, default filtering (e.g., archived excluded), or any limits/pagination. The inclusion of 'all' is slightly ambiguous given the includeArchived parameter default.

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 front-loads the primary action and resource, then appends the useful return detail. 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?

For a tool with one optional parameter, full schema coverage, and no output schema, the description is near-sufficient. It tells the agent what will be returned (projects with task counts and metadata), and the parameter is defined in the schema. It could be slightly more complete with a note about default archived filtering, but that is already in the schema.

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

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

Schema description coverage is 100%, so the includeArchived parameter is fully documented in the schema itself. The tool description does not add any semantics beyond the schema, matching the baseline of 3.

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

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

The description states a specific verb ('List') and resource ('Trackfusion projects'), and adds useful detail about the return content ('task counts and metadata'). It is clear enough to identify what the tool does, but it does not explicitly differentiate from sibling list tools like list_tasks or list_items; the resource name alone provides differentiation.

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, no conditions, and no exclusions. The description merely states the action; an agent must infer that this is the right tool when needing a project overview. No sibling comparisons or context are provided.

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

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

No annotations are provided, so the description carries the full burden. 'List all' communicates that this is a read-only operation, which is useful. However, it does not disclose output format, ordering, or whether the returned categories include the IDs needed for creating expenses.

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. Every word adds value, and the purpose-related qualifier is placed where it is most useful.

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

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

For a zero-parameter list tool, the description is nearly sufficient. The main gap is that it does not specify what the returned categories look like, especially whether they include identifiers that can be passed to create_spending, which the parenthetical implies is the intended use.

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

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

The tool has zero parameters and the schema coverage is 100%, so there are no parameter semantics to clarify. The description adds relevant purpose context, and the baseline for zero-parameter tools is 4.

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 ('List') and a clear resource ('all spending categories'), immediately distinguishing it from related tools like list_spendings and list_spending_sources. The parenthetical additionally signals its role in the expense-creation flow.

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 parenthetical '(needed for creating expenses)' provides clear context for when to use this tool. It does not explicitly name alternatives or exclusions, but the usage intent is conveyed well enough for an agent to select it.

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?

With no annotations provided, the description must carry the behavioral burden. 'List' implies a non-destructive read operation, and the filter dimensions are stated, but ordering, pagination behavior beyond the limit default, and date-boundary semantics are not disclosed. Acceptable but thin.

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 that leads with the core action and resource, then lists the optional filters. Every word earns its place, 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 read-only list operation with no required parameters and full schema coverage, the description is largely complete. It could mention result ordering or pagination, but the essential information needed to select and invoke the tool is present.

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

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

Schema coverage is 100%, with all five parameters already described. The description reinforces the date/category/source filtering intent but adds no new semantic detail beyond what the schema provides. A baseline 3 is appropriate.

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

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

The description uses a specific verb ('List') and resource ('expense records'), and names optional filters (date range, category, source). This clearly distinguishes it from sibling tools like create_spending, update_spending, delete_spending, and list_incomes.

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 makes it clear that this tool is for retrieving expense records and optionally narrowing results by filters. It does not explicitly exclude alternative tools like get_spending_analytics, but the intent is unambiguous enough for an agent to select it correctly.

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

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

With no annotations, the description carries the burden of disclosing behavior. 'List all payment sources' clearly implies a read-only, non-mutating operation with no filtering. However, it does not describe the response shape or any edge behavior like empty results, which would help the agent use the returned data in subsequent create 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?

A single sentence that leads with the action and resource, then adds only the essential purpose. 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?

For a zero-parameter list tool, the description is adequately complete: it states what is listed and why it is needed. A minor gap is that it does not mention what fields the returned payment sources contain, but the absence of an output schema and the simplicity of the operation keep this from being a serious omission.

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 and the input schema. The description adds context about why these sources are needed, which is enough. With no parameters to document, 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 clearly states the verb 'List' and the resource 'payment sources', and it adds the purpose 'needed for creating expenses and incomes'. It is distinguishable from nearby siblings like list_spendings and list_spending_categories, though it does not explicitly name them.

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

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

The parenthetical '(needed for creating expenses and incomes)' gives clear context on when to use this tool: before creating spending or income records. It does not provide exclusions or name alternatives, but the context is sufficient for a zero-parameter lookup.

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?

With no annotations, the description carries the full burden of behavioral disclosure. 'List' appropriately implies a read-only operation, and 'optionally filtered by status' conveys filtering behavior. However, it does not mention potential limitations such as pagination, ordering, permission requirements, or behavior with invalid status values, so transparency remains minimal.

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 no redundant words, front-loaded with the verb and resource. It states the core action and optional filter concisely, earning its place with zero waste.

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

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

For a simple filtered-list tool, the description covers the essential calling context: projectId and optional status. However, with no output schema and no annotations, it omits return format and any behavioral caveats, leaving some room for ambiguity though not severely.

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

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

Schema description coverage is 100%, with both parameters already documented including status value examples. The description reinforces that status is optional but adds no new semantics beyond the schema, so a baseline score 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 uses the specific verb 'List' with the resource 'tasks' and the scope 'in a project,' clearly distinguishing it from get_task (single task) and list_projects (project list). The optional status filter adds useful behavioral detail. This is a strong, unambiguous purpose statement.

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

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

The description implies the tool is for retrieving multiple tasks within a project, but it does not explicitly state when to prefer it over get_task or other task-related tools. No alternatives are named and no exclusions are given, leaving usage guidance 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?

Without annotations, the description must carry the transparency burden. It implies a read-only operation via 'List' and mentions optional date filtering, but discloses nothing about the return shape, sorting, pagination, or the default limit, leaving the agent to infer those details.

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 with no filler, front-loaded with the verb and resource. Efficient and easily parsed.

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

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

For a simple list operation with three optional, fully documented parameters and no output schema, the description is largely sufficient. It lacks only return-value clarity, so an agent might not know the exact shape of the workout session objects, which is a minor gap.

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

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

Schema coverage is 100%, so the baseline is 3. The description mentions the date-range filtering behavior, which maps to 'from' and 'to' parameters, but it adds no semantic detail beyond the schema descriptions.

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

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

The description states a specific verb ('List'), a specific resource ('workout sessions'), and an optional filtering behavior ('by date range'), which clearly differentiates it from sibling tools like list_workout_templates or create_workout_session. The scope is immediately understandable.

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 choose this tool over siblings. There is no mention of alternatives, exclusions, or conditions, such as when to use list_workout_templates instead.

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

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

With no annotations, the description must carry the behavioral burden. The word 'List' implies a read-only operation, but the description does not explicitly state non-mutation, ordering, pagination, or whether only user-created templates are returned. It provides minimal but acceptable transparency for a simple list operation.

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 wasted words. It directly states the action and the target resource, which is ideal for such a simple tool.

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 no-parameter list tool, the description is largely complete: it tells the agent what will be listed and implies the return type. The lack of an output schema is not a significant issue here, though a mention of the template fields could make it fully comprehensive.

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 there is nothing for the description to explain. The schema coverage is effectively 100%, and the baseline of 4 applies since no parameter semantics are needed.

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

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

The description names a specific verb ('List') and resource ('saved workout templates'), so the purpose is clear. However, it does not explicitly distinguish itself from siblings like list_workout_sessions or list_meal_templates, though 'templates' is reasonably distinct.

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 about when to use this tool versus alternatives such as list_workout_sessions or list_exercises. No exclusions, prerequisites, or context are provided, leaving the agent to infer the appropriate 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?

No annotations are present, so the description carries the full behavioral burden. It discloses that all template items become meal entries, but it does not say whether existing entries for that date/meal are preserved, replaced, or duplicated, nor what the call returns. This is a significant gap for a mutating bulk operation.

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. Every phrase earns its place: the action, the scope ('all items'), the source ('meal template'), and the target ('specific date and meal').

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

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

With no annotations and no output schema, the description should clarify side effects and result shape. It provides the core invocation context but omits whether the operation is additive, idempotent, or replacing, and what response the agent should expect. This makes it incomplete for a write operation.

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 describes all three parameters, including the date format and meal type enum, so the description does not need to repeat them. The description adds the useful bulk-logging context but no parameter-specific meaning 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 uses a specific verb ('Log') and resource ('meal template'), and clearly explains the outcome ('as meal entries') plus the target date and meal. This distinguishes it from sibling tools like list_meal_templates and create_meal_entry by signaling a bulk logging 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 gives clear context: use this tool when you want to log all items from a meal template for a specific date and meal. It does not explicitly name alternatives or exclusions, but the scenario is specific enough to guide an agent reasonably.

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?

No annotations are provided, so the description carries full burden. It does disclose a meaningful behavioral trait: 'Tries Open Food Facts first, then UPC ItemDB as fallback,' which signals external data sources and ordering. However, it does not mention that this is a read-only network call, what happens when a barcode is not found, or any latency/error behavior that an agent might need to handle.

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 short sentences with no wasted words. It front-loads the core action and followes with the fallback behavior. 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?

Given the tool's simplicity (one param, no output schema, no annotations), the description is mostly adequate but misses key operational details. It does not explain what the returned product data looks like, what happens if neither source returns a result, or whether the tool has side effects. An agent would benefit from one more sentence about the return or failure behavior.

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

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

Schema description coverage is 100%, and the parameter is already described as 'Product barcode (EAN/UPC, 8-14 digits).' The tool description does not add any extra meaning about the barcode parameter beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Look up a product by barcode.' The fallback sources add clear scope and distinguish it from the many CRUD siblings, none of which do external barcode lookup. An agent can immediately identify what this tool does.

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

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

The description implies usage through the verb 'look up' and mentions the fallback order, but it does not explicitly state when to use this tool vs alternatives. There are no when-to-use or when-not-to-use conditions, and the closest sibling tools like search_foods are not referenced. The usage context is embedded but not spelled out.

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?

No annotations are present, so the description carries full burden for behavioral disclosure. It states the core action (accept/reject) but does not disclose consequences such as whether accepting creates a friendship, whether rejecting is reversible, what happens to related data, or error behavior for invalid IDs. This is a significant gap for a state-changing tool.

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

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

The description is a single efficient sentence that front-loads the action and target resource. There is no wasted wording, and every word earns its place.

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

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

For a simple two-parameter tool with no output schema, the schema plus description likely enables a correct call. However, missing behavioral context (side effects, error states) and lack of usage guidance mean the definition is only minimally complete rather than fully self-sufficient.

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

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

Schema description coverage is 100%: both parameters have descriptions, including the action enum values and the source of friendshipId. The description adds no additional parameter meaning beyond what the schema already provides, so the baseline 3 is appropriate.

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

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

The description 'Accept or reject a pending friend request' uses a specific verb (accept/reject) and resource (pending friend request). This distinguishes it from siblings like send_friend_request and delete_friend, which handle different stages of the friendship lifecycle.

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 'pending friend request' and the friendshipId description 'from list_friend_requests' imply the intended workflow: list requests first, then respond. However, there is no explicit guidance on when to use this tool versus send_friend_request or delete_friend, nor any exclusions or alternatives mentioned.

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 a behavioral trait ('sorted by popularity') beyond the schema, but does not disclose any side effects, limitations, or output characteristics. With no annotations present, the description carries the full burden and provides only minimal behavioral context, though the read-only nature is implied by 'search or browse'.

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 no wasted words and is front-loaded with the action verbs. It is concise and well-structured, though it may be slightly under-specified given the tool has four parameters and several closely related siblings.

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 but lacks explicit usage guidance relative to sibling search tools and does not describe return behavior in the absence of an output schema. The schema covers parameter meanings well, but the tool's selection criteria and output expectations are not fully addressed.

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 already documents all four parameters with descriptions and has 100% coverage, so the description adds no additional parameter semantics. It does not mention or elaborate on any parameters, which is acceptable under the baseline for full schema coverage.

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

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

The description clearly states the tool's function with specific verbs ('search or browse') and a specific resource ('community-contributed food definitions'). The qualifier 'community-contributed' distinguishes it from sibling tools like search_foods or list_food_definitions, which likely cover other scopes.

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 choose this tool over alternatives such as search_foods or lookup_barcode. The description does not include any when/when-not conditions or alternative references, leaving the agent to infer selection criteria solely from the word 'community-contributed'.

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?

With no annotations provided, the description carries the disclosure burden. It adds useful behavioral context like popularity sorting and community scope, but it does not state the return format, whether an empty search browses all templates, or pagination behavior beyond the limit parameter.

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 sentence with no filler, action first, and key traits (community scope, popularity sorting) included. Every word contributes to understanding.

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 two-optional-parameter search tool, the description plus schema is adequate for invoking it. However, since there is no output schema, a brief note about the returned template fields or result set would improve 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 100%, so both parameters are already documented. The description adds only the browse-vs-search distinction, which loosely maps to the optional search parameter but does not materially enrich parameter meaning.

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 an action ('Search or browse') and a specific resource ('community-shared meal templates'), with a useful sorting trait. The 'community-shared' qualifier distinguishes it from siblings such as list_meal_templates and search_community_foods.

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 'community-shared meal templates' gives clear context for when to use this tool: when the agent needs public/shared templates rather than personal ones. It does not explicitly name alternatives or exclusions, but the context is strong enough for correct routing.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose that this searches third-party external services and returns nutrition data, but it omits network/latency implications, pagination behavior, source defaults, result limits, and potential failure modes. This is minimal and non-contradictory, but not deeply transparent.

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

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

The description is one concise, front-loaded sentence with no filler. It states the action first, then the specific external databases and the intended data type, so every word contributes to tool understanding.

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 search tool with three well-documented parameters, the operation is adequately conveyed and the parameters are fully covered by the schema. However, with no output schema and no annotations, the description does not clarify what the returned nutrition data looks like or how this search relates to barcode-based and community-based alternatives, leaving meaningful 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 100%, so the baseline is 3 even though the description itself adds no parameter-specific guidance. The prose adds marginal value by expanding the source enum values (OFF/USDA into Open Food Facts + USDA) and clarifying that nutrition data is the target, but query and page semantics are already fully documented in the schema.

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

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

The description pairs a specific verb ('search') with a specific resource ('external food databases') and names the exact providers (Open Food Facts + USDA) plus the purpose ('nutrition data'). This distinguishes it well from siblings like search_community_foods (external vs community) and list_food_definitions (external vs local), even without inspecting the schema.

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

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

The description conveys clear general context: use this when you need nutrition data from external food databases. However, it does not explicitly state when not to use it, nor does it point to alternatives such as lookup_barcode or search_community_foods, so the routing guidance is implied 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?

No annotations are provided, so the description carries the full behavioral burden. It clearly conveys the primary side effect—a friend request is sent to the given email—but it does not disclose duplicate handling, validation rules, whether the recipient must exist, or what the response indicates. This is adequate but has noticeable gaps.

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 short sentence with no filler. The action and identifier are front-loaded, and every word contributes to the 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 tool is simple: one required parameter, no nested objects, and no output schema. The description plus schema are sufficient for a basic invocation. Missing details around duplicate requests or error behavior are notable but not critical given the tool's low 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 100%, so the schema already fully documents the 'email' parameter. The description adds no new semantic information beyond restating that the request is sent by email address.

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

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

States a specific verb ('send'), a specific resource ('friend request'), and the identification method ('by email address'). This clearly distinguishes it from related siblings like 'respond_to_friend_request', 'list_friend_requests', and 'delete_friend'.

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 intended use is implied by the verb 'send' and the resource 'friend request', but the description gives no explicit when-to-use or when-not-to-use guidance, and does not mention alternatives. It also omits prerequisites such as whether the recipient must already have an account.

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?

No annotations are provided, so the description must carry the behavioral disclosure burden. It indicates a mutating operation with 'set/update', but it does not explain whether bmr/tdee are calculated or overwritten, how a custom macroPreset is handled, whether the operation is idempotent, or what side effects occur on an existing 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, efficient sentence with no redundant words. It front-loads the action and resource, then gives the purpose, making it easy to parse.

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

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

Despite a rich schema, this is a complex tool with nine parameters, six required fields, enums, and a nested customMacros object with a conditional requirement, and there is no output schema. The description does not clarify the conditional behavior around customMacros, whether bmr and tdee are optional computed values or overrides, or what the caller should expect as a result.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds only minimal framing around TDEE calculation and goal setup, which loosely relates to bmr, tdee, and weightGoal, but it does not add meaningful parameter-level semantics beyond the schema.

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

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

The description names a specific action (set/update), a clear resource (user diet profile), and the purpose (TDEE calculation and goal setup). It is easily distinguished from sibling get_diet_profile because it is a write operation rather than a read.

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

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

The description implies when the tool should be used: when setting or updating the user's diet profile for TDEE-related calculations. However, it does not explicitly mention alternatives like get_diet_profile or set_nutrition_goals, nor does it state prerequisites such as whether an existing profile must already exist.

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?

With no annotations, the description carries the full burden of behavioral disclosure. It does not state whether setting goals overwrites existing goals, whether values must be positive, or what the response looks like. 'Set' implies replacement but that is not explicitly 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 efficient sentence with no wasted words. The core action and target are front-loaded, making the tool's purpose immediately understandable.

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 and the schema covers parameters well, but there is no output schema and no annotations. The description does not mention update semantics, validation constraints, or what happens after the goals are set, leaving meaningful gaps for a mutation tool.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description only groups them as 'calories and macro targets' and adds no additional semantic detail 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 uses a specific verb ('Set') and resource ('daily nutrition goals'), and clarifies the scope with 'calories and macro targets'. It clearly distinguishes this from the read-only sibling get_nutrition_goals.

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 about when to use this tool versus alternatives such as get_nutrition_goals or set_diet_profile. The agent is left to infer the appropriate context from the verb and 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?

With no annotations, the description carries the full burden of behavioral disclosure. It clearly indicates the operation is an assignment, but does not state whether it overwrites existing intake, what happens if a record for the date is absent, or how amountMl and glasses are reconciled.

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

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

A single, front-loaded sentence with no filler. It communicates the action, target, value, and temporal scope efficiently.

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 and all parameters are documented in the schema, so the brief description is nearly sufficient. However, because it is a mutation with no annotations and an add-vs-set sibling, the lack of explicit replace semantics and when-to-use guidance leaves a small but meaningful gap.

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