Vila Buarque

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It clearly states that nothing is booked until payment, the booking stays off the calendar until a human pays, and the contact email is not verified. These are critical side effects and state changes that an agent must know.

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

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

Every sentence in the description carries essential information: the action, the payment caveat, the instruction to tell the user, the prerequisite call, and the email verification limitation. It is front-loaded with the core purpose and wastes no words on redundant details.

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

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

The description is complete for a tool with six parameters, a nested contact object, and no output schema. It explains the return value (checkout URL), the necessary precondition, and the consequence of not completing payment. The level of detail leaves no critical ambiguity for an agent invoking this tool.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters and nested fields. The description does not add parameter-level details beyond the schema, but it reinforces the necessity of using `get_availability` output for start/end dates. Per the rubric, high coverage yields a baseline of 3.

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

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

The description opens with 'Book an appointment slot at a venue (Wix Bookings)', giving a specific verb and resource. It then clarifies the tool's actual behavior—returning a checkout URL rather than finalizing the booking—which distinguishes it from the sibling `create_checkout` and prevents misuse.

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

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

The description explicitly instructs to 'Call get_availability immediately before this' and warns that a taken slot will be rejected. It also tells the agent to 'Tell the user they must open the link', providing clear when-to-use and follow-up guidance. This effectively differentiates the orchestration flow from 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?

With no annotations, the description carries the burden and does well by clarifying that the AI agent is not authenticated and payment happens after the user clicks the URL. This disambiguates the tool's side effects (it doesn't complete the purchase), though it doesn't mention potential side effects like cart state.

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

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

The description is two sentences, with the first stating the core purpose and the second providing essential usage/security context. Every word earns its place, and the information is front-loaded.

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

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

For a simple tool with one parameter and no output schema, the description is sufficient: it implies the return value (the checkout URL) and explains the payment flow. It could be more explicit about the return format, but the purpose statement already indicates what the output will be.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no extra parameter-specific details beyond saying 'one or more store products', which the schema already conveys with the items array. No compensation needed.

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

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

The description identifies the action as 'Create a direct checkout URL' for 'one or more store products (Wix Stores)', which is specific and distinct from siblings like create_booking or list_products. The verb+resource+scope structure makes it immediately clear what the tool does.

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

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

The description provides clear context: it creates a URL that the user clicks to complete payment, and no login is required on the AI agent side. This implies when to use it (for store product purchases), though it does not explicitly name alternatives or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It discloses a critical behavioral detail: slot times are returned in the VENUE's timezone, not necessarily the directory's. The verb 'Get' implies read-only, but it does not explicitly mention side effects or authentication 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?

Three short sentences, each earning its place: the first states purpose, the second gives parameter dependencies and format, the third warns about timezone. Front-loaded and free of fluff.

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

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

Covers purpose, parameter origins, and a key timezone gotcha. No output schema exists, but 'available time slots' implies the return shape. It lacks explicit description of the response structure or error behavior, but for a simple read-only tool it is sufficiently complete.

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

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

Schema coverage is 100%, but the description adds valuable meaning beyond the schema: it explains that serviceId comes from list_booking_services, reinforces using the same place_slug as passed there, and highlights the timezone implication. This goes beyond simple restatement.

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

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

The description uses a specific verb+resource+scope: 'Get available time slots for a bookable service on a given date.' It clearly distinguishes from sibling tools like create_booking or list_booking_services.

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

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

Implies a clear workflow: first call list_booking_services to obtain serviceId, then pass the same place_slug used there. This connects to sibling tools and sets context for when to use the tool. However, it does not explicitly state when not to use it or name alternatives.

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

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

No annotations are provided, so the description carries the burden. It states what is returned (names, prices, sale status, availability count) and the input requirement, but it does not disclose any side effects, auth needs, or rate limits. For a read-only tool, this is adequate but not rich. Score 3 is fair.

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, each earning its place. Front-loaded with the action and result, and the second sentence adds the source hint and return details. No fluff.

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

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

For a simple single-parameter read tool, the description is sufficient: it states the input source, the specific outputs, and the event domain (Wix Events). No output schema exists, but the description covers the return values. It doesn't mention edge cases (e.g., events with no tickets), but for a simple getter this is acceptable.

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 the parameter. The description adds that the slug comes from list_events, reinforcing the schema. It doesn't add syntax or format details beyond the schema, so baseline 3 is appropriate.

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

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

