DOJO+

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

With no annotations, the description carries full burden and excels: discloses that booking is not finalized until payment, returns a checkout URL, the booking remains off-calendar, the email is not verified, and slot re-validation. This is rich, critical behavioral context beyond what a schema could convey.

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

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

The description is moderately sized but every sentence carries essential information, from purpose to critical caveats to sequencing. It is slightly verbose but well-structured with clear emphasis on the payment 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?

Despite lacking an output schema, the description reveals the key return value (checkout URL), the off-calendar behavior, the prerequisite call to get_availability, and user instructions. This is sufficient for an agent to invoke the tool correctly and set user expectations.

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. The description adds cross-tool context by referencing get_availability for start/end dates and list_booking_services for serviceId, which helps the agent correctly source parameter values. It also notes the contact email is not verified, adding behavioral nuance to the contact parameter.

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

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

The description clearly states the tool books an appointment slot at a venue via Wix Bookings, and immediately clarifies the crucial caveat that nothing is booked until payment. This distinguishes it from siblings like create_checkout by emphasizing the booking-creation aspect and the resulting checkout URL.

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 strong when-to-use guidance: explicitly instructs to call get_availability immediately before and warns that a taken slot is rejected. It also tells to inform the user to open the link. However, it doesn't explicitly name alternatives or state when not to use the tool, leaving a minor 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?

No annotations are provided, so the description carries the full burden. It discloses key behavioral aspects: no login required for the agent, and the user completes payment by clicking the URL. This adds context beyond the schema, though it doesn't cover all potential side effects or response details.

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 main action and a clarifying detail about authentication. No filler or redundancy.

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

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

For a simple tool with one parameter and no output schema, the description explains the core purpose and auth requirement. It doesn't explicitly state the return format, but the phrase 'checkout URL' implies a URL response, so 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?

Schema description coverage is 100%, with 'items' described as 'Products to add to cart' and productId referenced as from list_products. The tool description adds minimal extra parameter context beyond the schema, so the 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?

Description clearly states the tool creates a direct checkout URL for one or more store products, using a specific verb and resource. It distinguishes from sibling tools like create_booking by mentioning Wix Stores and the payment flow.

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

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

Implied usage context: the agent should use this to generate checkout links for products obtained via list_products. However, it doesn't explicitly say when not to use it or mention alternatives, so guidance is largely 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?

No annotations provided, so description carries full burden. It discloses a key behavioral trait: slot times are returned in the venue's timezone, not necessarily the directory's. Also implies dependency on consistent place_slug. However, it doesn't describe response format or error behavior, but the timezone warning is valuable.

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, front-loaded with purpose, then usage instructions, then the timezone caveat. Every sentence contributes essential information without redundancy or unnecessary 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 3-parameter tool with no output schema, the description covers input semantics and a critical timezone behavior. It doesn't describe the response structure (e.g., array of slots) or error cases, but given the tool's simplicity and the presence of sibling list_booking_services, the description is largely adequate.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds meaning beyond the schema by specifying the provenance of serviceId (from list_booking_services) and the need to pass the same place_slug. This enriches parameter understanding and cross-tool consistency.

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

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

The description states a specific verb ('Get') and resource ('available time slots for a bookable service'), with the scope (given date via Wix Bookings). It distinguishes itself from siblings like create_booking by focusing on availability retrieval.

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

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

Provides clear context on when to use: pass serviceId from list_booking_services, date in YYYY-MM-DD, and same place_slug used there. The timezone caveat adds practical guidance. It doesn't explicitly state when not to use alternatives, but the cross-tool references make usage clear.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It explicitly lists the return data: 'ticket names, prices, sale status, and how many are left', which gives the agent a clear picture of the output. However, it does not mention authentication requirements, error handling, or whether all ticket types are returned, but for a getter these omissions are minor. The description adds sufficient behavioral context to warrant a 4.

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 purpose, and every sentence earns its place. The first sentence states the action and scope, the second gives input guidance and output details. No fluff 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?

