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

Annotations include destructiveHint: false, which already signals this is non-destructive. The description reinforces this by saying 'Add a new FAQ' but adds no additional behavioral context (e.g., whether it appends to the end, handles duplicates, or requires authentication). It does not contradict the annotation, but it also doesn't go beyond it.

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

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

The description is a single, front-loaded sentence with no waste. It conveys the action and target immediately.

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

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

For a simple create operation with 3 parameters all described in the schema, the description is sufficient for an agent to decide when to call it. It does not explain the return value, but with no output schema and low complexity, this is a minor gap.

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

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

The schema covers 100% of parameters with descriptions for question, answer, and display_order. The description mentions 'question + answer' but does not add any meaning beyond the schema. Since schema coverage is high, a baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Add'), a clear resource ('FAQ'), and the target ('website FAQ page'). It is unambiguous and distinct from the sibling update_faq and remove_faq tools, which are for modifying and deleting.

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

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

The verb 'Add' clearly implies creation rather than update or removal, and the presence of update_faq and remove_faq siblings makes the intent obvious. However, it does not explicitly state 'use update_faq for existing entries' or mention any conditions for when not to use this tool.

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

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

Annotations only include destructiveHint: false, with no readOnlyHint or other safety metadata. The description adds the structural detail that a guest group is a household, but it does not disclose side effects such as duplicate handling, how plus-one fields fit into the household, or what the response contains. For a create operation with minimal annotations, this is insufficient.

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

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

A single, front-loaded sentence with no filler. Every word earns its place, and the key distinction (guest group/household) is included without redundant detail.

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

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

With 7 parameters, no output schema, and minimal annotations, the description is too sparse to be complete. It doesn't state return values, error conditions, or how this tool relates to other guest list operations, though the schema does cover parameter semantics.

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 describes all 7 parameters at 100% coverage, so the baseline is 3. The description adds no additional parameter-level meaning beyond the household concept, and it doesn't highlight the required first_name/last_name or the affiliation default.

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

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

The description uses a clear verb ('Add') with a specific resource ('guest group (household)') and target ('guest list'). The parenthetical clarifies that this creates a household rather than an individual guest, which helps differentiate it from related guest tools, though it doesn't explicitly name any sibling alternatives.

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

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

No guidance is given about when to use this tool versus alternatives like invite_guest_to_event, set_event_guests, or update_guest_address. There are no prerequisites, exclusions, or context cues beyond the name and description, so an agent must infer the intended usage scenario.

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 declare destructiveHint=false. The description adds that this is a creation operation and names the content fields, but it does not disclose how optional fields like hidden or display_order behave, where the section is inserted, or whether it appends to the page. No contradiction with annotations.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes to identifying the action, target, and core content of the operation.

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

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

For a creation tool with five parameters and no output schema, the description is underspecified. It covers the required fields but gives no guidance on optional behavior, ordering, visibility, or return value, making it minimally viable but 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 0%, so the description must compensate. It names title, subtitle, and description, which correspond to the three required properties, but it entirely omits hidden and display_order, leaving two of the five parameters semantically unexplained.

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 ('Add') and resource ('story section to the home page') and lists the core content fields ('title + subtitle + description block'). It clearly distinguishes itself from siblings like update_home_section, remove_home_section, and list_home_sections.

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

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

The description gives clear context: this tool creates a new section on the home page. Sibling names imply that update_home_section is for modifying an existing section and remove_home_section for deleting one, but the description does not explicitly state these alternatives 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 only provide destructiveHint=false, so the description carries most of the behavioral burden. It discloses the destination page but says nothing about required permissions, duplicate handling, response behavior, or side effects of adding a POI.

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

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

A single, front-loaded sentence that conveys the essential action and scope with zero filler. It is appropriately concise for a straightforward CRUD tool.

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

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

For a 14-parameter mutation tool with no output schema and minimal annotations, the description is too thin. It doesn't mention required inputs beyond what the schema implies, nor does it clarify expected outcomes or failure modes.

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 29% schema coverage and 14 parameters, the description needed to compensate, but it adds almost no field-level guidance. It only hints at types of places, while leaving most parameter semantics to the sparse schema descriptions.

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

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

States a clear action ('Add') and a specific resource ('point-of-interest to the Things-to-Do page'), with helpful examples of what counts as a POI. This distinguishes it from update_poi and remove_poi.

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 clear: creating a new POI on the Things-to-Do page. It doesn't explicitly name alternative tools or exclusion cases, but the add/update/remove sibling structure makes the usage context evident.

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 provide destructiveHint: false, which is minimal. The description adds the default-collection lookup behavior, but this largely repeats the collection_id parameter schema. It does not disclose whether adding an already-present SKU is idempotent, what happens if the SKU is invalid, or what the tool returns after a successful add.

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, tightly worded sentence with no filler. The core action is front-loaded, and the only conditional detail — default collection lookup — is relevant and expressed efficiently.

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

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

For a straightforward add operation with a fully documented schema, the description is reasonably complete. It states the action, the identifier type, and the key default behavior. It does not discuss errors or return values, but the absence of an output schema and the simplicity of the operation make this only 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 schema fully documents all five parameters. The description adds little parameter meaning beyond the schema; it just confirms the SKU is used to identify the product and that collection_id defaults. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: "Add a product (by SKU) to the registry." This clearly differentiates it from sibling tools like update_registry_item, remove_registry_item, and search_registry_products, all of which act on registry items but are distinct actions.

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

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

The description gives no explicit guidance on when to choose this tool over alternatives like update_registry_item or remove_registry_item. It implies usage by its action verb, but does not state prerequisites, exclusions, or conditions under which a sibling tool would be more 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 clearly signals a create/insert action, which is consistent with destructiveHint=false. It adds minimal context beyond the annotation by naming the destination and item categories, but it does not disclose any side effects, duplicate handling, or validation 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 single front-loaded sentence with no wasted words. It is economical, though it could have used the saved space to add a bit more behavioral or parameter context.

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

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

For a tool with 19 parameters, no output schema, and only a sparse annotation, a one-line description is insufficient. It does not tell the agent about the two required fields (though the schema does), item-type-specific requirements, or how the operation integrates with the travel page in the broader workflow.

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 description only reiterates a subset of enum values from the 'type' parameter and does not explain required fields, address formats, or the meaning of source/country_code beyond the schema. With only 53% schema description coverage, the description should compensate but does not.

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

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

The description uses a specific verb ('Add') with a concrete resource ('travel item') and destination ('Travel page'), and enumerates the covered categories (hotel, flight, train, car, bus). This makes the tool's purpose unambiguous and distinguishes it from sibling tools like update_travel_item and add_poi.

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 'to the Travel page' gives a clear context for where the item will appear, and the verb 'Add' implies use when creating a new entry. However, it does not explicitly state when to prefer this over update_travel_item, remove_travel_item, or any alternative.

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 include destructiveHint=false, so the description carries most of the burden. 'Book a new vendor' indicates a creation side effect but says nothing about persistence, idempotency, required permissions, response behavior, or whether reference_vendor_id must come from a prior search.

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

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

The description is a single short sentence with no wasted words and is immediately understandable. It is concise, though extremely minimal for a tool with nine parameters.

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

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

For a creation tool with nine parameters, no output schema, and minimal annotations, this description is underspecified. It lacks guidance on when to use it, what the expected outcome is, and how the parameters relate to a real booking workflow.

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 nine parameters. The description adds no additional meaning about parameter relationships, required fields, or how vendor_type should be chosen.

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 'Book a new vendor' uses a clear verb and resource, and the word 'new' signals a create operation. It does not explicitly distinguish itself from related tools like update_vendor or search_vendors, though the intent is inferable.

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

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