The description has a specific verb ('Get') plus a specific resource ('ticket types and prices for a specific event') and clearly distinguishes from siblings by naming the event slug source (list_events). It also lists the exact data returned, making it unambiguous.

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

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

It gives a clear prerequisite: 'Pass the event slug from list_events.' This implies use after list_events and before ticket purchase. It doesn't explicitly name alternatives, but the sibling set includes reserve_event_tickets, so the description implies when to use this vs another tool. Clear context, minor exclusion 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?

With no annotations, the description carries the behavioral burden. It clearly signals a read-only retrieval via 'Get' and discloses the exact return content (program name, points currency, tier structure). It doesn't mention auth or side effects, but a zero-parameter getter has minimal behavioral complexity.

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

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

The description is a single, front-loaded sentence that states the action, resource, and important return fields. It contains no filler and each phrase adds useful information.

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

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

For a no-input, no-output-schema tool, the description fully covers what is returned and scopes to the current site. It is complete and leaves no major gaps for an agent to invoke and interpret correctly.

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

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

The tool has zero parameters and an empty input schema, so the baseline of 4 applies. No parameter explanation is needed, and the description focuses on what the returned data contains.

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

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

The description uses a specific verb ('Get') with a concrete resource ('loyalty/rewards program details') and scopes it explicitly to 'this site (Wix Loyalty)'. It clearly distinguishes itself from sibling tools like get_site_info by naming the loyalty domain and the exact return fields.

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

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

The description provides clear context: use this tool to retrieve the Wix Loyalty program details for the current site. It doesn't explicitly list exclusions or alternatives, but the scope and output are specific enough that the intended use case is unambiguous.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It transparently lists the exact response components, including the structure of the delivery array and the open_now boolean, which is valuable. However, it does not mention potential errors (e.g., invalid slug) or any side effects, though for a read-only get operation this is acceptable.

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

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

The description is a single, information-dense sentence that leads with the primary purpose and then enumerates key response fields. While long, every phrase contributes value (e.g., specifics about delivery platforms and the 'precomputed open_now boolean'). It is well-structured and front-loaded.

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

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

Given the tool's moderate complexity (one parameter, no output schema), the description effectively covers what the caller can expect, including the structure of nested arrays. It does not explain error handling or null cases, but for a simple get-detail tool the provided information is largely complete.

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

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

Schema coverage is 100% with a clear schema description for 'slug'. The tool description adds minimal extra meaning beyond restating 'by its URL slug', essentially echoing the schema. Thus the baseline of 3 applies, as the schema already 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 clearly identifies the tool's action ('Get full details') and resource ('a specific place'), with the unique identifier ('URL slug') and the exact data returned (opening hours, open_now, attributes, delivery, ratings, address, neighborhood). This distinguishes it from sibling tools like search_places (searching) and get_reviews (reviews only).

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 clear usage: use this when you have a place's URL slug and need full details. It does not explicitly mention when not to use it or name alternative tools, but the context ('by its URL slug') and the list of sibling tools provide enough situational clarity.

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

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

With no annotations, the description carries the transparency burden. It clearly indicates a read-only operation ('Get') and describes the exact return payload, including dietary labels. However, it doesn't disclose behavior on invalid slugs or mention any potential side effects, though none are expected.

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 action and return value, then a single instruction for finding the parameter. 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?

For a tool with one required parameter and no output schema, the description fully covers what it does, what it returns, and where to get the input. No significant gaps.

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

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

The schema provides 100% coverage with a type and example for place_slug, and the description adds practical guidance on how to obtain the value via search_places or list_categories, exceeding the schema's basic documentation.

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

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

The description uses the specific verb 'Get' with the resource 'food menu for a specific restaurant', and explicitly lists return contents (sections, dishes, descriptions, prices, dietary labels), distinguishing it from sibling tools like search_places and get_reviews.

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

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

The description explicitly instructs to use search_places or list_categories first to find the place_slug, providing clear prerequisite context. It does not explicitly state when not to use it, but the guidance is sufficient for this simple read tool.

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

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

No annotations are provided, so the description carries the full burden. It reveals it returns only 'published' reviews and lists the output fields, but does not disclose any potential caveats like pagination, sorting, or authentication requirements. For a simple read tool this is adequate but not rich.

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

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

The description is a single sentence that is front-loaded with the action and resource, followed by the key return fields. No wasted words.

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

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