Given the simple nature of the tool (1 parameter, no output schema), the description is nearly complete: it covers what the tool does, the input source, and the expected return fields. It lacks explicit error or edge-case handling, but for a straightforward getter, this is acceptable. The 4 accounts for the lack of an output schema and the absence of any note about why you might not want to use 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?

The schema has 100% coverage with the property description 'Event slug from list_events', which already explains the parameter. The description repeats this instruction rather than adding new meaning. Since schema coverage is high, the baseline is 3, and the description does not extend beyond the schema, so no higher score is justified.

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 'Get ticket types and prices for a specific event (Wix Events)', which is a specific verb+resource+scope. It clearly distinguishes from sibling tools like list_events (which lists events) and reserve_event_tickets (which likely reserves tickets). The event slug relationship is explicitly tied to list_events, making the purpose unmistakable.

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 states 'Pass the event slug from list_events', which clearly indicates a prerequisite and establishes the expected workflow. It implies this tool is used before reserving or checking out, but it does not explicitly say when to avoid using it or name alternatives for excluding use cases. This is clear context without explicit exclusions, so a 4 is appropriate.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It clearly implies a read-only operation via 'Get', and it discloses what the tool returns in concrete terms. It doesn't mention potential errors or prerequisites, but for a simple read-only information retrieval with no parameters, this is adequate.

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

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

The description is a single, well-structured sentence. It front-loads the action and resource, followed by the return details. It is concise and every clause adds meaning, though it is slightly longer than necessary. Overall, it is efficient and clearly structured.

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

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

Given that there are no parameters and no output schema, the description is the sole source of information about the tool's behavior and return values. It lists the key fields returned, covering the main aspects of the loyalty program. It doesn't explain the format of the tier structure, but for a simple GET-like tool, this is sufficient.

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

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

The tool has no parameters, and the schema is empty. The baseline for 0 parameters is 4. The description adds no parameter-specific details because there are none to describe, which 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: it retrieves loyalty/rewards program details for the site, specifically Wix Loyalty. It lists the specific information returned (program name, points currency name, tier structure with required points per tier), which is specific and distinguishes it from the sibling tools, none of which relate to loyalty.

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 this tool: whenever loyalty/rewards program details are needed. It doesn't explicitly mention alternatives, but there are no other loyalty-related tools among the siblings, so excluding alternatives is not necessary. The context is clear and there are no exclusionary clauses.

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 compensates by enumerating the exact returned fields—opening hours, open_now, attributes, delivery deep-links, ratings, address, neighborhood—giving a transparent view of response behavior. It does not discuss auth or failure modes, but for a read-only getter this is largely 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?

The description is a single dense sentence that front-loads the purpose and then lists the key return fields in a compact way. It contains no fluff, though the long enumeration makes it slightly heavy; still efficient.

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 responsibility of explaining return values. It does so thoroughly by listing the core place details and the delivery deep-link structure. The word 'including' hints at non-exhaustiveness, but for a one-parameter read tool it is complete enough for an 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 single 'slug' parameter already has 100% schema description coverage with an example. The description merely restates that the slug is a URL slug, adding no additional meaning or format details beyond what the schema already 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?

The description opens with a specific verb+resource: 'Get full details for a specific place by its URL slug'. This clearly identifies the action and target, and naturally distinguishes it from sibling tools like search_places or 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 implies usage when a URL slug is already known, but it does not explicitly state when to use this tool versus alternatives, nor does it mention using search_places when no slug is available. The prerequisite is clear, but exclusions and alternatives are absent.

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

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

With no annotations, the description carries the burden of disclosure. It discloses return content but does not mention side effects (e.g., read-only nature), auth requirements, or potential error/empty-menu behavior. It adds some value by listing return fields but is not rich in 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?

Two sentences, no fluff, and the most critical information (purpose, return content, prerequisite) is front-loaded. 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?

The tool has a single parameter and no output schema, so the description covers the main purpose, return structure, and prerequisite. It lacks mention of edge cases like a restaurant with no menu, but for a simple retrieval tool this is adequate.

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

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