The word 'new' implies this tool is for creating a vendor rather than updating or removing one. However, no explicit guidance is given about when to prefer this over search_vendors or update_vendor, and no prerequisites or exclusions 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?

The annotations only state destructiveHint=false, so the description carries the burden of disclosing behavioral details. It does not explain what happens if the seat is already occupied, whether the guest is moved from a previous seat, or whether the assignment overwrites existing data. The description adds no behavioral context beyond the tool's name.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to understanding the core action, and there is no unnecessary repetition of the schema or annotations.

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

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

For a mutation tool with four required parameters and no output schema, the description is too thin to be contextually complete. It omits workflow context, side-effect behavior, and any guidance about seat availability or reassignment, leaving important decisions to 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?

Schema description coverage is 100% and each parameter references its source (e.g., 'Seat UUID from get_seating_chart'), so the structured schema already explains parameter semantics. The description does not add additional parameter-level meaning, which matches the baseline score of 3.

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

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

The description uses a specific verb ('assign') and resource ('guest' to a 'specific seat' in a 'seating chart'), clearly distinguishing it from sibling tools like add_guest or invite_guest_to_event. It communicates exactly what operation the tool performs without ambiguity.

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

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

The description provides no guidance on when to use this tool, what preconditions exist, or how it relates to alternatives like get_seating_chart, list_unseated_guests, or remove_guest. An agent must infer the proper workflow from parameter descriptions alone.

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

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

The annotations only declare destructiveHint=false, so the description carries some burden for side effects and return values. It says only that a project is 'created,' providing no information about returned values, draft vs. finalized state, or other behavioral details. This adds little beyond what the tool name and annotations already imply.

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 clean, front-loaded sentence states the action and resource, and the parenthetical explains the lead variation. There is no wasted wording or redundancy 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?

The schema and annotation cover required inputs, optional quantity, and non-destructiveness, but there is no output schema and the description does not state what is returned after creation or how downstream tools like get_card_project or validate_card_project receive the result. Invocation inputs are fully specified, so the gap is moderate but not severe.

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

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

Schema coverage is 100%, with each parameter already documented in the schema: suite_uuid source, lead_variation_uuid size/paper/color, and quantity default 150. The description adds no meaning beyond re-stating the suite/variation relationship, so the baseline 3 applies.

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

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

The description uses a specific verb ('Create'), identifies the resource ('invitation project'), and names the two required inputs (design suite, lead variation). It clearly distinguishes this creation tool from siblings like list_card_projects, get_card_project, and swap_card_project_variation by emphasizing 'new'.

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

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

The description implies that creation requires an existing design suite and lead variation, and the word 'new' signals it is for creating rather than updating or validating. However, it does not explicitly state when to choose this tool over alternatives like validate_card_project or swap_card_project_variation, nor does it list 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. The description adds value by specifying the exact data returned (total budgeted, actual cost, paid, all budget items), which is beyond the annotation. No behavioral 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?

A single, front-loaded sentence that immediately states the purpose and lists key data fields. No wasted words.

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

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

For a zero-parameter read tool, the description fully explains what the tool returns. No output schema is present, but the description compensates by listing the returned data elements. No missing context.

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

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

The input schema has 0 parameters with 100% coverage, so the schema fully defines the parameter space. The description adds no param info but none is needed; baseline for no parameters is 4.

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

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

The description uses the verb 'Get' with the resource 'wedding budget summary' and lists specific data fields (total budgeted, actual cost, paid, all budget items). It clearly distinguishes from sibling tools like update_budget_item or list_* tools.

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

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

The description clearly implies when to use this tool (to retrieve budget summary), though it does not explicitly state when not to use it or suggest alternatives. No exclusions are needed given the tool's specificity.

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 readOnlyHint: true, the safety profile is already known. The description adds valuable context about the return payload's breadth—customizations, paper/color options, and pages—which is helpful given there is no output schema. No contradiction with annotations.

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

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

A single, front-loaded sentence communicates the resource, scope, and key included content with no filler. The parenthetical list is compact and informative.

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

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

For a one-parameter read tool with readOnlyHint and no output schema, the description adequately explains the scope and response contents. It could be more explicit about response format or error handling, but the essentials are present.

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

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

Schema description coverage is 100%, so the single project_uuid parameter is already documented. The description only restates 'one invitation project' and does not add further meaning about the parameter's format or behavior.

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

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

The description uses a specific verb ('get'), identifies the resource ('one invitation project'), and enumerates what is included ('all customizations... paper/color options, and per-customization pages'). This clearly distinguishes it from list_card_projects and related card tools.

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

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

The description conveys a clear use case: retrieve full details for a single project. The schema parameter description ('from list_card_projects') adds contextual guidance. However, it does not name alternatives or explicitly state when not to use this tool.

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

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

The annotation readOnlyHint=true already establishes the read-only nature, and the description is consistent. It adds useful behavioral context by specifying that the result includes font-size overrides for printed addressing, which is not derivable from the schema alone.

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

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

The description is a single, front-loaded sentence that states the action and resource immediately. It contains no filler and every element contributes to understanding the tool's purpose.

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

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

For a simple read tool with one well-documented parameter and a read-only annotation, the description sufficiently explains what is returned. There is no output schema, but the description covers the main output content and no critical information is missing.

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

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

The only parameter, project_uuid, has 100% schema description coverage, including guidance to obtain it from list_card_projects. The description adds no additional parameter-level meaning, so the baseline of 3 applies.

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

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

The description uses a specific verb 'List' and names the exact resource 'guest groups assigned to an invitation project'. The added detail about 'per-group font-size overrides' makes it distinct from generic guest list tools and from related siblings like set_card_project_guests.

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 or when-not-to-use guidance is provided. The description implies the tool's role as the read counterpart to set_card_project_guests, but it does not name alternatives or state exclusions, leaving usage to inference.

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

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

The readOnlyHint annotation already declares this is a safe read operation, so the description does not need to restate that. The description adds context about what data is returned (paper types, sizes, price range), which is useful, but it does not disclose any additional behavioral traits such as pagination, auth requirements, or rate limits. No contradiction with annotations 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 a single, well-structured sentence. It front-loads the action and resource, defines the key term 'suite' in a parenthetical, and lists the relevant return categories without any 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 single-parameter, read-only tool with complete schema coverage, the description provides enough information for correct invocation. It identifies the input source, clarifies the object type, and describes the output contents. No additional context is necessary for an agent to call this tool correctly.

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

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

Schema description coverage is 100%, and the schema already explains suite_uuid with examples of where to obtain it. The tool description itself adds no additional parameter-level detail, so it does not need to compensate. Baseline 3 applies because the schema carries the parameter documentation burden.

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

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

The description uses a specific verb and resource: 'Get details for an invitation design suite', and clarifies what a suite is ('family of matching invitation + RSVP + details cards'). It also names the data areas returned (paper types, sizes, price range), which distinguishes it from sibling tools like search_card_catalog and get_card_project.

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 schema parameter description says the suite_uuid comes from search_card_catalog or list_favorite_card_suites, which strongly implies this tool is used after those lookup tools and takes a UUID as input. However, it does not explicitly state when to prefer this tool over alternatives or when not to use it.

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

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

Annotations already declare readOnlyHint=true, consistent with description. The description adds value by specifying the return fields, which is beyond what annotations provide. 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?

Single sentence, concise, front-loaded with verb and resource. No extra 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?

Adequate for a simple read-only tool with no parameters. Lists return fields. Could mention edge cases (e.g., no theme set) but still complete enough.

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 has zero parameters and 100% coverage. Baseline is 3 as per guidelines. Description does not add parameter info (none needed).

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

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

The description clearly states the action 'get' and the resource 'currently-selected website theme', and lists the specific fields returned (key, name, swatch color, layout type). It distinguishes itself from siblings like 'search_themes' and 'update_current_theme'.

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?

