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

With no annotations provided, the description carries the full burden of behavioral disclosure. It partially satisfies this by describing the return value as a 'Formatted table,' but fails to disclose what 'providers' refers to (likely OpenTable/Resy given siblings), whether this operation is cached or hits live endpoints, cost implications, or rate limits. It does correctly imply this is read-only via 'Show'.

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 uses a structured docstring format (Args/Returns) that is clear and front-loaded with the main purpose. While slightly verbose compared to single-sentence descriptions, the structure is appropriate for the parameter documentation needed given poor schema coverage. No sentences 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?

Given the tool's placement among restaurant reservation APIs, the description inadequately explains the domain context—it should clarify that this tracks costs for the third-party restaurant APIs (OpenTable/Resy) managed by this server. While it documents the single parameter and mentions output format, the lack of domain linkage to siblings creates ambiguity about which APIs' costs are being tracked.

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

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

The input schema has 0% description coverage (the 'days' property has no description field), requiring the description to compensate. The Args section successfully provides this: 'Number of days to look back (default 30)' explains both the semantics and default value, effectively compensating for the schema's lack of documentation.

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

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

The description clearly states the tool 'Show[s] API usage costs broken down by provider' with a specific verb (Show) and resource (API usage costs). However, given that all 19 siblings are restaurant/reservation management tools (make_reservation, store_opentable_credentials, etc.), the description fails to clarify that this tracks costs for those specific restaurant APIs (OpenTable/Resy), which would help distinguish its purpose within this domain 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?

The description provides no guidance on when to use this tool versus alternatives. It does not indicate whether this should be checked periodically, before/after heavy usage, or how it relates to the credential storage tools. No 'when-not-to-use' or prerequisites are mentioned.

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

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

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It explains the selection logic (most recent upcoming when using restaurant name) and mentions return types. However, for a cancellation operation, it omits critical safety context such as irreversibility, refund implications, or notification 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?

Uses a structured docstring format with Args and Returns sections that frontload the essential information. The content is dense with no redundancy, though the Returns section is slightly superfluous given the existence of an output 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 presence of an output schema, the description appropriately avoids detailing return values. However, for a destructive operation (cancellation) with zero security annotations, the description should include warnings about irreversibility or required permissions to be 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 0% schema description coverage, the description fully compensates by documenting both parameters in the Args section. It clarifies that restaurant_name triggers a lookup while confirmation_id is specific, providing sufficient semantic context for the AI to populate arguments correctly despite the sparse 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 (Cancel) and resource (reservation), specifying support for Resy and OpenTable platforms. While it identifies the domain effectively, it does not explicitly differentiate from siblings like 'make_reservation' beyond the implicit verb difference.

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 guidance on parameter selection logic: 'Provide either the restaurant name... or a specific confirmation ID.' It clarifies that using the restaurant name triggers cancellation of the 'most recent upcoming' reservation, which is critical for correct invocation. Lacks explicit 'when not to use' guidance or named alternatives to sibling tools.

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

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

No annotations provided, so description carries full burden. Discloses multi-platform search scope (Resy/OpenTable), sorting behavior ('sorted by proximity to this time'), and empty-result handling ('message if none found'). Missing: explicit readOnly/safety declaration, rate limits, or auth requirements.

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

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

Uses efficient docstring format with clear Args/Returns sections. Front-loaded with core action. No redundant text—every sentence adds value (platform scope, date examples, sorting logic). Well-structured for parsing.

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?

Comprehensive given constraints. Covers 4 parameters with 0% schema coverage, explains output schema content ('time slots with platform info'), and behavioral nuances. Output schema exists so return values don't need full detailing. Could mention credential requirements for the platforms.

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 has 0% description coverage. Description fully compensates by documenting all 4 parameters with rich semantics: date includes flexible parsing examples ('Saturday', 'tomorrow'), party_size clarifies 'diners', preferred_time notes sorting side-effect. Comprehensive 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?

Clear specific verb 'Check' + resource 'reservation availability'. Explicitly mentions searching 'both Resy and OpenTable', which distinguishes it from sibling 'make_reservation' (which books) and 'search_restaurants' (which finds restaurants, not slots).

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 implicit context by describing multi-platform search behavior, but lacks explicit guidance on when to use this vs 'make_reservation' (e.g., 'use this to find available slots before booking'). No mention of prerequisites like stored credentials.

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

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