For a tool with one optional parameter and no output schema, the description covers the core purpose and return fields. It lacks mention of ordering or pagination, but the limit parameter in the schema handles that partially. Overall sufficient for a simple getter.

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

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

The schema already provides 100% coverage for the single parameter 'limit' with default and max values, so the description adds no additional parameter meaning. Baseline of 3 applies because 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 clearly states the tool gets published reviews for the site (Wix Reviews), with a specific verb and resource. It also lists the returned fields (reviewer name, rating, title, content), making it distinct from sibling list/get tools.

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

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

The description implies this is for fetching site-specific reviews, giving clear context for when to use it, but does not explicitly mention alternatives or when not to use it. The distinction from siblings is clear enough for a simple fetch tool.

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

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

With no annotations, the description carries the full burden. It discloses the return structure (cinema, session times, format, language) and a prerequisite (movies_enabled). The verb 'Get' strongly implies a read-only operation, and it does not hide side effects. It lacks error-case handling but is reasonably transparent for a simple query 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?

The description is two sentences, with purpose first, then return details, then a prerequisite. Each clause adds value, with no redundant information. It is well-structured and concise.

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

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

For a simple read tool with two parameters and no output schema, the description sufficiently covers purpose, return format, and a prerequisite. It is slightly incomplete in explaining how to determine 'movies_enabled' or the meaning of 'this neighborhood,' but given the tool's simplicity, it is adequate. Not a full 5 due to these minor gaps.

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

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

The schema covers both parameters with clear descriptions (date format, movie_slug from list_movies). The description adds minimal extra meaning beyond mapping 'given date' and 'specific movie' to the parameters. With 100% schema coverage, the baseline of 3 applies, and the description does not enhance beyond that.

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

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

The description clearly states the tool's function with a specific verb 'Get' and resource 'showtimes for a specific movie at cinemas in this neighborhood, for a given date.' It distinguishes itself from siblings by focusing on movie showtimes and specifying return fields (session times, format, language). This leaves no ambiguity about the tool's purpose.

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

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

The description implies usage by requiring a specific movie and date, and notes the prerequisite 'Requires movies_enabled on this site.' It does not explicitly mention alternatives or exclusions, such as using list_movies to find the movie_slug, but the context is clear. It provides a clear usage context without exclusions.

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

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

With no annotations, the description carries the full burden. It clearly discloses that the tool returns information including local time and weather, making its read-only nature obvious. It does not mention rate limits or auth, but these are less critical for a simple info retrieval tool. The description adds value beyond the schema by listing exact data fields.

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

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

Two sentences, front-loaded with the main purpose and followed by a usage hint. Every word earns its place, no redundancy.

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

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

Given the tool has no parameters, no output schema, and no direct siblings with overlapping functionality, the description is fully complete. It tells the agent what data is returned and when to use it, covering all necessary context.

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

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

With zero parameters, the baseline is 4. The description adds context by enumerating the return fields, which helps the agent understand what the tool will provide even without an output schema. No parameter clarification is needed.

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

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

The description clearly states it returns basic neighborhood directory information (name, locale, domain, description, canonical URLs) plus local time and weather. It uses a specific verb 'Returns' and identifies the resource accurately, distinguishing it from siblings like 'get_place' and 'list_events'.

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

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

Explicitly states when to use: 'Use this for any "what time is it there" or "what's the weather like" context.' This provides clear context, though it does not mention exclusions or alternatives, which is acceptable since no sibling offers similar functionality.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It discloses the output fields and that only published posts are returned, which is useful. It implicitly signals a read-only operation through the verb 'list' and specifies recency, but does not explicitly state 'read-only' or discuss sorting/limits beyond the schema.

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

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

The entire description is a single sentence that front-loads the action and resource, adds a parenthetical for clarity, and enumerates return fields. Every word earns its place with no redundancy or vague 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 simple list tool with two optional parameters and no output schema, the description is sufficiently complete. It names the return fields, qualifies 'recent published posts', and identifies the site type. Given the low complexity, no additional information is needed for an agent to invoke it correctly.

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

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

Schema coverage is 100% — both 'limit' and 'category' have descriptive text. The tool description adds no parameter details beyond what the schema already provides, so a baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('List') with a clearly scoped resource ('recent published blog posts for this site (Wix Blog)'). It lists concrete return fields, making it unmistakable what the tool does and distinguishing it from sibling list tools that target other resources.

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

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

