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 says a child profile is added, which essentially restates the create action; it does not disclose side effects, whether the operation creates immediately, any uniqueness constraints, or what happens on failure. There is no contradiction, but also almost no behavioral depth beyond the tool name.

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 short sentence with no filler or redundancy. It is front-loaded with the action, though the brevity borders on under-specification; that gap is handled more directly by other dimensions.

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 documented parameters and an output schema, the one-sentence description is largely sufficient to let an agent invoke the tool correctly. The main missing piece is explicit guidance about when to choose this over update/get/list, but the low complexity plus rich schema makes the overall definition reasonably complete.

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

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

Schema description coverage is 100%, so the input schema already documents all four parameters including birth_date format and birth_time optionality. The description itself provides no parameter-level detail, but the baseline of 3 applies because the schema carries the semantic weight.

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-resource pair, 'Add a new child profile', leaving no doubt that this tool creates a child entity. The word 'new' also distinguishes it from the sibling children_update_child, which modifies an existing profile. It is concise and unambiguous.

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

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

The wording 'Add a new' implies this is the creation counterpart to children_update_child, children_get_child, and children_list_children, but the description never explicitly states when to use it instead of those siblings. No exclusions, prerequisites, or alternatives are named, so 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?

With no annotations, the description carries the behavioral burden. It usefully discloses that children are keyed by slug rather than numeric ID, which is a real behavioral nuance. It doesn't mention error cases or authentication, but for a simple read operation 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?

Two concise sentences with no filler. The core action is front-loaded, and the key-based distinction is stated in the second sentence without 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 single-parameter, single-resource retrieval tool with an output schema present, the description covers everything needed to call it correctly. No additional context about return values or nesting is required because the output schema exists.

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

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

Schema coverage is 100% and the schema already explains that slug is the child's slug from list_children. The description repeats the slug concept but adds no additional meaning beyond the schema, 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 clearly states the tool 'gets a single child profile by slug,' specifying the exact verb, resource, and identifying key. It also distinguishes itself from list_children by emphasizing the singular retrieval and slug-based keying.

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 establishes clear usage context: use this when retrieving one child by slug, not when listing all children. It doesn't explicitly name alternatives or when-not conditions, but the singular-versus-list distinction is implicit and sufficient for this simple 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 behavioral disclosure burden. 'List child profiles' clearly indicates a read-only operation, and 'get child IDs and slugs needed by other tools' explains the output's purpose. It omits possible pagination or result-size caveats, but nothing suggests destructive or unexpected 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 two short sentences with no filler. It front-loads the core purpose and immediately adds the most important usage instruction. Every sentence 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?

Given the simple list operation, the schema covers parameters, and an output schema exists, the description is nearly complete. The workflow hint about calling this first adds valuable context. It could mention result-size behavior or pagination, but that is not critical for this tool's apparent simplicity.

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

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

Schema description coverage is 100%, so all four optional parameters are already documented in the schema. The description adds no additional parameter-level meaning beyond the workflow context of returning IDs and slugs. Baseline of 3 is appropriate 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?

The description clearly states the verb and resource: 'List child profiles.' It also communicates its role as the entry point for obtaining child IDs and slugs. However, it does not explicitly differentiate from siblings like children_get_child or children_create_child, so it lacks explicit sibling distinction.

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

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

The instruction 'Always call this first to get child IDs and slugs needed by other tools' provides explicit when-to-use guidance and establishes the tool as a prerequisite. It does not mention when not to use it or name alternative tools, but the precedence guidance is strong.

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 burden. It discloses the partial-update behavior ('Only provided fields are changed'), but omits potential edge cases like invalid slug handling, whether null values clear fields, or any error/success response details. The one disclosed behavior is useful but not enough for a mutation tool 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?

A single 8-word sentence that front-loads the core action and the key behavioral caveat. No filler or repetition of 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?

