Framezone

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the agent knows this is a non-destructive write. The description adds no behavioral context beyond the save operation itself — no deduplication, overwrite, or side-effect information. It does not contradict the annotations, but it contributes nothing beyond them.

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

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

One sentence with zero waste: it front-loads the operation ('Save a bookmark URL'), lists the optional fields, and omits redundant detail. It is efficiently scannable.

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

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

For a simple create tool with full schema coverage and no output schema, the description covers the operation and core parameters adequately. It could mention edge behaviors like duplicate handling, but those are not necessary for a basic 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%, so all five parameters are already well documented. The description adds a light confirmation by listing the optional fields and implying url is required, but it provides no additional semantic detail beyond the schema.

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

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

The description states a specific verb ('Save') and resource ('bookmark URL'), then enumerates the optional fields (title, description, category, tags). It clearly identifies the operation as creating a bookmark and is easily distinguishable from sibling tools like delete_bookmark and list_categories.

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

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

Usage is implied by the verb and resource: use this to save a bookmark URL. However, it does not explicitly state when to use this versus alternatives, mention prerequisites (e.g., whether categories must already exist), or give 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?

The description reveals a meaningful behavioral trait: 'Updates shares and average cost' – this goes beyond the annotations (which only say readOnlyHint=false). It doesn't disclose potential failure modes, exchange requirements, or reversibility, and with no supporting annotation detail, the description could carry more behavioral load.

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 no filler. The core purpose is front-loaded and the side-effect is stated 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 6-parameter tool with no output schema and no meaningful annotations, the description provides essential info but omits important operational details: reliance on holding_id, behavior on sell that exceeds shares, trade date defaults, and what is returned after success. It is adequate but not complete enough to fully guide an agent without further schema inspection.

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 semantic linkage by tying 'buy or sell' to the type enum and explaining that shares and price_per_share affect average cost. This clarifies the meaning of parameters beyond their schema descriptions, so a 4 is warranted.

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

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

The description clearly states a specific verb ('Record') and resource ('buy or sell trade for a portfolio holding'), and explains the side effect ('Updates shares and average cost'). This distinguishes it from sibling add_* tools like add_transaction or add_bookmark without needing to inspect the schema.

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

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

The phrase 'for a portfolio holding' provides clear context for when to use the tool, and the buy/sell distinction frames the trade types. However, it does not mention alternatives or explicitly state when not to use it (e.g., if holding_id is invalid), so it falls just short of a 5.

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

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

Annotations already indicate this is a mutating but non-destructive operation, and the description's 'add' is consistent with that. The description adds little beyond the annotations, such as side effects on account balances or validation behavior, but it does not contradict the annotations.

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

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

The description is a single sentence that leads with the action and resource, uses a parenthetical to clarify the main transaction types, and flags the optional category. There is no filler or repetition, making it easy to scan.

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 creation tool with no output schema, the description plus the fully documented input schema provides enough information to invoke it correctly, including defaults already provided in schema descriptions. It is not a 5 because it omits the transfer type and does not describe expected results or side effects, though these are minor given the schema richness.

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 description does not need to explain parameters in detail. It adds marginal value by highlighting 'optional category' and describing the transaction types, but the schema already documents all parameters and includes 'transfer' in the enum, making the description's contribution limited.

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

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

The description clearly states a specific verb and resource: adding a financial transaction to an account, which differentiates it from most sibling tools. It is slightly inaccurate by narrowing transaction types to 'income or expense' when the schema enum also includes 'transfer', so it is clear but not fully aligned with the accepted values.

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

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

The description gives a clear context for using the tool: recording a financial transaction against an account. However, it does not explicitly address when to prefer an alternative like add_trade, nor does it explain when this tool would not be appropriate, leaving usage to be inferred rather than stated.

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

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

Annotations already mark the operation as non-read-only and non-destructive. The description adds real behavioral context: the 50-memory cap and the demand for concise 1-2 sentence content. It does not explain what happens when the cap is reached, but the key constraint 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?

Two short sentences carry all essential information with no filler. The core purpose is front-loaded, and each additional phrase ('1-2 sentences', 'Max 50 memories') earns its place.

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

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

For a simple two-parameter write operation with full schema coverage, the description covers purpose, content format, and a cardinality limit. The only missing detail is the behavior at the 50-memory cap, which is minor given the tool's low complexity.

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

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

Schema coverage is 100%, so content and category are already documented. The description adds a minor reinforcement by echoing the '1-2 sentences' rule, but it does not materially extend the schema's meaning. Baseline 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?

Description states an explicit verb ('Add') and resource ('user's AI memory'), and clarifies scope ('personal fact'). It directly distinguishes the tool from siblings like add_bookmark or create_note, so an agent can identify it without inspecting other definitions.

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 purpose is stated clearly enough that the intended use case is obvious: store a personal fact in AI memory. There are no competing 'add memory' siblings, so exclusions aren't necessary; however, no explicit conditions or alternatives are discussed.

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

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

The annotations already indicate readOnlyHint=false and destructiveHint=false, so the description's 'Add' is consistent but adds no new behavioral context. It does not disclose potential side effects, whether duplicates are allowed, or any required preconditions beyond what annotations provide. No contradiction exists, but the description contributes nothing beyond the structured annotations.

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

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

The description is a single, compact sentence that front-loads the core action and key optional attributes. There is no redundancy or filler. Every word contributes to conveying the tool's purpose 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 9 parameters (only 1 required) and a complete schema, the description is adequate but not thorough. It doesn't clarify the relationship between price_min and price_max, the meaning of priority values, or any validation rules. Since there is no output schema, the description could have explained expected return behavior, but that's not strictly necessary. Overall, an agent can likely invoke it correctly, but additional context would improve completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The description highlights price range, priority, and URL, which maps to several parameters, but it adds no meaning beyond the schema's own property descriptions. The mention of 'price range' hints at price_min/price_max relationship, but that is already inferable from the schema. It is adequate but not enhancing.

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 verb 'Add' with the resource 'item to the wishlist' and lists the key fields (price range, priority, optional URL). It is clear and distinct from sibling tools like list_wishlist or update_wishlist_item, though it doesn't explicitly name them. The purpose 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?

There is no guidance on when to use this tool versus alternatives such as update_wishlist_item or list_wishlist. No exclusions or conditions are provided. An agent must infer that this is for creating a new wishlist item, but the description doesn't clarify when to prefer it over related tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds that the tool shows 'SC and GA metrics' with percentage changes, which is useful but does not disclose additional behavioral traits (e.g., pagination, response format, or handling of missing data). It is adequate but does not significantly extend beyond the annotations.

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

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

The description is two sentences with no redundancy. The purpose is stated first, followed by practical use cases. 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 comparison tool with 5 parameters and no output schema, the description covers the core purpose and the metrics shown. The only gap is not explaining what 'SC' and 'GA' stand for, which might be domain-specific but is a minor omission. Overall, the agent has enough information to call the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description does not add meaning beyond the schema, such as explaining what 'SC' and 'GA' refer to or detailing how the date ranges interact. It relies on the schema for parameter understanding, which is acceptable.

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 ('Compare'), a resource ('analytics periods'), and the scope (two date periods for a project). It also distinguishes itself from the sibling get_project_analytics by explicitly mentioning period-over-period comparison with percentage changes. This is clear and unambiguous.

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

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

The description provides explicit use cases: 'Use for week-over-week, month-over-month comparisons, measuring campaign impact, tracking growth/decline.' It gives clear context for when to apply the tool. It does not name an alternative or state when not to use it, but the guidance is sufficient for an agent to decide.

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 two non-obvious behavioral traits: cascading to subtasks and handling recurrence. These go beyond the minimal annotations (readOnlyHint=false, destructiveHint=false) and are important because the toggle can affect multiple records, not just the one identified by task_id.

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 tight sentence that front-loads the core action and appends the two key behavioral caveats. Every word contributes meaning; there is no filler or redundancy.

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

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

For a simple one-parameter toggle with no output schema, the description adequately covers the operation and the main side effects (subtask cascade and recurrence). It leaves slight ambiguity about whether cascading occurs in both toggle directions, but the essential calling context is present.

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

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

The only parameter, task_id, is fully described in the input schema as 'ID of the task to complete/uncomplete', achieving 100% schema coverage. The description's toggle language adds a bit of context but no additional parameter detail beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Toggle') and resource ('task') with an explicit state transition ('between completed and pending'), leaving no ambiguity about what the tool does. It clearly distinguishes itself from sibling tools like create_task, update_task, and delete_task by focusing on toggling completion state rather than generic creation, updating, 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?

