Aisle

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

The description discloses a rich set of behavioral traits beyond annotations: the room is unpriced with no payment requirement, an invalid id returns not-found, results include the saved room and place info, and whether the call created the place. It also describes ordering behavior for new places. These are critical behaviors for a mutation tool with destructiveHint=true.

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 well-structured, covering purpose, property logic, outcome behavior, and prerequisites in a logical flow. Every sentence adds value without redundancy.

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

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

Given the absence of an output schema, the description does a good job explaining return values (saved room, place id/name, whether place was created). However, it doesn't cover all parameter behaviors or error cases beyond not-found, leaving some gaps for a 12-param tool.

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

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

Schema coverage is 100%, so the schema already documents all 12 parameters thoroughly. The description adds context about property_id vs property_name semantics (id names existing place, name creates or matches) and room_name being required, which is already in the schema. Marginal added value over structured data.

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 (adds) and resource (accommodation/room under a property in a wedding), and specifies the key constraint: it's an unpriced room with no payment requirement. This clearly distinguishes it from siblings like add_my_event and add_my_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 explains the property identification logic (id vs name) and when an id lookup fails (not-found result). It also notes sign-in and membership requirements. However, it doesn't explicitly contrast with update_my_accommodation or add_my_place 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 the safety profile (readOnlyHint=false, destructiveHint=true, idempotentHint=false, openWorldHint=true), so the description is not the only source of behavioral signal. It adds genuinely new context beyond the annotations: the authentication and membership requirement, plus which fields are optional versus required. It stops short of describing validation rules or whether duplicate events are allowed.

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

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