The description clearly states the context (blog posts for this site) and what it returns, making the use case obvious. It does not explicitly name alternatives or exclusion criteria, but the sibling tools are all different resource types, so the intended usage is clear without needing explicit contrast.

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

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

With no annotations, the description carries full burden. It discloses that services are listed for every venue, that non-bookable services have null id, and that bookingUrl should be used when bookableViaMcp is false. It also specifies return fields, giving rich behavioral context.

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

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

The description is dense but every sentence serves a purpose: core action, parameter guidance, return details, and fallback behavior. It is front-loaded with the primary use case and avoids 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?

The tool has one optional parameter and no output schema, but the description covers return fields, edge cases (non-bookable venues, default directory services), and integration with create_booking. It is complete for an agent to use correctly.

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

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

Schema coverage is 100% and the schema already describes place_slug's role. The description adds critical extra meaning by noting that only the venue form's serviceId works with create_booking, which is not in the schema. This goes beyond the baseline of 3.

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

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

The description clearly states the tool lists a venue's services with price and duration, using a specific verb and resource. It distinguishes itself from sibling tools like list_events or list_products by focusing on venue services and explicitly linking to create_booking.

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

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

Provides explicit when-to-use guidance: passing place_slug is recommended for venue services, omitting it returns directory-site services. Also explains when not to book (bookableViaMcp false) and directs users to bookingUrl as an alternative, which is actionable.

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

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

With no annotations, the description carries the burden and it does disclose key behavioral traits: return contents include hierarchy, localization, schema.org types, and live place counts. It does not mention auth, errors, or response structure, but for a simple read-only listing this is meaningful context.

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

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

A single, directly phrased sentence leads with the verb and object, then efficiently enumerates the included components. No wasted words; the main 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?

Given no parameters and no output schema, the description provides solid coverage of what the tool returns, including hierarchy and data categories. It is complete enough for an agent to select and invoke it, though it stops short of specifying the exact JSON shape or edge-case behavior.

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

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

The tool has zero parameters and an empty input schema, so there is nothing to explain. Baseline for 0 params is 4, and the description does not add or need param 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?

The description starts with a specific verb ('Returns') and resource ('full category taxonomy'), clearly distinguishing it from sibling list_* tools. The detail about top-level groups, subcategories, localized labels, schema.org types, and live place counts makes the scope concrete.

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?

Clear context for when to use: a need for the directory site's full category taxonomy. However, it does not explicitly mention alternatives or exclusions, unlike a high-scoring tool that names sibling tools.

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

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

With no annotations, the description carries the burden and does well: it reveals that events within 7 days include a weatherForecast (condition + min/max temperature) and that 'agora' is resolved live on every call. These are non-obvious behaviors not derivable from the schema, adding real 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?

Two sentences, front-loaded with the core purpose, and no wasted words. The weatherForecast note and filter guidance are packed into a tight second sentence.

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

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

For a list tool with three fully described params and no output schema, the description covers essential behaviors: return fields, special weather data, and filter semantics. It is complete enough for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, giving a baseline of 3. The description adds extra meaning for `filter`, explaining it can narrow by time or price and giving a concrete live-use case for 'agora'. This goes beyond the schema's individual enum descriptions.

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

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

The description clearly states 'List upcoming events in this neighborhood with date, venue, price, and URL.' This identifies the verb (list), resource (events), and scope (neighborhood), and distinguishes it from sibling tools like list_movies or list_blog_posts by focusing on events.

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

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

The description provides concrete usage guidance for the `filter` parameter, including a specific example: 'filter: "agora" answers "what can I go to right now"'. It even notes the live response advantage over cached pages. However, it does not explicitly name alternatives or exclusions, so it's clear context without full differentiation.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It discloses that the tool retrieves all FAQs and groups them by category, but does not explicitly state read-only safety, return format, pagination, or any other behavioral traits. The 'Get' verb implies a safe read, but lacks the richness needed for full transparency.

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

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

The description is very concise, with three short sentences that front-load the core action. 'Get all FAQ questions and answers' is immediately actionable, and every subsequent phrase adds value (grouping, use case). No filler or redundant language is present.

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

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

Given there is no output schema, the description should convey what the agent will receive. It states that the tool returns FAQ questions and answers grouped by category, which is sufficient for a simple no-parameter retrieval tool. It lacks explicit field names or examples, but the overall use case is well covered.

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

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