The description implies the intended use: call this tool when you want to toggle a task's completion state. However, it does not explicitly explain when to prefer complete_task over update_task or delete_task, and no exclusions or alternative routing are provided.

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

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

Annotations already indicate a mutating, non-destructive operation, so the description's 'Add' largely restates that signal. It does not disclose additional behavioral context such as duplicate book handling, whether the title is required for creation, or what happens after a book is added. No contradiction exists, but the description adds little beyond the annotations.

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

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

Two short sentences front-load the action and purpose with almost no filler. The second sentence adds a useful example of setting status. The vague 'etc.' is a minor weakness but does not undermine the compact structure.

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 all parameters already defined in the schema, the description covers the basic intent. However, it does not address potential overlap with add_wishlist_item or mention the required title parameter's relevance. It is minimally complete but not fully self-sufficient.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description mildly supplements this by giving example status values, but the 'etc.' is less precise than the schema's explicit enum. This matches the baseline expectation rather than exceeding 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 the core action explicitly: 'Add a book to your library.' This is a specific verb plus resource and destination, and the added nuance about setting status at creation time helps distinguish it from plain create or read tools. The purpose is unambiguous and easy for an agent to act on.

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 siblings such as update_book, delete_book, or add_wishlist_item. It implies creation by using 'Add,' but it never states exclusions or selection conditions, leaving the agent to infer the boundary.

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

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

Annotations already mark the tool as mutating but not destructive (readOnlyHint=false, destructiveHint=false), and the description's 'Create' action is consistent with those flags. The description adds no additional behavioral details such as behavior on duplicates, required-field constraints, or response format, but it does not contradict the annotations.

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

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

Two tightly scoped sentences with no filler; the action is front-loaded and the purpose clause is a single useful addition. 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?

The description is minimal but adequate for a create tool whose full parameter semantics live in the schema and whose safety profile is covered by annotations. It does not mention that only first_name is required or what the call returns, but the schema carries the required-field information and no output schema was expected.

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 13 parameters with descriptions, so schema description coverage is 100% and the baseline of 3 applies. The description names three business-relevant fields (birthday, relationship, contact_frequency_days), which slightly emphasizes which parameters matter, but adds no semantic detail beyond the schema.

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

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

The description opens with the specific action 'Create a new contact', a clear verb-plus-resource pair with the CRM context. It does not explicitly differentiate from siblings like update_contact or list_contacts, though the verb makes the intended operation 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 the tool is for adding people to a personal CRM and highlights the tracking features (birthdays, relationship types, contact frequency reminders), suggesting when it should be used. It lacks explicit when-not-to-use guidance or routing to alternatives such as update_contact or list_contacts.

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

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

Annotations already communicate that this is a mutation (readOnly=false) and not destructive (destructive=false). The description adds no behavioral detail beyond that, such as what is returned or whether creation can fail, so it does not earn credit for extra transparency, but it does not contradict the annotations.

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

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

The description is two short sentences with no filler. The core action is front-loaded and the type glossary is compact and immediately useful.

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

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

The input schema provides full parameter coverage, including type-specific hints, so the description does not need to restate them. Given the remaining gaps are minor (e.g., no explicit return behavior), the combined description and schema are sufficient for correct invocation.

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

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

The schema documents all 11 parameters, so the baseline is 3. The description adds useful semantic mapping by glossing milestone as a checklist and numeric as value tracking, helping an agent pick the right goal_type.

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

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

The description states a specific action ('Create a new goal') and resource, and adds the four goal types to make the scope concrete. It does not explicitly distinguish this from closely related siblings such as create_habit or update_goal, but the create/goal pairing is 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?

There is no guidance about when to prefer this tool over alternatives. Nothing routes habit-goal creation to create_goal versus create_habit, or directs users to update_goal for existing goals; the type list is descriptive, not usage guidance.

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

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