Implied usage context: retrieve current theme. With sibling 'update_current_theme', the agent can infer when to use this read tool. No explicit exclusions or alternatives mentioned, but context is clear.

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

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

The readOnlyHint annotation already declares read-only behavior. The description adds specific data fields viewed, which is useful context. However, it doesn't disclose whether data is per-wedding, return format, or what happens if no gifts tracked.

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 a single concise sentence covering key points. Could be slightly improved with a colon or list structure, but no unnecessary 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?

Without an output schema, the description provides a reasonable expectation of return data (three components). It could mention scope (current wedding?) despite no parameters, but overall adequate.

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

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

The input schema has no parameters, so baseline is 4. The description adds meaning beyond the schema by stating the data returned (total gifts, values, thank-you status), which is sufficient for parameter-free tools.

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: viewing gift tracking data including total gifts, values, and thank-you note status. It uses specific nouns and distinguishes itself from sibling tools like get_registry that focus on registry items.

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

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

No guidance on when to use this tool versus alternatives (e.g., get_registry) or any preconditions. The description only states what it does, not when it should be invoked.

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 readOnlyHint annotation already communicates that this is a read operation, so the description does not need to restate that. The description adds useful context about what the response contains (messages and inquiry details), but it does not disclose anything about errors, authorization, or size/pagination behaviors.

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

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

A single, front-loaded sentence communicates the action, target, and included content with no redundant words. Every element earns its place.

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

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

For a simple single-parameter read tool with a readOnlyHint annotation, the description is sufficient: it tells the agent what the tool returns and where the UUID comes from. There is no output schema, but the description covers the return content well enough; only minor details such as ordering or response shape remain unspecified.

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 only parameter, uuid, is described as 'Inquiry UUID from list_inquiries,' so the schema does the heavy lifting. The description adds the 'vendor inquiry' framing but not additional parameter-level detail beyond the schema.

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

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

The description states a clear verb and resource: 'Get full conversation for a vendor inquiry,' and specifies the contents via 'including messages and inquiry details.' It is clear enough to distinguish from sibling read tools like list_inquiries, though it does not explicitly name a sibling 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 conveys the use case: fetching a full conversation for a vendor inquiry with messages and details)Skip – this implies it is the deeper dive compared to list-only tools. The parameter description adds guidance that the UUID comes from list_inquiries, but there is no explicit when-not-to-use or alternative routing.

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

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

The description states that purchase quantities and fulfillment status are 'derived,' signaling that these fields are computed rather than raw stored values, and it discloses pagination via limit/offset. These details go beyond the readOnlyHint annotation, which only establishes safety. No contradiction with the 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 front-loads the main action and resource, then packs the derived fields in parentheses and ends with pagination. 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 read tool with no required parameters and no output schema, the description gives enough: it lists the notable derived fields and confirms pagination. It omits a full response shape, but the listed fields plus the schema defaults are sufficient for an agent to call it correctly.

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

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

With 100% schema description coverage for limit and offset, the schema already documents both parameters. The description adds only the high-level 'Paged via limit/offset' note, which reinforces rather than extends the schema. Baseline 3 applies.

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

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

The description opens with the verb 'View' and a precise resource, 'the couple's registry items,' and then specifies the distinguishing output: derived purchase state per item. This clearly separates it from mutation siblings like add_registry_item and update_registry_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?

It establishes a clear use case: retrieve registry items along with derived purchase-state fields, and the paging behavior is stated. However, it does not explicitly contrast itself with related read tools such as get_gift_tracker or reconcile_registry, so the when-to-use guidance is implied rather than explicit.

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

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

With readOnlyHint=true annotation, the description adds minor context about the returned fields (title, intro copy, etc.), but does not disclose any behavioral traits beyond what annotations already imply. No mention of side effects or limitations.

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

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

The description is a single sentence with no wasted words. It front-loads the verb and resource, and efficiently conveys the purpose and scope.

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

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

Given the tool has no parameters and no output schema, the description adequately lists representative fields. It could be more complete by noting that it returns a full RSVP page settings object, but the coverage is sufficient for understanding its purpose.

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

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

The input schema has zero parameters with 100% schema description coverage, so there is no structural deficiency. The description adds meaning by listing example fields (title, intro copy, visibility, customization) that the tool returns, going beyond the empty 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 'Get the RSVP page settings on the wedding website' with specific examples of fields (title, intro copy, visibility, customization). This is a specific verb+resource that distinguishes it from generic 'get_website_customizations' or 'get_wedding_settings'.

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

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

The description implies usage for retrieving RSVP page settings, but does not explicitly state when to use this tool over alternatives like 'get_website_customizations' or 'list_pages'. No guidance on exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=true, covering the safety profile. The description adds useful content expectations (tables, seats, occupants) but does not disclose error handling or what happens for an invalid UUID. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately conveys the action and the return scope.

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

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

For a low-complexity read-only tool with one well-documented parameter and a readOnly annotation, the description adequately explains what the tool returns. The lack of an output schema is mitigated by the explicit content enumeration in the description.

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

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

Schema description coverage is 100% for the single uuid parameter, so the schema fully documents it. The description adds no further parameter detail, but none is necessary for such a simple 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?

The description states a specific verb ('Get') and resource ('seating chart'), and specifies scope ('full' with all tables, seats, and current occupants). This clearly distinguishes it from siblings like list_seating_charts and assign_seat.

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

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

The description implies use when a complete seating chart is needed, but it does not explicitly contrast with list_seating_charts for enumerating charts or assign_seat for modifying seats. No when-not or alternative guidance is provided, though the intended use is inferable.

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

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

The readOnlyHint annotation already establishes this is a safe read operation, and the description enhances it by enumerating the major data sections returned. For a simple retrieval tool, this is useful, though it stops short of describing exact response structure or any 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?

The description is a single, compact sentence that precedes all relevant content immediately. There is no redundancy or filler, and the main purpose 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?

For a one-parameter read-only getter with a fully documented schema, the description is sufficient. It names the resource, the identifier source, and the expected detail categories, so an agent can invoke it with confidence even with no output schema.

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

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

Schema description coverage is 100%, and the schema already documents the sole parameter `uuid` with a helpful source hint ('from search_storefronts or list_favorites'). The description does not add additional parameter-level meaning, so the baseline score is appropriate.

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

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

The description clearly states a specific verb ('Get'), resource ('vendor storefront'), and key content areas ('pricing, reviews, photos, about, FAQs'). It distinguishes this from search-oriented siblings by signaling it returns full details for a single storefront rather than a list of results.

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

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

No explicit guidance on when to use this tool versus alternatives like search_storefronts or list_favorites is provided in the description. The parameter description in the schema hints at chaining after search/list, but the description itself does not elaborate on usage context 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 provide readOnlyHint=true, so the safety profile is clear. The description adds that it retrieves 'current' settings and 'available options', providing some context beyond annotations but not extensive 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?

The description is a single sentence of 13 words, no waste, front-loaded with action and resource. Every word contributes.

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 no output schema and no parameters, the description adequately states what the tool returns. It could be slightly more complete by mentioning the response structure, but it suffices for a simple getter.

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 no parameters, and schema coverage is 100% (empty). The description adds meaning by specifying what the tool returns, which is sufficient for a parameterless 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 clearly states the verb 'Get' and the specific resource 'current website colors, font settings, and available font/color options'. It distinguishes the tool from siblings like get_current_theme and update_website_customization by focusing on customization options.

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

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

The description does not explicitly state when to use this tool versus alternatives (e.g., get_current_theme). It implies usage for retrieving customization settings but lacks when-not-to-use or alternative recommendations.

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=true, indicating a safe read operation. The description adds that it returns an overview of invites, paper, and planning progress, but does not disclose additional behavioral traits such as response format or data freshness. With annotations covering read safety, the description provides adequate but not rich context.

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

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