Schema coverage is 100% and includes an example and source hint for place_slug. The description adds a small extra hint by also mentioning list_categories, but does not significantly go beyond the schema's parameter 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 a specific verb ('Get') and resource ('food menu for a specific restaurant'), clearly distinguishing it from siblings like get_place or search_dishes. It also details return contents (sections, dishes, prices, dietary labels), making the tool's purpose immediately clear.

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

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

It explicitly states to use search_places or list_categories first to find the place_slug, giving clear prerequisite guidance. It does not explicitly mention when not to use this tool versus alternatives, but the context is sufficient.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It mentions the return fields, which is helpful, but does not state safety (read-only), auth requirements, rate limits, or behavior such as pagination beyond the optional limit parameter. The description is minimally transparent.

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

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

The description is a single, front-loaded sentence that states purpose and return fields with no filler or redundant phrasing. Every word contributes value.

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

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

For a simple read-only listing tool with one optional parameter and no output schema, the description covers the essential context: what data is returned and the source. It lacks details on ordering or result shape, but given the low complexity, it is mostly complete.

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

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

Schema description coverage is 100% for the only parameter (limit), including default and max values. The description does not add additional meaning beyond the schema, so it earns the baseline score of 3.

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

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

The description states a specific verb ('Get') and resource ('published reviews for this site (Wix Reviews)'), clearly distinguishing it from sibling list/get tools such as list_blog_posts or get_site_info. It also explicitly lists the returned fields, leaving no ambiguity about its function.

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

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

The description implies when to use the tool—when needing published reviews—but provides no explicit guidance on when NOT to use it or alternatives to consider. Context is clear but lacks exclusionary or comparative instructions.

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 transparently lists all returned data categories, including the notably unusual local time and weather. It does not mention side effects or auth requirements, but for a read-only information retrieval tool this is adequate.

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

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

The description is two sentences with no filler. The first sentence enumerates the returned data; the second provides usage context. Every word contributes to understanding the 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?

Given the tool has no parameters, no output schema, and no annotations, the description fully specifies the return contents and the intended use case. It is complete and self-contained.

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

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

The tool has zero parameters, so the schema if fully self-contained. The description adds no parameter information, which is appropriate since no parameters exist. Baseline 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 uses the specific verb 'Returns' and clearly identifies the resource as 'basic information about this neighborhood directory', enumerating concrete fields (name, locale, domain, description, canonical URLs, local time, weather). This distinguishes it from sibling tools like get_place or get_reviews, which focus on specific entities.

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 second sentence gives explicit usage guidance: 'Use this for any "what time is it there" or "what's the weather like" context.' This clearly states when to use the tool, though it does not explicitly discuss 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses read-only intent via 'List' and specifies filters like 'recent published', but does not elaborate on response format, ordering, or potential errors. 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, well-structured sentence that fronts the verb and resource, then efficiently lists the returned fields. No unnecessary words or repetition, making it concise 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?