The tool has zero parameters, and the input schema is an empty object with 100% coverage. Since there are no parameters to document, the baseline of 4 applies. The description confirms there are no inputs needed, adding no confusion.

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

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

The description starts with a specific verb 'Get' followed by the resource 'all FAQ questions and answers', making it immediately clear what the tool returns. Adding '(Wix FAQ)' and 'Grouped by category' further distinguishes it from sibling list tools like list_blog_posts or list_events.

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

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

The description explicitly states when to use the tool: 'Use this to answer common questions about the site — opening hours, parking, policies, etc.' This provides clear context and intent. It does not mention alternatives or exclusions, so it misses the top score for explicit sibling differentiation.

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

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

With no annotations, the description carries the full burden. It discloses the return payload (form name, ID, field definitions) and the read-only nature via 'List.' It lacks explicit side-effect or permission notes, but for a zero-parameter list tool this is sufficient.

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

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

Two concise sentences, each adding value: the first states the action and scope, the second details the return info and usage guidance. No wasted words.

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

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

For a zero-parameter tool with no output schema, the description fully covers its purpose, return data, and how it fits into a broader workflow (before submit_form). It is complete for its complexity.

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

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

The tool has zero parameters, so the description does not need to explain parameter semantics. The baseline of 4 applies.

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

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

The description clearly states the tool lists available contact/signup forms with the specific scope of 'Wix Forms.' It distinguishes itself from sibling tools by explicitly mentioning its role in discovering fields before submit_form.

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?

'Use before submit_form to discover which fields to fill' provides direct workflow guidance and names a related tool. This establishes when to use it relative to an alternative.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It mentions the content (ranked places with editorial notes) but does not explicitly state read-only behavior, pagination, or potential side effects. The verb 'List' implies safety, but this is implicit rather than explicit.

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

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

The description is two sentences, front-loaded with the core purpose, and every word adds value. It is concise without sacrificing key details about what the tool does and when to use 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?

For a simple list tool with one optional parameter and no output schema, the description fully covers purpose, content, and ideal usage context. It is complete enough for an agent to select and invoke this tool effectively.

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

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

The input schema covers the single 'limit' parameter with a full description (default 20, max 50), so schema coverage is 100%. The description adds no further parameter context, which is acceptable per the baseline of 3 when schema fully documents parameters.

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

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

The description clearly states the tool lists 'curated editorial guides' and explains they are 'best of' lists with 'ranked places with editorial notes.' This specific verb+resource combination distinguishes it from sibling tools like search_places or list_blog_posts.

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

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

The description explicitly says this is 'The best source for "best X in this neighborhood" questions,' providing a clear when-to-use context. However, it does not name alternative tools or state when not to use it, only implying its niche.

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

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

No annotations are provided, so the description carries the full burden. It discloses the conditional availability (movies_enabled), the return categories, and the specific fields included, giving a transparent view of behavior for a read-only list tool. It doesn't cover error handling, but that's a minor 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?

Three sentences, each adding value: purpose, return categories, and included fields. Front-loaded and free of unnecessary details.

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

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

Given no output schema, the description adequately covers return contents (title, genres, TMDB rating, runtime, detail URL). It also explains the status categories. Minor omissions like response structure don't significantly hinder usage.

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

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

Schema coverage is 100%, with both parameters fully described in the schema. The tool description adds no additional parameter semantics beyond what's already in 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?

The description clearly states it lists movies available in the neighborhood, with a scoping condition (movies_enabled). It differentiates from siblings by explicitly covering now-showing, coming-soon, and streaming categories, which is distinct from the showtime-specific sibling tools.

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

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

It provides clear context on when to use (neighborhood, movies_enabled sites) but doesn't explicitly name alternative tools or exclusion criteria. However, the scope and categories are well-defined, so it's clear what this tool is for.

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?

Without annotations, the description carries full burden for behavioral disclosure. It does reveal that only 'active' offers are returned, lists the output fields, and notes FLASH offers have countdown deadlines. However, it does not explicitly state that the operation is read-only, mention authentication/authorization needs, or describe behavior like sorting, pagination beyond the limit parameter, or error conditions. These omissions leave some behavioral transparency gaps.

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

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

The description is concise and well-structured: the first sentence states the primary purpose, the second enumerates the return fields, and the third highlights the FLASH offer special behavior. Every sentence contributes information without redundancy, making it efficient and easy to parse.

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

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