A single sentence front-loads the purpose and enumerates key content areas. Every word is necessary, with no redundancy or extraneous detail.

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

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

For a parameterless read tool with no output schema, the description sufficiently conveys the tool's function and output scope (dashboard overview). It could optionally mention the format, but is adequate for selection and basic understanding.

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

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

There are no parameters (0 params, 100% schema coverage). Baseline of 4 applies. The description adds meaning by specifying what the dashboard overview includes, which helps the agent understand the output content.

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

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

The description clearly states 'Get the wedding planning dashboard overview' with specific content areas (invites, paper, planning progress). It distinguishes itself from sibling 'get_' tools like get_budget or get_card_project by specifying it returns a dashboard overview.

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

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

No guidance is provided on when to use this tool versus alternatives. The description only states what it does, without mentioning context, exclusions, or prerequisites.

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

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

The annotation 'readOnlyHint: true' already indicates no side effects. The description adds no further behavioral context (e.g., auth needs, rate limits). It is adequate but not enriched beyond the 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?

The description is a single sentence that efficiently lists the returned fields with no redundancy or unnecessary 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?

The description covers what the tool returns. Given no output schema, it could mention that it returns a single object, but the context is sufficient for a simple getter. Minor improvement possible.

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 no parameters and the schema coverage is 100%. According to guidelines, zero parameters baseline is 4. The description correctly implies no inputs needed.

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

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

The description clearly states the action ('Get') and the resource ('top-level wedding settings'), and lists the specific fields returned. This distinguishes it from sibling tools like 'update_wedding_settings' and other 'get_*' tools.

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

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

Usage is implied as a simple retrieval of wedding settings, but no explicit guidance is given on when to use this tool versus alternatives. There are no prerequisites or exclusion criteria 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?

Annotations already declare idempotentHint=true and destructiveHint=false, and the description reinforces idempotency. It adds value beyond annotations by explicitly stating the additive nature ('does not affect other events') and the mutual-exclusion requirement, which are not fully captured by the schema alone.

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

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

Three short sentences, all substantive: purpose, additive scope, the exactly-one semantic, and idempotency. No filler or repetition; the most important constraint 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?

The description covers purpose, scope, idempotency, and parameter exclusivity. For a 3-parameter tool with no output schema and no nested objects, this is sufficient for an agent to select and 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 coverage is 100%, so the schema fully documents event_id, guest_id, and guest_group_id with descriptions. The description adds the critical cross-parameter constraint 'Pass exactly one of guest_group_id or guest_id', which materially improves correct invocation beyond the schema.

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

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

The description states a specific verb ('Invite'), a clear resource ('a single guest or guest group to an event'), and the additive scope ('does not affect other events'). This distinguishes it from related siblings like set_event_guests and remove_event_invitation.

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

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

The description gives clear context for use: it is additive, idempotent, and requires passing exactly one of guest_group_id or guest_id. It does not explicitly name alternative tools or exclusion conditions, but the additive framing makes the intended use reasonably unambiguous.

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

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

Annotations already declare readOnlyHint=true, and the description adds scope details (invitation categories, paper/digital) and output fields. It does not contradict the annotation, and the extra context is useful but not extensive; there is no mention of pagination behavior or the meaning of the returned 'customizations' beyond the schema.

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

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

The description is a single efficient sentence that front-loads the action and resource, then adds a compact list of return fields. Every phrase 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?

For a read-only listing tool, the description covers the resource, scope, and returned fields, while the schema fully documents both optional parameters and defaults. It does not explicitly mention how to fetch a single project or search the catalog, but those are covered by sibling tools and are not necessary for calling this tool correctly.

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

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

Schema description coverage is 100%: both 'limit' and 'include_completed' have clear inline descriptions, including defaults. The tool description itself adds no parameter-specific detail, so the baseline of 3 is appropriate rather than higher.

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: list the user's card projects. It scopes the resource precisely with 'invitation / save-the-date / shower-invite' and 'paper or digital', which distinguishes it from catalog search and single-project fetch siblings. The listed return fields further clarify what this tool produces.

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 'your ... card projects' implies this is for listing the current user's own projects rather than searching the catalog or retrieving a single project, but it does not explicitly name alternatives or state when NOT to use it. The usage context is implied rather than stated, so it stays at the rubric's midpoint.

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. Description adds that it lists all events with RSVP counts, but does not disclose additional behavioral traits like response format or ordering.

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

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

Single sentence, front-loaded with verb, no unnecessary 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?

Adequate for simple list tool with no params; provides examples and notes RSVP counts. However, lacks details on response structure or ordering.

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?

No parameters in schema; schema coverage 100%. Baseline 4 for 0 params, description does not add parameter info but is not 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?

Description clearly states verb 'List', resource 'wedding events', and adds context with 'RSVP counts' and examples (ceremony, reception, etc.). Distinguishes from sibling tools like list_guests.

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 for listing events with RSVP counts, but no explicit guidance on when to use this vs alternatives, or when not to use.

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

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

Annotations provide readOnlyHint=true, and the description confirms a read operation. No additional behavioral details needed; 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?

Single sentence, front-loaded with key information (verb and resource), no unnecessary 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?

With no parameters and no output schema, the description provides complete information for a simple list-all tool. Context from sibling tools further clarifies its role.

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?

No parameters exist, so the description does not need to add parameter information. Baseline score of 4 applies.

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

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

Description clearly states a specific verb (List) and resource (all FAQs on the wedding website), distinguishing it from sibling tools like add_faq and remove_faq.

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

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

No explicit guidance on when to use this tool versus alternatives, but the simplicity of the tool (no parameters, read-only) makes it implicitly clear for retrieving all FAQs.

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 provide readOnlyHint=true. Description adds context that it lists favorited suites, but doesn't disclose additional behavior like ordering or pagination. With annotations, this is acceptable.

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

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

Single sentence with no waste. Verb front-loaded, clear and concise.

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

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

Simple tool with no parameters and no output schema. Description is fully adequate for the task.

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?

No parameters, so baseline 4. Description doesn't need to add parameter info as schema coverage is 100%.

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' with specific resource 'invitation design suites you have favorited (hearted)'. Distinct from sibling 'list_favorites' which likely lists all favorites.

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 vs alternatives. Implies it's for listing favorited card suites, but doesn't mention sibling tools like 'list_favorites' that could be 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 indicate readOnlyHint, but description adds that it lists only favorited/saved vendors, providing behavioral context beyond the 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?

Single, front-loaded sentence with no unnecessary words, effectively communicating the tool's purpose.

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

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

For a simple tool with no parameters and no output schema, description adequately covers what the tool does; no major gaps but could mention pagination if applicable.

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?

No parameters in input schema; baseline score of 4 applies as description does not need to add parameter meaning.

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

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

Description uses specific verb 'List' and resource 'favorited/saved vendors', clearly differentiating from sibling tools like list_vendors that list all vendors.

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/why to use this tool versus alternatives like list_vendors; usage context is implied but not stated.

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

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

Annotations declare readOnlyHint=true, and the description is consistent with that. It adds useful behavioral context beyond the annotation: exactly which fields are included in the default compact view and what full includes. It does not discuss pagination or potential size limits, but the read-only nature and field-level detail are disclosed.

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

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

Two dense sentences with no filler. The primary behavior is front-loaded, and the conditional instruction about view:full is clearly attached to the relevant scenario. Every sentence adds value.

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

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

Given one optional parameter, a rich schema description, a read-only annotation, and a read operation with no output schema, the description is sufficiently complete for an agent to select and invoke the tool correctly. It covers scope, fields, and the full-view switch.

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

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