Two sentences, no redundancy, with the action and its scope front-loaded and the prerequisite placed last. Every clause carries information the agent needs.

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 10-parameter create tool with full schema coverage and no output schema, the description covers the action, the field surface, optionality, and the auth gate. The main omission is the return value (e.g. the new event's identifier), which the agent must guess since no output schema exists.

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

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

Schema description coverage is 100%, so every one of the 10 parameters is already documented in the schema, including the subtle local-time-vs-offset semantics of 'date' and the all-day handling. The description adds only a summary list of fields and the optional/required distinction, 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 opens with a specific verb and resource ('Creates an event in the selected wedding') and enumerates the payload fields it accepts, so an agent can immediately tell it apart from the update/remove/get/list siblings by their verbs. It does not name a specific alternative, but the create-vs-modify distinction is unambiguous.

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

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

It supplies a real prerequisite ('Requires sign-in and an Aisle membership'), which tells the agent when the call will fail, and the create semantics imply the usage context. However, it never states when to prefer this over update_my_event (existing event) or how it relates to list_my_events, so routing is left 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?

Annotations already declare a non-read-only, non-idempotent, destructive write, so the bar is lower, yet the description still adds auth requirements, the ordering constraint on age confirmation, the explicit statement that age cannot be inferred, and the fact that notes and dietary details are unsupported fields. It does not explain the destructiveHint=true flag for what reads like an additive operation, which is the one behavioral gap.

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

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

The operation is front-loaded in the first clause, followed by tightly ordered constraints. Five sentences with essentially no filler, though the density makes it slightly heavy for a single-field-mapping create 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?

Covers both input expectations (required vs optional fields, age eligibility) and output behavior ("results return the saved guest details"), despite there being no output schema. Auth requirements and unsupported fields are also disclosed, leaving nothing essential for a correct invocation unstated.

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 3 is the baseline, but the description adds real semantic meaning: it explains why age_band must be an explicit confirmation rather than something derived from names or relationships, and clarifies that phone/email are optional against required names. wedding_id is only loosely covered by "the selected wedding."

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 ("Adds a guest to the selected wedding") and pins the scope to the signed-in account's wedding, which cleanly separates it from update_my_guest and remove_my_guest. An agent can identify the operation without opening the schema.

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

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

Gives clear preconditions (explicit 13+ confirmation obtained before name/contact collection, sign-in plus Aisle membership) and states what input is required vs optional. It stops short of explicitly naming sibling alternatives such as update_my_guest or list_my_guests, so it is strong context rather than full routing guidance.

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

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

Adds substantial context beyond annotations: it creates only a private preview with no membership purchase, publication, invitations or marketing enrollment, and sign-up happens in the browser, not via arguments. This discloses exactly what is not triggered, which the destructiveHint and openWorldHint flags cannot convey, and does not contradict them.

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

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

Front-loaded purpose followed by edge-case and side-effect clauses, each earning its place. Slightly dense, but no filler sentences.

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

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

For a mutation tool with no output schema, it covers confirmation requirement, idempotent behavior, multi-wedding handling, and what is deliberately not performed. An agent has everything needed to call it 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 coverage is 100%, so parameters are documented in the schema. The description reinforces omit-if-undecided behavior for date and location, but adds little syntax beyond what the schema already 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?

Specific verb and resource (creates the signed-in couple's first wedding) with scope boundaries that distinguish it from update_my_wedding and get_my_wedding: 'first wedding', existing weddings returned unchanged, multi-wedding accounts asked which to use.

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?

Clearly states when this applies (first wedding, after explicit confirmation) and what happens in the edge cases (existing wedding returned unchanged, multiple weddings disambiguated). It doesn't name sibling tools directly, but the preconditions cover the routing decision.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false). The description adds genuine behavioral context beyond that: results are deduplicated, deterministic in ordering, and are suggestions rather than verified/registered hashtags. A note on cost, rate limits, or handling of sparse input would push this higher.

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, zero filler, and the core capability is front-loaded before the clarifier. 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?

With no output schema, the description usefully characterizes the return (deduplicated, deterministically scored, not an availability check). It doesn't mention that all six parameters are optional or what happens with no input, which is a minor gap for a tool with zero required parameters.

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 of the six parameters already carries a per-field description, so the schema does the heavy lifting. The description merely names the same input categories without adding format, default, or interaction semantics beyond what the schema provides.

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

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

Names a specific verb and resource ('Generates deduplicated wedding hashtag suggestions') and enumerates the inputs it draws from (partner names, surnames, year, place), plus the output ordering. It also fences off adjacent concepts ('not registrations or availability checks'), so an agent can distinguish it from the get_/list_ siblings without opening the schema.

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

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

The description implies the usage context (name-based hashtag ideation) and explicitly excludes two misinterpretations, but it never states when to reach for this tool versus a sibling or what prerequisites exist. No alternative is named, so the routing guidance is only implied.

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

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

Annotations already establish readOnly, idempotent and non-destructive behavior. The description adds context beyond them: bottles and cases are rounded up, quantities are rules-of-thumb rather than a consumption guarantee, and the tool does not actually purchase alcohol. That is meaningful boundary-setting for an estimating tool.

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

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

Three tight sentences, front-loaded with the core capability, followed by the rounding behavior and then the non-purchase disclaimer. No filler.

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

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

No output schema exists, yet the description sufficiently conveys the return shape (bottles and cases, rounded up) and the non-guarantee caveat. Only a fuller statement of the returned fields/pagination would push this higher, and for a simple planning estimator this is close to complete.

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

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

Schema description coverage is 100%, so every parameter including enums and defaults is already documented; baseline is 3. The description names guest count, duration and drink mix but adds no syntax or defaults beyond the schema.

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

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

States a specific verb (estimates), a specific resource (wedding bar quantities), and the inputs that drive it (guest count, duration, drink mix). An agent can distinguish this from get_budget_estimate or get_cash_gift_suggestion without opening any schema.

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

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

The description implies when it applies (planning bar quantities for a wedding) but offers no explicit when-not guidance and does not reference any alternative tool. Usage is inferable but not spelled out.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description adds genuinely new behavioral context: the country-fallback pricing rule with the result flagging it, coverage information returned for uncovered places, and an explicit disclaimer that figures are modelled estimates rather than supplier quotes or booked-wedding prices.

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

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

Four sentences, front-loaded with the core promise and then the fallback and output-shape details, with no filler. The fallback rule ('priced at its country and the result says so') is stated twice across the definition, which is minor redundancy rather than bloat.

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 carries the return contract and does so well: line-by-line breakdown, a typical total, the range most weddings land in, and coverage info when a place is not indexed. Combined with the modelled-estimate caveat, an agent has everything needed 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 documents all four parameters including the destination-versus-country rule and the style default. The description restates the destination fallback semantics but adds no new syntax or format detail beyond what the schema provides, which is the expected baseline when the schema does the heavy lifting.

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

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

The description states a specific verb and resource (estimates a whole destination wedding budget in USD) and scopes it by guest count, place and style tier from a named cost index. It distinguishes itself from cost-adjacent siblings like get_alcohol_estimate, get_guest_travel_estimate and get_who_pays_split by being the whole-budget estimator.

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 clarifies the input selection rule (accepts a destination or a country; a destination without its own row is priced at its country) which is useful usage guidance. However, it never names an alternative tool or states when not to use this one (e.g. versus get_alcohol_estimate for a component), so routing is left 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description still adds real value by characterizing the output as illustrative etiquette guidance rather than advice, and by explicitly ruling out a money-transfer behavior, which preempts a plausible misinterpretation of a 'cash gift' tool.

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

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

Three short sentences: what is returned (with units), what the numbers mean, and what the tool does not do. The return-value statement is front-loaded and nothing is redundant or 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?

There is no output schema, but the description supplies the essential return shape (low/typical/high range in USD), which is the main thing an agent needs. It stops short of describing the response envelope or any caveats about which relationship/party combinations are supported, but it is complete enough for correct invocation.

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

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

Schema description coverage is 100%, with enums documented for party and travel and an explanation that an absent relationship value returns the available options. The description names the same input dimensions but adds no formats, defaults, or interaction rules beyond the schema, so the baseline of 3 applies.

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

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

States a precise verb and resource: returns an illustrative low/typical/high cash wedding gift range in USD, and enumerates the four inputs that drive it (relationship, party, travel, wedding-party role). That level of specificity separates it from the other estimate-style siblings such as get_budget_estimate, get_alcohol_estimate, and get_who_pays_split without needing to name them.

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

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

The description frames the output as 'US etiquette conventions, not obligations' and clarifies it 'does not transfer money,' which implies a consultative/advisory use case, but it never states when to call this versus alternatives like get_who_pays_split or get_budget_estimate, nor any prerequisites. Usage is inferable but not explicit.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world. The description adds genuine behavioral context beyond that: the output is a draft built from standard planning offsets, not confirmed vendor/venue/sunset schedules, which tells the agent how much to trust the result. It doesn't describe return format, but with annotations covering the safety profile this is solid.

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

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

Two tight sentences: the first states what it builds, the second states the key limitation. Zero filler and the purpose is front-loaded before the caveat.

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, no-output-schema generation tool with fully documented parameters, the description covers what an agent needs: what it produces and the caveat that timings are generic offsets rather than confirmed. Only the shape of the returned schedule is left unstated, which 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% and each of the three parameters is fully documented in the schema, including alternate time formats. The description only restates the parameter names at a high level, adding no format or edge-case detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb and resource — builds a draft wedding-day schedule — and names the three inputs it keys on. It implicitly contrasts with the long-horizon get_planning_timeline sibling but never says so explicitly.

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

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

The description implies the use case (day-of schedule rather than long-term plan) but gives no explicit when-to-use versus get_planning_timeline or get_wedding_checklist. No exclusions or prerequisites are stated.

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

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

Annotations already establish readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds genuinely useful undisclosed context: matching is approximate, results include examples and an Aisle guide link, and the no-arg path returns a list rather than an error.

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 covers the primary lookup, the fallback list mode, and the return contents with no filler. Every clause carries information an agent needs.

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 does the work of describing the return payload (definition, clothing examples, invitation wording, guide link), which is sufficient for a read-only lookup. Only the fuzzy-match failure behavior, e.g. what happens with a misspelled or unknown code, is left unstated.

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 itself already states the parameter is optional and matched approximately, so the description adds essentially no parameter meaning beyond the structured field. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description names a specific verb and resource (returns a wedding dress code definition) and covers both operating modes: lookup by code vs. listing all codes. It does not, however, distinguish itself from the sibling get_invitation_wording, whose territory it partially claims by returning invitation wording.

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

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

Usage is implied through the conditional 'or lists the available dress codes when none is specified', which tells the agent how the absent-parameter case behaves. There is no explicit when-to-use guidance or pointer to an alternative such as get_invitation_wording for wording-only requests.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), but the description adds real behavioral detail: partial totals include only priced groups, unpriced guests and unsupported origins are reported separately, and urlRestoresEstimate signals whether the link preserves the supplied groups. It does not describe pagination or caching, but for an estimate endpoint this is substantial added 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?

Five short sentences, each earning its place, front-loaded with the core purpose before edge-case behavior. Slightly dense but no wasted phrasing.

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

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

For a read-only estimation tool with no output schema, the description covers return semantics (typical figure, low-to-high range), partial-result behavior, the urlRestoresEstimate field, and the non-live-fare caveat. Nothing essential for correct invocation 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% (baseline 3), and the description further clarifies defaults: stay length and guests-per-room default to the destination's typical stay in a private room per guest, with guests_per_room=2 pricing couples sharing. This adds meaning beyond the schema's 'default 1' wording.

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 (estimates) and resource (round-trip flights + lodging for guest groups from US metros), with a clear currency/scope (USD). An agent can separate it from siblings like get_budget_estimate or get_alcohol_estimate without opening the schema.

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

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

The description implies usage (price travel for guest groups) and adds a useful scope disclaimer ('not live fares or bookings'), but it never states when to use this vs. the other estimate/suggestion tools such as get_budget_estimate. No explicit alternatives or exclusions beyond the disclaimer.

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

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

Annotations already establish the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false), so the bar is lower. The description adds two non-obvious traits: that it acts as a discovery endpoint when scenario is absent, and that wording follows etiquette conventions rather than legal requirements — a meaningful expectation-setting note about output nature.

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

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