No annotations are provided, so the description carries the full disclosure burden. It correctly identifies the read-only nature via 'Show' and documents the return value ('formatted summary'), but omits details about authentication requirements, rate limits, data persistence, or whether results are cached versus real-time.

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?

Description is two efficient sentences with zero redundancy. The first sentence front-loads the core purpose with specific content categories; the second documents the return value. No filler text or tautology present.

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

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

For a zero-parameter read tool with existing output schema, the description is fully complete. It defines the resource scope (four preference categories) and acknowledges the return structure, satisfying all informational needs without over-documenting what the output schema already provides.

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

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

Input schema contains zero properties. Per scoring rules, zero parameters establishes a baseline of 4. The description appropriately avoids inventing parameter documentation where none exist 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 uses specific verb 'Show' with resource 'restaurant preferences' and enumerates exact scope (dietary restrictions, favorite cuisines, saved locations, dining defaults). The term 'current' clearly positions this as a retrieval operation, distinguishing it from sibling tools 'setup_preferences' (creation) and 'update_preferences' (modification).

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 read-only usage through 'Show' and 'current' but provides no explicit guidance on when to use this versus 'setup_preferences' or 'update_preferences'. The agent must infer from verb semantics rather than explicit directives.

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

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

With no annotations provided, the description carries the full disclosure burden. It effectively documents behavioral inputs (considers weather, recent visit history, group restrictions) and output characteristics (curated list of 3-5 items with reasoning). Missing only side-effect or rate-limit disclosures.

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?

Well-structured with clear summary, Args, and Returns sections. While verbose compared to highly condensed descriptions, the detail is necessary given zero schema coverage. Information is front-loaded and every section 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 5 optional parameters and output complexity, the description covers all inputs and describes return values (since no formal output schema exists). Could benefit from mentioning relationship to 'manage_group' for the group parameter, but otherwise 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?

Despite 0% schema description coverage, the Args section comprehensively documents all 5 parameters, including semantic enums for 'occasion' (date_night, casual, etc.) and valid values for 'location' (home/work/address). The description fully compensates for the bare schema.

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

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

The description opens with a specific action ('Get personalized restaurant recommendations') and clearly identifies the resource type. It distinguishes from sibling 'search_restaurants' by emphasizing personalization factors (history, preferences, weather) versus generic search.

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

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

While the description implies usage context through personalization emphasis (history, recent visits), it lacks explicit guidance on when to choose this tool over 'search_restaurants' or 'search_for_group'. The occasion parameter examples provide implicit usage guidance but no explicit 'when to use/when not to use' statements.

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

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

No annotations provided, so description carries full burden. It discloses 'merged dietary restrictions' revealing aggregation logic/computation on member data, which is valuable behavioral context. However, lacks disclosure on auth requirements, pagination, or performance characteristics for 'all' groups retrieval.

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

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

Two concise sentences. The 'Returns:' label is slightly formal/structured rather than flowing prose, but content is efficient with no wasted words. Business logic (merged restrictions) is front-loaded in the first 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?

Adequate for a simple list operation. Given output schema exists, the description appropriately avoids redundant return value specification while highlighting key business logic (dietary restriction merging) that schema likely doesn't capture.

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?

Zero parameters exist (empty schema), which per guidelines sets a baseline of 4. No parameter documentation needed.

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

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

Clear verb (List) + resource (saved groups) with specific scope including members and merged dietary restrictions. However, it does not explicitly differentiate from sibling tools like 'search_for_group' or 'manage_group' which likely overlap in functionality.

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 provided on when to use this versus 'search_for_group' (likely search/filter capability) or 'manage_group' (likely modification capability). No prerequisites or conditions mentioned.

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

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

No annotations provided, so description carries full burden. States it returns a 'Formatted list,' indicating read-only behavior, but lacks safety disclosures (e.g., 'does not modify data'), rate limits, or caching behavior. Adequate but minimal behavioral context.

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

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

Front-loaded with action. Two sentences total. The 'Returns:' section is slightly redundant given output schema exists, but overall efficient 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?

Appropriate for complexity: 0 params, output schema present. Description provides essential domain context (dining companions, dietary restrictions) not present in structural fields. Sufficient for agent selection.

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?