The input schema already provides 100% coverage for the single parameter, including a detailed explanation of compact vs. full response shapes. The description repeats this guidance rather than adding new semantic meaning beyond the schema, so 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 ('List'), a specific resource ('all guest groups (households)'), and the output's scope ('with stats'). It clearly distinguishes itself from sibling tools like list_unseated_guests by indicating it returns all guest groups, not just unseated ones.

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

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

The description gives clear context on when to use the compact default versus view:full, explicitly saying to pass full when contact details are needed. It does not explicitly name sibling alternatives or exclusions, but the guidance about when to request full details is actionable and clear.

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

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

Annotations already declare readOnlyHint=true, so the description does not need to reiterate safety. However, the description adds no further behavioral context (e.g., whether the list is ordered, if sections can be empty). It is neutral but does not enhance transparency beyond the 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?

The description is a single, concise sentence that conveys the exact purpose. It is front-loaded with the verb and resource, and every word earns its place. No unnecessary 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?

Given the tool's simplicity (no parameters, no output schema, read-only annotation), the description is largely complete. It could optionally mention that the result is a list, but 'List the story sections' inherently implies that. Thus it is adequate but not exhaustive.

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

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

There are zero parameters, and schema description coverage is 100% (the schema is empty). The description does not need to explain parameters. Baseline score of 4 applies for zero-parameter tools.

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 specifies the verb 'List' and the resource 'story sections on the website home page', distinguishing it from sibling list tools like list_pages or list_guests. It leaves no ambiguity about the tool's function.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as list_pages or other listing tools. It only states what it does, leaving the agent to infer context from the tool name alone.

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

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

Annotations already mark readOnlyHint=true, so the description does not need to reiterate. It adds minor context about the output fields, but does not disclose pagination, ordering, or limits. Adequate but not exemplary.

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

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

Single sentence, front-loaded with action verb 'List', no redundant words. Efficient and to the point.

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

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

With no output schema, the description provides enough context by listing the fields returned. However, it omits details like whether the list is sorted, paginated, or filtered. Still, for a simple list tool, it is mostly 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?

No parameters in schema, so the description does not need to explain any. Baseline 4 for zero-parameter tool is appropriate; no additional meaning 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?

Description clearly states the action (list) and resource (vendor inquiries) and specifies the fields returned (status, vendor name, unread flag). It is specific enough to distinguish from sibling list tools like list_guests or list_vendors.

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

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

No guidance on when to use this tool versus alternatives like get_inquiry_conversation or mark_inquiry_read. No mention of prerequisites, context, or exclusions. Sibling tools are many but no comparative hints.

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

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

Annotations already declare readOnlyHint=true, so the description adds value by specifying the exact fields returned. It does not disclose any additional behavioral traits beyond what annotations indicate.

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

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

Single sentence with no filler; front-loads the purpose and efficiently lists the output fields.

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

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

For a zero-parameter, read-only list tool with no output schema, the description sufficiently explains what the tool returns. It omits ordering details but the output field 'display order' implies the list order.

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

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

No parameters exist, so the description carries no burden. Baseline of 4 is appropriate as there are no parameter details to add.

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

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

The description uses a specific verb 'list' and resource 'pages', and clearly enumerates the output fields (IDs, types, display order, visibility, theme info), distinguishing it from sibling list tools.

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

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

No explicit when-to-use or when-not-to-use guidance is provided, but the tool is self-explanatory as a simple list operation with no parameters. Usage is 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?

The readOnlyHint annotation already indicates this is a read-only operation. The description does not add further behavioral details such as pagination, ordering, or response format. It is adequate for a simple list tool but lacks additional context.

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

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

The description is a single, clear sentence with no filler. It efficiently conveys the tool's purpose.

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

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

Given the tool has no parameters, a readOnly annotation, and no output schema, the description is sufficiently complete. It provides the location context, but could optionally mention the format of the list (e.g., array of objects).

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

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

There are zero parameters, so the baseline is 4. The description does not need to add parameter meaning beyond the schema, as 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 verb 'list' and the resource 'points-of-interest', and specifies the location 'on the "Things to Do" page'. This effectively differentiates it from sibling tools like 'add_poi', 'remove_poi', and 'update_poi'.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It is implied that one uses it to retrieve the list, but no context about when to prefer it 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 declare readOnlyHint=true. The description adds transparency about the return fields (UUID and event name), which is beyond the 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?

Single sentence, concise, and directly states the tool's functionality without any fluff.

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

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

For a simple list tool with no parameters and only one output field mentioned, the description is complete enough. It does not explain additional context like pagination, but for this tool it may not be needed.

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

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

No parameters exist (schema coverage 100%), and the description adds no parameter info, which is appropriate given there are none to document.

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

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

The description clearly states it lists all seating charts and specifies the returned fields (UUID and event name). It distinguishes itself from sibling tools like 'get_seating_chart'.

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 implicitly makes it clear when to use this tool (to list all seating charts) but does not explicitly state when not to use it or mention alternatives.

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

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

Annotations already declare readOnlyHint=true, so the read-only nature is known. Description adds context about the scope (Travel page), which is beyond the annotation.

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

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

One clear sentence with no unnecessary words. Perfectly concise for the information needed.

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 no parameters and no output schema, the description adequately explains what the tool does. Could optionally mention return type (list), but not required for completeness.

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

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

No parameters exist, so schema coverage is 100% by default. Description adds value by specifying what is listed (hotels, flights, transportation) and where (Travel page), which is meaningful beyond the empty 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?

Clearly states it lists hotels, flights, and transportation on the Travel page, specifying the verb and resource. Distinguishes from sibling list tools like list_guests or list_vendors.

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 or when-not-to-use guidance, but context from sibling tools (add/update/remove_travel_item) implies usage for viewing existing travel items. Adequate but minimal.

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, so the description's statement about listing unseated guests adds specific behavioral context beyond the 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?

Single sentence of 10 words, no redundant information, perfectly concise.

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

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

Adequate for a simple read-only tool with no parameters and no output schema. Could mention return type but not essential.

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?

No parameters exist; schema coverage is 100%. Baseline 4 applies as no parameter documentation is needed.

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

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

The description clearly states the verb 'List' and the specific resource 'guests who have not yet been assigned a seat', distinguishing it from sibling tools like list_guests (all guests) and assign_seat.

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

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

No guidance on when to use this tool versus alternatives like list_guests. The description is purely functional with no contextual advice.

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, so the description does not need to reiterate safety. It adds value by specifying 'booked' vendors and 'with details', providing context beyond the annotation. However, it lacks details on pagination or ordering, which are minor gaps given no parameters.

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

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

The description is a single concise sentence with no unnecessary words. It front-loads the key action and resource, and every word adds value.

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

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

Given the tool's simplicity (no parameters, no output schema), the description is largely complete. It states the scope and that details are returned. However, it could mention if there is any default ordering or if the list is exhaustive, but these are minor omissions.

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?

Since there are zero parameters and schema coverage is 100%, the baseline is 3. The description adds no parameter information, but none is needed.

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

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

The description clearly states the verb 'list', the resource 'vendors', and the scope 'all booked vendors with details'. It effectively distinguishes from sibling tools like search_vendors (which implies filtering) and add/remove/update vendors.

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 when you need a complete list of all booked vendors, but it does not explicitly mention when to use this tool versus alternatives like search_vendors for specific queries. No when-not-to-use or alternative guidance is provided.

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

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

Annotations only declare destructiveHint=false, so the description carries most of the behavioral burden. It does clearly state the state-change nature ('mark as read'), but it does not mention idempotency, whether there is a response, or any effect on other state (e.g., unread counts). For a simple mutation, this is adequate but not richly transparent.

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

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

The description is a single front-loaded sentence with zero filler. Every word contributes to the core action and resource, making it optimally concise for the tool's simplicity.

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

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