Three tightly packed sentences with zero filler: purpose first, then the no-scenario fallback, then the etiquette caveat. Each sentence carries distinct information and the most decision-relevant content 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 13-parameter, zero-required, read-only generator with no output schema and full schema coverage, the description covers purpose, input intent, the discovery fallback, and output character. It could say more about the shape of the composed result, but annotations and the rich schema already cover safety and inputs, so the remaining gap is minor.

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

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

Schema description coverage is 100% across all 13 parameters, including defaults and enum meanings, so the schema already carries the semantic load and baseline 3 applies. The description only loosely gestures at the parameter set ("supplied names, event details and optional reception wording") without adding syntax, format, or default-resolution detail beyond the schema.

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

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

States a specific verb ("Composes") and resource ("wedding invitation text") with the inputs that drive it (hosting situation, formality, names, event details, reception wording). This clearly separates it from siblings like generate_wedding_hashtags or get_dress_code_guide, and the no-scenario fallback behavior is disclosed up front.

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 tells the agent what happens when scenario is omitted (it lists available options), which is genuinely useful call-time guidance for a generator. However, it never states when to reach for this tool versus alternatives, nor any prerequisites, so usage is only implied from the tool's purpose.

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 the safety profile (readOnly/idempotent/non-destructive), and the description adds genuinely new behavior: missing, removed and other-wedding rooms all collapse to the same not-found result, guest assignments and occupant identities are excluded, and sign-in is required. That is exactly the kind of edge-case and auth disclosure annotations cannot carry.

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

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

Front-loaded with the return payload, then edge-case behavior, exclusions, and auth in three efficient sentences. The field enumeration is slightly dense but justified given there is no output schema to carry it.

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

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

With no output schema, the description takes on the burden of describing the returned shape and does so thoroughly, while also covering not-found semantics, exclusion rules, and authentication. Nothing essential for correct invocation is missing.

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

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

Schema description coverage is 100%, so both parameters are already documented by the schema. The description reinforces that the room belongs to a 'selected wedding' but adds no format or syntax detail beyond that, so the baseline 3 for a fully-covered schema is appropriate.

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

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

States a specific verb and resource: 'Returns one identified room in the selected wedding', immediately distinguishable from the sibling list_my_accommodations. It also enumerates the returned fields (property, capacity, status, stay details, overrides), so an agent knows exactly what this singular getter yields.

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 singular 'one identified room' framing implies this is the by-id lookup counterpart to list_my_accommodations, but the description never names the alternative or states the condition for choosing it. The scoping note about other-wedding rooms is behavioral context rather than usage guidance.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the safety bar is met; the description adds genuinely new behavior beyond them — an authentication requirement and the deliberate collapsing of 'missing' and 'other-wedding' into one not-found result, which prevents existence probing. It also enumerates derived outputs (overlapping event ids, matched dress-code guide entry) that the agent could not infer.

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

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

Two sentences, front-loaded with the return contract before the caveats, and no filler about the tool's importance. The first sentence is field-dense but each listed field is load-bearing since there is no output schema to fall back on.

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 correctly takes on the burden of describing return values and does so thoroughly, including computed fields and the not-found semantics. The only residual gap is the multi-wedding/wedding_id selection behavior, which the schema covers but the description only gestures at with 'the selected wedding'.

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

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

Schema description coverage is 100%, so both parameters are already documented, including the multi-wedding conditional for wedding_id. The description only restates the 'selected wedding' scoping in prose and adds no format or constraint detail beyond the schema — the baseline 3 for a fully documented 2-param schema.

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

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

States a specific verb and resource ('Returns one identified event in the selected wedding') plus the exact payload fields, which cleanly separates it from list_my_events (plural listing) and get_my_wedding (the wedding itself). The singular 'one identified event' makes the cardinality explicit.

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

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

Usage is implied rather than stated: the singular 'one identified event' signals fetch-by-id versus the list_my_events sibling, but neither the list nor update/remove siblings are named. The line about missing/other-wedding events implicitly tells the agent not to use this tool to probe for existence, which is useful but indirect.

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?

Goes well past the annotations (readOnly/idempotent/non-destructive) by disclosing error-equivalence semantics that prevent enumeration, the exact field set returned, the meaning of the 'defaulted' contact-preference list, and that guest notes and dietary details are excluded. These are behavior traits an agent could not infer from structured fields.

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

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

Three dense sentences, front-loaded with the core purpose, then return contents, then edge-case/auth behavior. No filler or repetition of the title.

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

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

With no output schema, the description enumerates the returned fields itself, and it adds auth requirements and error behavior for a single-entity read tool. An agent has everything needed to call it correctly and interpret the result.

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 guest_id and wedding_id are already documented in the schema, including the multi-wedding requirement. The description adds only incidental meaning ('selected wedding', implicit 13+ eligibility for guest_id), so the schema does the heavy lifting.

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

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

States a specific verb and resource ('Returns one identified guest') and constrains scope to guests recorded as 13 or older in the selected wedding. The 'one identified' framing clearly separates it from list_my_guests without needing to name the sibling.

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

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

Gives concrete preconditions and routing context: requires sign-in, and missing/other-wedding/under-13/unconfirmed-age lookups all collapse to the same not-found result. It does not explicitly name list_my_guests as the alternative for enumeration, so it stops short of full when/when-not guidance.

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

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

Annotations already declare readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds real context beyond that: the manage-scope authorization limit and the fact that the returned destination feeds the budget and guest travel estimate tools, which is cross-tool behavior the agent cannot get from 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 dense sentence, front-loaded with what is returned and ending with the authorization constraint. Every clause carries information, though the run-on enumeration of every returned field is slightly heavy.

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 carries the burden of describing return contents, and it does so comprehensively while also stating the authorization scope. Missing only explicit routing against sibling read tools, which is a minor gap for a simple single-parameter 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?

Schema description coverage is 100% and the single wedding_id parameter is fully documented in the schema, including the multiple-weddings condition. The description adds no new syntax or format detail about the parameter, so the baseline 3 applies.

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

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