For a simple single-resource update, the description plus the fully documented schema and output schema cover most needs. It lacks error/edge-case context and explicit alternate usage, but the essential identification and partial-update semantics are present. This is above the minimum viable but not exhaustive.

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 value by clarifying that omitted fields remain unchanged, which explains the null-default schema pattern. It also indicates the slug is the targeting key, complementing 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 clear verb ('Update') and resource ('child's profile') with a specific identification method ('by slug'). Clearly distinct from siblings like children_create_child, children_get_child, and children_list_children.

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

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

The description implies this is for updating an existing child, but does not explicitly contrast with create or list, nor state prerequisites like 'child must exist'. The partial-update note is more of a behavior than a usage condition, so 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 carries the full burden of behavioral disclosure. It merely restates the action and adds no context about persistence, idempotency, return behavior, or how this event relates to existing records. This is a thin description for a tool without annotation support.

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 or redundant information. It efficiently conveys the core purpose without wasting tokens.

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 description is minimal, the schema covers all parameters and an output schema exists, so the agent has the necessary structured information. The main missing piece is explicit usage guidance, but for a straightforward create operation 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?

Schema description coverage is 100%, so all seven parameters, their types, defaults, and required status are already documented. The description adds no additional parameter-level meaning, 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 ('Record') and a specific resource ('a diaper change event'), clearly identifying the action. It also differentiates from sibling tools like diapers_update_diaper_change and diapers_delete_diaper_change by indicating creation rather than modification or deletion.

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

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

There is no explicit guidance about when to use this tool instead of the update or delete variations. However, the verb 'Record' reasonably implies creating a new event, so usage is contextually evident though not explicitly 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?

With no annotations, the description carries the behavioral disclosure burden. It explicitly warns that the deletion is permanent, which is the key behavioral trait for a destructive tool. However, this wording largely duplicates the input schema's 'permanently delete' parameter description)Skip, and no other behavior such as side effects, error conditions, or return semantics is 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 two short sentences with no filler: the action is front-loaded, and the permanence warning follows immediately. This is appropriately concise for a single-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 one-parameter destructive tool with a fully documented input schema and an output schema, the description is nearly sufficient: it identifies the resource and warns that deletion is irreversible. It only lacks explicit when-to-use/alternative guidance, which is already accounted for under usage guidelines.

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 provides 100% coverage for the only parameter, including the fact that change_id identifies the record to permanently delete. The description adds no parameter-level detail beyond the schema, so the baseline 3 applies.

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

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

The description states a clear verb and resource: 'Delete a diaper change record.' This directly distinguishes it from sibling tools like diapers_update_diaper_change and the other delete_* tools while also making the scope unambiguous.

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

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

There is no guidance about when to use this tool versus alternatives such as diapers_update_diaper_change or diapers_create_diaper_change. The description only states the action, leaving the agent to infer the appropriate selection context.

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

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

Annotations are absent, so the description carries the full burden. It only says 'List with optional filters' without disclosing pagination, default ordering, response format, or any side effects. The output schema exists but the description doesn't mention what to expect.

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

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

A single sentence that is efficient and front-loads the core purpose. No fluff or redundancy. It is appropriately concise for a simple list 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?

With 10 parameters and an output schema, the description is too thin. It doesn't explain that filters can be combined, that limit defaults to 50, or any typical use cases. An agent is left to infer capabilities from the schema alone, which the description should complement.

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 all parameters are documented in the schema. The description adds no additional meaning—'optional filters' merely echoes the schema. Baseline of 3 applies because the schema handles parameter 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 action (list) and resource (diaper change records). It distinguishes from create/update/delete siblings by using 'list', but doesn't explicitly differentiate from other list tools like list_tummy_times; however, the resource name makes it specific enough.

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

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

No guidance on when to use this tool vs alternatives. It doesn't mention that this is the appropriate tool for retrieving diaper change history or mention any exclusions. There is no reference to sibling list tools or to create/update/delete 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?

No annotations are provided, so the description carries the behavioral burden. It usefully discloses the partial-update behavior ('Only provided fields are changed'), which is the main non-obvious trait, though it omits error behavior and return details; the available output schema mitigates the return question.

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

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

Two short sentences, front-loaded with the action and resource, followed by the one essential behavioral qualifier. No filler or repetition of schema details.

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 straightforward CRUD update with a fully documented schema and an output schema present, this is nearly complete. It could mention what happens when change_id does not exist, but that is the main 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?

The schema already documents all 7 parameters at 100% coverage, so the baseline is 3. The description adds meaningful partial-update semantics: unprovided fields are left unchanged, which clarifies the default-null parameters without contradicting 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 ('Update') and resource ('existing diaper change record'), and the 'existing' qualifier distinguishes it from create/delete siblings. It does not explicitly contrast with the other update tools, but the resource is unambiguous.

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

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

'Update an existing diaper change record' gives clear context for when to choose this tool over create or delete equivalents. It does not list explicit exclusions or alternatives, but the partial-update sentence reinforces its intended use for modifying an existing record.

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, but 'Record a feeding session' only implies a create action. It does not disclose anything about validation, required fields, timer behavior, or the output format, leaving the agent to infer the operational semantics from the schema and tool name.

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 or redundant phrasing, making it highly concise and front-loaded. However, it is arguably too sparse for an 8-parameter tool, though conciseness itself is handled well.

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 the rich schema and output schema, the description does not provide important contextual guidance such as how timer_id relates to start/end, the meaning of feeding_type and method choices, or when to prefer this tool over the update variant. It is minimally adequate but incomplete for a tool with this many parameters and no annotations.

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

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

The input schema has 100% parameter description coverage, so the schema already documents each parameter including units, formats, and defaults. The description adds no extra parameter-level meaning, which is acceptable given the schema's thoroughness, warranting the baseline score.

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

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

The description 'Record a feeding session' is a clear verb+resource statement indicating a create operation. It distinguishes itself as the create variant from siblings like feedings_update_feeding and feedings_delete_feeding, 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 description gives no guidance on when to use this tool versus alternatives such as feedings_update_feeding or feedings_delete_feeding. It does not mention important selection criteria like using timer_id versus explicit start/end times, or when to create a feeding versus a pumping session.

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 explicitly states the permanence of the deletion, which is valuable, but does not mention error behavior, idempotency, authorization requirements, or what happens to related records.

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 with zero filler: the core action is stated first and the key consequence (permanence) is front-loaded. 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?

This is a simple single-parameter delete operation with an output schema available and full schema coverage. The description covers the target resource and the critical permanence consequence, which is sufficient 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?

Schema description coverage is 100%, and the schema already documents feeding_id as 'ID of the feeding record to permanently delete.' The description adds no parameter-level meaning beyond the schema, 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: 'Delete a feeding record.' It clearly differentiates from siblings like feedings_update_feeding or feedings_list_feeding by targeting deletion only, and the addition of 'permanent' reinforces the action's nature.

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, no exclusions, and no mention of prerequisites such as the record existing or being owned by the current user. Usage context is only implied by the tool's name and delete-sibling pattern.

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 for behavioral disclosure. It says 'List feeding records' but doesn't detail important behaviors like what happens with the 'exact' filters (likely equality on timestamps), whether the tool returns all matching records or paginates (limit is available), or whether the tool is read-only. The description does not mention anything about the response shape despite having an output schema, nor does it disclose any side effects—but since it's a list, sides effects are minimal. Still, for a tool with no annotations, it should explain default behavior when no filters are given or how 'exact' contrasts with range filters.

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 names the resource and mentions filters. It is appropriately short and front-loaded with the core action. No fluff or unnecessary detail, though it could have included a bit more context without becoming verbose.

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

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

Given the tool has 12 optional parameters, an output schema, and no annotations, the description is somewhat thin. It doesn't explain default behavior (e.g., what happens if no filters are provided), or how to interpret 'exact' vs 'range' filters, or whether limit applies. However, the output schema likely provides return structure, and the parameter descriptions cover each field. For a listing tool, it is minimally complete but could benefit from a note on default pagination or sort order.

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 parameters are documented with descriptions. The description adds little beyond the schema, but it does mention 'optional filters' which hints at the filtering purpose. The schema already explains each parameter, including the child_id hint to use list_children, so the description doesn't need to duplicate that. 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 clearly identifies the action (list) and resource (feeding records), with a nod to optional filters. It distinguishes from creation/update/delete siblings by implying a read operation, though it doesn't explicitly name a sibling like feedings_create_feeding. The verb and resource are specific enough for an agent to differentiate.

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 explicit when-to-use instructions or alternatives. However, the 'list' verb and the context of sibling tools (create/update/delete) imply it is for retrieval. It lacks guidance on when to use versus other list tools (e.g., sleep_list_sleep) but that's a minor gap for a simple listing operation.

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. It discloses a key behavioral trait: 'Only provided fields are changed' – a partial-update semantics that is important for an agent to know. However, it does not disclose what happens when a field is set to null (whether that clears the field or is ignored), nor does it mention any validation, side effects, or return behavior. The partial-update note is valuable but incomplete.

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 with no filler. The first sentence states the action and target; the second adds the most important behavioral nuance. 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 update tool with full schema coverage and an output schema, the description is mostly adequate. The main gap is the ambiguity around null values: since all optional fields default to null, an agent cannot tell whether passing null clears a field or means 'do not change'. This is a meaningful completeness gap for an update 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 every parameter. The description adds the crucial semantic that only provided fields are changed, which clarifies how the optional parameters behave. It does not add detail about null semantics or format constraints beyond what the schema provides, but the baseline of 3 is appropriate given 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 verb ('Update') and resource ('an existing feeding record'), and the schema confirms the target is identified by feeding_id. It doesn't explicitly distinguish from feedings_create_feeding or feedings_delete_feeding, but the verb 'update' plus the resource makes the purpose unambiguous.

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

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

The description implies usage: call this when you need to modify an existing feeding record. It does not explicitly state when not to use it or mention alternatives like feedings_create_feeding for new records or feedings_delete_feeding for removal. The context is clear enough for an agent to infer the right scenario, but no explicit guidance is given.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosurecars. 'Record a BMI measurement' signals a write operation but does not explain side effects, whether duplicates are allowed, required permissions, or what happens if the child does not exist. It adds no behavioral information 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 or redundant content, and the core action is front-loaded. It is economically written, though it could have added a short clause about intended use without becoming excessive.

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?

Because the output schema exists and all parameters are described, the schema covers return values and parameter semantics, reducing the description's burden. The description is sufficient to identify the action but lacks usage context and safety disclosure, making it minimally viable with clear 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 for all four parameters, so the baseline is 3 even though the description itself mentions no parameter details. The schema already explains the date format, required fields, optional notes, and how to obtain the child_id, so the description need not repeat this.

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 ('Record') and a resource ('BMI measurement'), making it clear this is a create operation for BMI data. It differentiates from other measurement types by naming BMI, but the distinction from operations like measurements_update_bmi is left to the tool name rather than the description.

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 measurements_update_bmi or measurements_list_bmi. It also lacks any prerequisites or context about whether this should be used for new measurements only; the child_id schema hint ("Use list_children to get IDs") is the only related guidance, but it does not address the tool-choice question.

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 behavioral burden, but it only says 'Record a head circumference measurement.' It does not disclose that it creates a new entry, any validation behavior, or what response to expect. The verb 'Record' only weakly implies creation, and the 'create' in the tool name is the main signal.

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 core purpose with no filler or redundant phrasing. It is as concise as possible while still conveying the essential action.

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

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

For a simple create tool with a fully described schema and an output schema, the core purpose is covered. However, it lacks any usage context, such as when a head circumference measurement should be recorded or any relationship to other measurement types suggestions. The absence of usage guidance leaves a gap in 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 the schema already documents all parameters with types, formats, and helpful hints (e.g., 'Use list_children to get IDs'). The description adds no parameter information, but that is unnecessary given the schema's completeness. 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 clear verb ('Record') and a specific resource ('head circumference measurement'), which distinguishes it from sibling create tools for height, weight, or BMI. The resource noun makes the tool's purpose unambiguous and differentiates it from list/update/delete variants.

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 measurements_update_head_circumference or other measurement creates. There are no prerequisites, exclusions, or context cues like 'for new measurements' or 'if the child has no existing head circumference entry'.

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. 'Record' implies a persistent write operation, but the description does not mention required child context, idempotency, side effects, or what the response contains. This is similar to a minimal mutation description that only names the 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 extremely short with no wasted words, and the operative verb is front-loaded. It is appropriately concise, though it leaves some informational gaps that other dimensions capture.

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 tool with a fully documented schema and an output schema available, the description is minimally viable. However, it lacks sibling differentiation and any usage context, so an agent receives no support beyond the raw schema and tool name.

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 child_id, date, height, and notes thoroughly. The description adds no parameter-specific meaning, 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?

The description uses a specific verb ('Record') and a clear resource ('a height measurement'), so an agent can immediately tell this creates a height entry rather than lists, updates, or deletes one. It does not explicitly differentiate from sibling create tools like measurements_create_weight, but the resource name 'height' carries that distinction.

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

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

There is no guidance on when to use this tool versus alternatives such as measurements_list_height or measurements_update_height. The description provides no context, prerequisites, or exclusions, leaving the agent to infer usage entirely from the tool name and schema.

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, but it only states the action without mentioning permissions, side effects (e.g., creates a new record), or any constraints. The schema's note about units is the only behavioral hint, and it lives in the schema, not the description.

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, lean sentence with no wasted words, effectively front-loading the core purpose. It is appropriately sized for the tool's simplicity.

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 schema and output schema cover parameters and return values, the description lacks usage context and does not explicitly state that it creates a new record. For such a simple tool, the minimal text is borderline adequate, but the absence of usage guidance leaves a small gap.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters (child_id, time, temperature, notes). The description adds no parameter-level semantics, meeting 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 action ('Record') and resource ('a temperature reading'), making it immediately clear this is the create operation for temperature measurements. The verb distinguishes it from sibling update/delete tools, even without naming 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 description provides no guidance on when to use this tool versus alternatives like measurements_update_temperature or measurements_list_temperature. It only states the action, leaving the agent to infer usage context from the name and schema.

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 disclose behavioral traits itself. It indicates persistence through 'Record' but says nothing about side effects, duplicate handling, permissions, or any special measurement rules that an agent should know before invoking this write 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 one short, front-loaded sentence with no filler. It may be terse, but it is appropriately sized for a simple create operation given the rich input 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?

For a simple CRUD create, the description plus fully documented schema and output schema is minimally viable: the agent knows the action, resource, and inputs. It falls short of complete because there is no usage guidance or behavioral context around the write operation, though output schema covers the return contract.

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 documents all 4 parameters with descriptions, including units for weight and the YYYY-MM-DD format for date, so schema description coverage is 100%. The description adds no parameter-level semantics, which is acceptable under the baseline for complete 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 clear action verb ('Record') and names the specific resource ('weight measurement'), so an agent can tell what this tool does. It does not explicitly differentiate it from measurements_create_height or measurements_create_bmi, but the resource is unambiguous.

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

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

There is no guidance about when to use this tool vs. alternatives such as measurements_update_weight or measurements_list_weight. The verb 'Record' implies adding a new measurement, but no exclusions or sibling-routing information is 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?

The key behavioral trait disclosed is that the deletion is permanent, which is important for a destructive operation. However, with no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention potential side effects, authorization requirements, or behavior for non-existent IDs, leaving gaps in 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 extremely concise with two short sentences. It front-loads the primary action and immediately follows with the critical caveat about permanence. There is no wasted wording 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?

While the tool is simple (single parameter, no nested objects), and an output schema exists to document return values, the description lacks cues about error handling, prerequisites, or any broader context. For a deletive action, one might expect guidance on irreversible impact or confirmation steps, but the permanence note partially covers that. The description is adequate but not thorough.

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 bmi_id parameter is fully documented in the schema (100% coverage) with a clear description. The tool description adds no new semantic information about the parameter beyond what the schema already provides. Given the high schema coverage, this baseline of 3 is appropriate.

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

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

The description clearly states the action ('Delete') and the specific resource ('a BMI record'). It is unambiguous and distinguishes from sibling delete tools by naming the resource type. However, it does not provide any additional context that differentiates it from other delete operations on related resources beyond the resource 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?

There is no guidance on when to use this tool versus alternatives, nor any preconditions or context for deletion. The description simply states what it does without any clues about appropriate usage scenarios, such as requiring explicit user confirmation or when it should be avoided.

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 does disclose a key trait: 'This action is permanent,' which signals irreversibility. However, it does not mention lower-level details such as permission requirements, potential cascading effects, or what happens to dependent data. For a destructive operation, the permanence disclosure is valuable but not exhaustive.

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 core action and resource front-loaded. There is zero redundant wording, and it avoids repeating schema details. Every word contributes to the core message.

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

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

For a single-parameter, destructive tool with an output schema present, the description covers the essential facts: what it operates on and that it is irreversible. The lack of usage guidance is a minor gap given the simplicity and clarity of the operation, and the output schema handles return-value documentation.

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's own description ('ID of the head circumference record to permanently delete') already conveys its meaning. The tool description adds no additional detail about the parameter's format, validation, or behavior. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states a specific verb ('Delete') and a specific resource ('head circumference record'), which clearly distinguishes this tool from the many sibling delete tools for other measurement types (e.g., measurements_delete_bmi, measurements_delete_height). The action is unambiguous and matches the schema's head_circumference_id parameter.

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 situations where a different action (e.g., update instead of delete) would be appropriate. The only context is the permanent nature of the deletion, which is a cautionary note but not usage direction.

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. The explicit 'This action is permanent' is valuable because it signals irreversibility, a key behavior for a delete operation. It does not detail side effects or authorization, but for a simple single-record delete this is sufficient.

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

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

The description is two short sentences with no wasted words. The core operation is stated first, and the critical permanence warning follows immediately, making the key information highly scannable.

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

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

This is a simple one-parameter delete operation. The description names the operation, marks it permanent, and the output schema is present, so return behavior is covered. Nothing else is needed 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?

Schema description coverage is 100%, and the height_id parameter is already described as the ID of the height record to permanently delete. The tool description adds no further parameter meaning beyond what the schema provides, 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 states a specific verb and resource: 'Delete a height record.' This clearly distinguishes it from sibling deletion tools for other measurement types (e.g., delete_bmi, delete_weight) and from non-deletion height tools.

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

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

Usage is implied rather than explicitly stated: the description tells the agent what the tool does, so an agent can infer to use it when a height record needs to be removed. However, it does not explicitly say when to prefer this over alternatives or mention any prerequisites.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It explicitly states 'This action is permanent,' which is the key destructive trait. However, it does not mention how the API handles invalid IDs, whether there are cascading effects, or any authorization requirements. The permanence warning provides some transparency, but it 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?

The description is two short sentences with zero waste. The action is stated first, followed by the crucial permanence warning. It is optimally sized for this 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?

Given the tool's simplicity (one required parameter, schema fully documents it, output schema exists), the description is mostly complete. The permanence warning covers the main user concern. It lacks explicit mention of preconditions (e.g., the record must exist), but this is minor for a delete 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 provides 100% coverage for the only parameter, temperature_id, with a clear description ('ID of the temperature record to permanently delete'). The tool description adds no further semantic value about the parameter, so the baseline 3 applies.

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

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

The description states a clear verb and resource: 'Delete a temperature record.' The resource 'temperature record' makes it easy to distinguish from sibling delete tools for other record types (e.g., delete_weight, delete_height). It could have been slightly more specific about it being a measurement record, but the name and context make that 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?

No explicit guidance is given about when to use this tool versus alternatives. There is no mention of when deletion is appropriate (e.g., correcting an erroneous entry, removing outdated data) or exclusions. The description relies entirely on the tool name to convey its 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?

With no annotations, the description carries the full burden of behavioral disclosure. It states 'This action is permanent,' which is a key trait for a delete operation. However, it does not mention other potential behaviors like error handling, idempotency, or side effects on related data, leaving some 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?

Two sentences with zero waste. The action is front-loaded, and the permanence warning adds value. 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 one-parameter delete operation, the description covers the core purpose and permanence. The output schema exists, and the schema documents the parameter. While it lacks error-handling details, the tool is simple enough that this is adequate. The description is complete for the agent to know what it does and that it's destructive.

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 describes weight_id as 'ID of the weight record to permanently delete' with 100% coverage. The description adds no additional meaning to the parameter, 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 clearly states the action (delete) and the resource (a weight record), distinguishing it from sibling delete tools for other measurements like height or BMI. The phrase 'weight record' is specific and unambiguous.

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

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

No explicit guidance on when to use this tool versus alternatives. The tool name itself implies it's for weight records, but the description does not mention other delete tools or provide context like prerequisites or conditions. Usage is implied but not 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, the description must carry behavioral disclosure. It only says 'List BMI measurements', which implies a read operation but doesn't disclose pagination, default ordering, or other traits. Minimal 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?

A single sentence with no filler, front-loading the action and resource. It is concise, though it offers no additional helpful context beyond the bare minimum.

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 an output schema and fully-described optional parameters, the description is adequate but thin. It doesn't mention caveats, defaults, or typical usage, though the schema fills most 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 schema already documents all parameters. The description adds no parameter-level semantics, 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 states the specific action 'List' and resource 'BMI measurements', making the purpose clear. It differentiates from sibling list tools by the resource type, though it doesn't explicitly contrast with them.

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

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

No guidance is provided on when to use this tool vs alternatives. Siblings like measurements_list_height and measurements_list_weight exist, but the description offers no conditions, exclusions, or reasons to choose this one.

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. It only says 'List', which implies read-only, but it does not disclose any other behavioral traits such as return format, pagination, or ordering behavior. It is extremely minimal and leaves the agent to infer basic 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 concise sentence with no wasted words. It is appropriately sized for a simple list operation, though it lacks substantive content. It is front-loaded with the core purpose, but nothing more.

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 an output schema and fully documented parameters, the description is marginally adequate. However, it does not mention the default limit or ordering options (even though these are in the schema), and it lacks any usage context relative to the many sibling list tools. An agent could likely call it correctly, but would benefit from more guidance.

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 each parameter (date, limit, child_id, ordering) has a clear description in the schema. The tool description adds no additional parameter information, so it relies on the schema. Baseline 3 is appropriate.

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

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

The description 'List head circumference measurements' clearly states the verb and resource, which is sufficient to identify the tool's purpose. It distinguishes itself from other measurement list tools by the specific resource type, though it does not explicitly contrast with 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 is provided on when to use this tool versus other list tools (e.g., measurements_list_bmi, measurements_list_height). There is no mention of typical use cases, prerequisites, or any conditions that would make this tool the preferred choice.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, but it only restates the operation already implied by the tool name. It does not mention read-only behavior, default limits, filtering semantics, ordering, or pagination, offering no meaningful behavioral context beyond '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?

The description is a single, front-loaded sentence with zero filler or unnecessary repetition. It is efficient, though so terse that it misses the opportunity to provide helpful usage context without adding structural 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 list tool with four optional parameters that are fully documented in the schema and an output schema present, the minimal description is nearly adequate. However, it does not distinguish this tool from the many sibling measurement list tools or explain how scoping filters like child_id or date should be used, leaving a moderate gap in 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%, and each parameter already has a clear description in the schema, so the tool description does not need to repeat them. The description adds no parameter-level detail, but the baseline of 3 applies because the schema fully documents all four parameters.

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

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

The description clearly states the action ('List') and the resource ('height measurements'), so an agent can tell it is a retrieval operation. It does not explicitly differentiate itself from sibling list tools like measurements_list_weight or measurements_list_bmi, though the resource name supplies that distinction.

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 rather than create/update/delete height tools or other measurement list tools. The description does not mention relevant use cases, such as retrieving measurements for a specific child or date, so the agent must infer appropriate usage from the name and schema.

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 that temperature readings are listed and does not mention pagination limits, ordering defaults, filtering semantics, or the read-only nature beyond what the name 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, front-loaded sentence with no filler or redundant phrasing. It is efficiently minimal, though it leaves most contextual information to 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 7 optional parameters, no annotations, and many sibling measurement tools, this sparse description does not give the agent enough orientation. It omits mention of date filtering, tags, child scoping, ordering, and default limits, and offers no usage guidance; the output schema may cover return values, but not selection 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% and all 7 parameters are well-documented in the schema, so the baseline is 3. The description itself adds no parameter semantics, but the schema fully compensates for that gap.

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

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

The description uses a specific verb ('List') and resource ('temperature readings'), clearly identifying this as a read-only listing operation for temperature measurements. It is distinguishable from sibling measurement list tools by the resource type, though it does not explicitly contrast with measurements_list_bmi, measurements_list_height, etc.

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 sibling list tools or the create/update/delete temperature tools. There is no mention of supported use cases, default behavior, or how the filter parameters should be applied; the agent must infer all of this from the name and schema.

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. 'List' implies a read-only retrieval, but the description does not disclose default limit behavior, available filters, ordering semantics, or any other behavioral traits. It adds little beyond what the tool name already suggests.

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 with no filler or redundancy. It is front-loaded and easy to parse, though its extreme brevity means it sacrifices useful behavioral and usage context 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?

For a simple list operation with a fully described input schema and an output schema available, the description may be minimally adequate. However, the lack of annotations and absence of usage guidance leave some context unfilled. The combination of a clear purpose, complete parameter documentation, and output schema keeps it at a viable but not exemplary level.

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 four parameters are already documented with meaningful descriptions and defaults. The tool description adds no additional parameter context, which is acceptable given the schema's completeness, so the baseline score 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 combines a specific verb ('List') with a specific resource ('weight measurements'), so an agent can identify the operation and distinguish it from the sibling measurement tools for BMI, height, temperature, and head circumference. It is concise and unambiguous, though it does not elaborate on scope beyond the verb and 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 description provides no guidance on when to use this tool versus alternatives. With siblings like measurements_list_height, measurements_list_bmi, and measurements_list_temperature, an explicit note about choosing this tool for weight data would help. There are no exclusions, prerequisites, or alternative routing hints.

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 discloses the partial-update behavior ('Only provided fields are changed') and implies the target record must exist. It does not address error behavior for invalid IDs, permissions, or side effects beyond the mutation, though output is covered by an output schema.

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 carry all essential information, with the action front-loaded. There is no filler or redundancy; both sentences contribute 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 4-parameter tool with a required ID, no annotations, and an output schema present, the description covers core semantics but omits failure behavior (e.g., what happens if bmi_id is invalid) and does not reference sibling tools. The input and output schemas handle parameter and return-value details, so the gaps are moderate.

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 every parameter is already documented. The description adds a global semantic about optional parameters: 'Only provided fields are changed' clarifies that supply is what triggers an update, which is not stated in individual parameter descriptions. It does not add per-parameter details beyond the schema.

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

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

The description clearly states the action and resource: 'Update an existing BMI record' uses a specific verb and resource, and 'Only provided fields are changed' further distinguishes it from create/delete siblings. The resource 'BMI' separates it from other measurement update tools like height or weight updates.

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: 'existing' suggests updating rather than creating, and 'only provided fields are changed' gives partial-update semantics. However, it never explicitly names alternatives such as measurements_create_bmi or measurements_delete_bmi, nor provides exclusion criteria. The 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 behavioral burden. It usefully discloses partial-update behavior with 'Only provided fields are changed' and the existing-record precondition, but it does not mention what happens when the ID is not found, authorization needs, or other 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?

The description is two short sentences with no filler. The purpose is stated first, followed immediately by the most important behavioral qualifier, making it easy for an agent to parse quickly.

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 CRUD update with a fully described input schema and an output schema, the description plus schema is sufficient for correct invocation. It lacks error-handling and alternative-tool guidance, but those are not necessary to invoke the tool correctly in the common case.

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. 'Only provided fields are changed' adds meaningful patch semantics beyond the schema's individual parameter descriptions by clarifying that omitted fields are not overwritten. It still leaves explicit null-vs-omitted behavior unspecified, so it does not fully reach 5.

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

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

The description clearly identifies a specific verb and resource: 'Update an existing head circumference record.' This distinguishes it from the create/delete/list siblings by resource and by the 'existing' qualifier, though it does not explicitly name an alternative 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?

'Existing' implies this tool is for updating records that already exist, not for creating new ones, which gives some usage context. However, it does not explicitly say when to use this tool versus create_head_circumference or delete_head_circumference, and no alternatives are named.

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

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

The description discloses that only provided fields are changed, which is a key behavioral trait and adds value beyond the schema. However, it does not mention error handling, validation, or prerequisites beyond the existence of the record. With no annotations, the description carries the full burden, and this is only partially addressed.

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 purpose stated first and the key caveat second. No unnecessary words, and the structure is front-loaded for quick comprehension.

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 update tool with a well-defined schema and an output schema, the description covers the essential purpose and behavior. It doesn't elaborate on error conditions, but that is acceptable given the simplicity and the presence of an output schema that likely documents return values.

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 describes all parameters clearly, including formats and units (e.g., YYYY-MM-DD, centimeters). The description does not add any additional parameter semantics. Since schema coverage is 100%, 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 action (update), the resource (height record), and the partial-update behavior, distinguishing it from create/delete and other measurement types. The verb and resource are specific, and the 'only provided fields are changed' clause adds precision that separates it from full-replacement update tools.

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

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

The description indicates the tool is for updating an existing height record, but provides no explicit guidance on when to use it versus alternatives, such as creating a new record or updating other measurement types. The name and context imply usage, but no direct exclusions or alternatives are 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?

With no annotations, the description carries the full burden. It discloses a key behavior: 'Only provided fields are changed,' which is important partial-update semantics. However, it does not mention what happens if the record is not found, whether the update is irreversible, or what the response contains. For a mutation tool, this is a moderate 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 two short sentences with zero redundancy. It front-loads the purpose and immediately states the key semantic (partial update). 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 CRUD update, the description is minimal but mostly adequate. It does not cover error cases (e.g., non-existent ID) or mention the return value, but an output schema is present. Given no annotations and a simple operation, a bit more context (like 'returns the updated record') would make it 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 coverage is 100%, so all parameters are documented. The description adds value by clarifying that only provided fields are changed, which is not explicit in the schema (the schema shows 'New time', etc., but does not state the omission behavior). This helps the agent understand that null means 'do not update'.

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

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

The description clearly states the action: 'Update an existing temperature record.' It identifies the resource and the verb, distinguishing it from create/delete/list tools. It does not explicitly mention the measurements domain, but the tool name carries that context.

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 by the tool name and description, but no explicit guidance is given about when to use this vs. other update tools (e.g., for weight, height). There are no exclusions or alternatives mentioned, so an agent must rely on the name to infer the intended use.

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 discloses a key trait: partial update semantics ('Only provided fields are changed'), which prevents an agent from assuming unspecified fields are cleared. It could add error/validation behavior, but the core update behavior is explicit.

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 with no filler. The purpose is front-loaded and the partial-update nuance is stated in the second sentence without 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 4-parameter update with 100% schema coverage and an output schema, the description is complete: it identifies the target resource, the action, and the crucial partial-update behavior. No critical contextual information is missing.

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

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

Schema description coverage is 100%, so the schema already documents weight_id, date, notes, and weight. The description adds no parameter-specific detail beyond restating partial-update behavior, 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 and resource ('Update an existing weight record') that clearly identifies this as the update tool for weight measurements. It distinguishes itself from sibling create/delete weight tools and from update tools for other measurement types.

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 the context clear: use this when an existing weight record needs to be changed. It does not explicitly list exclusions or alternatives, but the sibling set and the phrase 'existing' imply it is not for creation or deletion.

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 merely says 'Record' without disclosing whether it appends a new record, requires the child to exist, or has any side effects. This is minimal behavioral 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, front-loaded sentence with no wasted words. It earns its place by stating the core action, though it is very terse for a tool with 8 parameters.

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, 8 parameters, and no usage or behavioral context, the one-sentence description is not complete enough for an agent to confidently invoke the tool. The output schema helps, but important contextual details are missing.

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

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

Schema description coverage is 100%, so the schema already documents all 8 parameters. The description adds no parameter meaning beyond 'for a child', 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 ('Record') and resource ('medication administration') scoped to a child. This clearly distinguishes the tool from siblings like medications_update_medication, medications_delete_medication, and medications_list_medications.

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 no guidance on when to use this tool versus alternatives, no preconditions, and no exclusions. An agent must infer from the tool name and sibling list when this is the right choice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states 'This action is permanent,' which is critical for a destructive operation. However, it does not disclose other potentially relevant behaviors such as cascading effects, required permissions, or error conditions, leaving some gap in 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 two short sentences with zero redundancy. It front-loads the action ('Delete a medication record') and adds the key consequence ('permanent') immediately, making it efficient 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?

For a simple delete tool with one parameter, the description covers the essential purpose and a critical behavioral trait (permanence). The presence of an output schema means return details need not be explained. No further information is necessary for an agent to correctly invoke this 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 fully documents the single parameter medication_id. The description adds no extra meaning beyond mentioning 'medication record,' which mirrors the schema. Per calibration, a baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific verb ('Delete') and resource ('a medication record'), making its purpose unambiguous. It clearly identifies the target entity and distinguishes it from sibling delete tools for other resources (e.g., notes_delete_tag, feedings_delete_feeding) without needing to inspect 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 provides no guidance on when to use this tool versus alternatives. It does not mention when to use this over medications_update_medication or medications_create_medication, nor does it state any prerequisites or conditions for deletion. The only implicit cue is the action itself, which is not enough for explicit usage direction.

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 burden of behavioral disclosure. 'List' weakly implies a read-only operation, but there is no mention of pagination, default ordering, filter combination semantics, or side-effect safety.

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 states the action, resource, and filter capability 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?

With full schema coverage and an output schema, the tool is callable as specified. However, the bare description leaves gaps around filter interactions, default ordering, and read-only reassurance, which matter for a 9-parameter tool with no annotations.

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

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

The input schema covers 100% of the 9 parameters with detailed descriptions (e.g., 'YYYY-MM-DD', 'records having all listed tags'). The description adds no extra parameter meaning, 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 ('List') and resource ('medication administration records'), clarifying that this returns administration events, not a medication catalog. It does not explicitly differentiate itself from sibling list tools, but the resource is unambiguous.

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

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

No guidance is provided on when to use this tool versus the sibling medications_create/update/delete tools or other resource-specific list tools. The operation is stated, but no context, prerequisites, or exclusions are given.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It transparently states that only provided fields are changed, which is a key behavioral trait. However, it omits any mention of permissions, side effects, reversibility, or what happens when a field is explicitly set to null—important for a mutation 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 two concise sentences with zero filler. The primary action is front-loaded, and the partial-update rule is stated in the second sentence. 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 an 8-parameter update tool, the description is adequate but leaves a key ambiguity: whether null values are treated as 'not provided' or as explicit attempts to clear fields. The description says 'Only provided fields are changed' but does not clarify null semantics. Since the output schema exists, return values need no explanation, but this null-handling gap affects 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 coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining that only provided fields are changed, giving each optional parameter a consistent partial-update semantic that the individual field descriptions do not convey. This is meaningful context for how to use parameters like name, dosage, or notes.

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 'Update' and the specific resource 'an existing medication record', distinguishing it from siblings like medications_create_medication and medications_delete_medication. The added note 'Only provided fields are changed' clarifies the partial-update scope, reinforcing the purpose.

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

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

The description implies use for existing medication records by saying 'an existing medication record' and indicates partial-update behavior, but it does not explicitly contrast with create/delete alternatives or provide when-not-to-use guidance. 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 behavioral burden. It clearly states the mutation (creating a note) and the optional image attachment, but adds no context about side effects, persistence, or response behavior. The output schema partially covers the latter.

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 concise sentences with no filler. The main action is front-loaded and the optional image behavior is presented as a single additional clause.

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 a complete schema and an output schema, the description is nearly sufficient. It could add a line about when to prefer it over notes_update_note, but nothing essential to invoking the tool correctly is missing.

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

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

Schema description coverage is 100%, so the baseline is 3; the description does not need to restate parameters. It adds only the high-level note about optional image attachment, which the schema already documents via image_path with default null.

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 ('Create') and resource ('a new note for a child'), and adds the distinguishing capability of optionally attaching an image. This is clearly separable from sibling operations like notes_update_note, notes_delete_note, or notes_create_tag.

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 by the create verb: the agent can infer it should be called when creating a new note rather than updating or deleting. However, it never explicitly contrasts with alternatives or mentions prerequisites such as needing an existing child_id.

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. 'Create a new tag.' discloses only that a tag is being created and nothing else — no mention of uniqueness constraints on the name, color validation, error behavior on duplicates, or whether creation is reversible. For a write operation with zero annotation coverage, this is insufficient.

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 short sentence that is efficient and without waste, but it is borderline under-specified rather than genuinely concise — it delivers the minimum and no additional structuring or enrichment.

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 (2 flat params, output schema present), so the description need not explain return values. However, given zero annotations, the lack of guidance on tag-name uniqueness or color constraints leaves the description at the bare-minimum threshold for 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 (name and color) are documented in the schema, including the hex format example for color. The description adds no parameter-level meaning beyond the schema, so 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 'Create a new tag.' states a specific verb ('create') and resource ('tag'). The sibling set includes notes_update_tag and notes_delete_tag, so the create/update/delete action implicitly differentiates it, though the description doesn't explicitly name the alternatives.

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

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

No guidance is provided on when to use this tool versus notes_update_tag or notes_delete_tag. There are no stated prerequisites, exclusions, or context cues — an agent must infer from the verb 'create' alone. This is a clear gap for a mutation operation.

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 burden. It explicitly adds 'This action is permanent,' which is the key behavioral trait for a delete operation. However, it omits any mention of prerequisites, cascading effects, or error conditions.

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, direct sentences with zero filler. The main action is first, followed by the critical warning about permanence. 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 single-parameter delete operation with an output schema and a clear warning about permanence, the description covers the essential call requirements. It lacks usage guidance, but nothing critical for actually invoking the tool is missing.

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

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

Schema description coverage is 100%, with note_id already described as 'ID of the note to permanently delete.' The tool description adds no parameter-level meaning beyond the schema, matching 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 states a specific verb ('Delete') and resource ('a note'), cleanly differentiating this tool from siblings like notes_delete_tag and notes_update_note. The scope is unambiguous: removing a note, not modifying or creating one.

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, or any exclusions. The agent must infer from the name and schema that this is for permanently removing a note.

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 disclosure. It clearly states two important behavioral facts: the deletion is permanent, and it removes the tag from all notes. This goes beyond the basic delete operation and communicates irreversible scope and cascading effects, which is valuable for an agent deciding whether to execute the 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 two sentences with no filler. The primary action is front-loaded, and the second sentence adds critically important behavioral detail about permanence and scope. 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 single-parameter delete tool with full schema coverage and an output schema, the description covers the essential operational context: how to identify the tag (by slug), the permanent nature, and the scope of the removal. It does not mention edge cases like non-existent tags or idempotency, but those are likely covered by the output schema, and the description is otherwise complete for correct invocation.

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

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

Schema description coverage is 100% and the parameter is already well-documented in the schema ('Slug of the tag to permanently delete'). The tool description adds that deletion is by slug and references list_tags as the source, which slightly reinforces the schema but does not introduce significant new meaning. A baseline 3 is appropriate given the strong 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 specific verb and resource ('Delete a tag by slug') and clearly distinguishes this from sibling tools like notes_delete_note, which deletes a note, and notes_update_tag, which would modify an existing tag. An agent can immediately identify the tool's scope and 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?

The description implies the tool is used when a tag must be deleted by its slug, and it notes the permanence of the action. However, it does not explicitly mention when to prefer this over alternatives such as notes_update_tag (e.g., when you want to rename rather than delete) or notes_list_tags for finding slugs. The context is implied but not fully 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 provided, so the description must carry the burden. It only states 'List notes with optional filters' without disclosing behavior such as default limit, pagination, ordering behavior, or return format. It doesn't mention that it's a read-only operation or any side effects. The schema covers parameter details but not the tool's behavior. This is a significant gap for a tool with no annotation support.

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

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

The description is a single concise sentence that front-loads the core action. It's efficient and not bloated. It could arguably be slightly more informative, but for a simple list tool, this level of conciseness is appropriate.

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 moderate complexity (7 parameters, output schema present), the description is minimally sufficient. It communicates the basic function but lacks contextual details like how filters combine (e.g., exact date vs range), default behavior when no filters are given, and any notes about ordering or limits. The schema fills in parameter details, but the description doesn't provide a holistic view of expected 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%, so the baseline is 3. The description adds no parameter-specific information, but the schema already documents all 7 parameters clearly, including defaults and examples. The description's mention of 'optional filters' aligns with the schema, but adds no new meaning beyond 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?

States a clear verb and resource: 'List notes'. The phrase 'with optional filters' indicates the core capability, and the schema provides filter specifics. It doesn't explicitly differentiate from sibling list tools like notes_list_tags, but the resource 'notes' is distinct enough that an agent can infer it's for note 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 description implies usage for listing notes, which is clear. However, it provides no guidance on when to choose this over alternatives (e.g., when to use list_tags instead) or any exclusions. There's no mention of prerequisites like having a child_id or using other tools to get IDs, though the schema hints at that for child_id. 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?

With no annotations, the description carries the behavioral burden. 'List' clearly signals a non-mutating read operation, and 'all available tags' conveys broad scope, but it does not disclose ordering, scoping details, or whether the list includes only user-created tags. Acceptable for a simple list tool 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, well-structured sentence that front-loads the action and resource. Every word is meaningful, 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 parameterless listing tool with an output schema, the description is nearly sufficient. It clearly identifies what will be returned (available tags for notes), though it leaves minor ambiguity around whether tags are global or note-specific and whether any filtering applies.

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 100% schema description coverage, so there is no parameter ambiguity. Per the baseline for parameterless tools, the description needs to add no parameter detail, and it does not.

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 ('tags'), and the intended purpose ('can be applied to notes'). It clearly distinguishes this read operation from sibling tag mutations like notes_create_tag, notes_update_tag, and notes_delete_tag.

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

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

The description implies use when the agent needs the full set of available tags, but it does not explicitly state when not to use it or mention alternatives. Sibling tools make the CRUD distinction inferable, but there is no direct 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 provided, so the description is the sole source. It discloses the partial-update behavior, which is useful, but lacks info on side effects, permissions, or return value. It adds value beyond the schema but 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?

Two short sentences with no fluff; the key behavior is front-loaded after the action. Extremely concise.

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

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

Given the output schema exists and parameters are fully documented, the description covers the critical usage rule (partial update). It doesn't mention clearing tags via null, but that's a detail in the schema. Overall adequate.

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

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

Schema coverage is 100%, so parameters are already documented. The description reinforces that only provided fields are changed, adding minimal extra meaning beyond what the schema's optional fields indicate. Baseline 3 applies.

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

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

States a specific verb (update) and resource (note), and the phrase 'Only provided fields are changed' distinguishes it from create/delete and clarifies partial update semantics, differentiating from notes_create_note.

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?

Implies usage when the note exists and needs modification; the name and sibling list make it clear that create is for new notes. But no explicit exclusions or alternatives are mentioned, so it's clear context without 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 of behavioral disclosure. It discloses the keying behavior (slug-based) but doesn't state whether the update is partial or full replacement, what happens to associated notes, whether the slug itself can be changed, or what the response contains. For a mutation tool with zero annotation coverage, this is a significant 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?

Two short sentences with zero waste. The core action is front-loaded, and the keying clarification is valuable and concise.

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

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

The tool has an output schema, so return values are covered elsewhere. The description covers the essential keying mechanism and the schema covers parameters. However, for a mutation tool with no annotations, the lack of behavioral context (partial vs full update, effects on related data) leaves the description incomplete for an agent to fully understand the operation's implications.

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 adds the keying context (slug from list_tags) which helps the agent understand the slug parameter's origin, but doesn't add meaning beyond what the schema provides for name and color. 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 ('Update') and resource ('existing tag by slug'), and clarifies the keying mechanism ('Tags are keyed by slug, not numeric ID'). This distinguishes it from notes_delete_tag and notes_create_tag, though it doesn't explicitly name those siblings.

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

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

The description implies usage context by explaining that tags are keyed by slug, which tells the agent to use the slug from list_tags. However, it doesn't explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites beyond the slug keying.

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 disclosure burden. 'Get' signals a safe read-only operation, and specifying that it returns user details, language, timezone, and API key adds meaningful behavioral context beyond the tool name. Authentication is implied by 'current authenticated user.'

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 no filler. The verb and resource are front-loaded, and the field list is compact and complete.

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 tool with an output schema, the description is fully sufficient. It names what the agent gets and implies the authentication requirement.

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 description provides no parameter semantics, but none are needed; it instead clarifies the output content.

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') and a precise resource: the current authenticated user's profile. It also enumerates the contained fields (user details, language, timezone, API key), which clearly differentiates it from the many CRUD sibling tools for 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?

The description clearly defines the target context: the caller's own authenticated profile. There are no sibling tools that retrieve the current user's profile, so explicit alternatives or exclusions are not necessary; the usage context is unmistakable.

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 burden of behavioral disclosure. 'Record a pumping session' implies persistence but does not state side effects, visibility, idempotency, or whether timer_id replaces start/end times. For a create operation, this is a notable 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 very short and free of fluff, but it is under-specified. It essentially restates the tool name with a synonym; it is concise but lacks useful detail that would make the brevity valuable.

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 schema is rich and complete for parameter descriptions, the tool description omits important context, such as how timer_id interacts with the required start/end fields. This ambiguity could lead an agent to submit conflicting values. The description does not fill any gaps left by the structured fields.

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 no parameter-level meaning, but the schema already explains child_id, start, end, amount, notes, and timer_id. No additional compensation is 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 the specific verb 'Record' with the clear resource 'a pumping session', which distinguishes this create operation from sibling tools like pumping_update_pumping, pumping_delete_pumping, and pumping_list_pumping. It unambiguously states the tool's core 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention when a pumping creation is appropriate, how it differs from feeding operations, or when to prefer pumping_update_pumping. The only usage hint is inside the child_id parameter description ('Use list_children to get IDs'), which is not in the tool description itself.

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. It discloses the most important consequence—deletion is permanent and irreversible—but does not mention permissions, side effects, or what happens to associated data. This is adequate 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 two short sentences with no filler. It front-loads the primary verb and resource, and the permanence warning is an efficient, useful addition.

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 tool with an output schema, the description plus schema are nearly sufficient for an agent to invoke it correctly. It lacks optional context such as authorization requirements or cascading effects, but these are not essential for a simple delete 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?

Schema description coverage is 100%, with the single required `pumping_id` already documented as the ID of the pumping record to permanently delete. The description adds no additional parameter meaning beyond what the schema already 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 ('Delete') and resource ('pumping record'), clearly identifying the operation. It is distinct from sibling tools by the delete action, though it does not explicitly name or contrast with an alternative.

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

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

The description implies use when a pumping record needs to be removed, and the permanence warning hints that it is not appropriate if reversibility is needed. However, it does not explicitly state when to prefer this over update or mention 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only restates that the tool lists records with optional filters; it does not mention that this is a read-only operation, how filters combine, default ordering, or pagination behavior. The word 'List' hints at non-mutation, but no meaningful behavioral context is added.

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 or redundant phrasing. It is appropriately concise, though it leans toward under-specification for a tool with nine parameters.

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 parameters thoroughly and an output schema exists, so the mechanical invocation is well specified. However, the description omits usage context and behavioral details, which are not compensated by annotations. For a straightforward list tool, this is minimally adequate but not 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 input schema already explains every parameter. The description adds no extra parameter semantics beyond saying filters are optional, which is already evident from the schema's defaults and nullable types. 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 clearly states the action ('List'), the resource ('pumping session records'), and the optional nature of filters. It is distinguishable from the pumping create/update/delete siblings, though it does not explicitly differentiate itself from other list_* tools.

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

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

No guidance is provided about when to use this tool versus alternatives. There is no mention of situations favoring this list operation over other data-retrieval or pumping-related tools, leaving the agent to infer usage solely from the 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. It does disclose that only provided fields are changed, which is a key partial-update behavior. However, it doesn't mention error handling (e.g., what happens if the record doesn't exist), idempotency, or any side effects. For a simple CRUD update this may be adequate, but more context could be expected.

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

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

