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

Beyond annotations (readOnly=false, destructive=false), the description discloses the $0.10 cost and API-key requirement, which are useful operational constraints. It does not discuss duplicate handling or creation side effects, but the schema covers idempotency keys.

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 the purpose first and cost/auth appended compactly. No filler 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 simple create-style tool with an output schema and documented idempotency parameters, the description covers the main purpose and operational prerequisites. It could mention duplicate behavior or when to use update instead, but these lacks are minor.

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

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

Schema description coverage is 67%, so the schema already explains request_id and idempotency_key. The description adds little parameter-specific meaning; 'owned object' only weakly implies that name identifies the object being added.

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

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

The description uses a specific verb ('Add') and resource ('an owned object to Life Inventory'), making the core function clear. It does not expressly contrast itself with sibling add_inventory_valuation, but the 'item' vs 'valuation' distinction is inferable from name and wording.

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

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

No guidance is given on when to choose this tool over alternatives such as update_inventory_item, archive_inventory_item, or add_inventory_valuation, and no exclusions or prerequisites are stated beyond the API key requirement.

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

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

The description adds meaningful behavioral context beyond the annotations: the operation appends an immutable observation, costs $0.10, and requires an API key. Annotations already indicate it is a write operation, but the description usefully discloses immutability and cost.

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

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

The description is extremely concise and front-loaded with the action. The parenthetical cost and API key requirement earn their place without adding fluff. Every word contributes meaning.

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

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

For a simple append operation, the description covers the essential behavioral facts: immutability, cost, and authentication. However, it is incomplete as a standalone guide because it omits usage context and leaves the core parameters (value, currency, inventory_id) semantically under-specified despite low schema coverage.

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

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

Schema description coverage is only 40%, and the description does not explain value, currency, or inventory_id. The phrase 'valuation observation' hints at the meaning of value, but the description does not compensate for the missing parameter documentation, especially for required fields like inventory_id and the optional currency format.

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 'Append' and the resource 'valuation observation', making the core operation clear. The word 'immutable' also implicitly distinguishes it from update/delete tools, though it does not explicitly name sibling tools or state what it is not.

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 siblings like get_inventory_valuations, update_inventory_item, or add_inventory_item. It mentions API key and cost, which are prerequisites, but gives no context about when this tool is the right choice or when an alternative should be used.

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 indicate a non-read-only, non-destructive write operation. The description adds cost ($0.05) and API key requirement, which are not in annotations. However, it does not disclose behavior like duplicate handling or error responses. The added context is useful but limited.

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 purpose (add alias) and appends cost/auth details. It contains no filler or redundant information, making it highly concise and well-structured.

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

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

With six parameters, only two required, and schema covering only idempotency keys, the description leaves critical parameters like source and alias_kind unexplained. It also does not mention idempotency behavior despite having request_id fields. The output schema exists, but the description provides insufficient guidance for correct invocation, especially for optional parameters and expected outcomes.

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

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

Schema description coverage is low (33%) with only idempotency keys described. The description gives hints about the 'alias' parameter via examples but leaves person_id, source, and alias_kind unexplained. With low coverage, the description should compensate but does not adequately clarify the required and optional parameters.

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

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

The description clearly states the verb 'Add' and the resource 'alias' for a CRM person, with examples of alias types (nickname, payment handle, misspelling). This differentiates it from siblings like remove_person_alias and update_person_alias by explicitly indicating an additive operation.

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

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

The description implies when to use the tool (to add an alias) but does not explicitly mention alternatives or state when not to use it. There is no reference to update or remove operations, leaving usage guidance solely implied by the 'Add' wording.

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

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

The description adds meaningful behavioral context beyond the destructiveHint=true annotation by clarifying that this is a soft-delete: it sets archived_at and preserves original rows for versioning. This materially reduces the risk of an agent assuming permanent destruction. It also mentions the cost and API key requirement, adding operational transparency.

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

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

The description is compact and front-loaded. The core action and state change come first, followed by the preservation behavior and then operational prerequisites. Every sentence earns its place with no filler.

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

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

The tool's purpose, effect, cost, auth requirement, and non-destructive nature are all covered. The main omission is the return value or response shape, especially since no output schema is provided, but for a simple soft-delete operation the provided context is otherwise sufficient.

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

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

Schema coverage is 67%, with request_id and idempotency_key already described in the schema. The description itself does not add parameter-level detail, but asset_id is self-explanatory given 'archive an asset.' The description does not compensate for the undocumented asset_id semantics, but the gap is minor.

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: 'Soft-delete an asset (sets archived_at).' This is a specific verb plus resource, and it distinguishes the tool from related siblings like upload_asset and update_asset by clarifying the archive semantics.

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

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

The usage context is implied through the 'soft-delete' and 'archive' language, so an agent can infer when to use it. However, it does not explicitly state when not to use it or mention alternatives such as update_asset, upload_asset, or a hard-delete path.

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 non-read-only and non-destructive. The description adds critical behavioral details: the action is reversible, linked data is preserved, and a restore_id is returned. This goes well beyond the structured annotations and gives an agent a clear model of the operation's 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 a parenthetical covering cost and auth requirement. It is front-loaded with the core action and includes no redundant phrasing.

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

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

With an output schema present, return-value details are covered elsewhere. The description explains reversibility, data preservation, and the idempotency requirement. It mentions the ownership constraint ('owned event') but does not clarify the optional 'reason' parameter or any additional permissions beyond API key. Still, it is sufficiently complete for a tool of this complexity.

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

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

Schema description coverage is only 25% (only idempotency_key described as alias for request_id). The description adds meaning to request_id ('use a new one for each action') but leaves event_id and reason unexplained. Given the low schema coverage, the description should compensate more, but it only partially does so.

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 ('archive') and resource ('owned event'), and the qualifier 'reversibly' distinguishes it from permanent deletion (delete_event) and aligns with the sibling restore_event. Mentions preserving linked data and returning a restore_id, making the tool's role 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?

Provides concrete guidance to use a new request_id per action, which is useful for idempotency. However, it does not explicitly state when to use this tool vs. alternatives like delete_event or restore_event, though the word 'reversibly' implicitly suggests it for non-permanent archival. Lacks explicit when-not-to-use guidance.

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

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

The description adds substantial behavioral context beyond the annotations: it states the operation is reversible, preserves linked data, returns a restore_id, requires an API key, and costs $0. It also explains the idempotency requirement for request_id. These are meaningful disclosures that go beyond the bare readOnlyHint/destructiveHint flags and help the agent understand side effects and constraints.

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 compact three-sentence structure (including the parenthetical cost/auth note). The primary purpose is front-loaded, followed by the idempotency instruction and then operational constraints. Every sentence contributes information, with no redundancy or filler.

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

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

The description covers the essential behavior, idempotency, authentication, and cost. Since an output schema exists, it need not detail return values, and the description mentions restore_id anyway. It could mention that archived expenses can be restored via restore_expense, but that is an optional improvement. For a single-resource archive operation, the description is sufficiently complete.

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

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