The description names a specific verb and resource ('Returns the signed-in account's selected wedding details') and enumerates the fields returned (partner names, date, location, venue, city/country, destination). It is clearly distinguishable from get_my_wedding_stats or get_venue_details, though it never names a sibling explicitly.

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

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

Usage is implied rather than stated: it notes access is limited to weddings the account can manage and the schema notes wedding_id is required only with multiple weddings. There is no explicit guidance on when to prefer this over get_my_wedding_stats or get_venue_details, so an agent must infer the routing.

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

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

Annotations already cover readOnly, idempotent, non-destructive, and closed-world traits, so the bar is lower. The description still adds real context by disclosing aggregation semantics (what 'responded' vs 'outstanding' count, how response rate is computed), what is deliberately excluded (guest identities, individual event answers), and an auth requirement.

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 most important content (what is returned) is front-loaded in the first sentence, and the remaining sentences explain counting semantics and exclusions without padding. Slightly dense phrasing, but every sentence contributes information.

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

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

With no output schema, the description carries the full burden of explaining return values, and it does so thoroughly, including the exact meaning of each count and the response-rate formula. Sign-in requirement and exclusions round out what an agent needs to call and interpret 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?

There is a single parameter with 100% schema coverage; the schema already documents that wedding_id is needed when the account manages multiple weddings. The 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 verb ('Returns aggregate wedding statistics') and enumerates exactly what the aggregate contains: guest totals by age band, RSVP counts, event counts, and registry progress. This clearly differentiates it from the detail-oriented siblings like get_my_wedding and the identity-level list_my_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?

Usage is only implied: the aggregate framing and the 'Requires sign-in' note suggest it is a dashboard/summary tool. There is no explicit when-to-use guidance, no statement of when to prefer it over get_my_wedding or list_my_guests, and no alternatives named.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful output content categories (clothing, weather essentials, travel documents, practical supplies) but does not disclose return format, length, or generation logic.

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

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

A single sentence with zero waste, front-loading the verb, resource, and scoping dimensions. Every phrase contributes to explaining the tool's output.

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 generator with rich annotations and full schema coverage, the description is nearly complete. It omits only return format details, which are minor given the absence of an output schema and the simplicity of the tool.

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

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

Schema description coverage is 100%, and both parameters are documented with enums and defaults. The description only repeats 'by climate and role' and adds no extra syntax, filtering, or behavioral detail beyond what the schema already provides, 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?

States a specific verb ('Returns') and resource ('destination wedding packing list') with scoping dimensions (climate, role). It does not explicitly contrast with sibling tools such as get_wedding_checklist, so it falls short of full sibling 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?

No explicit when-to-use or when-not-to-use guidance is provided, and no alternative sibling is named. Usage is only implied by the resource name, leaving the agent to infer 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, idempotentHint, destructiveHint=false and openWorldHint=false, so safety behavior is fully covered. The description adds only that results are sorted by months-out and span venue planning through day-of logistics, which describes content but no filtering, pagination, or edge-case behavior.

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

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

A single well-formed sentence that front-loads the resource and scope with no filler. Every clause contributes: what is returned, how it's organized, and the range of content covered.

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?

No output schema exists, and the description does explain the shape of the return (timeline bucketed by months, spanning venue planning to day-of). Combined with annotations covering the safety profile and a fully documented optional parameter, this is nearly complete, though the absence of any mention of defaults for months_out is a small gap.

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

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

With one parameter and 100% schema description coverage, the schema already documents months_out including its filtering purpose. The description's phrase 'organized by months before the wedding' loosely aligns with the parameter but adds no format or syntax detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb (Returns) and resource (destination wedding planning timeline), plus the organizing dimension (months before the wedding). It implicitly separates itself from get_day_of_timeline and get_wedding_checklist via the month-based framing, but never names those siblings, so an agent must infer the distinction.

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

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

Usage is only implied: the month-based framing suggests this is for long-range planning rather than day-of logistics. There is no explicit when-to-use statement and no mention of alternatives such as get_day_of_timeline or get_wedding_checklist, which is a notable gap given the many sibling timeline tools.

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

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

Annotations already establish readOnly, idempotent and non-destructive, so the bar is low, yet the description adds real behavioral context: provenance labels for description/services/FAQs (Aisle-generated vs vendor-supplied), conditional price-band presence, category-choice provenance, and rating source. It stops short of covering error/nonexistent-slug behavior, so not a 5.

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

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

Two sentences, front-loaded with what is returned before the provenance caveats. Dense but every clause carries information; the second sentence is long due to enumerating conditional fields, which slightly hurts scannability.

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 correctly carries the return-value burden and does so in detail, including which fields are conditional. For a simple one-param read tool this is largely complete, with only error/not-found behavior left 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?

There is only one parameter and schema description coverage is 100%, so the baseline is 3. The phrase 'by its slug' reinforces the key but adds no syntax or format detail beyond what the schema already documents.

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 ('Returns') and resource ('a published wedding vendor') plus the retrieval key ('by its slug'), and enumerates the payload (services, descriptions, FAQs, ratings, photos, links). This clearly separates it from sibling search_vendors and list_vendor_categories, which are list/query tools rather than single-entity lookups.

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 only implied: the agent can infer you call this to expand a vendor found elsewhere, but there is no explicit when-to-use, no pointer to search_vendors as the way to obtain a slug, and no stated behavior when the slug is unpublished or unknown.

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

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

Annotations already declare read-only, idempotent and closed-world behavior, yet the description goes well beyond them: it discloses exactly what is returned, that each price carries a numeric value, currency and per-unit basis, that a response returns one price and names any superseded estimate, the semantics of the estimators block, and detailed failure semantics. It even adds the important caveat that estimates are neither supplier quotes nor live availability.

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?

It is front-loaded correctly — resource, then payload, then edge cases — but it is delivered as three very long, clause-packed sentences with no formatting, making the estimator and not-found rules hard to scan. Every sentence carries real information, so this is a structure problem 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?

With no output schema and a single trivial input, the description carries the full burden of describing the return shape, and it does so thoroughly: payload contents, price representation, estimate provenance, the estimators block, and the not-found response. An agent can interpret the response without any additional documentation.

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

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

Schema coverage is 100% and there is a single parameter whose description ('Unique slug identifying a published Aisle venue') is already complete. The description restates 'by its slug' and adds only the behavioral consequence of a non-published slug, which is useful but not parameter-syntax detail. Baseline 3 applies when the schema does the heavy lifting.

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

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

The first clause states a specific verb and resource ('Returns a published wedding venue by its slug') and immediately enumerates the payload (photos, highlights, travel information, planning estimates, sourced facts with provenance). This is clearly distinguishable from search_venues (a lookup) and get_vendor_details (a different resource) without opening any schema.

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

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

Usage is only implied: the tool takes a slug, so the agent infers it is the follow-up to search_venues or list_venue_countries, but no sibling is ever named and no 'use this when' condition is stated. The not-found handling (never listed vs. taken down, plus suggested alternatives) partially compensates by telling the agent what to do when the lookup fails.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint false). The description adds useful behavioral context about what is returned (milestones across eight phases, spanning eighteen months before through the day) and how the optional month limit filters results, but it does not describe the return format or pagination.

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

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

Two tightly written sentences with zero waste. The core behavior is front-loaded, followed by the optional filtering note; every phrase 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 getter with one optional parameter, no output schema, and annotations that carry the safety profile, the description sufficiently explains what the tool returns and how filtering works. It could be improved by clarifying its relationship to the similar get_planning_timeline sibling.

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 parameter months_out is already documented in the schema. The description adds that it is optional and that it narrows the milestones shown, which is marginally useful but does not add syntax or format details beyond the schema.

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

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