The description is a single, front-loaded sentence with zero redundancy. It conveys the essential purpose and the key behavioral note efficiently, making it highly readable 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?

For a standard update tool with a full parameter schema and an output schema, the description is minimal but sufficient. It doesn't mention required fields (though the schema marks ID required) or error cases, but the core usage is clear. Given the presence of the output schema and complete parameter documentation, the description doesn't need to elaborate on return values. It could still mention that the record must exist, but 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?

The schema already documents all parameters with 100% coverage, providing 'New start time' etc. The description adds the crucial semantic that only provided fields are changed, meaning omitted fields remain unchanged. This is not inferable from the schema alone and clarifies the null/default behavior, adding meaningful value beyond the schema.

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

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

The description clearly states the action (update) and resource (pumping record). It is not a tautology and distinguishes from create/delete/list siblings by the verb 'update'. However, it doesn't explicitly differentiate itself from other update tools beyond the resource name, which is already evident from the tool 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention that this is for modifying existing records while create is for new ones, nor does it reference any sibling tools. The only hint is the verb 'update' and the schema's required ID, but no explicit context or exclusion is given.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. 'Record' implies creating a new sleep entry, but the description does not state whether it inserts a new record, overwrites anything, or how it relates to timers versus explicit times. It adds little beyond the tool name.

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 and front-loads the action. It is efficient, though it is so minimal that it may be under-specified rather than optimally 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?

The input schema covers every parameter and an output schema exists, so the tool is broadly invocable from structured data. However, with no annotations and no usage or behavioral context, the description alone leaves meaningful gaps about when to select this tool and what side effects to expect.

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 documents all six parameters, including timer_id, nap, and notes semantics. The description itself adds no parameter-specific meaning, which aligns with the baseline-3 expectation for high 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 names a specific action ('Record') and a concrete resource ('a sleep session'), which clearly matches the create operation and distinguishes it from the sibling sleep update/delete/list tools. It is brief but 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 gives no guidance on when to use this tool versus sleep_update_sleep or any other sleep-related sibling. There are no prerequisites, exclusions, or alternative routing, so usage is only implicitly inferred from the name and the word 'Record'.

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