Zero parameters present per empty schema. Baseline score applies; description correctly implies no filtering arguments by stating 'all saved' companions.

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?

Excellent specificity: 'List' (verb) + 'saved dining companions' (resource) + 'dietary restrictions and notes' (scope/data). Clearly distinguishes from generic 'manage_person' sibling by emphasizing bulk retrieval of preferences.

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

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

No explicit when-to-use guidance or contrast with siblings. Missing direction such as 'use manage_person to edit individual companions' or when filtering is needed vs listing all.

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

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

No annotations provided, so full burden on description. It discloses the mutation (logging) and return value (visit ID), but lacks details on idempotency, duplicate handling, or persistence guarantees.

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?

Structured Args/Returns format is appropriate for 0% schema coverage. Every section earns its place, though the docstring-style format is slightly verbose compared to prose.

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?

Complete given constraints: handles zero schema coverage via Args block, references output schema value (visit ID), and connects to sibling functionality (adding reviews). Could explicitly reference rate_visit 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?

With 0% schema description coverage, the Args section fully compensates by documenting all 5 parameters with semantic meaning and examples (e.g., date formats, companion array structure). Minor deduction for slight discrepancy between schema default (null) and described default ('today').

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 opens with specific verb 'Log' and resource 'restaurant visit', immediately clarifying scope with parenthetical '(for places booked outside the system)' that distinguishes it from automatic logging.

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 defines when to use ('booked outside the system') and implies when not to use ('Visits booked through this assistant are logged automatically'), though it doesn't explicitly name alternative tools like make_reservation.

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

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

No annotations provided. Description mentions external platforms and return format but fails to disclose critical behavioral traits: requires prior credential storage (evident from store_*_credentials siblings), potential API costs (api_costs sibling exists), error handling for unavailable slots, and idempotency concerns. Lacks disclosure of mutation consequences.

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?

Well-structured with clear purpose statement upfront followed by constraint. Args section is necessary given poor schema coverage. Returns section is somewhat redundant given output schema exists, and docstring format adds slight verbosity, but overall efficient with 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?

Covers core functionality and all parameters well. However, for a complex external integration tool with 5 parameters and authentication dependencies (evident from sibling tools), it lacks critical context about credential prerequisites, cost implications, and error scenarios that would help an agent handle failures gracefully.

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 Args section comprehensively compensates by documenting all 5 parameters with clear semantics and concrete examples (e.g., date formats '2026-02-14'/'Saturday', time formats '19:00'/'7:00 PM', special_requests examples). Essential given schema lacks descriptions.

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

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

Description clearly states 'Book a reservation at a restaurant via Resy or OpenTable' with specific verb (book), resource (reservation/restaurant), and platform mechanism. Clearly distinguishes from siblings like check_availability (query) and cancel_reservation (deletion).

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

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

Explicitly states prerequisite 'Only call this after the user has confirmed they want to book', preventing premature invocation. However, omits mention that check_availability should logically precede booking and fails to reference credential storage requirements implied by store_resy_credentials/store_opentable_credentials siblings.

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

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

With no annotations provided, the description carries the full burden and successfully discloses the side effect on search/recommendation results and the personal scope ('your blacklist'). However, it lacks details on idempotency, error handling for invalid restaurant names, or persistence guarantees.

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 uses a structured docstring format with clear Args and Returns sections. It is front-loaded with the core purpose and maintains appropriate length, though the Returns section is somewhat redundant given the output schema context.

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

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

Given three parameters with zero schema coverage, the description adequately compensates with Args documentation. It covers the tool's primary effect and return confirmation, appropriate for a moderately complex mutation tool with an output schema.

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

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

With 0% schema description coverage, the Args section compensates effectively by documenting all three parameters: it clarifies restaurant_name, provides the specific enum values for action ('add'/'remove'), and explains reason's purpose. This adds substantial value beyond the raw schema.

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

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

The description opens with specific verbs ('Add or remove') and the resource ('restaurants from your blacklist'), then explains the functional consequence ('will never appear in search results or recommendations') which distinguishes it from sibling tools like manage_wishlist.

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

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

The description implies usage through the side effect explanation (use when you want to hide restaurants from search), but lacks explicit when-not guidance or direct comparison to siblings like manage_wishlist or search_restaurants.

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

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