For a one-parameter, no-output-schema mutation tool, the description tells an agent what it does and the schema tells it what to pass. It lacks any note on return values or success indication, but given the trivial action and the annotations, the essential context for correct invocation is present.

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

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

Schema description coverage is 100%, with the uuid parameter already described as 'Inquiry UUID from list_inquiries'. The description adds no further parameter-level detail beyond naming the resource type, so it neither compensates nor detracts from the schema. Baseline of 3 applies.

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

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

The description uses a specific verb ('mark') with a clear resource ('vendor inquiry conversation') and the resulting state ('as read'). It clearly distinguishes this mutation tool from siblings like list_inquiries or get_inquiry_conversation, which read or list rather than change state.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives, such as calling it after get_inquiry_conversation or only for unread inquiries. The intended use is only implied by the verb and resource, offering no exclusions or contextual prerequisites.

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

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

Given the annotation readOnlyHint=true, the description adds value by stating that it is a preview operation, implying no side effects. It also mentions text substitution and return of template structure, which goes beyond the annotation's bare read-only hint. No contradiction with annotations.

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

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

Two sentences with no filler, front-loading the core purpose and a clear use case. The second sentence specifies the output, which is useful but concise. Every word earns its place.

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

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

For a read-only preview tool with a rich schema and a simple output description, the definition is largely complete. The absence of an output schema is partially mitigated by mentioning it returns 'template structure including page layouts'. Could specify that it returns rendered images or whether it is synchronous, but these are minor gaps 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?

Schema description coverage is 100%, so each parameter is already documented. The description adds context that the tool substitutes placeholders, but it doesn't provide additional semantics beyond what the schema covers. Baseline 3 is appropriate because the schema carries the meaning for 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, resource, and purpose: render a preview with text substitution. It distinguishes itself from sibling tools like create_card_project or validate_card_project by focusing on previewing, and the mention of returning template structure with page layouts adds specificity.

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

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

The description implies when to use it—to see how a design looks with specific names and date. It doesn't explicitly state when not to use it or mention alternative tools, but the sibling names are clearly about other operations (create, validate, swap), so the context is clear without explicit exclusions.

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

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

The readOnlyHint annotation already establishes that this is a safe read operation. The description adds useful behavioral context by stating that the tool returns a PNG image for inspection, which is valuable given there is no output schema. It does not overpromise or contradict the annotations.

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

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

Two concise sentences, with the core purpose front-loaded and the sibling distinction stated immediately after. Every sentence carries useful information and there is no redundancy.

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

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

For a preview tool with readOnlyHint true and a fully documented input schema, the description covers the essential context: what it produces, that it returns the image, and how it differs from the placement tool. No critical information appears to be missing for an agent to call it correctly.

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

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

The input schema already documents all four parameters with 100% coverage, so the description is not required to explain them. The description adds general context about generating an invitation QR code but does not add parameter-level meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Generate a QR-code PNG for an invitation.' It also clarifies the return value ('Returns the image so it can be inspected'), distinguishing it from set_card_project_qrcode, which places the QR code on a card. This is a clear and differentiated 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 explicitly names the sibling alternative set_card_project_qrcode and contrasts previewing the image with actually placing it on a card. This gives an agent direct guidance for choosing between the two related tools.

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

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

The description goes beyond the readOnlyHint annotation by explaining exactly what kinds of results are returned and what each means: DUPLICATE_RISK, UNATTRIBUTED, ORPHAN_ORDER, and MATCHED count. It also explicitly states 'Read-only,' reinforcing that no mutation occurs.

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 with the core action. Each parenthetical earns its place by clarifying what each result category means, and the final 'Read-only' is a useful behavioral reinforcement despite also being in the annotations.

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

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

With no parameters and no output schema, the description carries the full burden of explaining return semantics. It does so thoroughly by naming all four result categories and explaining the implications of the risk cases. An agent has enough context to call this tool correctly.

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

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

The tool has zero parameters, so the baseline is 4; there is nothing for the description to explain. Schema coverage is vacuously 100%, and the description correctly focuses on behavior instead.

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

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

States a specific verb and resource pair: 'Reconcile the registry against the gift tracker.' It also distinguishes this from simple read tools like get_registry and get_gift_tracker by describing a mismatch-detection operation with named result categories.

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

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

The description makes the use case clear: this is a read-only reconciliation operation that surfaces discrepancies between registry and gift-tracker data. It does not explicitly name alternatives or exclusion conditions, but with zero parameters and a self-contained purpose, the intended context is evident.

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 well beyond the idempotentHint and destructiveHint annotations by disclosing that removal discards the guest's RSVP details, that re-inviting does not restore them, that other events are unaffected, and by detailing the two-step confirmation flow with a confirmToken. This is substantial behavioral context that 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 dense but every sentence earns its place: purpose, scope selection, consequences, idempotence, and confirmation protocol. It is front-loaded with the core operation and parameter rule before explaining caveats and fallback behavior, with no redundant 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?

Given the tool's destructive nature, idempotence, and non-trivial confirmation flow, the description covers everything an agent needs: what to pass, what will be lost, what is preserved, that it is idempotent, and exactly how to handle the two-step confirmation fallback. The absence of an output schema is acceptable because the description specifies the preview/confirmToken contract.

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

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

The schema already documents all parameters with 100% coverage, so the baseline is 3. The description adds meaningful semantics by imposing the mutually exclusive 'exactly one of guest_group_id or guest_id' rule and explaining the confirmToken's role in the confirmation fallback, which is valuable beyond the schema text.

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

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

The description uses a specific verb and resource: 'Remove an event invitation for a single guest or guest group.' It clearly states the operation's target and scope, and the parameter-level conditional ('Pass exactly one of guest_group_id or guest_id') makes it easily distinguishable from sibling tools like invite_guest_to_event or remove_guest.

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 usage instructions: pass exactly one of guest_group_id or guest_id depending on target scope, and explains effects like 'Other events' invitations are preserved.' It does not name sibling alternatives for when not to use this tool, but the usage context is otherwise clear and unambiguous.

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

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

Beyond the destructiveHint annotation, the description discloses a confirmation requirement, a two-step fallback with a preview and confirmToken, and the need to repeat the call with the same arguments. This is rich behavioral context that prevents an agent from assuming a single call completes the deletion.

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

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

The description is two sentences with no filler. The core purpose is front-loaded, and the confirmation mechanics are stated compactly in the second sentence. 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 adequately covers the two invocation modes and references the MCP_CONFIRM_MODE contract. It explains what happens on the first call and what is needed for the second. It does not describe the final success response, but for a simple one-required-parameter tool this is a minor gap.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds context about the confirmation flow but does not explain parameter meanings beyond what the schema already provides. The schema already documents faq_entity_id and confirmToken precisely.

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 ('Remove'), a specific resource ('an FAQ'), and the affected scope ('from the public website'). It differentiates itself clearly from sibling tools like add_faq, update_faq, and list_faqs by naming the exact operation.

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

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

The usage context is implied by the purpose: this is the tool to use when an FAQ must be removed. It does not explicitly state when to prefer this over update_faq or list_faqs, and it offers no exclusions. The confirmation flow guidance helps with invocation but not tool selection.

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 declare destructiveHint=true, but the description adds substantial behavioral detail: there is no trash, deletion cascades to all related RSVPs/invitations/seat assignments, and the confirmation flow differs by client capability. This is exactly the kind of context annotations cannot 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?

Three front-loaded, information-dense sentences: the action, its permanent scope, then the confirmation protocol. 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?

Despite having no output schema, the description fully explains the destructive consequences and the two-step confirmation fallback, including what the first call returns and when the token can be used. This is complete enough for an agent to call the tool correctly and safely.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining what the confirmToken is for, that the first call returns a preview, and that a repeat call with the token proceeds, which clarifies the guest_group_id confirmation semantics beyond the schema.

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

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