States a specific verb (Returns) and resource (destination wedding planning milestones) with scope detail (eight phases, eighteen months before through the day itself). However, it does not distinguish itself from the sibling get_planning_timeline, leaving ambiguity about which timeline tool to use.

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, when-not-to-use, or alternatives are named. The description implies usage for destination wedding checklists, but given the sibling get_planning_timeline, the lack of routing guidance is a clear gap.

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 readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds real context beyond them: output is 'whole-dollar USD', traditional assignments are 'etiquette conventions, not obligations', and the tool 'does not transfer money' – each a meaningful behavioral caveat.

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

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

Three tight sentences, front-loaded with the core function before the caveats. Every sentence earns its place, though the 'whole-dollar USD' detail could be folded more economically.

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 usefully characterizes the return shape (percentages plus per-party amounts in whole-dollar USD) and the two parameters are fully schema-documented. Complete enough for an agent to invoke correctly, though the model enum values themselves are only in the 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%, so both parameters are fully documented in the schema, making 3 the baseline. The description only alludes to the model ('under a selected model') and currency ('USD') without adding format or enum semantics beyond what the schema already 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?

States a specific verb ('Calculates') and resource ('percentages and amounts for dividing a wedding budget among the couple and their families') with the scope qualifier 'under a selected model'. An agent can distinguish it from get_budget_estimate, but the description never names that or any sibling, so differentiation is left to inference.

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

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

The description explains what the tool produces but gives no when-to-use guidance and no alternatives. It clarifies that it does not transfer money, which is a useful exclusion, but there is no signal for choosing this over get_budget_estimate or get_cash_gift_suggestion.

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 readOnly/idempotent/non-destructive, and the description adds value beyond them: it discloses the auth requirement and explicitly states that guest assignments and occupant identities are excluded, which is meaningful scoping context.

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

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

Front-loaded with the core action, but the middle is a dense run-on enumeration of return fields. Since no output schema exists the enumeration earns its place, but the packing into one sentence hurts readability.

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?