For a simple list tool with only two optional parameters and no output schema, the description is sufficiently complete. It specifies the scope (neighborhood directory), the default return set (active offers), the fields returned, and the special FLASH offer behavior. No critical information appears to be missing for an agent to effectively invoke and interpret results.

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

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

The schema already provides 100% coverage for both parameters (kind and limit) with descriptions. The tool description adds minimal semantic value beyond the schema; it mentions FLASH offers in the context of countdowns, which is already captured in the kind parameter's description. Thus, the description does not materially enhance parameter understanding beyond what the schema provides, yielding a baseline score of 3.

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

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

The description clearly states the tool's action: 'List active promotions and deals available in this neighborhood directory.' It specifies the resource (promotions/deals) and provides additional detail on what the results include (discount label, promo code, CTA link, validity window, business/place), effectively distinguishing it from sibling listing tools like list_products or list_events.

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

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

The description provides clear context for when to use the tool—anytime active promotions/deals in the neighborhood directory are needed. It does not explicitly name alternative tools or state when not to use it, but the scope is evident from the content type, which differentiates it from siblings that list other entity types.

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

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

With no annotations, the description carries the burden of explaining behavior. It discloses the effect of omitting `place_slug` (falls back to directory plans) and lists the return fields (name, description, price, billing cycle, perks, checkout URL). While it doesn't explicitly state read-only semantics, 'List' implies that, and the output details are useful. It could have mentioned permissions or potential empty results, but it is above average.

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 front-loaded with the core purpose in the first sentence. It uses three sentences, each earning its place: purpose, parameter behavior, and return data. No filler or redundancy.

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

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

For a tool with one optional parameter and no output schema, the description fully covers what the tool does, how to use it, what happens with different inputs, and what results are returned. The return field list compensates for the missing output schema. It is complete for the agent to select and invoke correctly.

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

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

The schema already provides a highly descriptive explanation of `place_slug`, including that it comes from `search_places` and the behavioral difference when omitted. The description adds a usage recommendation ('what you want in almost every case') and examples like 'monthly/annual membership', but these are guidance-oriented rather than new parameter semantics. Since schema coverage is 100% and baseline is 3, this is appropriate.

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

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

The description clearly states the tool's function: 'List membership or subscription plans (Wix Pricing Plans).' It uses a specific verb and resource, and distinguishes itself from sibling tools by focusing on pricing plans rather than products, events, or bookings. The addition of 'Wix Pricing Plans' gives domain context.

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

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

Explicit guidance is provided: pass `place_slug` to get a venue's plans, and omit it to get the directory's own plans, with the note that 'that is what you want in almost every case' and that most sites don't have directory plans. This clearly tells the agent when and how to use the tool, including the recommended input.

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

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

With no annotations provided, the description carries the full burden. It states the tool lists products and returns specific fields, but does not disclose any side effects, authentication requirements, rate limits, or explicitly confirm it is read-only. This lack of behavioral context is a significant gap for a mutation-free tool, though 'list' implies read-only.

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

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

The description is a single, front-loaded sentence that states the tool's purpose and output fields. It is concise with no fluff, earning a 5.

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

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

Given no output schema, the description should explain the return values. It lists the fields but does not specify the structure (e.g., array of product objects) or any additional behavior such as pagination defaults or ordering. For a simple list tool, this is adequate but incomplete, scoring a 3.

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

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

The input schema has full description coverage for both parameters (q and limit). The description adds no additional parameter context 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?

The description clearly states it lists products in the site's Wix Stores, with a specific verb and resource. It also mentions the return fields, which matches the tool's purpose. It distinguishes from sibling list tools by targeting products specifically.

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

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

The description implies usage when product information is needed but provides no explicit guidance on when to use this tool versus alternatives. There are no exclusions or comparisons to other list_* tools, so the agent must infer from the resource name.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does state what the tool returns (name, profile URL, category, metadata) and the verb 'List' implies a read-only operation, but it does not mention pagination behavior, authentication requirements, or whether any metadata fields may be absent. This is adequate but not rich.

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

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

The description is two sentences that efficiently convey what the tool does, what it returns, and what qualifies as a 'solo service-provider profile.' There is no redundant wording or filler.

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

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

The tool is simple (one optional parameter, no output schema), and the description covers the core definition and return fields. It could be slightly more complete by noting that profiles with fixed physical locations are excluded, but the examples already make this clear. Overall, it provides sufficient context for invocation.

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

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