With no annotations provided, the description carries the full burden and successfully discloses key behaviors: 'add' performs an upsert (create/update), 'remove' deletes, and return values include 'merged dietary restrictions'. It also notes the referential integrity constraint on members.

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?

Uses a standard docstring format with clear Args and Returns sections that are easy to parse. The Returns section is potentially redundant given the output schema exists, but the structure remains efficient and 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?

Comprehensive for a 3-parameter tool: covers operational semantics, prerequisite workflows, constraint handling, and return value structure. The description adequately compensates for the lack of schema annotations and the missing title field.

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?

Despite 0% schema description coverage, the Args block fully compensates by documenting all three parameters: group_name includes examples ('work_team'), action maps values to CRUD operations ('add' to create/update), and members specifies the data type and external dependency constraint.

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 specific verbs ('Create, update, or remove') and the exact resource being managed ('named group of dining companions'), clearly distinguishing it from siblings like 'manage_person' (individuals) and 'list_groups' (read-only operations).

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

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

Provides explicit prerequisite guidance that members 'must already be saved via manage_person', establishing a clear workflow dependency. However, it lacks explicit guidance on when to prefer 'list_groups' for verification or the specific consequences of duplicate group names.

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

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

With no annotations, the description carries the full burden and succeeds: it discloses case-insensitive name matching, upsert behavior (add creates OR updates), destructive capability (remove), and return value (confirmation).

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?

Uses a structured docstring format (Args/Returns) that efficiently packs information. Slightly more verbose than pure prose but appropriate given the schema coverage gap; zero 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?

Comprehensive for a CRUD person-management tool: covers all parameters, return values, and behavioral quirks. Given the 0% schema coverage, the description successfully provides everything needed for 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?

Exceptional compensation for 0% schema coverage: documents all 5 parameters with rich semantics including examples (e.g., ['nut_allergy', 'vegan']), allowed values ('add'/'remove'), and behavior (case-insensitive).

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 specific verbs (Add, update, remove) and a clear resource (dining companion), distinguishing it from siblings like list_people (read-only) and manage_group (group-level).

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 internal usage guidance for the 'action' parameter (add vs remove) and explains that 'add' creates or updates, but lacks explicit comparison to sibling tools like list_people or manage_group.

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

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

With no annotations provided, the description carries full disclosure burden, revealing the side effect ('boost in recommendations'), return type ('Confirmation'), and prerequisite constraint. Lacks details on idempotency or error states, but covers primary behavioral traits well.

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?

Follows a logical structure (purpose → side effects → prerequisites → parameters → returns). The common tags list is lengthy but justified as it substitutes for absent schema enums. No tautological 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?

Given moderate complexity (4 parameters, mutation semantics) and presence of output schema hints ('Returns:' section), the description adequately covers the workflow chain (search→wishlist→recommendation boost). Would benefit from explicitly referencing 'my_wishlist' for verification, but remains 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 0% schema description coverage, the text fully compensates by providing rich semantics: 'action' values explained ('add' vs 'remove'), 'notes' includes concrete example ('get the tasting menu'), and 'tags' documents format ('comma-separated'), examples, and enumerates common values serving as surrogate enum constraints.

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

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

Specifies the exact mutating actions (add/remove) on the wishlist resource and distinguishes from sibling tools like 'my_wishlist' (view-only) and 'search_restaurants' (discovery), while clarifying these are 'places you want to try in the future' vs immediate reservations.

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 prerequisite workflow: 'The restaurant must already appear in search results (search first)', directing users to the 'search_restaurants' sibling tool before invocation, and implies temporal use (future dining plans vs immediate booking).

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

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

No annotations provided, so description carries full disclosure burden. It valuablely specifies the dual-platform scope (Resy/OpenTable) and return structure. However, it omits safety characteristics (read-only vs destructive), rate limits, or the definition of 'upcoming' time window.

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

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

Two tightly constructed sentences with purpose front-loaded and return values secondary. No redundant words. Appropriate length for a parameter-less retrieval tool.

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

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

Adequate for a simple retrieval tool with existing output schema (per context signals). The description covers data source systems and return format. Minor gap: lacks explicit temporal scope definition for 'upcoming' and read-only safety assurance given the presence of destructive 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?