The description lists the key return fields, which compensates for the lack of an output schema. It clearly states the scope (site's Wix Blog) and the 'recent published' filter. Minor omissions like sorting order or default pagination behavior are not critical for a simple list 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?

The input schema covers both parameters (limit, category) with clear descriptions, so the description adds no extra parameter-level semantics. Baseline of 3 is appropriate because the schema already provides full coverage; the description does not go beyond it.

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

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

The description clearly states the action (List) and resource (recent published blog posts) for the site's Wix Blog. It distinguishes itself from sibling list tools by explicitly naming blog posts and scoping to the current site.

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 that this tool is for fetching recent published blog posts, which differentiates it from other listing tools like list_products or list_events. However, it does not explicitly state when to use this over alternatives or provide exclusion criteria.

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

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

With no annotations provided, the description carries the full burden and does so thoroughly: it discloses what fields are returned, that services are listed for every venue even without online booking, and that `bookableViaMcp: false` means `id` is null and booking must fall back to `bookingUrl` or the venue page. This is rich, non-obvious 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 multi-sentence but every sentence earns its place. It is front-loaded with the core purpose, then logically moves through parameter guidance, return fields, and the booking fallback caveat — no filler or redundant 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?

Given that there is no output schema and no annotations, the description is remarkably complete: it enumerates returned fields, explains the `bookableViaMcp`/`id` null behavior, and gives the user a concrete fallback path. The tool is simple enough that all relevant operational context is 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?

Although the schema already covers the single parameter, the description adds important semantics: it says `place_slug` comes from `search_places`, explicitly contrasts venue vs directory services, and warns that omitting it yields a different (often empty) result. This goes well beyond the schema's generic description.

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

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

The description opens with a specific verb and resource: "List a venue's services — what it offers, with price and duration." It also distinguishes this tool from sibling list tools by noting that it is "the only form whose serviceId works with 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?

The description explicitly tells when to use the tool: pass `place_slug` from `search_places` for a venue, and notes this is "what you want in almost every case." It also explains when not to use it, when omitting `place_slug` lists the directory's own services (which most sites do not have), and connects to `create_booking` and `bookingUrl` fallback behavior.

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 clearly states this is a return operation with no side effects implied, and enriches with details like 'live place counts' and 'localized labels'. It does not explicitly state read-only, but 'Returns' and the nature of the resource make that clear. This is adequate for a simple retrieval 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 a single, well-structured sentence that front-loads the action and resource, then lists the included components. Every part adds value with no redundancy or 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 zero-parameter, no-output-schema tool with no annotations, this description is fully complete. It explains what is returned, at what level of detail, and signals that the output is a structured taxonomy rather than a simple list. No missing information for an agent to use 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 has zero parameters, and the baseline for zero-param tools is 4. The description adds context about what the fixed output contains, which is sufficient.

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

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

The description uses the specific verb 'Returns' and names the exact resource: 'the full category taxonomy of this directory site'. It lists what the output includes (top-level groups, subcategories, localized labels, schema.org types, live place counts), making it unambiguous and clearly distinct from sibling list_* tools.

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

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

The description implies usage for retrieving category taxonomy but does not explicitly state when to use it instead of other list tools. While the name and content make the purpose obvious, there is no explicit when/when-not guidance, so it scores at the 'implied usage' 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?

With no annotations, the description carries the full burden and does well by disclosing the weather forecast behavior for the next 7 days, the live resolution of 'agora', and the exclusion of season/day-granular sources for that filter. It does not state read-only or idempotency, but for a list operation that is less critical.

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 outputs. The second sentence packs filter semantics and live behavior efficiently, though it is slightly dense with parentheticals. Still, 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?

Without an output schema, the description adequately lists return fields (date, venue, price, URL, weatherForecast) and covers edge cases like multi-day runs and free events. It does not mention pagination or error behavior, but for a simple list tool with three optional parameters, coverage is strong.

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 real meaning: it explains the 'agora' filter semantics, clarifies 'gratis' includes externally-ticketed zero-price events, and ties weatherForecast to the date field. This goes beyond the schema's simple enum labels.

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 ('List'), resource ('events in this neighborhood'), and output fields ('date, venue, price, and URL'). It distinguishes from sibling listing tools like list_movies and list_blog_posts by scoping to neighborhood events and adding the weather forecast detail.

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

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

Provides explicit guidance on using the 'filter' parameter, especially the 'agora' value for live results, and contrasts it with cached pages. However, it does not explicitly mention when to prefer this tool over sibling event-related tools like get_showtimes or get_event_tickets, so it lacks full alternative 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 transparency burden. It discloses that it is a read operation ('Get all') and that results are grouped by category, which is key behavioral context. It does not mention pagination or response format, but for a simple FAQ list 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 concise and front-loaded, stating the purpose first, then grouping behavior, then usage guidance. Every sentence adds value with no redundancy.

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

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

For a no-parameter list tool without an output schema, the description sufficiently covers what the tool does, how results are organized (by category), and when to use it. No critical gaps are identified.

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

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

There are zero parameters, so schema coverage is 100%. The description does not need to add parameter semantics, and the baseline for no parameters is 4.

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

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

The description clearly states the verb 'Get' and the specific resource 'all FAQ questions and answers' for the site, and distinguishes it from sibling tools by focusing on FAQ content and category grouping.

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 with 'Use this to answer common questions about the site — opening hours, parking, policies, etc.' It does not explicitly name alternatives or exclusions, but the guidance is sufficient for an agent to know when to select this tool.

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

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

With no annotations, the description carries the full transparency burden. It discloses the return payload (form name, ID, field definitions with label/type/required) and implies a read-only operation via 'List' and 'Returns'. It could more explicitly state that it has no side effects, but it is largely transparent for a simple list 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?

Two sentences: the first states purpose and platform, the second covers return values and usage guidance. It is concise, front-loaded, and every sentence contributes necessary information.

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

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

Given that there are no parameters, no output schema, and no annotations, the description covers all essential aspects: what the tool does, what it returns, and when to use it. It is sufficiently complete for this zero-parameter 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?

The input schema has no parameters, so the description doesn't need to explain any. Per the rubric, 0 params gives a baseline of 4, and the description doesn't miss anything in this dimension.

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 on the site, specifically naming Wix Forms. It distinguishes itself from sibling list_* tools by the resource type (forms) and mentions the returned data (form name, ID, field definitions).

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 use this tool before submit_form and explains why: to discover which fields to fill. This provides clear workflow context and effectively communicates when this tool is appropriate, even without naming an alternative since none 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?

No annotations are provided, so the description carries the full burden. It discloses the data source ('published by this site') and content nature ('ranked places with editorial notes'), making the read-only behavior implied. It does not describe response structure, pagination, or ordering beyond 'ranked,' but for a simple list tool 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, front-loaded sentence with no filler. Every phrase adds value, and the structure makes the tool's purpose immediately clear.

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

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

For a low-complexity list tool with one optional, well-documented parameter and no output schema, the description sufficiently conveys what is listed and why. It could mention return format, but the lack of output schema and the simple use case make this a minor gap.

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

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

Schema coverage is 100% because the only parameter 'limit' has a clear description in the input schema. The tool description does not add extra semantics for this parameter, which aligns with the baseline; the schema already does the work.

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

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

The description uses a specific verb ('List') and clearly identifies the resource ('curated editorial guides'), further clarifying them as 'best of' lists with 'ranked places with editorial notes.' This clearly distinguishes it from sibling list tools like list_blog_posts and list_categories.

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

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

The phrase 'The best source for "best X in this neighborhood" questions' provides concrete guidance on when to use this tool. However, it does not explicitly name alternatives or state when not to use it, so it falls 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 provided, so the description carries full burden. It discloses behavior beyond a simple 'list' by noting the return fields (discount label, promo code, CTA link, validity window, business/place) and the special FLASH countdown deadline. This gives the agent useful expectations without needing to see output data. It stops short of discussing read-only status, but the verb 'list' strongly implies it.

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

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

Two concise, front-loaded sentences. The first sentence states the action and return fields; the second highlights the FLASH nuance. No wordiness or repetition. Every sentence earns its place.

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

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

For a simple list tool with no output schema, the description provides key return fields and a relevant special case (FLASH countdown). The optional parameters are fully explained in the schema. It does not explicitly mention pagination or read-only nature, but these are less critical for a non-destructive list operation.

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

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

Schema covers both parameters with clear descriptions (kind filter, limit with default/max). The description does not add parameter-specific semantics beyond what the schema provides. Baseline 3 is appropriate because full schema coverage means the agent can rely on it.

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

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

Clear and specific: 'List active promotions and deals' with a defined scope ('neighborhood directory'). Distinguishes itself from sibling tools like list_products or list_events by focusing on promotions/deals. Also lists return fields, making the purpose 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?

The description implies when to use it: when you need active promotions and deals. It clearly states what it returns, so users can infer suitability. However, it does not explicitly mention alternatives or exclusions (e.g., 'for products, use list_products'), so it lacks explicit when-not-to-use guidance.

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

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

With no annotations, the description carries full responsibility. It discloses the behavior of omitting place_slug, specifies the return fields (name, description, price, billing cycle, perks, checkout URL), and implies a non-mutating read operation. It could add an explicit read-only or auth note, but the transparency is strong.

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

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

Three concise sentences, front-loaded with the main purpose, then usage guidance, then return values. No unnecessary words or repetition; every sentence earns its place.

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

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

For a single-parameter tool with no output schema, the description fully covers usage, the meaning of the parameter, and the return fields. It also places the tool in context relative to search_places, making it self-contained.

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

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

Schema coverage is 100%, but the description adds value beyond the schema by labeling place_slug as 'Strongly recommended' and explaining the consequence of omission. This enriches the parameter's semantics beyond the raw schema description.

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

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

The description clearly states a specific verb and resource: 'List membership or subscription plans (Wix Pricing Plans).' It immediately distinguishes venue-specific plans from directory site plans, aligning with sibling tools like list_products and list_offers but with a unique scope.

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: use place_slug from search_places for a specific venue's plans, and omit it only if the directory's own plans are intended (which 'most sites do not have'). This contrasts with alternative usage and recommends the common case.

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 must carry behavioral burden. It does add context by listing return fields (name, price, stock status, product type), implying a non-destructive operation. However, it doesn't explicitly state read-only behavior, authentication needs, or side effects, leaving some transparency 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 description consists of two short sentences. The first states the action and resource, the second lists return fields. No wasted words, and the most important information is front-loaded.

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

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

For a simple list tool with two optional parameters and no output schema, the description provides sufficient information: what it returns and the scoped context. It doesn't mention pagination or ordering, but the schema's limit parameter covers pagination partially, and the mention of return fields compensates for the missing output schema.

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

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

Schema coverage is 100%, and both parameters (q, limit) have descriptions in the schema. The tool description adds no extra parameter meaning, so the baseline of 3 applies as the schema already documents semantics adequately.

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

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

The description clearly uses the verb 'List' with a specific resource ('products') and context ('this site's store (Wix Stores)'). It also enumerates the return fields, making it distinct 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 context 'in this site's store (Wix Stores)' makes it clear when to use this tool—when you need the site's product data. Though no explicit alternatives are mentioned, the uniqueness of the resource (Wix Stores products) among siblings avoids ambiguity. Lacks explicit when-not-to-use guidance, but context suffices.

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 the return fields (name, profile URL, category, metadata) and clearly defines the profile scope, which is valuable behavioral context. However, it omits details about pagination, sorting, or authentication, which are minor for a listing tool but could be useful.

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 action, and every sentence contributes value: the first defines the resource, the second lists return fields. There is no fluff or redundancy, making it concise and well-structured.

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

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

Given the tool's simplicity (one optional parameter, no output schema, no annotations), the description covers the essential return values and scope. It does not mention default limit or pagination, but the schema covers the limit default. It is complete enough for an agent to understand what this tool does and what it returns, though some minor behavioral details are omitted.

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 one optional parameter (limit) with a description ('Max profiles to return (default 50)'), yielding 100% schema coverage. The tool description adds no additional meaning for this parameter beyond the schema, so the 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') and identifies the resource ('solo service-provider profiles') with a clear definition and examples (dog walkers, tutors, personal trainers). This distinguishes it from sibling tools like list_products or search_places, which target physical locations or other entity types.

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 defines the scope: profiles for businesses without a fixed physical location. This context implies when to use the tool, but it does not explicitly state when not to use it or mention alternatives like search_places for physical locations. The clarification is strong enough for an agent to infer usage, but it lacks explicit exclusions.

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

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

With no annotations, the description fully discloses the tool's side effects: the restaurant is not notified yet, a confirmation email is sent, the link expires in 24 hours, and the link is deliberately not returned to the agent. This is rich behavioral context beyond what the schema conveys.

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 front-loads the primary purpose, then delivers critical behavioral warnings in a logical sequence. Every sentence earns its place, avoiding 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's multi-step behavior (request held, email sent, link click required, restaurant confirms out of band), the description covers all necessary context. There is no output schema, but the description explicitly states that no confirmation is returned to the agent, setting correct expectations for the return value and follow-up.

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 adds meaningful context for the 'email' parameter by explaining it must belong to the person being represented and that the confirmation link is sent there, which clarifies why this parameter is essential. Other parameters are adequately documented in the schema, so the description need not repeat them.

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 requests a table at a restaurant, using a specific verb and resource. It explicitly distinguishes itself from a confirmed booking ('This is a request, not a confirmed booking'), which differentiates it from sibling tools like 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 usage context: the request is held and not sent to the restaurant until the confirmation link is clicked. It advises the agent to tell the user to check their inbox and to use a real address of the person being represented. It also clarifies when not to treat it as a confirmed booking, offering an alternative path ('confirms out of band').

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 burden of behavioral disclosure. It clearly states that the hold is temporary, nothing is paid, the tickets are not the user's until checkout is completed, and the hold expires on its own. It also discloses limits (max 10 tickets and 10 ticket types), leaving no major behavioral surprises.

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

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

The description is compact and front-loaded. The first sentence states the core action, the second emphasizes the temporary nature, and the third covers limits and exclusions. Every sentence earns its place without redundancy or low-value 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 two-parameter tool with no output schema, the description is exceptionally complete. It explains the return value (checkout URL), the temporary nature, expiration behavior, limits, and when to use an alternative tool. No critical details are missing.

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

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

The input schema already describes both parameters comprehensively (100% coverage). The description adds valuable constraints beyond the schema: the maximum of 10 tickets and 10 ticket types per reservation, which helps the agent validate input. This goes slightly beyond the baseline for high schema coverage.

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

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

The description opens with a specific verb and resource: 'Hold tickets for an event sold through this site (Wix Events) and return a checkout URL.' This clearly distinguishes it from sibling tools like create_booking, create_checkout, and request_reservation by focusing on temporary holds rather than final purchases or reservations.

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

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

The description provides explicit when-to-use guidance: it only works for events sold directly through Wix Events. It also names an alternative for other cases: 'use the event's own ticketUrl instead' for events sold on Sympla, Ingresse, or Sesc. This gives the agent clear decision criteria.

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

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

With no annotations provided, the description fully carries the burden of disclosure. It explicitly states that the RSVP is not submitted until the confirmation link is clicked, that the link expires in 24 hours, that a confirmation email is sent to the provided address, and that the link is deliberately not returned to the caller. This is excellent transparency about side effects and limitations.

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

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

The description is appropriately sized: four sentences, each serving a distinct purpose. The first sentence states the tool's purpose, the second explains the confirmation flow, the third tells the agent what to tell the user, and the fourth gives a critical safety instruction. No filler or repetition, and the structure is front-loaded with the most important information.

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

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

Given the tool's moderate complexity, the description covers everything an agent needs: the action, the asynchronous nature, the required user-facing instruction, and the constraint about using a real email. There is no output schema, but the description does not need to explain return values since the outcome is clear from the described flow. The description is complete for safe and 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?

The input schema already has 100% coverage with clear descriptions for all four parameters, so the baseline is 3. The description adds minimal new parameter-level meaning—it reinforces the email purpose but mostly repeats what the schema states. It does add an important instruction to use a real address, which relates to the email parameter but is more of an operational guideline than a semantic enhancement.

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: 'RSVP to a free event on this site (Wix Events).' This clearly distinguishes it from sibling tools like create_booking or reserve_event_tickets, which handle paid or ticketed events. The scope is precise and 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?

The description implies the appropriate use case: RSVPing to free events on Wix Events. It also provides critical operational context, such as the need to inform the user to check their inbox and to use a real address. It does not explicitly name alternatives, but the context is clear enough to avoid confusion with related tools.

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

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

No annotations are present, so the description carries the full burden. It discloses that the search covers 'every menu item across all restaurants' and that results are grouped by dish, returning price, description, dietary labels, and place URL. It also mentions the omit-query behavior. Minor gaps include not specifying result ordering or potential error cases, but overall it is quite transparent.

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

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

The description is two sentences plus an example, tightly structured and front-loaded. Every sentence contributes: the first defines the core purpose, the second provides usage detail and output expectations, and the example is illustrative. No redundant or extraneous 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?

This is a relatively simple search tool with two optional parameters and no output schema. The description fully covers its behavior, including the search scope, grouping, returned fields, and alternate mode (top dishes). It gives enough context for an agent to invoke it correctly and interpret results, making it 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 schema already documents both parameters well (100% coverage), including the omit behavior for query. The description adds meaning by explaining the search scope and what each result contains, e.g., 'returns each restaurant serving it with price, description, dietary labels, and the place URL.' This contextualizes how the query parameter is used beyond mere syntax, justifying a score above the baseline.

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: 'Find which restaurants serve a dish in this neighborhood.' It uses a specific verb and resource, and distinguishes itself from sibling tools like search_places and get_restaurant_menus by focusing on dish-level search across all restaurant menus. The example with 'feijoada' further clarifies its 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?

Explicit guidance is given: 'Use this for any "where can I eat X" question.' This tells the agent exactly when to use the tool. It also explains the conditional behavior of omitting the query to list the most-served dishes, providing a clear alternative invocation pattern.

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. It discloses accent-insensitive and typo-tolerant matching, relevance ranking, the exact semantics of 'open_now', the ALL-must-match behavior of attributes, and the detailed result shape including hours format and delivery links.

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

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

The description is dense but every sentence earns its place. It front-loads the core purpose and then efficiently covers query behavior, filters, result fields, and common slugs without unnecessary fluff. The length is appropriate given the tool's complexity and the lack of an output schema.

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

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

Given six parameters, no output schema, and no annotations, the description is remarkably complete. It explains not only how to invoke the tool but also what the response contains, including nested structures like the delivery array and hours periods, so an agent can use the 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?

Although the schema already describes every parameter, the description adds substantial meaning: examples of typo tolerance, the definition of 'open_now' as 'open at this exact moment', the requirement that attributes ALL match, and a list of common amenity slugs. This goes well beyond the structured schema.

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

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

The description opens with a specific verb and resource: 'Search for places (restaurants, cafes, shops, etc.)'. It distinguishes itself from siblings like search_dishes by targeting places generally and by describing the available filters, making the tool's purpose 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?

The description provides clear context: it is for searching places in a neighborhood and supports multi-condition filters. However, it does not explicitly state when to use this tool over siblings such as search_dishes or list_categories, so it stops short of full alternative-based 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 must carry the full transparency burden. It discloses the success return (submissionId) and the prerequisite, but omits details about error behavior, irreversibility, or authentication requirements. For a mutation tool, this is a notable gap, though the description is not misleading.

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 consists of three concise sentences, each delivering essential context: the action, the prerequisite step, and the return value. There is no redundant or filler content; 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?

Despite lacking annotations and an output schema, the description covers the critical workflow: get form info via list_forms, submit, and receive a submissionId. It does not explain failure modes or long-term side effects, but for a relatively simple tool with well-documented schema, this 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?

The input schema already provides descriptions for both parameters, and the schema coverage is 100%. The tool description adds no additional parameter semantics beyond referencing list_forms. The schema itself includes a helpful example for fields, 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 submits a Wix form on the user's behalf, using a specific verb and resource. It distinguishes itself from siblings by mentioning the prerequisite of calling list_forms, which implies the tool's role in the workflow.

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

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

It explicitly instructs to call list_forms first to obtain the formId and field keys, providing a concrete usage step. However, it does not explicitly mention when not to use this tool or list alternatives, though the prerequisite effectively scopes its usage.

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