Annotations already indicate this is a mutating operation (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds the tracking type definitions, but not behavioral details like return values, side effects, or permission requirements. It neither contradicts annotations nor adds substantial behavioral context beyond the creation 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. It front-loads the core purpose and then concisely summarizes the main disambiguating information about tracking types. Every element 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 9-parameter creation tool with no output schema, the description plus the fully covered input schema is sufficient. The tracking type summary adds critical context for choosing the right fields. It could be more complete by noting that name is required and that certain fields apply only to specific tracking types, but the schema already documents those details clearly.

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 meaningful semantics to the tracking_type enum by explaining what each value means (check = daily toggle, count = hit a number, duration = minutes, times_per_week = weekly frequency), which the schema does not fully convey. This helps an agent correctly pair tracking_type with target_value, target_duration, and times_per_week.

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: 'Create a new habit.' It also distinguishes the tool from siblings like log_habit and update_habit by emphasizing creation and listing tracking types. No ambiguity remains about the tool's core 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 that this tool is for creating habits, but it does not explicitly say when to use it instead of related tools like log_habit, update_habit, or list_habits. Sibling names make the distinction inferable, but no explicit alternatives or exclusions are provided.

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

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

The annotations already establish that this is a mutating (readOnlyHint=false) but non-destructive (destructiveHint=false) operation. The description adds no additional behavioral context such as side effects, return behavior, permissions, or creation semantics beyond what the annotations and name convey, so it earns only a basic non-contradictory level.

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

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

A single front-loaded sentence states the verb, resource, and primary fields with no filler. There is no redundant repetition of the schema or annotations.

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

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

With a fully documented 5-parameter schema and read/write annotations, an agent has everything needed to construct a valid call; the description covers the core creation intent. It could be more complete by noting return behavior, but that is not critical for a straightforward create 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?

Input schema coverage is 100%, and the schema already documents title, body, tags, is_pinned, and project_id. The description's 'optional tags' restates what the required array already implies and adds no new semantic detail, matching the baseline 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 uses a specific verb ('Create') and resource ('note'), and the mention of title, body, and optional tags makes the core behavior immediately recognizable. Among siblings like create_book, create_task, and create_contact, this is unambiguously the note-creation tool. Minor omission of is_pinned/project_id doesn't obscure 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 gives no explicit when-to-use guidance versus alternatives such as list_notes or delete_note, nor does it distinguish from sibling create_* tools. However, the tool name and 'Create a new note' make the primary use case obvious, so 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?

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the description doesn't need to restate safety. The description adds that tier, goal link, and target date are optional, which is useful. However, it doesn't disclose behaviors like whether creating a project with a duplicate name fails, whether goal_id must exist, or what the response contains. With annotations covering the basic safety profile, a 3 is appropriate.

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

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

The description is a single sentence that front-loads the core action and lists the most important optional fields. It is concise and free of filler, though it could be slightly more structured by separating the core action from the optional fields.

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 create tool with 9 parameters and no output schema, the description is adequate but not complete. It doesn't mention required fields (name is required but not highlighted), nor does it explain what happens after creation (e.g., response format, whether the project appears immediately). The annotations cover safety, but the description could do more to guide an agent on required vs optional inputs.

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 9 parameters. The description adds a little by highlighting tier, goal link, and target date as notable fields, but it doesn't provide additional meaning beyond the schema. Baseline 3 is correct.

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 ('Create a new project') and lists the key configurable fields (tier, goal link, target date). It distinguishes itself from siblings like update_project and list_projects, though it doesn't 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 implies usage for creating a project and mentions optional fields, but it doesn't explicitly state when to use this tool versus alternatives like create_goal or update_project. The context is clear enough for a create operation, but no exclusions or alternative routing are provided.

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

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

Annotations already indicate readOnlyHint=false, so the mutating nature is covered by structured data. The description adds no further behavioral context, such as duplicate handling, return value, or side effects, but it is accurate and does not contradict the annotations.

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

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

The description is a single front-loaded sentence with no filler. 'Save a quote' immediately states the action, and the optional-book-link detail is useful without bloating the text.

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 every parameter and the annotations cover the safety profile, making this minimally complete for a straightforward create tool. However, the description does not address success/failure behavior, duplicate quotes, or what happens if the book_id is invalid, so it is adequate but not rich.

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 six parameters. The description mentions 'author and optional book link,' but it does not add meaning beyond what the schema already states; 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–resource pair ('Save a quote') and adds a distinguishing detail ('optional book link'). Sibling tools such as list_quotes make it clear this is the creation tool, so an agent can tell it apart from read-only 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?

The description gives no explicit guidance on when to use this tool versus alternatives. It does not mention list_quotes or any exclusion conditions, and it provides no context such as 'use this when you want to add a new quote.' The usage is only implied by the name and verb.

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

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

Annotations already signal a write operation (readOnlyHint=false), and the description's 'Add' is consistent with that but not additive. It adds the 'recurring' characterization but does not disclose duplicate handling, side effects, or return 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?

A single sentence with no filler; the core action is front-loaded and the cadence examples follow immediately. Nothing could be removed without losing information.

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

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

The schema covers all 8 parameters and the annotations cover the write safety profile, so a short description is workable. However, with no output schema and no mention of quarterly frequency or return behavior, the description is only minimally complete for a create 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%, so the description is not required to restate parameter meanings. It adds little beyond the schema and actually lists 'monthly, yearly, or weekly' while omitting the schema-supported 'quarterly', which is a minor inconsistency.

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

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

The description uses a specific verb ('Add') and a concrete resource ('recurring subscription'), making the tool's core action clear. It does not explicitly distinguish itself from sibling tools, and the parenthetical omits the schema-supported 'quarterly', so it stops short of a perfect 5.

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

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

The intended use is implied: it should be used when the agent needs to add a recurring subscription. There is no explicit when-not-to-use guidance and no mention of alternatives such as list_subscriptions, so the guidance is helpful but not thorough.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, and the description does not contradict them; however, it also adds no behavioral detail beyond the creation act. It does not state the return value, idempotency, or any side effects, so the agent has no information about what happens after a successful call.

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 is appropriately short for a simple creation tool, though the content is sparse.

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 8 parameters and no output schema, the one-sentence description leaves key questions unanswered, such as what the tool returns and whether there are restrictions visible elsewhere. The schema covers field semantics, but the description does not compensate for the missing output contract or provide operational context.

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

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

Schema description coverage is 100%, so the parameters are already fully documented. The description's mention of optional project, priority, due date, and recurrence merely echoes a subset of these fields and adds no new constraints, defaults, or format 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 states a specific verb ('Create') and resource ('a new task') and lists several optional fields. Within the sibling set of task operations (update_task, complete_task, delete_task, list_tasks), the create verb makes the intended action clear, though it does not explicitly call out sibling 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 given about when to use create_task versus update_task, complete_task, or delete_task, nor are any prerequisites or exclusions mentioned. The only signal is the verb itself, so the agent must infer usage from the tool 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?

Annotations already declare destructiveHint=true. The description adds context about why deletion is appropriate (drag on weight trend and waist rule), and implies the action is irreversible in a practical sense. This goes beyond the annotation by explaining the consequence.

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 no fluff. The core purpose and trigger condition are front-loaded, and the rationale is concise. 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 delete tool with destructive hint, the description covers the why and when. It doesn't mention return values or error handling, but no output schema exists and such details are not essential for a simple delete. It is sufficiently complete for an agent to decide and invoke correctly.

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

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

Schema description coverage is 100%, so both parameters are fully documented in the schema. The description does not add extra parameter-specific meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action (Delete), the specific resource (body measurement), and the condition (logged by mistake). It also gives a concrete reason (two entries on one date drag the trend), distinguishing it from other delete 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 explains when to use it (for erroneous measurements) and implicitly when not to (for valid ones). It doesn't explicitly name alternatives, but the context of logging over is mentioned, which guides the agent. Could be improved by explicitly contrasting with log_body_measurement.

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

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

Annotations already declare destructiveHint=true, so the destructive nature is covered. However, the description adds no additional behavioral context beyond that, such as permanence, reversibility, cascading effects, or required permissions. It simply restates the obvious without enriching the agent's understanding of 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 a single, concise sentence with no filler. It is front-loaded with the action and resource, making it easy to scan. Every word contributes meaning, exemplifying excellent 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 delete operation with one parameter, the description is sufficient. The parameter is fully documented in the schema, destructive behavior is noted in annotations, and no output schema exists. While it omits potential details like idempotency or error behavior, these are not critical for a basic delete action. The description covers the essentials adequately.

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 fully documents the single parameter book_id with a clear description ('ID of the book to delete'). The tool description adds no further parameter semantics, but since schema coverage is 100%, the baseline of 3 is appropriate. No extra value is provided by the description.

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

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

The description clearly states the verb (Delete) and the specific resource (book from the library). It is unambiguous and distinguishes from other delete_* siblings that target different resources like notes, tasks, or bookmarks. No ambiguity exists about what this tool does.

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

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

The description offers no explicit guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or comparisons to related tools such as update_book or create_book. For a tool with many siblings, this lack of usage context leaves 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?

The addition of 'permanently' usefully indicates the deletion is irreversible, going slightly beyond the destructiveHint annotation. However, it does not disclose behavior such as idempotency, handling of nonexistent bookmark IDs, or any side effects. The annotation already covers the core destructive nature.

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

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

The description is a single sentence that earns its place by adding the important 'permanently' qualifier. It is appropriately sized and front-loaded for a one-parameter delete tool.

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

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

For a simple destructive tool with a fully documented single parameter and a destructiveHint annotation, the description is nearly complete. The only minor gap is not describing the outcome or behavior when the bookmark does not exist, but this is not essential for invoking the tool correctly.

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

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

Schema coverage is 100% and the bookmark_id parameter is already described as 'ID of the bookmark to delete.' The description adds no additional parameter context, which is acceptable given the 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 states a specific action and resource—'Delete a bookmark permanently'—and the explicit 'bookmark' target distinguishes it from sibling delete tools for books, notes, tasks, and other entities. It is not a vague or tautological phrasing.

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

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

There is no explicit when-to-use guidance or comparison with alternatives. The intended use is implied by the verb and resource, but the description does not mention conditions, prerequisites, or situations where another tool would be preferable.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, covering the mutation/safety profile. The description adds the 'soft' qualifier, which is useful context beyond the annotations, but it does not explain what soft-delete entails (e.g., recoverability, visibility in list_notes), so the behavioral disclosure remains thin.

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

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

The description is three words, front-loaded with the action and qualifier, and contains no filler. For a one-parameter tool this size is appropriate; 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?

The schema covers the only parameter and the annotations cover the destructive nature, so the core invocation is complete. However, the description does not clarify the observable effect of a soft delete (e.g., whether the note disappears from lists or can be restored), which matters given there is no output schema.

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

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

The input schema fully documents note_id as 'ID of the note to delete' with 100% coverage, so the description has no additional parameter burden. Per the baseline rule, the schema doing the heavy lifting yields a score 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 ('soft-delete') and a clear resource ('a note'), and the 'soft' qualifier distinguishes it from a hard-delete operation. This is enough to tell it apart from the other delete_* siblings, which target different resources.

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

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

The description does not explicitly state when to use this tool or name alternatives; it only implies that it should be used when a note needs to be removed without permanent deletion. The note resource is unambiguous among siblings, so the lack of explicit routing is a gap but not a fatal 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?

Annotations already indicate destructiveHint=true and readOnlyHint=false, so the description does not need to restate that this mutates state. It adds value beyond annotations by explicitly disclosing that the delete is soft and reversible, which an agent cannot infer from the schema alone.

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

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

The description is a single sentence with no filler. The core action is front-loaded ('Soft-delete a task') and the key qualifier about restoration is provided immediately in parentheses.

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 mutation tool with full schema coverage and annotations describing its destructive nature. The description adds the essential missing behavioral context (reversibility), making it complete enough for an agent to invoke correctly.

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

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

The input schema has 100% description coverage for the single task_id parameter, already clearly explaining its meaning. The description adds no additional parameter-level semantics, 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 states the verb ('soft-delete'), the resource ('task'), and the distinguishing behavioral nuance ('can be restored later'). This separates it from other delete_* tools and from complete_task, even without opening schema definitions.

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

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

The phrase 'soft-delete' and 'can be restored later' provide useful context implying when this tool is appropriate, but there is no explicit statement of when to prefer it over alternatives like complete_task or a permanent delete option. Usage is implied rather than explicitly guided.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description does not need to restate that this mutates state. It adds minimal context by specifying that the target is an AI memory entry and that deletion is scoped by ID, but it does not disclose permanence, cascading effects, or failure behavior. This is acceptable for a simple delete with destructive annotation, 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 sentence states the action, resource, and targeting mechanism with no filler or redundancy. The description is front-loaded and every word earns its place.

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

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

For a single-parameter delete operation with schema coverage, a destructive annotation, and no output schema, the description is nearly sufficient. It could briefly note permanence or what happens on success/failure, but the tool is simple enough that the current description together with the annotation covers most relevant 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 the id parameter is already described as 'ID of the memory to delete'. The description repeats the ID-based targeting without adding format, source, validation, or behavior details, so it does not meaningfully increase understanding beyond the schema. Baseline 3 applies.

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

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

The description uses a specific verb ('Delete'), a clear resource ('AI memory entry'), and a scope qualifier ('by ID'), which immediately distinguishes this tool from the many delete_* siblings. An agent can tell exactly what the tool operates on without needing to inspect the schema or compare with other tools.

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

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

The description provides no guidance on when to choose this tool over alternatives, when not to use it, or how it relates to related memory tools like add_user_memory or get_user_memories. The only usage clue is the imperative verb and resource, which forces the agent to infer context rather than being told.

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

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

Annotations already declare destructiveHint=true, and the description adds meaningful behavioral context by clarifying the cascade scope ('every set in it'). It effectively communicates the blast radius beyond what the annotation alone provides.

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 tight sentences with no filler. The key scope information is front-loaded, and the alternative routing is efficiently included in the second sentence.

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

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

For a destructive operation, the description conveys scope, alternative, and consequence in minimal text. The annotations carry the safety profile and no output schema is needed for a delete operation, so nothing essential 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 each parameter already documented in the schema. The description adds no further parameter-level detail, which is acceptable since the schema carries that burden.

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

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

States a specific verb and resource: deletes a whole training session including every set. Explicitly differentiates from the sibling delete_workout_sets, so an agent can distinguish them immediately.

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?

Provides explicit usage guidance: use this tool for a full session, and names delete_workout_sets as the alternative for partial removal. This clearly routes the agent to the right tool without ambiguity.

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 destructive annotation already warns about mutating behavior, and the description adds valuable scoping: deleting sets does not delete the session, and duplicate removal keeps the first occurrence. This is consistent with annotations, with no contradiction.

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

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

Two sentences, front-loaded with the core action, and every clause earns its place by clarifying scope or usage. No redundancy or filler.

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

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

The description covers the main scenarios and effectively communicates the destructive scope. A minor gap is that all parameters are optional per the schema, and the description does not state what happens if neither exercise nor duplicates_only is provided; however, the parameter docs handle most formatting and defaults.

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, but the description adds meaningful purpose to the parameters: duplicates_only maps to undoing a double-sent log and exercise maps to removing a mistaken movement. This helps an agent choose the right parameter more confidently.

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 ('Remove') and a precise resource ('sets from a session'), while explicitly scoping the behavior with 'without touching the session itself.' This clearly distinguishes it from a full-session deletion tool like delete_workout.

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

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

It gives explicit usage scenarios: 'duplicates_only' for a log sent twice and 'exercise' to drop an incorrectly entered movement. It does not explicitly name a sibling like delete_workout as the alternative for deleting the whole session, though 'without touching the session itself' implies that boundary.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the field listing but does not disclose behavior such as what happens when no entry exists for the requested date or whether the default date applies. Given the annotations, 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 a single, front-loaded sentence with no filler: verb, resource, condition, and content are all included in a compact form. Every word contributes to understanding.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description adequately conveys the resource and its expected fields. It does not specify the return structure or behavior on missing entries, but the low complexity and strong annotations make the tool callable without those details.

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

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

The input schema already fully documents the date parameter with format and default, so the description's brief mention of 'for a date' adds no new semantic detail. With 100% schema description coverage, 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 opens with a specific verb and resource, 'Get the daily journal entry for a date,' and enumerates the exact contents (mood, energy, focus, morning/evening notes). This makes the tool's purpose clear and distinguishes it from siblings like update_daily_entry.

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

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

The 'for a date' context implies when to use this tool, and the optional date default is present in the schema. However, the description does not explicitly mention alternatives, exclusions, or when not to use it, leaving routing largely to the agent's inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds detail about the content returned but does not disclose any additional behavioral traits such as data dependencies or performance implications. It does not contradict the annotations.

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

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

The description is a single, dense sentence that front-loads the core concept 'Current fitness state' and lists the key components. It is concise but somewhat run-on; it could be broken into bullet points for clarity, but it remains efficient.

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

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

The description gives a clear overview of the summary content, covering the main data areas. However, it does not mention default parameter values (though the schema does) or the response format, and it lacks guidance on how to interpret the summary. Given the tool's simplicity and the schema's coverage, this is adequate 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?

The input schema already provides 100% coverage with descriptions for all three parameters (training_days, nutrition_days, include_training_grid). The tool description does not add any additional meaning or context about how these parameters influence the summary, so it adds minimal 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 enumerates the specific components of the fitness summary (weight trend, waist thresholds, nutrition averages, training frequency, missing data), making it distinct from sibling tools like get_focus_summary. However, it lacks an explicit verb like 'retrieves' or 'returns', relying on 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 such as weekly_summary or get_daily_entry. No exclusions or conditions are mentioned, leaving the agent to infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds the aggregation behavior (totals, sessions, project breakdown) but does not disclose other behavioral traits such as date inclusivity, timezone handling, or limits. No contradiction with annotations.

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

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

A single, front-loaded sentence containing the verb, resource, return details, and date-range scope. Every word earns its place with no redundancy.

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

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

For a simple read-only tool with two optional, fully documented parameters and no output schema, the description adequately informs the agent of the return content and the date-range scope. Minor gaps like inclusive/exclusive date boundaries are not critical for its straightforward use 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 description coverage is 100%, with both 'from' and 'to' documented with formats and defaults. The description only restates the 'date range' concept without adding new meaning beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb and resource ('Get focus time summary') and specifies the return content: total minutes, sessions, and breakdown by project. This clearly distinguishes it from sibling tools like get_daily_entry or get_fitness_summary, though it does not name a sibling explicitly.

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

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

The phrase 'for a date range' gives clear context on when to invoke this tool. However, it provides no exclusions or explicit alternatives among the many sibling tools, so it falls short of full 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?

The annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it's a safe read operation. The description adds value by explicitly stating the data returned (daily metrics list) and the purpose (trend analysis, reports), which goes beyond the annotations. However, it doesn't disclose details like data aggregation, timezone handling, or pagination, but given the read-only nature and no output schema, the description provides adequate context. No contradiction with annotations.

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

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

The description is concise and front-loaded. It starts with the core purpose and lists key metrics, then ends with use cases. Three sentences with no redundancy, every sentence adds value. It's appropriately sized for the tool's simplicity and matches the schema coverage.

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 a simple structure: 3 parameters with full schema coverage, no output schema, and annotations that cover safety. The description provides the purpose, the returned metrics, and example use cases, which is complete for an agent to decide whether to call it and set the right parameters. Nothing critical is missing for a read-only analytics 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%, and the schema provides clear descriptions for each parameter (e.g., end_date, start_date with defaults, project_id as required). The description adds context by implying the date range is for daily metrics, but it doesn't add syntax or format details beyond what the schema already states. With full schema coverage, a 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 tool's purpose: fetching daily Search Console and GA4 metrics for a project, and lists specific metrics (clicks, impressions, sessions, etc.). It is distinct from sibling tools like get_top_pages or get_top_queries, which focus on specific subsets, and from compare_analytics_periods, which compares periods. However, it doesn't explicitly name those siblings or draw the contrast, so it doesn't fully 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 explicitly states when to use this tool: 'Use for trend analysis, performance reports, comparing periods.' This gives clear context. It doesn't explicitly say when not to use it or mention alternatives, but given the clear use cases and the nature of the tool (a read-only analytics fetch), the guidance is sufficient. Sibling tools like compare_analytics_periods suggest an alternative for period comparison, but the description doesn't exclude that.

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

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

Annotations already establish readOnlyHint and non-destructive behavior. The description goes beyond annotations by disclosing exactly what the tool returns ('page URL, total clicks, impressions, avg CTR, avg position'), which is important because no output schema exists. No hidden side effects or state changes are implied.

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

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

Three short sentences: what it does, what it returns, when to use it. The description is front-loaded and each sentence earns its place with no fluff or repetition.

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

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

For a read-only, non-destructive tool with a fully documented schema, the description is nearly complete. It states the data source, output fields, and common use cases. It could add an example or note about the default date range, but the schema already covers those defaults.

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 parameters including defaults and constraints. The description adds no extra parameter context, such as how search filtering or sort behavior works, but it does not need to compensate because the schema is thorough.

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

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

The description names a specific verb ('Get'), resource ('top performing pages'), and data source ('Search Console data'), and lists the returned metrics. It is clear and distinct from likely siblings like get_top_queries, though it does not explicitly call out that sibling for differentiation.

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

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

The phrase 'Use for content performance analysis, finding underperforming pages, identifying top content' gives concrete usage context. It does not mention exclusions or when to prefer a sibling tool, but the intended scenarios are clear enough.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds the data source and the return fields, which is useful but does not disclose any further behavioral traits such as authentication requirements, rate limits, or pagination behavior. Since annotations carry the safety profile, the description adds minimal extra behavioral context.

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

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

The description is three sentences, each with a purpose: state the action, list the output fields, and give use cases. It is front-loaded with the core function and avoids redundancy or filler. 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 8 parameters (1 required) and no output schema, the description compensates by listing the returned fields and typical use cases. It does not explain the meaning of metrics like CTR or position, nor explicit date-range handling, but the schema already covers parameter defaults and filters. Overall, an agent receives enough to call the tool correctly.

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

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

Schema description coverage is 100%, so every parameter is already documented. The description does not add meaning beyond the schema—it mentions the return metrics, which are related to the sort_by enum but do not clarify parameter usage. Thus it stays at the baseline of 3 for tools with 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 specifies the exact action ('Get top search queries'), the resource (search queries for a project), and the data source (Search Console). It also enumerates the returned fields (query text, clicks, impressions, CTR, position). This distinguishes it from sibling tools like get_top_pages, which operate on pages rather than queries.

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

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

The description gives explicit use cases: 'Use for keyword analysis, content strategy, SEO optimization, finding ranking opportunities.' This provides clear context for when to call the tool. However, it does not mention alternatives like get_top_pages or get_project_analytics, nor does it state when NOT to use it, so it stops short of full guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds useful context about the content type ('personal facts, preferences, and context') but does not disclose any operational behavior such as how filtering works, whether all entries are returned when no category is given, or the order of results.

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 immediately states the core operation and then explains what the memory entries are. There is no filler or redundant phrasing, making it highly efficient.

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

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

For a tool with one optional parameter, full schema coverage, and annotations covering read-only and non-destructive behavior, the description is nearly complete. A minor gap is that it does not explicitly state that omitting the category returns all memories, though the schema's optionality implies this. No output schema exists, but the return concept ('entries') is intuitively clear.

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

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

The schema fully covers the single 'category' parameter with an enum and a clear description ('Filter by category'). The tool description adds no parameter-specific information beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the verb ('Get') and the resource ('the user's AI memory entries'), and it adds context about what those entries contain. It does not explicitly distinguish itself from broader tools like 'search' or other list tools, but the resource is specific enough that the name and description together make the purpose 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?

There is no guidance on when to use this tool versus alternatives such as 'add_user_memory', 'delete_user_memory', or the general 'search' tool. No prerequisites, exclusions, or situational context are provided, leaving the agent to infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it's a safe read. The description adds that it returns balances and types, which is useful behavioral context beyond annotations. No contradictions.

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 and includes the key data points (balances and types). No wasted words.

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

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

For a simple, parameterless, read-only tool with no output schema, the description covers the essential purpose. It could mention the return structure or potential variations (e.g., currency), but that's not necessary given the simplicity and 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?

With zero parameters, the schema coverage is 100% (trivially). Since there are no parameters to describe, the description doesn't need to add parameter details. The baseline for 0 params is 4, as it's fully adequate.

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 it lists financial accounts with balances and types, using a specific verb and resource. It is broad but distinct from siblings like 'list_holdings' or 'list_subscriptions', though it doesn't explicitly differentiate from 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 implies use when the agent needs account information, but provides no explicit guidance on when to prefer this tool over alternatives like 'list_holdings'. Given the tool is simple and parameterless, this is adequate but leaves room for improvement.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds useful context about the output content (both unlocked and locked achievements plus fields), but does not mention pagination, rate limits, or return format. This adds some value but not rich 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?

A single sentence with no filler. The core action and resource are front-loaded, and the qualifier 'unlocked and locked' adds precise scope immediately. 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 list tool with no parameters and no output schema, the description covers the essential facts an agent needs: it returns all achievements, including both states, with descriptions and unlock dates. It does not specify ordering or pagination, but these are minor for a straightforward read-only list.

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

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

There are zero parameters, so the schema is fully covered and no parameter explanation is needed. The description compensates by briefly describing what the returned list will contain, which is helpful given the absence of an output schema. Baseline 4 is appropriate for a no-parameter tool.

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

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

States a specific verb and resource ('List all achievements') and immediately clarifies scope ('unlocked and locked') with the returned fields ('descriptions and unlock dates'). Among many list_* siblings, the unique resource makes it distinguishable without opening the schema.

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

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

The description implies when to use it: whenever a full list of all achievements is needed. However, there is no explicit when-not-to-use guidance or mention of alternative tools, though no achievement-specific alternatives exist among siblings. The 'all' wording sets a clear context but leaves no exclusions or special cases.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the returned fields, which is useful, but it does not disclose pagination, ordering, or default-status behavior. 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 a single, front-loaded sentence with no filler. It communicates the action, the optional parameter, and the expected output fields in minimal space.

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

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

For a simple list operation with one optional enum parameter, the description is complete: the schema covers the parameter, the annotations cover the safety profile, and the description states the returned fields despite the lack of an output schema. Nothing needed to call it 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 coverage is 100%: the status parameter already has an enum and a description ('Filter by status'). The description only repeats the optional-filter idea and adds no additional semantics such as default behavior or interaction with other parameters. 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 and resource ('List books'), names an optional status filter, and enumerates the returned fields. This clearly distinguishes it from book mutation siblings like create_book, update_book, and delete_book.

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

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

The description clearly establishes a read-only listing context with an explicit optional filter. It does not name alternatives or exclusions, but no competing list-books sibling exists, so the usage context is unambiguous.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that results include type and monthly budget, but does not disclose additional behavioral traits such as default filtering when the 'type' parameter is omitted or any sorting/pagination behavior. With annotations present, this level of disclosure 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 entire description is one short, front-loaded sentence that states the action, resource, and returned attributes without any filler. Every word carries meaning, making it an exemplary concise definition.

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 low complexity (one optional enum parameter, no output schema, read-only annotations), the description covers the essential information: what is listed and what attributes are returned. It does not specify the default behavior when 'type' is omitted, but the enum's 'both' value makes this reasonably inferable.

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

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

Schema description coverage is 100%: the optional 'type' parameter is fully documented with an enum and description ('Filter by type'). The description's mention of 'type (income/expense)' aligns with the schema but adds no new semantic detail beyond it, so the baseline 3 applies.

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

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

The description uses a specific verb+resource pattern: 'List transaction categories' and further specifies the returned attributes ('type (income/expense) and monthly budget'). While it doesn't explicitly name a sibling, there is no sibling tool for categories, and the description unambiguously identifies what this tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention exclusions, prerequisites, or typical use cases. For a simple list tool this is a minimal gap, but the rubric requires explicit usage context for a score above 2.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds light behavioral context by paraphrasing the needs_contact filter as 'needing reach-out', but does not disclose pagination, ordering, or return shape. No contradiction with annotations.

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

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

Two short sentences with zero filler. The action 'List contacts' is front-loaded, and the filter capabilities are 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?

Adequate for a simple read-only list tool with full schema coverage and safety annotations. Gaps: it does not state that omitting all filters returns all contacts, nor mention the favorites_only parameter in prose. Without an output schema, the return shape is not addressed, though 'List contacts' implies a list of contacts.

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

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

Schema coverage is 100% with each parameter already described ('Filter by type' for relationship, 'Only contacts overdue for check-in' for needs_contact, 'Only favorite contacts' for favorites_only). The description adds only a paraphrase of needs_contact and relationship, and omits favorites_only entirely, so it does not meaningfully extend 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 states a clear verb-resource pair ('List contacts') and names two filter modes (relationship type, needing reach-out). It does not explicitly differentiate from sibling list_* tools, but the resource 'contacts' is unambiguous and no sibling list_contacts exists.

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 filter hints: use this when you want a list of contacts, optionally filtered by relationship or needing reach-out. No explicit when-not-to-use or alternatives are given, such as 'search' for finding a specific contact or 'update_contact' for modifying 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?

Annotations already cover read-only and non-destructive behavior. The description adds meaningful context about alias resolution and the risk of splitting a lift's history across near-duplicates, which goes beyond what annotations provide. It does not describe output shape, but that is a minor gap for a simple catalog 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?

Two concise sentences with no filler. The first defines the catalog contents, and the second provides a concrete usage rule with rationale, making every sentence earn 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 read-only list tool with fully documented optional parameters and no output schema, the description is complete. It states what the tool returns conceptually, when to use it, and why, leaving no critical gaps for an agent to invoke it correctly.

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

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

The input schema already documents all three parameters with 100% description coverage, so the baseline applies. The description's mention of aliases supports the search parameter's meaning but does not add operational detail beyond the schema.

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

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

The description clearly identifies the tool as a movement catalog containing canonical names, muscle groups, and aliases. It grounds the tool's purpose as a lookup step before logging sets, distinguishing it from logging tools even without naming a specific sibling.

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

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

It explicitly tells the agent when to use the tool ('Check here before logging sets') and why canonical names matter for data integrity. It does not name alternative tools or edge cases where the tool should not be used, but the usage context is clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds that results include progress/type/status and that filtering is supported, but says nothing about defaults, ordering, or pagination.

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 terse sentences with no filler; the core purpose is front-loaded before the filtering note.

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

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

For a simple read-only tool with two optional scalar filters and complete schema, the description is nearly complete. It could state the unfiltered default behavior, but the absence of required parameters and the read-only annotations already imply safe, flexible use.

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

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

Schema description coverage is 100%, with each parameter documented ('Filter by status', 'Filter by category'), so the description adds no extra semantic detail beyond what the schema already provides. Baseline 3 is appropriate.

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

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

States a clear verb-resource pair ('List goals') and names the returned fields (progress, type, status). It is distinct from create_goal and update_goal, though it doesn't explicitly contrast with other list_* siblings; the resource name keeps ambiguity low.

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 a read-only retrieval use case and mentions optional filtering by status or category, but gives no explicit guidance about when to choose this over search or other list tools, or whether multiple filters can be combined.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds genuinely useful behavioral detail beyond annotations: streaks count from yesterday while today is still open, and times_per_week habits have weekly streaks with streak_unit=weeks.

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 tight sentences with the main purpose front-loaded and the non-obvious streak rules explained succinctly after. Every clause adds useful information and there is no repetition of the schema or annotations.

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

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

For a read-only listing tool with one optional parameter and no output schema, the description names the key returned elements and explains a subtle streak behavior. An example of the response shape would add precision, but nothing critical is missing for an agent to select and call this 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?

There is only one parameter, date, and the schema already describes it fully with format and default behavior, giving 100% schema description coverage. The description does not add parameter-level detail, but it does not need to because the schema covers it. 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 tool as listing active habits and specifies exactly what it returns: value logged, done status for a date, and current streaks. This distinguishes it from the many other list_* siblings and from habit mutation tools like log_habit and create_habit.

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 read-only use case of checking habit completion and streaks for a date, but it does not explicitly say when to prefer this over alternatives or when not to use it. The context is present, but the guidance is not spelled out.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: totals are in the user's currency, and holdings without a live price are valued at cost with null P/L. This goes beyond what annotations provide and clarifies edge-case output 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?

Two sentences with zero filler. The first sentence delivers the core action and output fields; the second adds a specific, valuable clarification about currency and valuation. The description is front-loaded and 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?

For a no-parameter read-only list tool, the description covers the essential output semantics: what is listed, the fields included, and the edge case for unvalued holdings. It doesn't specify pagination or exact output structure, but those are likely unnecessary given the simplicity. The description is complete enough for an agent to call it correctly.

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

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

The tool has zero parameters, so there is nothing for the description to add beyond what the schema implies (an empty object). The baseline for 0 params is 4, and the description doesn't attempt to introduce nonexistent parameters. No further elaboration 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 states a specific verb ('List'), a specific resource ('portfolio holdings'), and the key data fields returned (market value, P/L, allocation). It clearly distinguishes from sibling list tools like list_accounts or list_books by focusing on holdings. The purpose is unambiguous.

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

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

Usage is implied: if an agent needs to see portfolio holdings, this is the tool. However, there is no explicit guidance on when to use it versus alternatives, no exclusions, and no mention of related tools like list_accounts. The context is clear but not fully explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds value by specifying the return structure (title, tags, truncated body), which is not present in the schema. No contradictions with annotations.

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

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

Two concise sentences with purpose, filters, and output. No waste, information is front-loaded.

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

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

Simple tool with three optional parameters and no output schema. The description covers the return fields, and the schema documents defaults and limits. Nothing an agent needs to invoke 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 parameters are already documented. The description reinforces filtering but adds no new semantics beyond the schema. Baseline 3 applies for high coverage.

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

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

States a specific verb ('List') and resource ('notes'), and specifies filtering options (search query or tag) plus return fields (title, tags, truncated body). Clearly distinguishes from other list_* tools targeting different resources.

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

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

Provides clear context for when to use (listing notes with optional filters) but does not explicitly mention alternatives or when not to use. Since it's a resource-specific listing tool, the use case is evident, but no exclusions are 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?

The description discloses that the tool returns task counts, tier, status, and linked goal, which adds value beyond the annotations. Annotations already indicate read-only and non-destructive behavior. There is no contradiction. However, it doesn't mention default filtering behaviors like excluding archived projects, though that is covered in the schema. It doesn't cover pagination or sorting.

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 unnecessary words. It states the action, resource, and key output fields efficiently. It is front-loaded with the primary action.

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

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

The description is adequate for a simple list tool. It specifies the output fields and the action. It doesn't mention pagination or sorting, but given the schema covers filtering and default behaviors, it is reasonably complete. It could benefit from mentioning that it's read-only (though annotations cover that) or that it lists all projects by default.

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 (tier, status, include_archived) are documented with descriptions. The description text does not add any additional parameter semantics, so it provides no extra value beyond the schema. Baseline score of 3 is appropriate.

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

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

The description clearly states the action (List) and resource (projects), and specifies the fields returned (task counts, tier, status, linked goal). It is distinct from other list_* tools by focusing on projects, though it doesn't explicitly differentiate from get_project_analytics or other project-related tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any exclusions or alternatives, such as using get_project_analytics for analytics or update_project for modifications. The usage is implied by the name but not explicitly 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?

The annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds only the 'saved' scoping and filter hints; it does not describe pagination, ordering, return format, or other behavioral traits beyond the annotations.

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

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

The description is a single sentence with no filler. It front-loads the verb and resource, then states the optional filters in a compact 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 read-only list tool with two optional parameters and no output schema, the description together with the schema is nearly complete. It lacks an explicit note about return format or pagination, but those are minor gaps for this straightforward 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%, so the schema already documents book_id and favorites_only. The description restates these as 'filtered by book or favorites only' but adds no new constraints, formatting, or usage 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 operation ('List saved quotes') and the resource (saved quotes), with optional filters by book or favorites. It is distinct from sibling creation tools like create_quote, though it does not explicitly name a competing listing 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?

The description gives clear context for when to use the tool: when listing saved quotes, with optional filtering. It does not explicitly discuss when not to use it or name alternatives, but no competing quote-listing sibling exists, so the guidance is sufficient.

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

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

Annotations already indicate read-only, non-destructive behavior, and the description adds context by specifying that only active subscriptions are returned and which fields appear (amounts, frequency, next billing date). This goes beyond the raw schema without contradicting any annotation.

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

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

One sentence, front-loaded with the action and resource, and no filler. It covers the essential scoping and output fields efficiently.

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

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

For a simple parameterless read-only tool, the description is sufficient: it states what is listed, the filter (active), and the key output fields. It does not describe formatting or edge cases, but no output schema exists and the tool is low-complexity.

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

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

There are zero parameters, so there is nothing the description needs to explain beyond the schema. The description focuses on the output rather than input, which is appropriate for a parameterless listing tool.

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

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

The description uses a specific verb ('List'), identifies the resource ('subscriptions'), and narrows scope to 'active' subscriptions while naming the returned fields. This clearly differentiates it from the create_subscription sibling and 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?

It clearly establishes the tool's purpose for retrieving active subscription data, but it does not explicitly state when to use it over alternatives or mention any exclusions. The context is clear enough for an agent to know this is the read-only listing counterpart to create_subscription, though not fully explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description does not contradict them. It adds the 'optionally filtered' behavior, but it does not disclose the default include_archived behavior, pagination, or result format beyond what the schema provides.

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

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

A single, front-loaded sentence states the operation and lists optional filters with no filler or redundancy. Every word contributes useful information.

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

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

For a read-only list tool with five optional parameters fully documented in the schema, the description plus schema are sufficient for an agent to invoke it correctly. However, it lacks any statement about the default unfiltered behavior or the expected return shape, so it is not fully complete.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. The description only paraphrases most of the existing parameter descriptions and omits include_archived, adding no new semantic 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?

Description uses a specific verb ('List') and resource ('tasks') and enumerates the filtering dimensions (status, priority, project, top3), making its role clear. It is easily distinguishable from sibling create_task, update_task, complete_task, and delete_task operations.

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 about when to use this tool versus alternatives or when not to use it. The agent must infer from the tool name and sibling list that this is the task-listing counterpart, but the description offers no explicit routing.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description adds minor behavioral context by naming the returned fields (price, priority, purchase status) but does not disclose other traits like default status behavior or pagination. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence that states the action, target, and included fields with zero wasted words. 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 read-only list tool with one optional parameter and no output schema, the description plus schema covers the essential calling context: the action, the optional filter, and the fields returned. There is no explicit mention of return format or empty-list behavior, but the simplicity and annotations mitigate that 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 single parameter (status) is fully documented in the schema with an enum and a default note, so schema coverage is 100%. The description does not add parameter-level meaning beyond the schema, which is acceptable at baseline; the enum values and default are clear from the schema alone.

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 ('wishlist items') and names the output fields (price, priority, purchase status), making the tool's function unambiguous. However, it does not explicitly distinguish itself from sibling tools—though no other list tool targets wishlists, so the risk of confusion is low.

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

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

The description implies when to use the tool ('when you want to view wishlist items') but provides no explicit when/when-not guidance or alternative routing. The optional status filter is documented in the schema, not in the description, so the usage context is adequate but not spelled out.

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

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

The description only restates the action without disclosing behavioral details such as whether it inserts a new record, updates an existing one, or requires authentication. Annotations already indicate a non-read-only, non-destructive operation, but the description adds no incremental transparency about side effects or data handling.

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

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

The description is a single sentence that leads with the verb and resource, followed by a compact list of examples. It contains no fluff or redundant content and is 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?

Given the tool's complexity (15 parameters, no output schema), the description is minimal but the schema covers parameter semantics fully. It does not mention what a successful log returns, how duplicates are handled, or that measured_at defaults to now (though that is in the schema). With high schema coverage, this is adequate but leaves some contextual gaps.

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

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

The schema provides complete descriptions for all 15 parameters, and the description merely lists a few examples without adding semantic nuance. It does not clarify relationships between parameters or any special constraints beyond what the schema already states, so it delivers no added value.

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

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

The description names a specific action ('log') and resource ('body measurements') and lists representative metrics, making the tool's purpose immediately recognizable. It implicitly differentiates itself from sibling logging tools like log_nutrition and log_workout by the resource type, but does not explicitly reference 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?

The description provides no explicit guidance on when to choose this tool over alternatives such as log_nutrition or log_workout, nor does it mention exclusions or prerequisites. However, the resource focus on body measurements makes the intended use case inferable.

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

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

The annotations already establish that this is a non-read-only, non-destructive write, and the description's 'Log' aligns with that. The description adds only that the session is 'completed', implying a one-time insert rather than an in-progress update. It does not disclose additional behavioral traits such as record creation, idempotency, or return value, but annotations cover the safety profile.

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

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

A single sentence with no filler; the action and key inputs are front-loaded. Every phrase ('completed', 'duration', 'project', 'task link') 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?

The description plus fully-described schema give an agent enough to invoke the tool: required duration_minutes, optional type, label, task_id, project_id, started_at. There is no output schema, but for a logging action the lack of return-value documentation is a minor gap. The six-parameter complexity is fully handled by the schema, so the description is not incomplete.

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

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

All six parameters have descriptions in the schema (100% coverage), so the baseline is 3. The description's mention of 'duration, project, and task link' merely summarizes three of the parameters without adding new meaning. No compensation 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 'Log' with the resource 'completed focus/pomodoro session', and lists the key attributes (duration, project, task link). This clearly distinguishes it from sibling logging tools like log_workout or log_nutrition by the session type. No ambiguity about what action is performed.

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 word 'completed' signals that the tool is for post-session logging rather than ongoing tracking, and naming the attributes tells the user what to supply. It doesn't explicitly name alternatives or exclusions, but the context is clear enough for an agent to route a focus-session logging request here. Sibling tools are mostly domain-specific loggers, so the description alone disambiguates.

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

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

Annotations provide only readOnlyHint=false, which is limited. The description adds meaningful behavioral detail: setting a value for a day, 0 clearing it, and no value meaning fully done. This goes beyond what the annotations alone convey, though it could also mention persistence/overwrite behavior more explicitly.

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 the essential meaning without redundancy. The main action is front-loaded, and the edge cases (0 clears, no value = done) are included with minimal wording.

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 3-parameter write tool with no output schema, the description together with the schema and annotations covers what an agent needs to invoke it correctly. It could mention the result/return behavior or confirm overwrite semantics, but nothing essential 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%, and the schema already documents date format, value semantics, and the habit_id. The description reinforces the core value behavior but does not meaningfully add beyond the schema's parameter descriptions, 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 identifies the action ('Log a habit entry') and the target resource (a habit date entry), making it easy to distinguish from sibling logging tools like log_focus_session or log_workout. It also conveys the core semantics of setting a value for a day, which disambiguates it from get_daily_entry or update_daily_entry.

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

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

The description provides clear context for when the tool is used: logging a habit entry for a date, including how missing vs zero values behave. It does not explicitly name alternatives or state when not to use it, but the intent is sufficiently clear given the tool name and sibling set.

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

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

Annotations already establish a write operation (readOnly=false). The description adds a critical behavioral trait beyond annotations: re-sending the same date replaces that day's data. No annotation contradiction is present.

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

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

Two sentences, no filler; the primary purpose is stated first and the critical overwrite caveat follows. 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 a fully described input schema and annotations, the description contains the key non-obvious behavior (replace-by-date) needed to call safely. A return-value note would be nice but is not necessary without an output schema.

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

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

Schema coverage is 100%, so the schema carries most parameter meaning. The description adds useful context that line items are optional and that the payload represents day totals, but it does not add per-parameter detail beyond the schema.

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

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

States a specific action ('Log') and resource ('a day of nutrition'), and clarifies the content: day totals plus optional food-by-food line items. The per-date replacement behavior further distinguishes it from generic daily-entry or logging 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 domain-specific phrasing implies when to use it, and the replacement sentence signals it works as an upsert for a date. However, it does not explicitly say when not to use it versus alternatives such as update_daily_entry or get_daily_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?

Annotations already indicate this is a mutation (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds minimal behavioral context beyond the act of logging, not disclosing potential side effects, auth requirements, or rate limits. It does not contradict annotations, but adds little value beyond them.

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

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

The description is a single, concise sentence that front-loads the action and resource. It wastes no words and is easily scannable.

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

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

For a tool with 12 parameters and no output schema, the description is minimal. It does not explain return behavior or any prerequisites beyond what the schema covers. However, given the schema's completeness and annotations, it is adequate but not rich.

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 already documented. The description mentions a subset (type, duration, calories, heart rate) but does not add new meaning or relationships beyond what the schema provides. Baseline 3 is appropriate given high coverage.

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

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

The description clearly states the verb 'log' and the resource 'workout session', and lists key fields (type, duration, calories, heart rate). It is specific and distinct from siblings like delete_workout and log_workout_sets, 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 such as log_workout_sets or log_body_measurement. It does not mention any prerequisites or conditions that would select this tool over others, leaving the agent to infer usage.

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

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

Annotations only indicate mutation, so the description usefully reveals a concrete side effect: a workout is created for that date if none exists. It also explains shorthand handling and auto-creation, which are behavioral traits an agent would not infer from readOnlyHint/destructiveHint alone.

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 front-loaded sentences with a useful shorthand example and zero filler. Every clause contributes either the core action, the input format, or the important create-if-none side effect.

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 rich schema covers all seven parameters, including examples and edge cases like repeated sessions and duplicate suppression. The description is thin on return behavior, but since there is no output schema and this is a straightforward mutation tool, the combined definition is enough 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 schema already explains sets_text, workout_id disambiguation, date defaulting, and allow_duplicates behavior. The description's shorthand mention adds a little flavor but does not materially go beyond the parameter descriptions, 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 clearly states the operation: adding exercises and sets to a workout, with a concise example of accepted gym shorthand. It does not explicitly contrast with sibling tools like log_workout, so the differentiation is implicit rather than stated.

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 about when to choose this tool over log_workout or delete_workout_sets. The description only states what the tool does; it neither names alternatives nor spells out the conditions under which set-level logging is appropriate.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=false, and destructiveHint=false, so the safety profile is covered. The description adds the scope of what is searched but does not disclose behavioral details such as result ordering, matching semantics, or pagination, which is acceptable given the 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?

One crisp sentence with the action front-loaded and a compact list of the searchable data types. There is no filler, and the scope is immediately visible to the 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 simple single-parameter read-only search tool, the description and schema adequately support correct invocation. It does not describe the return format, but the absent output schema makes that less critical, and the readOnly annotation reassures the agent that this is a safe query 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 input schema has 100% description coverage; 'query' is already documented as 'Search query (min 2 characters)'. The description's 'by keyword' conveniently matches the parameter intent but adds no new semantic detail beyond what the schema already provides, so the baseline 3 is appropriate.

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

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

The description states a specific verb ('Search') and resource ('the user's Framezone data'), then scopes the operation to six concrete types: tasks, projects, notes, bookmarks, books and goals. This clearly distinguishes it from the many list_* and create_* siblings without requiring an agent to open the schema.

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

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

The phrase 'by keyword' establishes a clear context for use: an agent should call this when the user wants to find items across multiple Framezone categories using a keyword. It does not explicitly name alternatives like list_tasks or list_notes for exhaustive browsing, so it falls just short of fully explicit 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?

Annotations already convey that this is a mutating but non-destructive and idempotent operation. The description adds the useful detail that current_page updates reading progress, but it does not disclose partial-update behavior, required book_id semantics, or any other side effects beyond the 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?

The description is a single, efficient sentence with no filler. It front-loads the action and resource, then immediately lists the mutable fields, making it easy to scan.

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 tool with fully documented parameters and annotations covering the safety profile, the description is largely complete. It could explicitly mention that unspecified fields remain unchanged and what the tool returns, but no output schema exists and the core semantics are clear.

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, with every one of the 8 parameters documented. The description adds little beyond the schema, though it does frame current_page as 'reading progress,' which is a mild semantic enhancement. 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'), a clear resource ('a book'), and enumerates the exact fields that can be changed (status, rating, notes, current page). This makes it easy to distinguish from sibling tools like create_book, delete_book, and list_books.

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

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

The description gives clear context: this tool modifies existing book fields rather than creating or deleting a book. However, it does not explicitly state when not to use it or name alternative tools for related operations, so it stops short of full 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?

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so the safety and mutation profile is known. The description adds value by explaining that mark_contacted=true records today's date as the check-in date – a behavioral detail not in the schema. It doesn't contradict any annotation and provides useful context beyond what structured fields carry.

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 main action ('Update a contact') is front-loaded, and the mark_contacted note is a targeted, useful addition. Nothing is redundant.

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 13 parameters (1 required), a complete schema, and no output schema, the description is adequately minimal. It covers the core purpose and one non-obvious parameter behavior. It doesn't mention partial-update semantics, but that is implicit for an update tool and the schema already lists all fields. The description is sufficient for an agent to call it correctly.

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

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

Schema description coverage is 100%, so all 13 parameters are already documented in the schema. The description only mentions mark_contacted, adding a bit of context for that parameter. Since the schema does the heavy lifting, a baseline of 3 is appropriate; the description adds marginal value but does not compensate for anything missing.

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 'Update a contact' – a specific verb and resource – and adds a special-case note about mark_contacted. It is unambiguous and implicitly distinguishes from create_contact and list_contacts among siblings, so an agent can immediately tell what it does.

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

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

The description gives a concrete usage hint: 'Use mark_contacted=true to record a check-in with today's date.' This tells the agent a specific scenario where this tool (and this parameter) is appropriate. It does not explicitly contrast with create_contact or other update tools, but the purpose is clear enough that an agent would know to use it for existing contacts. Minor gap: no explicit 'when not to use' guidance.

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

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