With only 25% schema description coverage, the description is expected to compensate. It does add semantics for request_id ('use a new one for each intended action') and expense_id (implies 'owned expense'), but it does not explain the 'reason' parameter at all. The schema itself only describes idempotency_key as an alias, so the description only partially fills the gap. It is not completely unhelpful, but it could do more.

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 'archive', the resource 'expense', and the specific scope 'one owned expense', which distinguishes it from sibling archive tools for assets, events, trips, etc. It also adds key behavioral details (reversible, preserve linked data, return restore_id) that make the purpose unambiguous. The name alone would be vague, but the description pins down exactly 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 gives clear contextual guidance: it is for archiving an owned expense, it is reversible (implying not for permanent deletion), and it instructs to use a new request_id for each intended action, which is an explicit usage rule. It does not explicitly name alternatives like delete_event or restore_expense, but the context makes the intended use 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 indicate readOnlyHint=false and destructiveHint=true, so the description correctly aligns with a mutating, destructive-intent operation. The description adds important context: the operation is non-destructive in terms of data loss ('archive instead of destructive delete'), there is a $0.10 monetary cost, and an API key is required. Ironically, the annotation destructiveHint=true may mean the operation is considered destructive (e.g., it removes the item from active lists), but the description clarifies it is not a permanent delete. The description adds value beyond annotations by disclosing cost and authentication requirements.

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

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

The description is extremely concise: one sentence with three useful clauses: the operation type, the cost, and the auth requirement. It front-loads the most important behavioral distinction ('Archive instead of destructive delete'). It could be slightly more structured (e.g., separate cost and auth into a second sentence), but it earns every word and has no wasted content.

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

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

For a tool with an output schema, 4 parameters, and destructiveHint=true, the description is minimally adequate: it tells the agent this is an archival operation with cost and auth requirements. But it doesn't explain the meaning of reason, what happens to the archived item (e.g., is it still visible in get_inventory?), or how retries work with idempotency keys (though the schema documents retries). Given the output schema exists, return values don't need explanation, but the behavioral consequence of archiving is left partially inferred.

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 50%, with documented parameters being request_id and idempotency_key. The description does not explain inventory_id or reason beyond the schema's basic type declarations. However, the description's 'Archive instead of destructive delete' implies inventory_id is the target item, and reason is presumably an audit/archive reason. Baseline 3 is appropriate because the schema covers half the parameters and the description partially compensates by clarifying the operation's nature, but it doesn't add specific meaning to the undocumented parameters.

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

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

The description uses 'Archive instead of destructive delete' which clearly indicates the operation is a non-destructive archival action on an inventory item. It distinguishes itself from delete operations by emphasizing it is not destructive, though it doesn't name a specific sibling alternative like delete_event or delete_food. The related get_inventory_item, update_inventory_item, and add_inventory_item siblings help contextualize it, but the primary behavior (archive an inventory item) 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?

The 'instead of destructive delete' phrase provides an implicit usage guideline: use this when you want to remove an inventory item from active use without permanently destroying it. However, it does not explicitly state when to use this over update_inventory_item (e.g., when the item should be retired) or contrast with alternative archive tools like archive_asset, nor does it mention the $0.10 cost as a decision factor. This is adequate but relies on 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 indicate it's not read-only and not destructive, and the description adds valuable context: it's reversible, preserves linked data, returns a restore_id, and requires an API key. The note about using a new request_id for each action is also behavioral. 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 extremely concise: two sentences that state the core purpose first, then add behavioral details and a critical usage instruction. Every sentence earns its place, and there's no filler 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 simple archive operation, the description covers the essential points: what it does, reversibility, linked data preservation, return value (restore_id), and idempotency guidance. It omits details about optional parameters like reason, but those are not critical for calling the tool. The output schema exists, so return details are handled there. Overall, it's nearly complete for the tool's 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 only 25% (idempotency_key has a description), and the description does not explain trip_id or reason. However, it does clarify that request_id should be new for each action, which adds meaning beyond the schema. For the other parameters, the schema itself lacks descriptions, and the description doesn't compensate, so it's a partial but not complete job.

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 (archive), the resource (one owned trip), and key behavioral aspects (reversible, preserves linked data, returns restore_id). It distinguishes from sibling tools like restore_trip by emphasizing reversibility, but it doesn't explicitly name alternative archive tools for other resource types, so it's not 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 description gives an explicit instruction about using a new request_id for each intended action, which is a concrete usage guideline. However, it doesn't specify when to choose archive_trip over alternatives like delete_event or other archive_* tools; the guidance is implicit through the 'reversible' and 'preserve' wording but lacks explicit when/not conditions.

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

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

Annotations are minimal, so the description carries the burden. It discloses the key side effect: it creates a linked copy rather than moving the original row. It also adds legacy URL behavior, role values, cost, and API-key requirements. It does not describe failure modes or output behavior, but the core semantics are clearly stated.

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 short and well-front-loaded. The first sentence delivers the operation and its main caveat, followed by compact role and legacy/cost information. Every sentence contributes practical information, though the role list is partially redundant with the schema.

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

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

Given the tool has 9 parameters, nested objects, and low schema coverage, the description is only minimally sufficient. It explains the main operation and one parameter relationship but leaves key invocation details—entity_type/entity_id allowed values, metadata/asset_type semantics, and URL vs. asset_id precedence—incompletely specified. The output schema helps, but the overall context is not fully self-contained.

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 only 33% schema description coverage, the description must compensate for undocumented parameters. It does explain asset_id vs. URL legacy behavior and role values briefly, but entity_type, entity_id, metadata, asset_type, and idempotency behavior are left under-explained. It also omits a valid schema enum value, 'photo', from its Roles list.

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

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

The description starts with an explicit verb and resource: 'Link an existing asset_id to another entity by creating a linked copy.' This is clearly distinct from upload_asset, update_asset, and archive_asset, and the clarifying clause 'does not move the original row' removes ambiguity about whether this is a move operation.

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

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

It provides clear context for the intended use: linking an existing asset to an entity, creating a linked copy, and supporting a legacy URL path. It also notes API key and cost requirements. It stops short of explicitly saying when not to use this tool or naming upload/update/archive as alternatives, so it is 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 mark this as read-only and non-destructive. The description adds useful behavioral context: it is server-side, returns only compact candidate clusters, costs $0.10, and requires an API key. This goes beyond the annotations without contradicting 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 compact and front-loaded: context, output, usage warning, and cost/auth are each conveyed in a single concise statement. Every sentence adds value, and there is no filler.

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

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

The description gives the essential context, output shape, and auth/cost details, and an output schema exists. However, because the parameters are entirely undocumented in both schema and description, the tool is not fully callable without guessing or external knowledge.

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

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

Schema description coverage is 0%, and the description provides no explanation of limit, checks, or min_confidence. The output-type hints (duplicates, normalization, etc.) are loosely related to possible checks but do not map to the actual parameters, leaving the agent without meaningful parameter guidance.

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

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

The description clearly states the tool's purpose: server-side contact hygiene returning compact candidate clusters for duplicates, entity-type hints, normalization, and payment-handle collisions. It also explicitly contrasts with get_people bulk dumps, helping differentiate it from a closely related 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 provides a clear use context (cleanup candidate clusters) and explicitly warns against using get_people bulk dumps for cleanup. However, it does not mention other relevant siblings like score_people_duplicates or start_people_cleanup, so the alternative-selection guidance is incomplete.

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 not a read-only operation (readOnlyHint=faalse). The description adds cost ('$0.05') and authentication ('API key required'), which are useful semantics beyond the annotations. However, it does not explain side effects such as whether the action is reversible, how many items are affected, or the exact criteria for 'non-person / typed junk'.

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 plus a parenthetical is extremely concise and front-loaded: the core action and scope are stated first, then cost and auth requirements. No words are wasted.

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

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