The description uses a specific verb and resource ('Remove a guest group (household) from the guest list') and goes further by spelling out the permanent deletion of every associated RSVP, invitation, and seat assignment. This clearly distinguishes it from add/update/remove sibling 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 explains when and how to confirm: a client-supported prompt, or a preview + confirmToken fallback with a repeat call. It does not name alternative tools or explicit when-not-to-use conditions, so it stops short of a 5.

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

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

Beyond the destructiveHint annotation, the description discloses the confirmation-first behavior, the two-step fallback with preview and confirmToken, and the requirement to call again only after explicit user approval. This adds substantial operational transparency about how the destructive action is gated.

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, front-loaded with the primary purpose, and then logically explains the confirmation mechanism. Every sentence adds useful information without repetition 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 adequately explains the action, the confirmation flow, and the token-based fallback, which is the main complexity of this tool. It could mention the success response shape or the permanence of the removal, but the destructiveHint annotation and confirmation gating make the behavior sufficiently clear for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters. The description reinforces the confirmToken protocol but does not add much meaning beyond what the detailed parameter descriptions already provide.

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 ('Remove') and a specific resource ('a story section from the public home page'), making the operation unambiguous. It differentiates the tool from its siblings add_home_section, update_home_section, and list_home_sections by focusing on the remova action on the home page.

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

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

The description clearly implies this tool is for when a home section must be removed, and it explains the mandatory confirmation flow. It does not explicitly name alternative tools for related tasks (e.g., hiding a section via update_home_section), but the context and schema reference to list_home_sections provide adequate usage direction.

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

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

Beyond the destructiveHint annotation, the description discloses the confirmation prompt behavior, the two-step fallback with preview and confirmToken, and the requirement to repeat the call with the token. These are critical non-obvious behaviors that ensure safe and correct invocation.

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

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

Two sentences with no redundancy: the first states the core action, the second explains the confirmation protocol. Every sentence contributes essential information and is well 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 tool's complexity—destructive action with a two-step confirmation flow—the description covers the non-obvious behavior (preview, confirmToken, repeat call) sufficiently for an agent to invoke it correctly. The schema handles parameter details and the annotation confirms destructiveness.

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 references confirmToken in context but does not add meaning beyond what the schema already provides; all important parameter details (POI ID source, token rules) are already 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 a specific verb ('Remove') and a specific resource ('point-of-interest from the public Things-to-Do page'), making the tool's action unambiguous. It clearly distinguishes itself from sibling POI tools like add_poi, update_poi, and list_pois.

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

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

The description gives clear context for when the tool is used (to remove a POI from the public Things-to-Do page) and provides detailed operational guidance for the confirmation flow. It does not explicitly name alternatives or when-not-to-use conditions, but the purpose is self-evident relative to 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?

Annotations declare destructiveHint=true, but the description goes beyond that by disclosing the confirmation-first behavior, including the two-step fallback with preview and confirmToken. This adds behavioral detail (how the tool interacts with the user and the MCP confirmation mode) that is not available from annotations alone. 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 a single sentence, which is efficient, but it is a long run-on with awkward phrasing ('registry guests shop from'). It front-loads the core action (Remove an item) and then adds confirmation details, but the structure could be clearer and more polished. It is reasonably concise but not a model of clarity.

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

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

The tool is destructive and has a confirmation flow, and the description covers the flow well. However, it does not mention what the final success response looks like, nor any side effects or irreversibility beyond the destructiveHint. Since there is no output schema, the agent is left without information on the return structure of a successful call. The confirmation behavior is well covered, but completeness for a destructive tool could be better.

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

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

Schema description coverage is 100%, and both parameters have detailed descriptions in the schema. The tool description's mention of confirmToken and the confirmation flow echoes the schema but does not add new information beyond what is already in the schema's parameter descriptions. The main description references MCP_CONFIRM_MODE, which is not explained, but overall the schema carries the semantic load adequately.

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

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

The description states a clear action ('Remove an item') and identifies the resource (registry). Despite awkward grammar ('guests shop from'), the verb and object are unambiguous, and it distinguishes itself from sibling tools like add_registry_item and update_registry_item by the remove action.

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

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

The description implicitly indicates when to use the tool (to remove a registry item) and spends significant text explaining the confirmation flow, which is a usage guideline. However, it does not explicitly mention alternatives or exclusions (e.g., 'use add_registry_item to add, update_registry_item to modify'). The confirmation guidance is useful but selection context 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?

While annotations already mark destructiveHint=true, the description adds crucial behavior: it requires user confirmation, and on clients without elicitation it performs a two-phase call with a preview and confirmToken. This explains exactly how the destructive action is gated, which goes well beyond the 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?

The description is a single dense sentence with no filler: it front-loads the core action and then details the confirmation behavior and fallback flow. The 'see MCP_CONFIRM_MODE' pointer is an efficient reference rather than padding.

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 destructive action, confirmation requirement, preview/token fallback, and repeat-call requirement, which is substantial for a tool with no output schema. It does not describe the exact shape of the preview response, but the provided information is sufficient for an agent to execute the flow correctly.

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

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

Schema description coverage is 100% and both parameters already have detailed descriptions, especially confirmToken, which includes strong usage warnings. The tool description does not add new parameter semantics, so the baseline of 3 applies.

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

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

The description states a specific verb ('Remove') and resource ('a travel item from the public Travel page'), clearly distinguishing it from sibling remove_* tools such as remove_guest or remove_faq. It immediately tells the agent what operation is performed and on what object.

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

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

The description makes the use case obvious: removing travel items on the public Travel page, and it explains the confirmation flow required before the removal proceeds. It does not explicitly name alternatives like update_travel_item or add_travel_item, so it lacks an explicit when-not-to-use statement, but the context is unambiguous.

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

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

The annotations already provide destructiveHint=true, and the description adds no behavioral context beyond that. It does not disclose what gets unbooked or destroyed, whether the action is reversible, or what side effects occur on related vendor data.

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 brief and front-loaded with no wasted words, but it is under-specified rather than appropriately concise. 'Unbook a vendor' is a complete sentence, but it leaves essential meaning about scope and effect to inference.

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

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

For a destructive operation with no output schema, this description is incomplete. An agent needs to know what 'unbook' means operationally, what is affected, and what the result looks like; none of that is provided.

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 uuid parameter description already tells the agent to use a UUID from list_vendors. The tool description adds no further parameter meaning, so the baseline of 3 applies.

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

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

The description states a specific resource ('vendor') and an action ('unbook'), so it is not a tautology. However, 'unbook' is ambiguous—it could mean deleting the vendor record or marking it as not booked—and the description does not differentiate this from the sibling add_vendor/update_vendor operations beyond the general direction.

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

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

There is no guidance on when to use this tool versus alternatives such as update_vendor or remove_guest, and no context about preparation steps. The only implicit hint is the destructive annotation, which is not enough to help an agent decide between this and 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?

Annotations declare destructiveHint=false, and the description adds meaningful behavioral context beyond that: the operation replaces the full navigation order, since a complete list must be supplied. It could go further by explaining what happens to omitted pages or what response is returned, but it covers the crucial mutation semantics.

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

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

Two short sentences with no filler. The purpose is front-loaded and the critical constraint ('complete ordered list') is stated immediately afterward.

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

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

For a simple one-parameter mutation with annotations and a fully documented schema, the description is nearly complete. It does not mention retrieving the current page list via list_pages or what happens on success, but those are minor gaps for this operation.

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

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

Schema coverage is 100%, and the schema already describes page_ids as the 'Full ordered list of page IDs in desired nav order.' The tool description mostly restates that requirement, adding little semantic value 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?

Description uses a specific action ('Reorder') and a clear resource ('pages in the website navigation'), so an agent can immediately identify what the tool does. The complete-list requirement also helps distinguish it from related page tools like update_page or set_page_hidden.

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

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