Zero parameters present, establishing baseline of 4 per rubric. Description correctly implies no filtering is available (returns 'all'), which matches the empty schema. No parameter explanation required or provided.

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?

Clear verb (Show) and resource (reservations) with specific scope (upcoming, across Resy/OpenTable). Distinguishes from visit_history (past) and cancel/make siblings by specifying read-only retrieval, though 'Show' is slightly less precise than 'List'.

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

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

No explicit guidance on when to use versus alternatives like visit_history or my_wishlist. No mention of prerequisites (e.g., requiring stored credentials from the store_resy_credentials or store_opentable_credentials siblings).

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

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

No annotations provided, so description carries full burden. It discloses return format ('Numbered list...with details') which adds value, but omits behavioral details like empty result handling, pagination, or caching behavior expected for a list operation.

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

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

Well-structured with clear sections: purpose statement, Args documentation, and Returns documentation. Every sentence earns its place; no verbosity or tautology. Front-loaded with the primary action.

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

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

For a single-parameter read operation with existing output schema, the description provides adequate coverage: it explains the parameter, the filtering behavior, and the return format. While additional behavioral details would help, it meets the bar for completeness given the tool's simplicity.

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

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

With 0% schema description coverage, the description compensates effectively via the 'Args:' section, explaining 'tag' semantics ('Filter by a single tag') and providing a concrete example ('date night'). This compensates for the undocumented schema property.

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?

Clear verb 'Show' and resource 'restaurant wishlist' establish specific purpose. However, it fails to explicitly distinguish from sibling 'manage_wishlist' (modification vs. viewing) or clarify read-only nature.

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

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

Mentions optional filtering ('optionally filtered by tag') but lacks explicit guidance on when to use this tool versus alternatives like 'search_restaurants' or 'manage_wishlist'. Sibling differentiation is absent.

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

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