The tool has no required parameters and four optional ones, but the description leaves the meaning of 'bulk' and the valid inputs (reason, entity_type) ambiguous. It also does not say how it differs from the per-item dismiss_clarification. The presence of an output schema helps with return values, but an agent still lacks enough context to construct a correct call confidently.

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 covers 50% of parameters: request_id and idempotency_key are described; reason and entity_type are bare strings. The tool description does not clarify what values reason or entity_type should accept, and the phrase 'typed junk' only loosely hints at entity_type's role. It does not compensate for the schema gaps.

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

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

The description states a specific verb ('Dismiss') and resource ('the clarification queue') with a clear scope: non-person / typed junk. The 'bulk' in the tool name and this qualifier distinguish it from the sibling 'dismiss_clarification', which presumably handles a single item.

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

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

There is no guidance on when to use this tool versus alternatives like dismiss_clarification or resolve_clarification. The use case is implied ('dismiss non-person / typed junk') but no explicit conditions, prerequisites, or exclusions are given.

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

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

Annotations already indicate readOnlyHint=false (mutation), destructiveHint=false (not destructive), and openWorldHint=false (closed world). The description adds transparency by stating that classification won't lose transactions or links, which is valuable behavioral context for a mutation tool. It also mentions cost and API key requirement, which are beyond annotations. No contradiction found.

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

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

The description is a single well-structured sentence that front-loads the core action and critical safety guarantee. The cost and authentication requirements are appended parenthetically without clutter. There is zero waste.

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

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

The description, combined with the annotations and output schema, covers most of what an agent needs: it's a safe mutation, it won't lose data, it requires an API key and costs $0.10. The only missing context is clarification on parameter usage (e.g., how entity_id vs person_id are used, what confidence means), but with an output schema present and the safety profile clear, the description is largely complete.

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

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

Schema coverage is only 25% (only request_id and idempotency_key have descriptions), so the description must compensate for the other 6 parameters. The description only explains entity_type's role, but doesn't clarify source, entity_id, person_id, confidence, identity_status, or the relationship between request_id and idempotency_key. While some parameters (like entity_id, person_id) may be self-explanatory, the description doesn't add significant semantic value beyond what's in the schema. Baseline 3 is appropriate, but it could be higher if it explained parameter interplay.

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 that this tool sets entity_type on a CRM row, with a specific list of allowed values (person/company/merchant/…). It differentiates from similar tools like convert_contact_entity and update_person_identity by focusing on entity_type classification without losing transactions or links. However, it doesn't explicitly name these siblings, so while purpose is clear, sibling differentiation is not explicit.

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

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

The description implies use for classifying a contact's entity type, and the emphasis on 'without losing transactions or links' suggests it's the safe alternative to destructive or lossy operations. However, there is no explicit when-to-use/when-not-to-use guidance or direct mention of alternatives. An agent would need to infer when this tool is preferred over others like convert_contact_entity.

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 non-read-only and non-destructive, so the description carries the full burden. It discloses atomicity, the refusal condition, idempotency ('replay performs no additional actions'), output (per-row statuses and restore_id), and auth/cost. This is rich behavioral context beyond annotations.

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

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