The description clearly states the key usage condition: the agent must pass the complete ordered list of page IDs, not a partial diff. It does not explicitly name alternatives or say when not to use this tool, but for a single-purpose reorder tool the context is clear enough.

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

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

The readOnlyHint annotation already signals that this is a safe read operation. The description adds that the search is 'faceted' and returns suites, which is useful but does not disclose behaviors such as result ordering, pagination beyond the limit parameter, or what happens when no matches are found. It does not contradict the 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?

The description is short and front-loaded with the main action ('Search the invitation design catalog'), and the second sentence explains the result shape. Each part earns its place, though the phrase 'faceted search returning suites' is slightly awkward and could be more precise.

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

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

For a simple read-only search tool with two optional parameters and no output schema, the description adequately covers what is searched, what filters are relevant, and what is returned. It does not need to explain return values in detail since 'returning suites' provides sufficient orientation.

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

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

Schema description coverage is 100%, and both 'limit' and 'card_type' already carry explanatory descriptions. The description only restates that matching is based on card type, adding little semantic value beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Search') and resource ('the invitation design catalog'), and explicitly describes the result ('returning suites matching the requested card type'). This clearly distinguishes the tool from related searches like search_registry_products or search_vendors by anchoring it in the invitation design domain.

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

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

The description implies use when searching for invitation card suites, but it does not explicitly mention when not to use it or name alternatives such as search_registry_products or search_vendors. The domain is clear, yet the guidance relies entirely on inference from the catalog reference.

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?

Consistent with the readOnlyHint=true annotation; 'browse' describes a safe read operation. The description adds useful context beyond the annotation: results are scoped to the user's registry and category IDs are fixed Zola constants, not arbitrary product taxonomy values.

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

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

Two sentences with no filler: the core purpose is front-loaded and the category-ID provenance earns the second sentence.

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

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

For a low-complexity read tool with only one required parameter and a readOnly annotation, the description covers purpose, scope, and parameter provenance. It stops short of 5 only because, with no output schema present, the return shape is never stated — though that's a minor gap for a browse operation.

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

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

Schema coverage is 100% (all three params documented), so the baseline is 3. The description adds value above baseline by grounding category_id with a concrete example (544 = Kitchen) and pointing to the source endpoint GET /v3/categories, which helps the agent supply a valid value.

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

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

The description names a specific resource (Zola registry products within a category) and the operation (browse), which distinguishes it from sibling search tools like search_vendors, search_storefronts, and search_themes. It stops short of 5 because the verb 'browse' is slightly imprecise about operation semantics and it doesn't state what the result set is.

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 registry-scoped, category-filtered nature of the operation implies when it should be used, and the sibling list confirms it targets a different domain than search_vendors/storefronts/themes. However, there is no explicit when/when-not statement or named alternative, so the agent must infer selection criteria.

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 tool is annotated readOnlyHint=true, and the description's 'Search' wording is consistent with a read-only operation. However, it adds no behavioral detail beyond that, such as result shape, pagination behavior, or what 'storefronts' means in this context.

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

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

The description is a single front-loaded sentence with no filler, making it easy to scan. It loses one point because the category-ID mapping is duplicated from the input schema, so part of the sentence is not adding net-new value.

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

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

With a simple read-only search, all required parameters documented, and no output schema, the description is minimal but workable. It is not fully complete because it omits any guidance about the overlapping 'search_vendors' tool and gives no sense of the returned data shape.

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

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

Schema description coverage is 100%, so the schema already documents every parameter and even the same taxonomy-node ID mapping. The description adds the 'marketplace by category and location' framing but does not explain any parameter 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 identifies a specific verb ('Search'), a specific resource ('Zola vendor marketplace'), and the two key search dimensions (category and location). It does not explicitly distinguish this tool from the similarly named 'search_vendors' sibling, so it falls just short of full differentiation.

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

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

The phrase 'by category and location' implies the natural use case, but the description states no when-to-use/when-not-to-use conditions and names no alternative tool. Given that 'search_vendors' exists as a sibling, the agent is left to infer which vendor-search tool fits.

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 annotation readOnlyHint=true already establishes the read-only nature. The description adds no further behavioral details—such as pagination behavior, filtering semantics, or the structure of the returned list. With annotations present, the bar is lower, but the description still fails to disclose any useful behavioral context beyond what the annotation implies.

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

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

The description is a single, well-structured sentence that states the purpose immediately. There is no fluff or redundant phrasing, making it highly 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?

For a simple search/list tool with fully documented parameters, the description is minimally adequate. It doesn't mention the output format or how filtering works, but the schema covers parameter semantics. Given no output schema and a straightforward purpose, the description could be more informative but is not severely deficient.

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

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

All three parameters (limit, offset, theme_layout_types) have descriptions in the schema, so schema coverage is 100%. The tool description itself adds no parameter-specific meaning, but since the schema already documents them, the baseline 3 applies. The description doesn't explain how theme_layout_types affects results, but the schema's enum values offer some clarity.

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

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

The description states a clear action ('Browse') and resource ('catalog of available wedding-website themes'), which distinguishes it from sibling tools like get_current_theme that target the current theme. It is specific and unambiguous, though it doesn't explicitly contrast with related tools.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., get_current_theme or update_current_theme). It doesn't mention typical use cases, preconditions, or exclusions. An agent would have to infer its role from the name and 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, covering safety. The description adds the typeahead behavior and the category scoping, which are not present in annotations. This provides useful context about how the search operates (partial-name matching, category filtering) without repeating the read-only fact. It does not mention response format or limits, but the annotation lightens 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 with zero filler. It front-loads the core action ('Search for vendors by name') and immediately adds the typeahead and category qualifiers. Every word earns its place, making it highly efficient for an agent to parse quickly.

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

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

For a simple, read-only search tool with two parameters (one required) and no output schema, the description is adequate. It covers the essential behavior (search by name within a category) and the typeahead aspect. It does not explicitly state that it returns a list of matching vendors, but that is a natural inference for a search tool, and the schema handles parameter details. The annotations cover safety, so the description meets the needs without over-explaining.

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

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

Schema description coverage is 100%, so both query and taxonomy_key are already documented in the schema. The tool description restates the query as 'by name (typeahead)' and taxonomy_key as 'within a vendor category', adding a slight behavioral nuance (typeahead) but not significant new meaning. With full schema coverage, a baseline of 3 is appropriate; the description adds marginal value beyond the schema.

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

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

The description clearly states the action (search), the resource (vendors), and the specific behavior (typeahead by name) plus a scoping constraint (within a vendor category). It distinguishes itself from sibling tools like list_vendors, add_vendor, etc., by emphasizing the name-based typeahead search, so an agent can immediately identify when this tool is relevant.

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 (searching vendors by name) but does not explicitly state when to choose this over alternatives such as list_vendors (which presumably returns all vendors) or search_registry_products. There is no mention of use cases like pre-filling a form or filtering a dropdown, and no exclusions or comparisons are provided. The guidance is implicit rather than explicit.

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

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

Annotations only say destructiveHint=false, so the description must carry the behavioral burden. It clearly states the mutating action and optional overrides, but it does not spell out that omitted groups remain unchanged or describe the result/return behavior.

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

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

Two short sentences convey the operation, the optional behavior, and the key call requirement without redundancy. The action is front-loaded and every sentence earns its place.

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

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

For a two-parameter mutation with fully documented schema fields, the description is nearly complete. It lacks an explicit prose statement of the 'omitted groups untouched' behavior, but the schema already covers that, so no major information is missing.

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

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

Schema coverage is 100% and every parameter already has a meaningful description in the schema. The description adds the full-list instruction, but this is a marginal addition over the schema's own 'Omitted groups are not affected' note, so baseline 3 is appropriate.

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