No output schema exists, so the description correctly compensates by enumerating returned fields, and it notes the sign-in requirement and excluded data. Adequate for an agent to call and interpret it, though pagination/size behavior is unaddressed.

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 on the single wedding_id parameter, the schema already carries the semantics. The description only refers to 'the selected wedding' and does not add format or selection detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Lists) and resource (the selected wedding's places) and is detailed about what the listing contains. It does not name or differentiate against siblings like get_my_accommodation, so an agent must infer the list-vs-single distinction.

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

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

Usage is implied by 'the selected wedding's places' and the precondition 'Requires sign-in' is stated, but there is no explicit when-to-use guidance or routing to get_my_accommodation / place_my_guests_in_rooms 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 readOnly, idempotent, and non-destructive, so the safety profile is covered. The description adds real context beyond that: the sign-in requirement, date ordering, that the total reflects returned events, and that each event names its time-overlapping peers.

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 sentences with no filler; the core purpose and output shape come first, with filters and auth note following. Slightly dense but every sentence carries information.

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

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

With no output schema, the description compensates by enumerating returned attributes (dates, times, venues, dress codes, descriptions, overlap names, total count) and the auth prerequisite. An agent has enough to call and interpret results correctly.

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

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

Schema description coverage is 100%, so both filters and wedding_id are fully documented by the schema, setting the baseline at 3. The description restates the filter dimensions and the wedding's time zone but adds no syntax beyond what the schema already 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?

States a specific verb (Lists) and resource (wedding's events) plus the ordering and returned fields. This clearly separates it from list_my_guests, list_my_accommodations, and the singular get_my_event sibling.

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

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

Explains that optional filters narrow results by event type or day range, and that sign-in is required, giving clear usage context. It never explicitly contrasts with get_my_event (single event) or add/update/remove_my_event, so the when-not-alternatives guidance is absent.

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

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

Annotations already cover read-only/idempotent/non-destructive, so the description is free to add the non-obvious behavior it does: guests under 13 and unconfirmed ages are excluded, notes and dietary details are omitted, and per-status counts span all listed guests before filtering. It does not mention pagination or result limits, which is the remaining gap.

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

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

Front-loaded with the verb and scope, then the returned fields, then filters/sorting, then exclusions. Two dense sentences with no filler, though the second sentence carries a lot of stacked clauses and could be split for scanability.

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 usefully compensates by naming the returned fields, the exclusion rules and the auth requirement. It is nearly complete for a list tool, missing only pagination/limit behavior and an explicit tie-break to sibling list/get tools.

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 of the five parameters is already fully documented with enum values, sort semantics and search behavior. The description restates the filter dimensions at a high level but adds no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Lists guests in the selected wedding') plus a precise scope constraint (recorded as 13 or older). It also enumerates the returned fields and the supported filters/sorts, so an agent can distinguish it from get_my_guest and list_my_events without opening any schema.

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

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

Gives clear usage context: optional filters narrow by RSVP status, language or name, and results can be ordered four ways. It also states the prerequisite ('Requires sign-in') and the eligibility boundary. It stops short of explicitly naming a sibling alternative or a when-not-to-use case, so it is not a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds real behavioral context beyond that: donor identities are suppressed (privacy), no payment/contribution side effects, and an auth requirement.

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 with zero filler, front-loaded on what is returned followed by exclusions and prerequisites. 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?

With no output schema, the description usefully enumerates what the list contains and what is deliberately omitted, and annotations carry the safety profile. An agent has everything needed to decide and call correctly.

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

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

There is a single parameter with 100% schema description coverage, and the schema already explains that wedding_id is required only when the account manages multiple weddings. The description references 'the selected wedding' but adds no format or selection guidance beyond the schema, so baseline 3 applies.

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

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

States a specific verb ('Lists') and resource ('the selected wedding's registry and honeymoon fund items') and even enumerates the returned fields (descriptions, goal amounts, received totals). It is clearly distinct from the add_/remove_/update_/get_ siblings. It stops short of explicitly naming a sibling to contrast against, which keeps it just below 5.

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

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

Gives a clear negative boundary ('does not collect contributions or initiate payments') and a prerequisite ('Requires sign-in'), which helps an agent avoid routing payment flows here. No alternative tool is named for the excluded cases, so it does not reach the explicit when/when-not/alternatives level.

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 readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds a genuinely useful behavioral detail beyond the annotations: zero-listing categories are still returned with a count of 0, which prevents an agent from misreading an empty result. It stops short of describing pagination 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?

Two short sentences with no filler; the core behavior comes first and the zero-count edge case follows. 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?

There is no output schema, so the description carries the burden of explaining returns, and it does: categories plus published listing counts, including the 0-count case. For a simple, read-only, zero-required-parameter listing tool, nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100% and the single location parameter is fully documented in the schema, including an example slug format. The description only restates that the filter is optional by location, adding little beyond the structured field, 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 gives a specific verb (Lists), a precise resource (every wedding vendor category), and states what accompanies each item (published listing count). This is readily distinguishable from siblings like search_vendors, get_vendor_details, and list_venue_countries, which address different resources or operations.

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

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

It tells the agent that the location filter is optional, which implies when to supply it, but offers no explicit when-to-use guidance, prerequisites, or named alternatives (e.g., versus search_vendors). Usage is inferable but not spelled out.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuinely new behavioral context beyond that: only countries with *published* venues are included, and venues lacking a price band are counted separately rather than dropped. It omits pagination/ordering and what the price bands actually are, so not a 5.

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; the scope constraint and the three counting dimensions all earn their place. It is somewhat dense and comma-heavy, which slightly hurts parseability, but nothing is wasted.

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

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

With no output schema and no parameters, the description carries the return-value burden and does so well, spelling out every count it returns. Minor gaps remain (no ordering, no definition of the price bands, no indication of result size), but an agent has enough to call it correctly.

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

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

The tool takes zero parameters and the schema is empty, so there is nothing for the description to clarify. Per the baseline for 0-param tools, this is a 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?

States a specific verb and resource ('Lists countries with published wedding venues') and goes further to specify the aggregation granularity: counts per country broken down by venue type, by searchable price band, and a no-price-band count. That result shape cleanly distinguishes it from siblings like search_venues or list_vendor_categories, so an agent knows this is a directory/aggregation endpoint, not a lookup.

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, when-not-to-use, or named alternative is given. The intent is inferable from the purpose (browse venue distribution by country), which is adequate but leaves the agent to decide on its own whether to call this or search_venues for discovery.

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?

Goes well beyond the annotations: dry_run defaults to planning only, rooms fill to bed counts with households kept together, held-back/full rooms are skipped, rules only touch unplaced guests, only 13+ guests are placed, and a 200-guest cap. This is exactly the behavioral context an agent needs before mutating data flagged destructive and openWorld.

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

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

Front-loaded with the core action and modes, then constraints and results. Dense but each sentence carries distinct information (modes, packing rules, dry_run, limits, auth); it is slightly long but not padded.

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 complex 5-parameter tool with nested objects and no output schema, the description compensates by describing the result shape (who was placed per room with occupancy, and skipped guests with reasons), the dry-run semantics, and the auth requirement. Nothing material is missing for correct invocation.

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

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

Schema coverage is 100%, so the schema already documents every parameter including dry_run, fill, and assignments. The description restates the fill/assignments split and dry_run default but adds no syntax, format, or default detail beyond what the schema already provides, 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?

States a specific verb and resource ('Places many guests in the selected wedding's rooms') and immediately clarifies the two input modes (rule vs. explicit list). An agent can distinguish this bulk-placement operation from any sibling like set_my_property_room_selection or add_my_guest without opening the schema.

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

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

Explains the two ways to invoke it (rule-based fill or a room/guest list) and states prerequisites ('Requires sign-in and an Aisle membership'). However, it never explicitly says when to prefer the rule mode over the assignments mode, nor names a when-not scenario, leaving some routing inference to the reader.

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 destructive/idempotent/openWorld and non-read-only; the description goes well beyond them by disclosing the payment and checkout safeguards that block deletion, that payment history is retained, the default place-retention behavior, and the auth/membership requirement. That is exactly the operational context a destructive tool needs.

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

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

Front-loads the core action, then layers safeguards and the place-retention rule; every clause carries operational meaning. It is dense and slightly long, but no sentence is filler.

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

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

For a destructive mutation with annotations and no output schema, the description covers preconditions, blocking states, retention semantics, and auth. The only gap is what the caller receives on a blocked removal (error vs. partial effect), which is left implicit.

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

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

Schema coverage is 100%, so the baseline is 3; the description nonetheless adds interpretive value by explaining the retention rule that governs remove_empty_place (place kept unless the flag is set and no other rooms or retained history exist) and the payment-history interaction. It adds nuance rather than restating types.

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 ('Removes an identified room and its guest assignments') scoped to 'the selected wedding', which cleanly separates it from remove_my_place, remove_my_event, and remove_my_guest among the siblings. An agent can identify the target entity without opening the schema.

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

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

Gives clear when-not conditions (uncharged checkouts without a payment method require confirmed cancellation; completed/refunded/processing payments and active card-backed checkouts block removal) and points to the alternative path for empty places. It never names the sibling tool (remove_my_place) directly, so routing is described functionally rather than explicitly.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is largely covered. The description adds genuinely useful context beyond that: the authentication/membership requirement and the fact that the removed event's id and name are returned.

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

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

Two tightly written sentences with zero filler; the core action is front-loaded and the return value plus prerequisite follow. Nothing is wasted.

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

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

For a simple destructive mutation with no output schema, the description covers purpose, required auth, and the return payload, while annotations cover irreversibility. It stops short of noting side effects such as cascading changes to related guests or places.

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 event_id and wedding_id both documented in the schema, so the schema carries the semantic load. The description only loosely touches the 'selected wedding' scoping and adds no format or multi-wedding nuance 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 pairs a specific verb ('Removes') with a clear resource ('event from the selected wedding') and even states the post-condition (returns the removed event's id and name). It is easy to distinguish from remove_my_guest or remove_my_place by resource, though it never explicitly contrasts with siblings.

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

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

Usage is only implied: removing an identified event. The description states a precondition ('Requires sign-in and an Aisle membership') but offers no when-to-use routing, no exclusions, and no pointer to alternatives like update_my_event or remove_my_accommodation.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the mutation profile is covered structurally. The description adds genuinely useful context beyond that: the return payload (removed guest's id and name), the age-eligibility gate, and the auth/membership requirement.

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

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

Three tight sentences, front-loaded with the destructive action and its target, followed by eligibility and auth constraints. No filler and nothing repeated from the schema.

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

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

With no output schema, the description usefully states what is returned (id and name), and it covers auth prerequisites and eligibility for a destructive single-entity operation. Only the absence of any alternative-tool routing keeps it from full completeness.

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

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

Schema description coverage is 100%, so both guest_id and wedding_id are already documented, including the conditional 'required when the account has multiple weddings' note. The description adds no format or selection detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb+resource ('Removes an identified guest') scoped to 'the selected wedding', and distinguishes itself from siblings like remove_my_accommodation, remove_my_event, and remove_my_place by naming the guest entity. It also adds the eligibility boundary (13+, confirmed age), which further narrows the 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?

Gives clear when-not conditions: guests under 13 or with unconfirmed ages are ineligible, and the caller must be signed in with an Aisle membership. It does not, however, name the alternative tools (e.g., update_my_guest for edits, list_my_guests for lookup), so routing guidance stops short of the top tier.

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 flag destructive/idempotent/open-world, and the description goes well beyond them: per-item partial success semantics ('each place is removed or kept on its own... with the reason'), dry-run behavior, side effects on recommendation/booking links, the safety guarantee that no rooms or payments are deleted, and explicit sign-in plus Aisle membership 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 core action and its precondition lead the text, and each sentence carries a distinct fact (multi-place semantics, dry run, side effects, blockers, auth). It is slightly long and repeats the dry-run/removal point across two sentences, costing it the top score.

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 still describes the return shape (remaining order, per-place removed/kept with reasons) and covers auth, constraints, dry-run escape hatch, and mutation side effects. Nothing an agent needs to call it safely 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%, so dry_run, place_id, place_ids and wedding_id are already fully documented in the schema. The description reinforces the sourcing of the ids and the dry-run meaning but adds no format, exclusivity, or batching detail beyond what the schema states, 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?

States a specific verb and resource ('Removes ... empty places from the selected wedding and its property order') plus the scope restriction that only empty places qualify. The mention of returning 'the order that remains' distinguishes it from reorder_my_places and the other remove_my_* siblings, which touch different resources.

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

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

Gives clear context: places come from the selected wedding's places list, dry_run previews without mutating, and 'any rooms, including archived history, prevent removal' defines the failure condition. It stops short of naming alternative tools (e.g. reorder_my_places) or explicitly stating 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?

Goes well beyond the annotations: it discloses that this is a full-replace operation (complete list mandatory), that partial/invalid input is refused rather than partially applied, that name matching is case- and whitespace-insensitive, and that responses return the order as ids with names. With destructiveHint and idempotentHint set, these added semantics are exactly what an agent needs to avoid surprising side effects.

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

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

Front-loaded with the core action, then constraints, matching rules, refusal behavior, and auth requirement, with no redundant sentences. Every sentence carries operational information.

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

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

With no output schema, the description still explains the return shape ('order as ids with names'), the failure mode, and the auth prerequisite, so an agent has everything needed to call and interpret 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 baseline is 3, but the description adds meaning the schema lacks: name matching ignores case and surrounding spaces, and results echo back ids with names. It clarifies the place_ids vs place_names relationship only at the level the schema already does.

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 (sets the order) and a specific resource (all properties on the wedding's guest site and accommodation screen), which is clearly distinct from siblings like set_my_property_room_selection or place_my_guests_in_rooms. An agent can identify the tool and its scope without opening the schema.

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

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

Gives concrete usage conditions: the complete list is required, ids or names are both acceptable, and partial or invalid lists are refused. It adds a prerequisite (sign-in plus Aisle membership) but does not name an alternative tool for related reordering tasks, so it stops short of explicit when-not guidance.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description still adds real value beyond that by disclosing the retrieval contract: up to 10 excerpts, links to full articles, last-revised dates, and the default 3-per-guide cap. Nothing here contradicts the annotations.

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

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

A single sentence with the action and resource front-loaded, followed by return-shape and limit clauses that all carry information. It is dense and slightly long, but no clause is pure filler.

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

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

With no output schema present, the description carries the return-value burden and does so reasonably, explaining the excerpt count, accompanying links, revision dates, and per-guide cap. Pagination or behavior on zero results is not addressed, which is the one remaining 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 both query and max_per_guide are fully documented in the schema itself, which sets the baseline at 3. The description's 'unless a different per-guide limit is supplied' gestures at max_per_guide but adds no format or constraint detail beyond what the schema already carries.

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 (Searches) and resource (Aisle wedding planning guides) scoped by keywords, and even characterizes the return shape. This clearly distinguishes it from search_vendors and search_venues, which are the only other search tools among the siblings.

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

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

Usage is implied by 'by keywords' and the guides domain, so an agent can infer when to reach for it. However, there is no explicit when-to-use, no when-not-to-use, and no routing against a sibling alternative (e.g. search_vendors vs this). Minimum viable guidance only.

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 readOnly/idempotent annotations already covering safety, the description adds substantial value: result field composition, summary mode behavior, Aisle-generated vs vendor-managed content attribution, rating provenance, price band conditional semantics, nearby-location fallback at <5 results within 150km, distance-from-corpus-center semantics, and duplicate detection via shared website/phone. This is unusually rich behavioral disclosure.

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

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

Front-loads the core purpose and filters, then layers behavioral details. At ~9 sentences it is longer than typical, but nearly every sentence conveys distinct non-obvious behavior. Slightly dense but justified.

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?

No output schema exists, so the description carries the return-value burden and does so thoroughly: field contents, summary mode, attribution fields, price band reporting, nearby-location fallback, distance semantics, and duplicate flagging. An agent has enough to interpret results without further structure.

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 already documents all 9 parameters including enums and defaults. The description re-states some semantics (price band conditional matching, min_rating filtering) but adds little beyond what the schema provides; baseline 3 is appropriate.

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

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

States a specific verb+resource (searches published wedding vendors) with scope modifiers (by category, location, price range). Clearly distinguished from siblings like search_venues and get_vendor_details.

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?

Implicitly places itself as the discovery tool versus get_vendor_details (siblings exist for detail retrieval), and the final sentence 'does not check live availability or make bookings' sets a negative boundary. However, it never explicitly names an alternative tool or states when to prefer it over search_venues.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world. The description adds real value beyond them: what the results contain (descriptions, photos, links, totals, pagination), how summary mode differs, and the null semantics for unknown capacity and unverified price bands, plus an explicit statement that no booking/availability side effects occur.

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 dense sentences, front-loaded with the core search action and filters before result shape and limitations. Every sentence carries information, though the null/import clauses are somewhat compressed into one long sentence.

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

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

With no output schema, the description usefully covers the return shape (descriptions, photos, links, totals, pagination) and the summary variant. All ten parameters are documented in the schema, and the no-booking limitation is stated, so little is missing for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning the schema lacks: 'Unknown capacity and unverified imported price bands are null' clarifies the result-side semantics of the capacity/price filters, and the summary clause explains the summary flag's effect on payload contents.

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 (Searches) and resource (published destination wedding venues) with the exact filter dimensions (country, type, capacity, price). It is easily distinguished from siblings like search_vendors, search_guides and list_venue_countries.

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 closing sentence gives a clear boundary ('does not check live availability or make bookings'), and the mention of optionally excluding unverified imports signals intent. However it never explicitly routes the agent between this and sibling tools such as search_vendors or get_venue_details.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, and the description usefully adds that only the targeted property is affected, that sign-in plus an Aisle membership is required, and that null reverts to the legacy wedding setting. This is meaningful context beyond the structured hints, though it does not cover error behavior on ambiguous names.

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?

Six compact sentences with no filler; the core action and object are front-loaded, followed by matching rules, mode semantics, side-effect scope, and auth requirements in a logical order. Slightly verbose on details that the schema already documents.

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

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

For a 4-parameter mutation tool with no output schema, the description covers the essentials: what is mutated, that other properties are untouched, auth prerequisites, and the returned fields (property id, stored override, effective mode). Only ambiguity/error handling for duplicate names is left implicit.

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's notes on id-or-name matching, case/space-insensitive matching, and the two mode meanings largely restate what both the schema and its parameter descriptions already say, adding little new semantics.

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 (\"Sets room choice\") and resource (one Hosted property in the selected wedding), with clear scope limits ('Other properties retain their settings'). It does not, however, name or differentiate itself from the nearest sibling, place_my_guests_in_rooms, leaving the agent to infer the boundary between the two.

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 through the mode semantics (non-null chooses an assignment mode, null restores the legacy wedding fallback), which tells the agent what each call accomplishes. There is no explicit when-to-use-vs-alternative statement or exclusion (e.g., versus place_my_guests_in_rooms), so guidance remains inferential.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered. The description adds genuinely useful context beyond that: redirects from the previous address are retained, and sign-in plus membership are required. It stops short of describing failure behavior when an address is unavailable.

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

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

Three tight sentences, front-loaded with the action and its main effect (redirect retention), followed by format rules and prerequisites. 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 mutation tool with solid annotations and full parameter coverage, the description covers the effect, the format validation, the auth requirements, and the redirect side-effect. With no output schema, little else is needed for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real constraints not in the schema: length (2-63), allowed character set, and the availability/unreserved requirement. This meaningfully extends what the agent knows about the address 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?

States a specific verb (Changes) and resource (the selected wedding's guest-site address within aisle.wedding), making the scope immediately clear. No sibling tool performs anything comparable, so there is no ambiguity to resolve.

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 clarifies operation context ('the selected wedding') and lists prerequisites (sign-in and Aisle membership). It does not name exclusions or alternatives, but no sibling tool overlaps with this action, so clear context is enough.

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

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

Annotations give destructive/idempotent/readOnly/openWorld hints, but the description adds genuine behavioral depth: partial-update semantics, which fields null clears, the price-enables-payment coupling with zero meaning free, the returned previous-values diff, and the sign-in plus membership requirement. This exceeds what the structured annotations convey.

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

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

Four sentences, each carrying distinct information — update scope, null/omit semantics, payment coupling, and return/auth behavior — with the core operation front-loaded. No filler or restated title text.

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

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

For a 19-parameter mutation tool with no output schema, the description covers what the tool writes, how null vs omission differ, the payment side effects, the returned result shape (saved details plus previous values), and the auth prerequisites. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds cross-parameter meaning the schema does not state: setting price_amount implicitly enables payment unless disabled, and zero makes the room free. It nonetheless does not clarify the deposit/balance due-date interaction beyond what the schema already documents, so it stops short of a 5.

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

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

States a specific verb (Updates) and resource (room details, pricing, payment/deposit schedules) scoped to the selected wedding, which cleanly separates it from add_my_accommodation, get_my_accommodation and remove_my_accommodation. An agent can identify the operation without opening the schema.

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

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

Gives strong invocation guidance: omitted fields remain unchanged, null clears specific fields, and it explicitly disclaims initiating a charge ('This tool does not initiate a charge'). It does not, however, route the agent to alternatives such as get_my_accommodation for reads or add_my_accommodation for creation, so no explicit when-not guidance exists.

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?

Adds substantial context beyond the annotations: omitted fields and existing invitations/responses are preserved, null explicitly clears specific fields, results echo previous values, and it requires sign-in plus an Aisle membership. The destructiveHint is substantiated by the concrete null-clearing rules rather than contradicted.

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

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

Front-loaded with the core action, then layered with preservation, null, return, and auth details, all of which earn their place. The field enumeration is slightly repetitive across sentences but not wasteful.

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

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

For an 11-parameter mutation with no output schema, it covers the essentials: partial-update behavior, null semantics for clearing, what the response contains, and the auth/membership prerequisite. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents every parameter including the null-clearing semantics. The description's field lists largely restate the schema rather than adding syntax or format detail, 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?

States a specific verb (updates) and resource (event fields in the selected wedding) with the partial-update scope made explicit. An agent can distinguish this from add_my_event, remove_my_event, and get_my_event without opening any schema.

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

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

The partial-update semantics ('Omitted fields ... remain unchanged') and null-clearing rules give clear context for how and when to call it. However, it never names alternatives (e.g. add_my_event for new events) or states exclusions, leaving routing to inference from the sibling names.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is partly covered. The description adds real context beyond that: what the response contains ('saved guest details, including cleared values'), the auth/membership requirement, and the boundary of what the write can touch. It never explicitly warns that supplying empty strings erases stored values, which is the main remaining gap given destructiveHint=true.

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

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

Four sentences, all front-loaded: purpose first, then required identifier, then return behavior, then exclusions and auth. Each sentence carries distinct information, though the return-value sentence is close to filler since it could be inferred.

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 usefully states what comes back, and it covers prerequisites, mutation scope, and field exclusions for a 10-parameter mutation tool. The one omission is an explicit warning that clearing fields is irreversible for those values, despite destructiveHint=true.

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

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

Schema description coverage is 100%, so every parameter already carries its own documentation (including the nuanced 'empty string clears it' and language-clearing semantics). The description only summarizes the updatable field families and notes guest_id is required, adding little beyond the schema; baseline 3 applies.

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

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

States a specific verb (updates) and resource (a wedding guest) plus the exact field families affected: name, contact, RSVP, communication preferences, language. It also scopes the target with 'already recorded as 13 or older in the selected wedding', which separates it from add_my_guest and remove_my_guest without opening either schema.

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

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

Gives clear when-not conditions ('cannot change age bands, guest notes or dietary details') and prerequisites ('Requires sign-in and an Aisle membership'), which route the agent away from this tool for those cases. It stops short of naming the alternative tool for the excluded fields, so it falls just under the explicit-alternatives bar.

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 assert destructiveHint=true and idempotentHint=true without saying what is destroyed; the description fills that gap by naming which fields can be cleared, forbidding empty partner names, and warning that unpublishing hides the site from guests 'including those with an existing link'. It also discloses the auth requirement and that results carry previous values alongside saved settings.

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

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

Four tight sentences, each carrying distinct information: purpose first, then mutation/merge semantics, then return shape, then access requirements. No filler and the most decision-relevant content (publish/unpublish, clearing) 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?

With no output schema, the description usefully enumerates what results contain, and it covers auth and destructive side effects for a 10-parameter mutation. The one gap is that it reports a site address in results without noting that changing that address belongs to the sibling set_my_site_address tool.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds non-obvious merge semantics ('Omitted fields remain unchanged') and the replace-vs-clear distinction that the schema only implies field by field. It stops short of clarifying the wedding_id resolution case for accounts with multiple weddings, which stays in the schema only.

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 ('Updates supplied wedding settings') and adds a distinguishing capability ('can publish or unpublish the guest site') that no sibling update_* tool offers. An agent can separate this wedding-level mutation from update_my_guest, update_my_event and update_my_accommodation without opening a schema.

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

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

Preconditions are implicitly supplied ('Requires sign-in and an Aisle membership') and the field rules imply when each parameter matters, but the description never states when to choose this tool over alternatives such as set_my_site_address or set_my_property_room_selection, whose concerns overlap with publishing and room mode. Usage is inferable rather than explicit.

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