The description is extremely concise—one sentence with semicolons—yet packs the action, requirements, conditions, output, idempotency, and cost. It is front-loaded with the primary verb and resource, and every clause 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 covers the action, required inputs, behavior, output (including restore_id), idempotency, and auth/cost. It does not explicitly link to cleanup_preview or restore_cleanup, but the presence of a restore_id and the requirement of a preview_id imply the workflow. Given the output schema exists, return details are 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 only 25% (idempotency_key's alias). The description lists the three required params and hints at candidate_hash's role via 'exact reviewed preview' and 'Refuses changed sources', but does not explain the format or exact meaning of each. It adds some semantics but not enough to fully compensate for the low schema coverage.

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

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

The description clearly states a specific verb ('archive') and resource ('exact reviewed preview'), and explicitly requires preview_id, candidate_hash, and request_id, which distinguishes it from cleanup_preview (which creates the preview) and other apply-like siblings. The 'Refuses changed sources' clause adds a distinctive behavior.

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 usage context: it is the apply step after a preview exists, requires those three parameters, refuses changed sources, and notes that replay is idempotent. It implies when to use it but does not explicitly name alternative tools or state 'use after cleanup_preview'.

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 this as read-only and non-destructive; the description reinforces that and adds useful behavioral details: the preview expires after 30 minutes, requires an API key, costs nothing, and returns specific audit artifacts. This goes beyond the annotations without contradicting 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?

Four short, information-dense sentences with the core purpose front-loaded. Every sentence contributes value: scope, outputs, relationship to cleanup_apply, expiry, and cost/auth. No filler or repetition of schema details.

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

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

For a single-parameter read-only tool with an output schema and annotations, the description is largely complete: it names the parameter scope, outputs, expiry, and usage context. It could clarify what consumers should do with the returned hashes or rollback payloads, but the output schema likely carries that detail.

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

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

The schema only defines 'family' with an enum and no descriptions, so the description must compensate. It does mention 'events, expenses or trips', matching the enum values, which gives minimal meaning. However, it does not explain how the family value affects the audit output or what exactly 'family' represents beyond those categories.

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 ('read-only account audit') and a clear resource scope ('events, expenses or trips'), lists concrete outputs (source hashes, rollback payloads, review queue), and explicitly distinguishes itself from the sibling cleanup_apply. An agent can understand what this tool does and how it relates to the cleanup workflow.

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

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

The description gives an explicit usage instruction: 'Review the exact candidate set before cleanup_apply.' This clearly positions the tool as a pre-apply review step. It does not name alternative tools or state when not to use it, but the read-only preview framing and 30-minute expiry provide enough context.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description discloses three behavioral traits the structured fields do not: the feature flag is off by default, an API key is required, and each call costs $0.10. That is exactly the kind of operational context annotations cannot convey, though it omits whether a commit is reversible.

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 fragments with parenthetical qualifiers — the gating facts (flag, cost, auth) are front-loaded and nothing is padded. The telegraphic style borders on cryptic, but no sentence is wasted.

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

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

An output schema exists, so return values need not be described, and the cost/flag/auth profile is covered. Still missing for a write/commit tool: whether the operation is idempotent or reversible, and what payload_hash must match — a material gap given three required parameters with no schema documentation.

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

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

Schema description coverage is 0% across 5 parameters, and the description only gestures at two of them (payload_hash, owner_session_id) without explaining format, provenance, or purpose. proposal_id, request_id, and idempotency_key are left entirely undocumented in both the schema and 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?

It names a specific action ('Owner approve+commit') and the key credentials involved (payload_hash, owner_session_id), which implies it finalizes a proposal created by propose_life_update. But 'life update' is never defined and the verb phrase 'approve+commit' is compressed jargon, so an agent must infer the resource being mutated.

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?

'flagged; off by default' and 'API key required' give real gating conditions for when this call is permitted. However, it never names propose_life_update as the prerequisite step or explains when an owner should choose to commit versus leave a proposal pending.

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 openWorldHint=true, so no contradiction exists. The description adds useful behavioral context beyond the annotations: it packages what would be two notable_pack calls into one, notes the timeline format, and discloses the $0.08 cost.

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 concise semantic units in one sentence: what it returns, why it is preferable to calling notable_pack twice, and a concrete example. No filler words or redundant restatements.

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 tool with only two required parameters, the description plus the input schema and annotations gives an agent everything needed to call it correctly. It also includes enough comparison-specific context to choose this over notable_pack, and the cost and timeline details remove the main remaining unknowns.

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?

slug_a and slug_b have schema descriptions, and the example reinforces what a slug looks like. However, the description adds nothing about date, peers, or similar, and peers/similar are not described in the schema either, so the 40% schema-description gap is left uncompensated.

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 operation: produce side-by-side notable packs for two slugs. It names the resource (notable packs with life_in_days + day_number timelines) and explicitly differentiates itself from notable_pack by noting it replaces two calls. The elon-musk vs steve-jobs example grounds the abstraction.

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 names notable_pack as the alternative and frames compare_lives as the one-call version for comparing two people. It doesn't give formal when-not conditions, but the intended context is clear enough for an agent to decide when to pick this over a single notable_pack call.

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, so the description's job is to add behavioral detail beyond that. The description notes 'Preserves FKs', which is a useful behavioral guarantee that foreign keys are not broken, and mentions pricing ($0.10) and API key requirement, adding context not in annotations. However, it doesn't disclose whether the operation is reversible, what happens to existing relationships, or what the output looks like, though an output schema exists. The description does not contradict annotations, so no contradiction flag.

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 sentence with high information density: it states the action, its equivalence to a sibling, a key guarantee (preserves FKs), and operational details (pricing, API key). Every word earns its place, no fluff or redundancy. It's front-loaded with the core purpose before the parenthetical notes.

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 schema has 5 parameters with low coverage, an output schema exists, and the operation is a simple conversion, the description is fairly complete. It covers the core action, equivalence, FK guarantee, and cost/auth details. However, it could be enhanced by clarifying the difference between entity_id and person_id and the allowed target_type values, but the output schema and annotations help. It's not fully complete but adequate for a straightforward mutation tool.

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

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

Schema description coverage is only 40%, so the description must compensate for undocumented parameters. The description mentions 'entity_type' which maps to 'target_type' parameter, but does not explain the meaning of 'target_type' values or the roles of 'entity_id' vs 'person_id'. It also hints at 'request_id' via idempotency context, but not fully. The description adds some value by referencing entity_type, but leaves ambiguity about which identity parameter to use and target enum values. Baseline is 3 due to moderate coverage, but description doesn't fully compensate.

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 ('Convert') and resource ('a contact's entity_type'), which clearly conveys the operation. It also references a sibling tool 'classify_contact', noting they are the same operation, which helps distinguish it from other contact/property tools. However, it doesn't explicitly state the purpose beyond the action, like what conversion means in terms of the domain, but the verb and resource are clear enough.

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

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

The description explicitly mentions 'same as classify_contact', which signals to the agent that this tool is equivalent to a sibling, but does not provide explicit when-to-use vs alternatives or when NOT to use it. The mention of preserving FKs is a key usage hint, implying it's safe to convert without breaking relationships. However, it lacks clarity on conditions like whether the contact must be a person or company, or why you'd choose this over classify_contact.

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 this as a non-read, non-destructive mutation, so the description adds value with duplicate-checking behavior, required API key, and cost. It does not specify what happens when a duplicate is found, but the stated behaviors go beyond what annotations convey.

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

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

The description is short and front-loads the primary purpose. The remaining sentences each add useful operational information: duplicate checking, name alias, cost, and auth requirement. No filler or redundant restating of the title.

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

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

Despite having an output schemaable, the tool has nine parameters with mostly undocumented semantics and no usage guidance versus sibling contact tools. The description covers auth and duplicate checking but leaves too many gaps for reliable invocation in edge cases.

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

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

Schema description coverage is only 22%, with request_id and idempotency_key already explained in the schema. The tool description adds no meaning for name, tier, email, notes, phone, aliases, or relationship, leaving the agent with only raw types and a required name.

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

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

The description opens with a specific verb and resource: 'Add a Dayze Contacts record'. This clearly distinguishes create_person from siblings like create_place and add_person_alias. The duplicate-check note adds useful behavioral context without muddying the 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 does not say when to use this tool versus alternatives such as update_person, merge_people, or add_person_alias. 'Checks duplicates first' hints at a creation workflow, but there is no explicit guidance about when not to use it or which sibling handles related 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 the non-read/non-destructive profile, so the bar is lower. The description adds genuinely useful context: idempotency behavior ('Idempotent by name or idempotency_key'), a cost signal ($0.10), and an auth requirement (API key required) — all beyond structured fields.

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 compact sentences with the primary purpose front-loaded, then behavioral constraints. Efficient; slight density of parenthetical signals but no wasted sentences.

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?

Output schema exists so return values need not be explained, and annotations cover the safety profile. However, for a 21-param creation tool with 29% schema coverage, the description omits many parameter semantics and gives no explicit relationship to siblings like update_place or resolve_place.

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

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

Schema description coverage is only 29%, and the description only names a handful of fields (address, opening_hours, affordability, notes, tags) out of 21 params. It doesn't clarify the alias relationships (hours↔opening_hours, price_level↔affordability) that the schema does document, leaving substantial gaps the description does not compensate for.

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

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

States a specific verb+resource ('Save a venue card') and enumerates the fields it holds (address, opening_hours, affordability, notes, tags). It is clearly a creation tool distinct from get_place/get_places/update_place siblings, but it does not explicitly name those siblings the way a 5 would.

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 clause 'does not create calendar notes' implies when-not usage by exclusion, but there is no explicit guidance on when to use create_place versus resolve_place or enrich_place_from_google. Usage is only implied.

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

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

Annotations only say readOnlyHint=false and destructiveHint=false. The description adds significant context: reversible (archives), preserves food/people/asset links, returns prior row for compatibility, idempotent replays, and includes cost/API-key requirements. This goes well beyond annotations and covers important behavioral traits.

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 dense sentences with zero waste. The purpose is front-loaded, then required params, return values, preservation, restore, idempotency, and cost are each mentioned in order. Every clause 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 reversible delete tool with an output schema, the description covers what is returned (prior row, changed, restore_id, life_state_rebuilt), what is preserved (links), idempotency, restore path, and cost/authentication. Nothing an agent needs to invoke 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% and the schema already describes event_id and request_id as required, with idempotency_key as an alias. The description reiterates these but adds the 'replays' behavior tied to request_id, which is a slight extra. Since the schema carries the parameter meaning, a baseline 3 is appropriate.

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

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

The description states a specific verb ('archives') and resource ('one owned event'), and clarifies it is reversible. It distinguishes from siblings like archive_event and restore_event by framing it as a reversible delete that preserves links. The purpose is unambiguous and differentiates from similar 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 explicitly points to restore_event for reversal and notes idempotency ('Replays perform no additional action'), which guides retry behavior. However, it does not explicitly contrast with archive_event or other delete tools, leaving some ambiguity about when to prefer this over a plain archive. The restore guidance is clear, so a 4 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 mark destructiveHint=true, and the description adds substantial behavior: it removes the mirrored calendar event, rebuilds life_state, returns an error for unknown/other-user food_id, and notes that share tokens cannot write. This goes far beyond the 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?

Every sentence earns its place: the mutating effect, required param, sibling routing, error behavior, side effect, auth requirements, and cost. Front-loaded with 'MUTATES' and sized appropriately for the information density.

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?

Covers purpose, target, side effects, error conditions, auth, and cost. With output schema present, return values need no explanation. Complete for a destructive single-object deletion tool with 3 parameters and rich 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?

Schema description coverage is 100%, so the baseline is 3. The description restates that food_id is required and is a UUID, but adds no extra semantics for request_id or idempotency_key beyond what the schema already provides. It is adequate but not additive.

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 ('removing'), resource ('Food Diary row'), ownership scope ('the authenticated user owns'), and the mirrored calendar event side effect. The title and description together make it clear this is the food-diary deletion tool, and it explicitly differentiates from delete_event via the 'prefer this over delete_event' note.

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

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

Explicitly names the alternative (delete_event) and provides the condition for choosing this tool ('for meals logged via log_food'). Also states error conditions for unknown/other-user food_id and gives auth prerequisites, which helps the agent decide when this tool 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?

The description goes beyond the annotations by disclosing the API key requirement and the $0.05 cost. It does not contradict the annotations, but it also does not explain the effect of dismissal, whether it is reversible, or what happens to the entity afterward.

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 adds only the essential cost/auth caveat. It is appropriately sized, though a bit more context about related tools would improve it without bloating it.

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 annotations and output schema, the description is mostly adequate for a simple dismissal action, but it leaves gaps around when to use bulk vs single dismissal and what the optional reason parameter is for. The presence of an output schema means return values need not be explained, but alternative routing 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 50%, covering request_id and idempotency_key, but the required clarification_id and the optional reason are undocumented in the schema. The description does not explain how to supply or format any parameter, so it adds little beyond the tool name and schema.

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

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

The description clearly states the action ('Dismiss'), the resource ('pending entity clarification'), and gives a concrete example type ('not_person'). It is distinguishable from siblings like resolve_clarification and bulk_dismiss_clarifications, though it does not explicitly name them.

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

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

There is no guidance about when to choose this tool over the related bulk_dismiss_clarifications or resolve_clarification siblings. The phrase 'pending entity clarification' implies when it is applicable, but the description does not state exclusions or alternatives.

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

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

Annotations cover the safety basics (readOnlyHint=false, destructiveHint=false), and the description adds genuinely new behavioral context: the default non-overwrite policy, a $0.15 per-call cost, and an API-key requirement. It does not describe rate limiting, failure modes when Google has no match, or interaction between place_id and business_contact_id; note also that openWorldHint=false sits uneasily with a documented external Google API dependency.

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 tight clauses: what it fills, the non-overwrite default, and the cost/auth note. Nothing is redundant, though the parenthetical field list and price note are packed densely into one sentence rather than separated for scanning.

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

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

An output schema exists, so return values need not be described. However, with five parameters and zero required, the definition should say which identifier (place_id or business_contact_id) the caller must supply and what happens if neither is given; that gap leaves the agent unable to construct a valid call from the description alone.

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

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

Schema description coverage is only 40% (request_id and idempotency_key are documented; place_id, fill_empty_only, business_contact_id are not). The description compensates partially by stating the default for fill_empty_only, but it never explains the role of place_id versus business_contact_id or whether either is required.

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 and resource ('enrich ... saved place card') plus the fields it fills (hours/address/phone/website) and the external source (Google Places). This clearly separates it from sibling mutators like update_place, which edit a place card without an external data source.

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 clear context for use: it is 'optional', defaults to non-overwriting behavior ('fill_empty_only — does not overwrite agent-supplied fields'), and carries a cost/auth requirement. It does not explicitly name alternative tools (e.g., update_place) or state when to prefer manual editing, so it stops short of full when/when-not guidance.

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

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

Beyond the readOnlyHint annotation, the description discloses the source lookup order, the API-key requirement, the $0.10 cost, and an important integrity constraint against inventing sources. This adds substantial behavioral context that the annotations alone do not provide.

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

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

The description is three short sentences: function, usage guidance, and cost/auth. Every sentence earns its place, and the most important 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?

Given the output schema exists and annotations cover safety, the description provides everything else an agent needs: the provenance strategy, when to invoke it, and operational constraints like API key and cost. Nothing critical is missing.

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

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

Schema description coverage is 100%, so the input schema already documents all parameters well. The description reinforces the notion of a 'claim' but does not add significant additional parameter semantics beyond what the schema provides.

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

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

The description starts with a specific verb and resource: 'Return evidence/provenance for a claim.' It goes further by naming the exact source types to consult and their precedence, which clearly distinguishes this tool from siblings like get_memories or get_life_graph.

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 an explicit trigger condition ('Use when the agent must cite why it believes something') and a clear negative behavior ('do not invent sources'). However, it does not explicitly name alternative tools or describe when NOT to use this tool beyond that one negative instruction.

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 meaningful behavioral context beyond the annotations: the result is 'compact' candidates, there is a $0.05 cost, and an API key is required. These details help an agent anticipate side effects and requirements.

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

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

The description is a compact two-sentence definition with no filler. The primary action and scope are front-loaded, and the routing hint, cost, and auth requirement are each given in clearly minimal phrasing.

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

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

With an output schema present, return-value documentation is covered, and annotations cover the safety profile. The description adds cost, auth, and a sibling preference. The only completeness gap is the undefined limit parameter, but overall the agent has enough context to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that person_id is a direct lookup key and that query can include alias/name/payment signals, giving meaning to two of the three parameters. The limit parameter is left unexplained, which is the only gap.

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

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

The description clearly states the operation: finding compact identity resolution candidates by person_id or query, and enumerates the query signals (alias/name/payment signals). It explicitly distinguishes itself from the bulk get_people sibling, which is exactly the kind of differentiation an agent needs.

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 direct routing guidance: 'Prefer over bulk get_people.' It also identifies the two input modes (person_id or query), making the intended use context reasonably clear. It does not exhaustively contrast with related search/resolve tools, but the explicit sibling preference is strong 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 signal read-only safety, and the description adds meaningful behavioral context: the operation costs $0.05 and requires an API key, which is beyond the structured annotations. It also discloses that the output can include a signed_url for download/processing, clarifying a key behavioral detail not present in the schema. No contradiction with 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 compact two-sentence definition with no filler. The primary action and resource are front-loaded, and the cost/api-key caveat is appended economically without disrupting the core message.

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

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

Given the low parameter count and existing output schema, the description provides the key context needed to call the tool: what it returns, the lookup method, cost, and authentication requirement. It falls slightly short only because it does not clarify the include_signed_url parameter's behavior, which is important for accurate 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?

With schema description coverage at 0%, the description must carry parameter meaning, but it only explicitly mentions asset_id and the concept of a signed_url. The optional boolean include_signed_url is not named or explained, leaving its effect ambiguous. This is a notable gap for an otherwise simple two-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?

The description uses a specific verb ('Fetch'), a clear resource ('one asset'), and the lookup key ('asset_id'), making the tool's core purpose unambiguous. It also states the return context ('signed_url for download/processing'), distinguishing it from sibling list-type tools like get_entity_assets or update-oriented tools like update_asset.

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 'Fetch one asset by asset_id' gives a clear and direct when-to-use scenario: retrieve a single asset when you have its ID. It also adds practical usage conditions, noting the $0.05 cost and API key requirement. However, it does not explicitly name alternatives or exclusion cases, such as when to use get_entity_assets instead.

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

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

Annotations already cover the safety profile (readOnly, non-destructive, closed-world), so the bar is lower; the description still adds real behavioral context by disclosing cost ($0.10), an API-key requirement, and the trip-status filter that governs what is returned.

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

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

Three tightly packed clauses with no filler; the scope constraint is front-loaded and the operational caveats (cost, auth) trail appropriately. Dense but every clause carries information.

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

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

With an output schema present, return values need not be described, and the inclusion rules plus cost/auth caveats are well covered. The gap is the two undocumented parameters, which leave the range arguments entirely unexplained.

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

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

Schema description coverage is 0% for the two parameters (to, from) and the description never mentions them or their expected format, so an agent gets no added meaning about the range semantics beyond the bare names.

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 resource (canonical cities) and its derivation scope (confirmed/completed trips only), which lets an agent distinguish it from the coarser get_countries_visited. It never says plainly that it returns a list, but the resource and scope are 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?

It gives inclusion/exclusion rules ('excludes soft pins / status=possible') and a data-derivation precondition (category=travel + structured location), which implies when the tool is populated. However it never names an alternative such as get_countries_visited or get_travel_history, nor states when to prefer this over them.

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

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

Annotations already mark the tool as read-only and non-destructive. The description adds useful context beyond that: it operates on the authenticated user, requires an API key, costs $0.20, and keeps location/money opt-in. No contradiction exists.

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 dense but efficient, front-loading the pack's purpose and sections before adding usage and pricing details. Every sentence earns its place, though the spec URL and pricing are packed into the last 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?

With a rich input schema, an output schema, and read-only annotations, the description covers authentication, cost, opt-in behavior, and section composition. The main gap is not explaining how this compares to get_life_context, given the overlapping name.

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

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

Schema description coverage is 100%, so the schema already documents all parameters well. The description adds only light grouping around a few include flags and a general opt-in note, but no significant new parameter semantics beyond what the schema provides.

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

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

The description clearly states what the tool returns: a Life Context Protocol pack for the authenticated user with specific sections (identity, pulse, who_matters, whats_next, memories, quiz_results). It is a specific verb+resource definition, but it does not explicitly differentiate from the similar sibling get_life_context.

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

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

Provides clear guidance on how to shape the response by passing include_relationships/include_memories/include_quiz_results as false, and clarifies that location and money are opt-in. It does not, however, state when to prefer this pack over sibling tools or individual getters.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable context beyond that: the data is canonical, derives from completed trips, excludes other people's travel, costs $0.10 per call, and requires an API key. No contradiction exists.

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

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

The description is extremely compact and front-loaded, with the core meaning first and the cost/auth note parenthesized. All words carry value, though the phrase 'not other people travel' is grammatically awkward and 'canonical' is undefined. Overall it is efficient, not bloated.

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 three optional and completely undocumented parameters, the description does not give the agent enough to call the tool correctly. The output schema and read-only annotations help, but the missing parameter semantics and the lack of explicit date-range/format guidance make this under-specified for a tool with multiple 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 0%, so the description must compensate for the undocumented 'to', 'from', and 'include_residence' parameters. It does not mention or explain any of them. The agent is left to guess whether 'from'/'to' are dates, ids, or something else, and what residence inclusion means.

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

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

The description clearly identifies the resource (countries) and the source scope (completed trips), and adds a distinguishing 'not other people travel' note. It does not use an explicit verb, but 'canonical countries from completed trips' is unambiguous enough for an agent to infer a retrieval operation.

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

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

The description implies when to use the tool (when the ask concerns canonical countries visited on completed trips, not cities or individual trips) but does not name any alternative tool or state explicit exclusions. Sibling tools like get_cities_visited or get_travel_history are present but not referenced, leaving routing 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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds the cost ($0.10) and API key requirement, which are useful operational constraints, but says nothing about what 'states' are, how they are filtered, or output behavior beyond what the output schema likely covers.

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 resource and includes cost/auth details. It is efficient, though the parenthetical may be too terse to be 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?

With an output schema present, return values need not be explained, but the description fails to explain the core concept of 'permitted assertion states' or how the temporal parameters affect results. For a tool with five parameters and 40% schema coverage, the description is incomplete.

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

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

Schema description coverage is only 40%, and the description provides no information about the five parameters (known_at, valid_at, people_id/person_id alias, predicates). Two parameters have schema descriptions (people_id and person_id alias), but the temporal and predicate parameters are undocumented, and the description does not compensate.

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 resource ('assertion states for a person') and implies a retrieval action, but the verb is not explicit and the phrase 'flagged life-graph; off by default' is ambiguous. It is distinguishable from siblings like get_life_graph or get_person_links only by the specialized 'states' concept, which is not clearly defined.

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 get_life_graph, get_context_pack, or get_life_context. The parenthetical about being off by default suggests limited availability but does not give actionable conditions for invocation.

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 read-only and non-destructive behavior, and the description's 'List' wording is consistent. It goes beyond annotations by disclosing that an API key is required and that the call costs $0.10, which is operationally useful for an agent deciding whether to call it.

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

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

The description is two compact sentences with no filler; the main verb is front-loaded and the cost/auth constraint is efficiently appended. The arrow notation is terse but packs useful parameter semantics into very few 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?

Cost, authentication, read-only intent, and some asset-type scope are covered, and an output schema exists so return format need not be described. However, with three un-described parameters, no enums, and many sibling tools, the description leaves enough ambiguity around entity_type values and the inventory mapping that invocation still requires inference.

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

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

With 0% schema description coverage, the description must explain parameters, and it partially does: the parenthetical likely enumerates asset_type values and 'entity_type inventory_item → inventory' adds domain mapping. But it leaves entity_id implicit and does not enumerate valid entity_type values, so the compensation for low schema coverage is incomplete.

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

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

The description clearly identifies the action ('List assets linked to an entity') and gives concrete asset-type examples (role, signed_url, versions), so an agent can tell what the tool returns. It does not explicitly contrast this with get_asset or get_inventory, so it misses the highest sibling-differentiation bar.

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

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

The intended use is implied by 'List assets linked to an entity,' and the 'entity_type inventory_item → inventory' hint is context-specific. However, there is no explicit guidance about when to choose this over get_asset/get_inventory or when it should not be used, which is noticeable given the large sibling list.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable context by stating the cost ($0.05) and auth requirement (API key), which are behavioral constraints not present in the structured metadata. It does not contradict any annotation.

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

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

A single sentence of about 13 words with no filler. The core action and scope are front-loaded, with cost and auth appended parenthetically. Every token earns its place.

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

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

Given the tool's simplicity, two required params, and an existing output schema, the description covers the purpose, entity types, cost, and auth requirement. The term 'graph edges' is somewhat technical but the output schema presumably defines the return shape. The only notable gap is lack of usage guidance, but that is covered by another dimension.

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

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

Schema description coverage is 0%, so the description must compensate. It partially does by enumerating the allowed entity_type values (event, trip, place, person) and implying entity_id is the identifier of that entity. However, it does not describe what IDs look like or the exact meaning of entity_id beyond that implication.

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

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

The description uses a specific verb ('List') and a specific resource ('graph edges') and names the valid entity types (event, trip, place, person). This clearly differentiates it from sibling tools like get_entity_assets or get_person_connections.

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 implies when to use the tool by scoping it to a specific entity type and graph edges, but it does not explicitly say when to use it over alternatives like get_life_graph or get_person_connections. There is no when-not-to-use guidance or mention of complementary 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 value by disclosing default exclusions (browsing noise excluded, archived excluded via include_archived flag), the range shortcut semantics (calendar year vs trailing), and the API key requirement plus cost. These behaviors go 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?

Three compact sentences pack significant behavioral detail: authentication scope, date preferences, shortcut semantics, default exclusions, cost, and API key requirement. Every clause earns its place with no filler.

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

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

With an output schema present and read-only annotations, the description covers the key operational aspects: date format, defaults, cost, auth, and filtering. It lacks explicit pagination guidance for the cursor parameter, which would matter for large result sets, but the overall tool complexity is handled well.

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

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

Schema description coverage is only 56%, so the description carries partial burden. It adds meaning for 'from' (preferred over range), 'range' shortcuts (calendar year clarification), and 'include_browsing' default. However, it doesn't explain 'cursor' pagination or 'kinds' acceptable values beyond the example in the schema.

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

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

The description identifies the tool as retrieving calendar events for the authenticated user, with specific filtering behavior. It clearly separates this from add/update/delete event siblings by using 'get' and specifying read semantics, though it doesn't explicitly name a sibling alternative like get_context_pack or get_memories that might overlap.

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: prefer explicit from/to dates, suggests shortcut range values, and explains that browsing noise is excluded by default. It doesn't explicitly state when not to use this tool versus alternatives, but the instruction to prefer explicit dates and the default exclusions give clear operational context.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only safety profile is covered. The description adds useful behavioral context beyond annotations: authentication requirements ('OAuth or a supported scoped credential'), API key requirement, and cost ($0.10). This is meaningful additional operational information.

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

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

The description is two short sentences with the core purpose front-loaded and the authentication/cost details appended compactly. Every sentence carries useful information with 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 zero-parameter tool with output schema present and annotations covering safety, the description is largely complete: it names the returned summary components, authentication requirements, and cost. The only minor gap is that it does not specify the time period or scope of the cashflow summary (e.g., all-time vs. current period), though this may be covered by the output schema.

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

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

The tool has zero parameters, so the schema offers no parameter documentation burden. Per the baseline for 0-parameter tools, a score of 4 is appropriate. The description adds no parameter details because none exist.

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

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

The description clearly states the tool returns an 'Authenticated user cashflow summary' with specific components: spend, income, net, and top spend categories. This gives a specific resource and output scope. It does not explicitly distinguish itself from siblings like get_transactions or get_money_between_people, but the summary purpose 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?

The description implies this is for the authenticated user's own cashflow summary and notes OAuth/scoped credential requirements. However, it does not explicitly state when to use this tool over alternatives, nor does it mention exclusions or alternative tools, leaving some usage inference to the agent.

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 read-only and non-destructive behavior. The description adds useful context by disclosing a $0.10 cost and API key requirement, which are behavioral constraints beyond the annotations. It does not mention pagination or filter specifics, but the annotations lower the burden.

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 communicates purpose, filtering capability, cost, and authentication requirement without any filler. It is efficiently front-loaded and 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 browse operation with no required parameters, an output schema, and read-only annotations, the description is mostly sufficient. The main gap is that the available filters are not enumerated, but this does not prevent a basic invocation and the overall context is adequate.

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

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

The tool has 0 parameters, so the baseline is 4. The description adds that filters are supported, which is meaningful even though the schema is empty and allows additional properties. It does not list filter names, but with no required parameters this 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 action ('Browse owned inventory') and mentions filters, making the core purpose clear. It does not explicitly differentiate itself from get_inventory_item or search_inventory, so it falls short of a 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?

No guidance is given on when to use this tool versus siblings like search_inventory or get_inventory_item. The phrase 'with filters' implies a browsing use case, but there are no explicit use conditions or alternatives.

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

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

Annotations already mark this as read-only and non-destructive, so the description is not burdened with safety disclosure. It adds meaningful context beyond annotations: the call costs $0.10, requires an API key, and returns a full item with related valuations, people links, and assets.

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 short and front-loaded with the most important functional information, followed by cost and auth requirements in parentheses. Every phrase earns its place, 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 an output schema and read-only annotations present, the description is adequate for a simple single-id retrieval: it states what is returned, the cost, and the API key requirement. It is not fully complete because it fails to distinguish this from the sibling list/get tools, which is relevant given the large sibling set.

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

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

Schema description coverage is 0%, and the description does not mention inventory_id at all. Although the parameter name and type are self-explanatory, the description provides no added meaning about what value is needed or how it maps to the returned item.

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

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

The description identifies the resource as a single inventory item and specifies what it contains ('valuations, people links, assets'), which is clear and useful. It does not explicitly name a sibling alternative, so it stops short of full differentiation from get_inventory or get_inventory_valuations.

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 choose this tool over the many related siblings like get_inventory, get_inventory_valuations, or get_entity_assets. It mentions API key requirement but does not state use cases or exclusions.

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

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

Annotations already indicate a safe read operation. The description adds useful behavioral context by disclosing the $0.10 cost and required API key, and by noting the chronological ordering of results. These details go 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 front-loaded sentence with a useful parenthetical for cost/auth. There is no fluff or redundant repetition of the tool name or title.

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 one required parameter, an output schema, and read-only annotations, the context is mostly sufficient. The description adds cost/auth and ordering behavior, though it could be more explicit about the inventory_id parameter and when to use this tool over siblings.

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 0%, so the description must compensate for the undocumented inventory_id parameter. It only refers to 'an item,' which provides minimal semantic context and does not explain the ID format, source, or relationship to get_inventory_item. The parameter name helps, but the description leaves most of the burden unmet.

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

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

The description states the tool returns a 'Chronological valuation history for an item,' which is a clear resource and scope. It does not explicitly contrast with siblings like get_inventory_item or add_inventory_valuation, but the word 'history' distinguishes it reasonably well.

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: an agent needing valuation history for an inventory item would choose this tool. However, there is no explicit guidance about when to prefer it over related tools such as get_inventory_item or add_inventory_valuation.

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 read-only and non-destructive, and the description adds meaningful context: authentication requirements via OAuth or scoped API keys, cost, and default inclusion behavior. This goes beyond the structured annotations and aligns with them, 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?

The description is three concise sentences that front-load the purpose and then cover defaults and auth/cost. Every sentence adds useful information without redundancy or filler.

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

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

For a read-only tool with zero required parameters, an output schema, and safe annotations, the description adequately covers defaults, opt-in location, and authentication. It is slightly thin on routing to more granular sibling tools, but an agent has enough to invoke the tool correctly.

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

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

Schema description coverage is 100%, so all three boolean parameters are already documented with defaults. The description reinforces the include_*=false pattern and the opt-in nature of location, but adds little new meaning beyond the structured schema. This fits the baseline where schema does the heavy lifting.

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

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

The description uses a specific verb ('Get') and names a composite resource ('snapshot of the authenticated user's current life context') with enumerated contents: identity, today/upcoming events, pulse, trackers. It also clarifies the optional relationship, memory, and location buckets. It does not explicitly differentiate from sibling tools like get_context_pack, so it is clear but not maximally distinct.

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

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

The description explains that relationships and memories are included by default and can be omitted via include_*=false, and that location is opt-in. This gives practical call-construction guidance but no explicit when-to-use versus alternatives such as get_memories, get_events, or get_trackers. Usage is implied by 'snapshot' rather than stated with exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to reassert safety. It adds valuable behavioral context by disclosing the private export scope, the cap behavior behind full=true, optional event-people links, the OAuth/scoped-credential requirement, and the $0.25 cost. This goes beyond what the annotations provide.

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

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

The description is compact and front-loaded: the first clause states what the tool exports, followed by the key flag, optional links, and auth/cost note. Every sentence earns its place, and there is no filler or redundant restatement of the tool name.

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

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

Given the output schema, annotations, and the tool's simple parameter structure, the description covers essential invocation details: scope, the full flag, optional links, auth, and cost. The only notable gaps are explicit guidance around the max_people/event_links_limit caps and alternatives, but these are not critical for a successful call.

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

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

With only 25% schema description coverage, the description must compensate for underdocumented parameters. It explicitly mentions full=true and 'Optional event-people links,' but it never names or explains max_people or event_links_limit, and 'larger capped list' is vague about the actual cap. This is only partial compensation for four parameters.

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

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

The description clearly identifies the action ('export') and the object ('private life-graph'), and it enumerates the graph's contents: favorites/VIP plus people with edges or recent event tags. It does not explicitly contrast with sibling tools like get_life_context or get_people, but the name and content make the purpose distinguishable.

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

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

The description implies usage context through phrases like 'Explicit private life-graph export' and 'Pass full=true for a larger capped list,' and it states an authentication requirement. However, it never explicitly says when to choose this tool over related siblings such as get_people or get_life_context, nor does it state exclusions or alternatives.

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

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

Annotations already mark this as read-only and non-destructive. The description adds useful behavioral context beyond those annotations: the result is a 'likely' estimate, includes confidence and provenance, requires an API key, and costs $0.10 per 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 sentence conveys the core purpose, uncertainty, provenance, cost, and authentication requirement without any filler. The most important information is front-loaded and 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?

Given one optional parameter fully documented in the schema, an output schema, and read-only annotations, the description covers the essential operational facts including cost and API key requirement. No critical information needed to invoke the tool correctly appears missing.

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

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

The schema already describes the only parameter, 'at', as an ISO timestamp with 100% coverage. The description adds meaning by distinguishing 'current' vs 'at-time', which clarifies that omitting the parameter yields the current estimate and providing it yields an estimate for that time.

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 names the resource, a place estimate at the current or a specified time, with confidence and provenance. It is understandable, though it lacks an explicit verb and does not distinguish itself from sibling tools like get_life_context or get_location_history.

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

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

The phrasing 'current or at-time place' implies this tool is for point-in-time location estimation, but the description does not explicitly say when to use it over alternatives or when not to use it. Cost and API key requirements are practical prerequisites, but 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 declare readOnlyHint=true, destructiveHint=false and closed-world scope, so the safety profile is covered. The description adds genuinely useful operational context beyond that: a $0.10 cost and requirement of an API key. It still says nothing about result volume, pagination, or the merge/deduplication behavior implied by 'Merges'.

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 compact sentences, front-loaded with the core purpose; the cost/auth parenthetical is efficient. It is telegraphic rather than wasteful, though the fragment style ('MCP/Uber digs') is an in-joke that consumes space without adding meaning.

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

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

An output schema exists, so return format need not be described, and the safety profile is covered by annotations. The remaining gap is the six entirely undocumented filter parameters, which leaves an agent guessing about how to scope a query.

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

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

Schema description coverage is 0%, so six parameters (to, from, city, place, country, precision) are documented nowhere. The description only hints at the precision dimension via 'venue-level by default'; it never explains what the date, city, place, or country filters do or how they combine.

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

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

States a specific verb+resource ('Normalized visit history') and adds scope detail (venue-level by default) plus the data sources it merges (GPS location_visits + place_visits), which helps separate it from get_place_visits. It does not explicitly name the sibling alternatives, so it stops short of a 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?

No guidance on when to call this versus get_place_visits, get_travel_history, get_location_context, or get_cities_visited, all of which sit adjacent in the sibling list. The only usage signal is the implied default granularity (venue-level), which is not framed as a selection criterion.

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 value beyond annotations by disclosing OAuth/scoped credential and API key requirements and the $0.10 cost. No behavioral trait contradicts 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?

Purpose is front-loaded, followed by usage guidance, alternative routing, and requirements in a compact form. Every clause contributes new information; no filler or redundant elaboration.

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 the input schema covering both parameters and an output schema present, the agent has all return and parameter details. The description fills the remaining gaps: when to prefer search, authentication needs, API key, and cost. This is complete for a read-only retrieval tool.

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

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

schema_description_coverage is 100%, so schema already documents both optional parameters. The description adds meaning to 'query' by stating it supports both semantic and keyword retrieval, which goes beyond the schema's 'Semantic focus' label. Limit semantics are left to the schema, which is sufficient.

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 a specific action and resource: retrieving authenticated user memories from Dayze Agent. It also distinguishes itself from sibling search by noting when search is preferred for event-first trip and calendar titles. This is more than a restatement of the name or title.

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 instructs passing a query for semantic/keyword retrieval and tells the agent to prefer search for event-first trip and calendar titles. It also discloses credential and API key prerequisites. This gives clear when-to-use and 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?

Annotations already cover read-only and non-destructive behavior. The description adds valuable operational traits beyond annotations: cost ($0.10), API key requirement, and the precise scoping 'authenticated user ↔ one contact via expenses FKs.' No contradictions with annotations.

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

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

The description is compact and front-loaded: it establishes the relationship to get_person_transactions first, then adds the alias rationale and cost constraints. Every sentence earns its place with no filler or redundancy.

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

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

With 100% schema parameter coverage, an output schema, safety annotations, and an explicit pointer to the sibling tool, the description is nearly complete. It could directly restate the return behavior instead of relying on 'Same as get_person_transactions,' but the alias framing makes this a minor gap.

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

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

Schema description coverage is 100%, so the baseline is 3 even without extra parameter details in the description. The description's scoping phrase 'one contact via expenses FKs' gives some context for person_id/name, but it does not add meaningful syntax or format details beyond the schema.

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

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

The description states the tool's function via 'Same as get_person_transactions: authenticated user ↔ one contact via expenses FKs,' which clearly specifies a verb, resource, and scope. It also distinguishes itself from the sibling by explicitly naming get_person_transactions and framing this as an alias, so an agent can tell them apart.

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 selection guidance: 'Prefer get_person_transactions; this alias exists for agent discoverability.' This tells the agent when not to use this tool and points to the preferred alternative, leaving no ambiguity about routing.

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