With zero annotations, the description carries full burden. It adequately discloses persistence ('review was saved') and side effects ('improve future recommendations'), but omits error handling, idempotency, or validation rules (e.g., verifying the restaurant 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?

Well-structured docstring format with clear Args/Returns sections. Minor redundancy ('future recs' appears twice). Front-loaded purpose sentence is effective. Returns section is present despite output schema existing, which is acceptable but not strictly necessary.

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 6 parameters with empty schema, the description achieves completeness by fully documenting each parameter's semantics and providing return value description. Lacks only advanced behavioral edge cases (duplicate ratings, restaurant existence validation).

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?

Excellent compensation for 0% schema description coverage. Documents all 6 parameters with constraints (1-5 stars, enum values for noise_level), optionality markers, and rich examples including JSON structure for dishes.

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?

Clear specific verb ('Rate') + resource ('restaurant') + scope ('recently visited'). Distinguishes from sibling 'log_visit' by implying evaluation vs mere recording, and from 'get_recommendations' by being a write operation.

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

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

Provides implied context ('recently visited', 'improve future recommendations') suggesting when to use, but lacks explicit guidance distinguishing it from 'log_visit' or prerequisites like whether the visit must be logged first.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It successfully explains the key behavioral trait of automatically merging dietary restrictions across group members and discloses the return value structure ('Restaurant recommendations with notes on dietary compatibility'). It does not address potential rate limits or 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 well-structured with the value proposition front-loaded in the first two sentences, followed by Args and Returns sections. While the docstring format is slightly verbose, it is necessary given the zero schema coverage; every sentence adds value either explaining core logic or parameter semantics.

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 presence of an output schema (not shown but indicated), the description appropriately focuses on the tool's unique group-based filtering logic rather than return value details. It adequately covers the single required parameter constraint (group_name) and the tool's specific domain (dietary compatibility).

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 Args block in the description provides crucial semantic meaning for all five parameters (e.g., 'group_name: Name of the saved group,' 'location: Where to search near'), fully compensating for the lack of JSON schema documentation.

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

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

The description clearly states the tool 'Search[es] for restaurants suitable for a saved group' and distinguishes itself from the sibling 'search_restaurants' by emphasizing automatic merging of 'members' dietary restrictions.' However, it stops short of explicitly naming the sibling tool or contrasting use cases directly.

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

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

The description implies usage context by referencing 'saved group,' which suggests prerequisite setup via 'manage_group.' However, it lacks explicit guidance on when to prefer this over 'search_restaurants' (e.g., for individuals vs. groups) or warnings about required group existence.

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

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

No annotations provided, so description carries full burden. Adds valuable behavioral context: automatically applies saved dietary restrictions, cuisine preferences, rating thresholds, and blacklist. Describes return payload composition (ratings, prices, walking distance). Missing operational details: no mention of result caching, API rate limits, empty result handling, or whether 'blacklist' refers to personal or group exclusions.

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?

Well-structured with clear Args/Returns sections. Front-loaded purpose statement followed by auto-filtering behavior. Parameter descriptions are dense but necessary given zero schema coverage. Single minor redundancy: Returns section documents output format despite existence of output schema, though this adds field-level detail that may supplement the structured 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?

Adequate for tool complexity (7 optional parameters, behavioral auto-filtering). Compensates completely for lack of schema descriptions via Args section. Specifies return data fields. Could improve by noting NYC-only limitation implied by location parameter examples, and error handling for invalid addresses.

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?

Exemplary compensation for 0% schema description coverage. Documents all 7 parameters with rich semantics: 'location' accepts magic strings ('home', 'work') or NYC addresses; 'price_max' uses 1-4 scale with fallback to saved preferences; 'max_results' caps at 10; 'query' supports free-text features. Examples and constraints provided for every parameter.

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?

Clear verb-resource-scope: 'Search for restaurants matching your criteria near a location.' Specifies automatic application of dietary restrictions and blacklist, distinguishing it from generic search tools. However, it does not explicitly differentiate from sibling 'get_recommendations' or 'search_for_group' despite their functional 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?

Implies usage context through parameter documentation (e.g., 'Leave empty to search all cuisines'), but lacks explicit when-to-use guidance contrasting with 'get_recommendations' (algorithmic curation vs. criteria-based search) or 'search_for_group' (group context vs. individual). No exclusion criteria or prerequisites stated.

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

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

No annotations are provided, so the description carries the full burden. It discloses the return value ('Confirmation message with saved preferences summary') and documents all parameters, but omits critical behavioral details like whether calling this overwrites existing preferences, merges data, or requires specific authentication.

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?

Uses an appropriate docstring format with clear Args and Returns sections. Well-structured for a 12-parameter tool, though the Returns section could be more detailed. Every sentence serves a purpose.

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

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

Given the complexity (12 params) and lack of schema descriptions, the parameter documentation is thorough. However, it critically lacks differentiation from the 'update_preferences' sibling, which is essential context for a tool that claims to handle updates.

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?

Despite 0% schema description coverage, the Args section comprehensively documents all 12 parameters with types, examples (e.g., '["vegetarian", "nut_allergy"]'), and semantic context that compensates completely for the bare JSON 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 it handles 'restaurant preferences' with specific verbs ('Set up or update'), but it actively claims functionality ('update') that overlaps with the sibling tool 'update_preferences', creating ambiguity about tool selection.

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

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

It specifies when to call the tool ('when the user first configures the assistant or wants to change their profile'), but fails to mention the sibling 'update_preferences' or clarify when to prefer that tool over this one, despite the functional overlap implied by 'or update'.

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

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

No annotations are provided, so the description carries full disclosure burden. It successfully explains the security-sensitive nature (credential persistence) and privacy implications (chat history exposure risk). However, it omits details about storage persistence scope, encryption, or error conditions that would be valuable for a credential storage tool.

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

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

Excellent structure with front-loaded purpose statement, followed by necessary setup instructions, then Args/Returns sections. The CSRF extraction steps are lengthy but essential for usability. No redundant or wasted language—every sentence provides necessary guidance or context.

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

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

Comprehensive coverage for a credential management tool: explains purpose, security best practices, parameter semantics, return values, and setup prerequisites. Despite having no annotations and a schema with no descriptions, the description provides everything needed for correct invocation.

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

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

With 0% schema description coverage, the description fully compensates by providing detailed semantic meaning for all 5 parameters in the Args section. It explains not just what each parameter is (csrf_token, email, etc.) but also environmental variable alternatives and the purpose of personal data fields (reservations).

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 clearly states the specific action (save/store) and resource (OpenTable DAPI credentials) for the specific purpose of automated booking. The name and description clearly distinguish this from the sibling tool 'store_resy_credentials' by specifying the OpenTable platform.

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 excellent step-by-step instructions for obtaining the CSRF token and strongly recommends environment variables to avoid exposing secrets in chat history. Lacks explicit contrast with 'store_resy_credentials' regarding when to use each platform, though this is implicitly clear from the naming.

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

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

With no annotations provided, the description carries full disclosure burden and excels: it explains encryption, local-only storage, that data is only sent to Resy servers, and crucially that 'The password is NOT persisted after authentication.' It also clarifies immediate verification behavior ('error if login failed').

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?

Information-dense and well-structured with clear paragraph breaks and bold headers. Every sentence earns its place, particularly the security guarantees which are critical for a credential tool. Slightly verbose formatting with Args/Returns sections, but necessary given the lack of schema documentation.

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?

Excellent completeness for a sensitive security operation. Covers purpose, security model, storage lifecycle (password not persisted), parameter semantics, and return behavior. Since output schema exists, the brief return summary is appropriate and adds context about verification.

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?

Given 0% schema description coverage, the description comprehensively compensates by documenting both parameters in the Args section and explaining their relationship to environment variables ('or set RESY_EMAIL env var'), which the schema cannot express.

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 'Save' with the exact resource 'Resy account credentials' and clarifies the purpose is 'for automated booking.' It clearly distinguishes from the sibling store_opentable_credentials by specifying the Resy platform.

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 guidance on when to call with no arguments ('If env vars are set, call this tool with no arguments') versus providing credentials inline. However, it does not explicitly mention when to prefer this over store_opentable_credentials, though the distinction is implied by the platform names.

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

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

No annotations provided, so description carries full burden. It clearly discloses the PATCH-like merge behavior and states the return value ('Confirmation of what was changed'). Could improve by explicitly stating this is non-destructive to unspecified fields or mentioning idempotency.

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?

Well-structured with 'Args:' and 'Returns:' sections. Front-loaded purpose statement. Slightly verbose due to 9 parameters requiring inline documentation, but every line earns its place given the schema gap. Could be tightened by removing boilerplate 'Args:' and 'Returns:' labels.

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?

Comprehensive given complexity: documents all 9 optional parameters, explains partial-update semantics for the PATCH-like behavior, and mentions return confirmation. Output schema exists per context signals, so return value need not be detailed further.

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

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

Schema has 0% description coverage, but the description compensates exceptionally by documenting all 9 parameters with specific semantics: operation types (Replace full list vs Add/Remove single items), enum values for noise/seating preferences, and clear descriptions for thresholds.

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?

Clear verb ('Update') + resource ('preferences') + specific scope constraint ('without resetting everything'). The phrase 'Only provided fields are changed; everything else stays the same' precisely defines the partial-update semantics, distinguishing it from a full replacement 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?

Explains the critical partial-update pattern ('Only provided fields are changed'), which implicitly guides when to use this vs. a full setup/reset operation. However, it doesn't explicitly reference sibling tools like 'setup_preferences' or 'get_my_preferences' that would provide explicit alternatives.

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

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

No annotations provided, so description carries full burden. It discloses return format ('Formatted list...with dates, ratings, and notes'), which is helpful. However, omits pagination behavior, data freshness guarantees, or what happens when no history 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?

Uses structured 'Args:' and 'Returns:' sections that efficiently organize information. First sentence establishes purpose immediately. Slightly verbose repetition of default values already present in schema, but overall 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?

Appropriate for a read-only query tool with two optional parameters. Explains return values despite existence of output schema (per context signals). Could mention pagination for large histories, but sufficient for this complexity level.

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

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

Schema coverage is 0%, so description compensates by documenting both parameters: 'days' includes semantics (lookback period) and default value; 'cuisine' notes filtering purpose. Loses a point for vague cuisine value format (no examples or constraints provided).

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 specific verb 'Show' and resource 'restaurant visit history'. However, lacks explicit differentiation from siblings like 'log_visit' (which records visits) or 'my_reservations' (which could overlap conceptually).

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

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

No guidance on when to use this versus alternatives like 'my_reservations' or 'log_visit'. Missing prerequisites (e.g., authentication requirements) or exclusion criteria.

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