The only parameter, limit, is fully described in the schema (max profiles, default 50), giving 100% schema coverage. The description adds no additional meaning beyond restating the tool's scope, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'List solo service-provider profiles on this site' with concrete examples (dog walkers, tutors, personal trainers). It is specific about the resource type, though it does not explicitly contrast with sibling list_* tools, so it falls short of full differentiation.

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

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

Usage context is implied through the definition of 'solo service-provider profiles' and the phrase 'on this site,' but there is no explicit guidance on when to choose this tool over alternatives like search_places or list_products. No exclusions or alternative tool references are provided.

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

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

With no annotations provided, the description fully discloses key behaviors: the restaurant is NOT notified yet, the request is held, a confirmation email is sent, the link expires in 24 hours, the link is deliberately not returned to the agent, and confirmation happens out of band. This goes well beyond minimal expectations.

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 appropriately sized for the tool's complexity. It is front-loaded with the core action, and every subsequent sentence adds critical operational detail (notification delay, email expiration, non-return of link). No word 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?

Given 7 parameters, no annotations, and no output schema, the description fully covers the tool's workflow, side effects, and critical caveats. It explains the multi-step confirmation process and sets user expectations about what happens after the request, making it sufficiently complete for an agent to invoke correctly.

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

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

Schema coverage is 100%, so parameters are already well documented. The description adds meaningful semantic guidance beyond the schema, particularly for the email parameter: 'Use a real address belonging to the person you are acting for' and clarifies that the link is sent there. It also reinforces that requestedAt must be in the future, adding context to the workflow.

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: 'Request a table at a restaurant.' It also differentiates from siblings like create_booking by explicitly stating this is a request, not a confirmed booking, and that the restaurant confirms out of band.

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

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

The description gives clear context: it explains the request flow (held until confirmation email link is clicked) and contrasts with a confirmed booking. It also instructs the user to use a real address belonging to the person they act for. However, it does not explicitly name alternative tools for confirmed bookings, though the differentiation is implicit.

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

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

With no annotations provided, the description fully carries the transparency burden and excels. It explicitly discloses that the hold is temporary, that nothing is paid, that tickets are not the user's until a human completes checkout, and that the hold expires on its own. It also states the limits (max 10 tickets/types) and the direct-sale-only constraint — far beyond a bare statement.

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

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

Every sentence earns its place: purpose, key behavioral warning, limits, and cross-tool guidance. It's front-loaded with the main purpose, and the structured explanation is clear and compact 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?

Without an output schema, the description still tells the agent the return value is a checkout URL. It covers all critical aspects: what the tool does, when to use it, constraints, and the distinction from external ticketing. No major gaps for an agent to misuse 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 coverage is 100%, so the schema already documents event_slug and the tickets array. The description adds value by imposing a max of 10 tickets and 10 ticket types, and clarifying that tickets array describes what to hold. It doesn't add syntax details, but the constraint is useful beyond the schema.

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

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

The description opens with 'Hold tickets for an event sold through this site (Wix Events) and return a checkout URL' — a specific action on a specific resource for a specific return value. It explicitly disambiguates from siblings by noting only events sold directly by the site, and points out that for external ticket sellers (Sympla, Ingresse, Sesc), the event's own ticketUrl should be used instead.

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

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

It provides explicit when-to-use and when-not-to-use guidance: use for events sold directly through this site; for events sold elsewhere, use the event's own ticketUrl. It also covers practical constraints like the max 10 tickets and 10 ticket types, and explains that this tool only creates a temporary hold, not a completed purchase.

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

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

With no annotations, the description fully discloses the tool's behavior: a confirmation email is sent, the RSVP is only submitted upon link click, the link expires in 24 hours, and the confirmation link is deliberately not returned to the agent. It also states the initial guest list state ('NOBODY IS ON THE GUEST LIST YET'), which is valuable behavioral context.

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

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

The description is front-loaded with purpose and then explains the confirmation flow and agent instructions in three sentences. The all-caps warning is emphatic but not wasteful. Each sentence earns its place, though it is slightly longer than strictly necessary.

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

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

Despite lacking an output schema, the description explains the full user-facing flow and what the agent should do (tell the user to check inbox). It does not detail response formats or error cases, but for an RSVP tool with this level of behavioral disclosure, it is reasonably 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?

Input schema already covers all four parameters with descriptions at 100% coverage. The description adds value beyond the schema by emphasizing that the email must be a real address belonging to the person being acted for, and that the confirmation link will not be returned—critical constraints not present in the schema.

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

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

The description opens with a clear verb and resource: 'RSVP to a free event on this site (Wix Events).' It distinguishes itself from sibling tools like reserve_event_tickets by specifying 'free event' and delivering the RSVP via email confirmation rather than ticket reservation.

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

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

It provides clear context for use (free Wix Events) and actionable instructions for the agent ('Tell the user to check their inbox', 'Use a real address belonging to the person you are acting for'). It does not explicitly name alternatives or state when not to use, but the 'free event' qualifier implicitly differentiates from paid-ticket 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?

With no annotations provided, the description carries the full burden. It discloses search scope ('every menu item across all restaurants'), grouping behavior, return fields (price, description, dietary labels, place URL), and conditional behavior when query is omitted. It does not cover rate limits, errors, or pagination, but offers substantial transparency.

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

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

The description is concise, with three sentences each serving a clear purpose: purpose, example/details, and usage instruction. No redundant or filler content.

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

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

The tool is simple (2 optional params, no output schema), and the description provides essential context: output fields, default behavior, and a usage pattern. It does not mention pagination or sorting, but for a search tool with clear examples, this is adequate. Sibling context suggests this fills a unique niche.

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 baseline is 3. The description adds value by providing a concrete query example and explaining the effect of omitting the query, which goes beyond the schema's simple field descriptions.

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

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

The description clearly states a specific verb ('Find') and resource ('which restaurants serve a dish'), and further distinguishes itself from siblings by describing the site-wide menu search and grouping by dish. The example with 'feijoada' reinforces the purpose.

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

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

It provides explicit guidance on when to use the tool ('Use this for any "where can I eat X" question') and describes the behavior of omitting the query. However, it does not explicitly mention alternative tools or exclusions, so it stops short of a 5.

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

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

No annotations are present, so the description carries full transparency burden. It discloses accent-insensitive/typo-tolerant matching with concrete examples, explains that open_now is computed server-side for the current moment, details that attributes must ALL match, and describes the delivery array structure and hours format — far beyond a basic 'search' statement.

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 front-loaded with purpose, then logically moves to matching behavior, filter composition, result shape, and amenity slugs. Every sentence adds information; it's appropriately detailed for a search tool with 6 parameters.

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

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

The description is complete for the tool's complexity: it covers matching semantics, filter usage, output fields, hours mapping, and amenity slugs. Since there is no output schema, the description's explanation of return fields fills that gap effectively.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful semantics: q matching behavior, open_now meaning, attributes ALL-match rule, and a list of common amenity slugs, which goes beyond the schema's basic field descriptions.

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

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

The description opens with 'Search for places (restaurants, cafes, shops, etc.) in this neighborhood', which clearly states the tool's action and resource. It distinguishes itself from siblings like search_dishes by targeting generic places rather than specific dishes.

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

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

It provides clear usage context by explaining how to compose filters for multi-condition queries, and lists the available filters and their semantics. It does not explicitly mention when to use this tool over search_dishes or other alternatives, so it lacks explicit exclusion/alternative 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?

With no annotations, the description carries the burden of behavioral disclosure. It adds a dependency (call list_forms) and a return value (submissionId), but does not disclose authorization requirements, side effects such as creating a submission record, or potential failure modes. This is a moderate level of transparency for a write operation.

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

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

The description is two concise sentences: first states the purpose, then gives a prerequisite and return value. Every sentence earns its place with no unnecessary detail or repetition.

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

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

For a simple write tool with two fully described required parameters and no output schema, the description covers the core elements: action, prerequisite, and return value. It lacks explicit error handling or permission notes, but these are not essential for basic usage and the tool is otherwise complete.

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

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

Schema coverage is 100% and both parameters are described in the schema, so the description does not need to add much. The description reinforces the prerequisite to get formId and field keys from list_forms, but it does not introduce new parameter-level 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?

The description clearly states the tool submits a form on behalf of the user, specifically in the Wix Forms context. It uses a distinct verb+resource combination ('submit a form'), which distinguishes it from sibling tools like list_forms and other write tools such as create_booking.

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

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

It explicitly instructs to call list_forms first to obtain the formId and field keys, which is a clear prerequisite and usage context. However, it does not mention exclusion criteria or alternative tools, but no direct alternative for form submission exists among the siblings.

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