lilo Vacation Rentals

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds useful output information (risk level, concerns, recommended actions) and input flexibility, but does not disclose potential limitations, such as whether at least one input is required or whether the analysis is purely deterministic. This is acceptable given annotation coverage, 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 long and front-loaded with the core purpose and return value. The second sentence lists input options in a compact, readable way. Every word contributes meaning; there is no fluff 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?

With 3 optional parameters, no output schema, and no required params, the description does a solid job of explaining the return values and accepted inputs. It covers what the tool does and what it produces. The main gap is the lack of differentiation from the many similar risk-analysis siblings, which could confuse an agent selecting among them. Otherwise, it is reasonably complete for a read-only analysis 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 already provides descriptions for all three parameters (100% coverage), so the baseline is 3. The description's phrase 'and/or' clarifies that parameters can be combined, which adds a small amount of relational semantics beyond the schema. However, it does not explain any parameter interdependencies or format expectations beyond what the schema already specifies.

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 ('Analyze'), the resource ('vacation rental booking or guest interaction'), and the purpose ('potential threats and risks'). It also mentions the outputs (risk level, concerns, recommended actions). However, it does not distinguish this tool from closely related siblings like analyze_guest_communication_risk, analyze_guest_interaction_risk, and detect_guest_message_threat_pattern, so it lacks explicit sibling differentiation.

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

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

The description gives no guidance on when to use this tool versus the many alternative risk-analysis tools in the sibling list. The instruction to 'Pass booking_id, message_content, and/or guest_profile' explains what to provide, but does not specify selection criteria or exclusions. Usage context is only implied, not articulated.

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

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

Annotations already indicate read-only and non-destructive behavior. The description adds that it returns risk assessment, evidence documentation, and response guidance, giving the agent expectations about the output. It does not contradict annotations and provides useful behavioral context beyond the structured data.

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

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

The description is two sentences long, front-loads the primary action, and includes essential output details without filler. Every clause serves a purpose, 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?

For a read-only analysis tool with a rich input schema (5 parameters) and no output schema, the description sufficiently explains the tool's purpose and returns without being exhaustive. It also references the alias, which adds contextual completeness by linking to the canonical tool, though a bit more detail on response format could improve it.

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

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

Schema coverage is 100% with each parameter described, so the description does not need to repeat parameter details. The description's mention of 'guest messages' aligns with the required 'message' parameter but adds no extra semantic value 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 action ('Analyze guest messages') and the specific resource ('at a vacation rental') with a clear goal ('for concerning patterns'). It also specifies the outputs, distinguishing it from more generic analysis tools, and the alias note links it to a sibling.

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

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

The description implies usage for guest message risk analysis but does not explicitly state when to prefer this tool over similar siblings like detect_guest_message_threat_pattern or analyze_guest_interaction_risk. The alias reference provides a clue but no exclusions or alternatives, leaving selection decisions partially ambiguous.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds that it returns risk assessment and recommended actions and that it is an alias for another tool, which is useful context. However, it doesn't disclose any other behavioral traits such as required auth, rate limits, or side effects.

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

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

The description is concise and front-loaded with the purpose. Each sentence adds value: what it does, what it returns, alias status, and parameter guidance. No redundancy or unnecessary detail.

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

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

The tool has three parameters including a nested object (guest_profile) that lacks schema structure. No output schema exists, so the description should clarify the output format more, but it only says 'Returns risk assessment and recommended actions'. The alias and parameter guidance help, but the lack of detail on guest_profile and output structure leaves 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 descriptions cover all three parameters, so the baseline is 3. The description adds 'and/or' which clarifies that any combination of booking_id, message_content, and guest_profile can be passed, a relationship not present in the schema. This provides meaningful semantic value beyond the structured definitions.

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 action (analyze guest interaction risk), a resource (guest interaction at a vacation rental), and an outcome (risk assessment and recommended actions). It also mentions being an alias for analyze_booking_threat_risk, but doesn't differentiate it from other similar sibling tools like analyze_guest_communication_risk.

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 listing the parameters to pass ('Pass booking_id, message_content, and/or guest_profile'), but it doesn't explicitly state when to use this tool versus alternatives such as detect_guest_message_threat_pattern or analyze_guest_communication_risk. The alias note provides a relationship but not a clear when-to-use condition.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds 'grounded in verified data,' which is a useful behavioral trait, but it does not disclose limitations such as unanswered questions, data coverage, or response format. With annotations present, the added context is minimal but not trivial.

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 purpose and immediately followed by useful, concrete examples. Every word earns its place 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 simple read-only Q&A tool with complete schema and annotations, the description is largely sufficient. It clearly conveys what the tool does and gives examples. It does not describe the return value structure (no output schema), but 'get an answer' plus examples provides adequate context 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 description coverage is 100%, with each parameter (property_id, question, guest_id) already described. The description provides example questions that clarify the expected format of the 'question' parameter but adds no significant semantic detail beyond the schema.

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

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

The description clearly states the verb 'ask' and resource 'vacation rental property', with the outcome 'get an answer grounded in verified data'. Concrete examples (WiFi password, parking, dishwasher, check-out) illustrate the scope, distinguishing it from sibling tools that fetch specific datasets like FAQs or house rules.

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 any natural language question about a vacation rental but does not explicitly address when to use this tool versus alternatives such as get_vacation_rental_faqs or get_vacation_rental_house_rules. It mentions required inputs (property_id and question) but offers no exclusions or preference 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 readOnlyHint=true and destructiveHint=false provided, the safety profile is already clear. The description adds valuable context: it evaluates against tenant protection laws and returns risk level, relevant state laws, and preventive recommendations – useful details beyond the annotations. No contradiction.

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

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

Three sentences, each earning its place: purpose, evaluation method, and return values. Front-loaded with the core function, no fluff or repetitive 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?

No output schema exists, but the description lists return items (risk level, state laws, recommendations). It covers the main inputs and purpose. A minor gap is not explaining property_id's purpose and the slight inconsistency of mentioning state code when state is optional, but overall it is complete enough for a read-only analytical 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 baseline is 3. The description's directive to 'Pass check_in_date, check_out_date, and state code' largely repeats schema info without adding formats or explaining property_id's role. It adds marginal value but is not misleading.

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

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

The description uses a specific verb and resource: 'Assess the risk of a guest establishing tenancy rights during an extended vacation rental stay.' This clearly distinguishes it from sibling risk-assessment tools like assess_vacation_rental_booking_risk, which cover broader booking risks.

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: extended vacation rental stays where tenancy rights may be a concern, and mentions evaluating stay duration against jurisdiction-specific laws. 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds behavioral context by stating that the tool returns risk level, identified concerns, and suggested protective actions, which is valuable since there is no output schema. No side effects are mentioned, but none are expected for a read-only 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, front-loaded with the main purpose and return information. It is concise with no filler; every component earns its place, including the parameter reminder at the end.

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 with 2 parameters, no output schema, and annotations indicating a safe read operation. The description adequately covers the input requirements and high-level output concepts (risk level, concerns, protective actions), though it stops short of detailing the exact output structure, which is acceptable given the tool's simplicity.

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

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

Schema descriptions cover 100% of parameters, so the baseline is 3. The description repeats parameter info (booking_id UUID, include_guest_risk default true) without adding new meaning 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 assesses risk factors for a specific vacation rental booking and returns risk level, identified concerns, and suggested protective actions. The verb 'assess' and resource 'vacation rental booking' are specific, but it does not explicitly distinguish this from sibling tools like analyze_booking_threat_risk or assess_extended_stay_squatter_risk.

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 specific booking needs risk assessment and notes the required booking_id. However, it does not provide when-not-to-use guidance or reference alternatives among the many sibling risk analysis tools, leaving the choice contextual rather than explicit.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the agent knows this is a mutation. The description adds the primary/backup role concept and scheduled_date context, which is useful. However, it does not disclose whether assigning a cleaner overwrites an existing assignment or any constraints on backup assignments, leaving some behavioral ambiguity.

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 action and immediately followed by a concise parameter guidance list. Every word earns its place, with no fluff 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?

Given that the schema fully documents parameters and there is no output schema, the description is mostly complete: it states the action, the timing, role options, and required vs optional inputs. It would benefit from mentioning whether existing assignments are replaced, but the destructive annotation already signals mutation, so this is a minor gap.

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

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

The input schema already provides 100% coverage with descriptions for all five parameters. The description only restates the parameter names and highlights that role is primary/backup and scheduled_date is optional, which is redundant with the schema. The only slight addition is the phrase 'between bookings' contextualizing scheduled_date, but overall it does not add significant semantic value beyond the schema.

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

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

The description clearly states a specific action ('Assign a cleaner') and the target resource ('vacation rental property turnover between bookings'). This verb-object structure distinguishes it from sibling tools like get_rental_cleaning_schedule or create_rental_maintenance_task, making its 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 usage context: it is for assigning cleaners to turnovers between bookings. It does not explicitly mention when to use alternatives like get_rental_cleaning_schedule for viewing assignments, but the context is sufficient to infer the intended use. A brief exclusion note would have earned a 5.

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

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

Annotations indicate readOnly=false and destructiveHint=true, but the description adds meaningful side effects: it creates a booking record, calculates pricing, notifies the host, and adds a 3% guest service fee. It stops short of discussing cancellation or refund behavior, but still adds value beyond the annotations.

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

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

Four compact sentences cover purpose, pricing transparency, side effects, return values, and a required prerequisite. There is no filler; every sentence contributes essential 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 an 8-parameter mutation tool with no output schema, the description provides expected return fields (booking_id, confirmation_code, pricing breakdown, check-in link) and a required preceding call. It could mention cancellation/error handling, but schema richness and annotations cover most missing context.

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

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

Schema description coverage is 100%, so the description does not need to re-document parameters. The description adds no parameter-specific details beyond the schema, but it does mention pricing calculation and the required prerequisite, which indirectly supports parameter usage.

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 direct verb ('Book') and a specific resource ('vacation rental property'), with the qualifier 'directly through AI.' It clearly distinguishes this from sibling risk/availability tools by stating it creates a booking record and returns confirmation artifacts.

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 'Always call check_vacation_rental_availability_and_pricing first,' giving a clear precondition. It also communicates the direct-booking context and fee structure, which signals when this tool is appropriate versus search or risk-assessment alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by specifying the output contents (permits, application processes, fees, renewal schedules), which goes beyond the annotations. No contradictions.

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

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

The description is two sentences, front-loads the core purpose, and contains no filler. Each word contributes to understanding what the tool does and how to invoke 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 read-only tool with 100% schema coverage and no output schema, the description sufficiently explains return values and required inputs. It could improve by noting that permits are location-specific, but it already implies that. The tool is adequately 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?

Schema description coverage is 100%, and each parameter already has a description (e.g., 'State code', 'City name', 'Property UUID'). The description merely restates that state is required and city/property_id are optional, adding no additional meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Check') and resource ('permits and licenses for short-term rentals at a location'), then details what is returned (required permits, application processes, fees, renewal schedules). This clearly distinguishes it from sibling tools like get_short_term_rental_regulations which are broader.

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 required and optional parameters ('Pass state code (required), optional city and property_id') and indicates the use case ('operate a short-term rental at a specific location'). However, it does not name alternative tools or explicitly 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?

The description adds valuable behavioral context beyond the annotations: it discloses that the tool returns availability, total price, capacity check, and conflicting bookings, and explains the fee structure (host receives 100%, 3% guest fee). This goes beyond the readOnlyHint and destructiveHint annotations, providing a clearer picture of the tool's behavior.

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

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

The description is three sentences long, with no unnecessary words. The first sentence states the purpose, the second lists the outputs, and the third provides fee details and a critical usage order. Each sentence earns its place, 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?

The description provides sufficient context for an agent to understand what the tool does, what it returns, and the pricing model. It also includes the key prerequisite relationship with the booking tool. While there is no output schema, the description's list of return values and fees covers the essential information, though it omits details like error conditions or response structure.

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

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

The input schema has 100% coverage with descriptions for all parameters, so the baseline is 3. The description adds no additional meaning to the parameters themselves; it only mentions "specific dates" and "capacity check," which are already implied by the schema fields. Thus, it does not exceed 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 purpose: "Check real-time availability and pricing for a vacation rental property on specific dates." It also distinguishes itself from the sibling tool 'book_vacation_rental_direct' by explicitly noting it should be called before that tool, making the purpose and scope 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?

The description gives explicit usage guidance with "Always call this BEFORE book_vacation_rental_direct," which indicates when to use the tool. However, it does not mention contexts where the tool should not be used or provide alternative tools for other scenarios, so it lacks complete when-not/alternatives coverage.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds meaningful behavioral context by disclosing the exact return fields and the set of possible statuses (active/inactive/expired). This goes beyond the annotations and helps the agent anticipate the response shape, though it does not cover potential errors or edge cases.

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: the first states the tool's purpose, and the second lists the returned data fields. It is front-loaded, free of redundancy, and every sentence earns its place.

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

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

For a single-parameter, read-only tool with no output schema, the description provides both the purpose and a complete enumeration of the return values (status, tier, features, timestamp). This is sufficient for an agent to invoke the tool correctly and interpret the response, especially with annotations covering safety.

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 fully documents property_id as 'Property UUID or lilo_code' (100% coverage). The description does not add any additional nuance about the parameter beyond the tool's purpose, so the baseline score of 3 applies—the schema carries the semantic weight.

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 ('Check') and explicit resource ('vacation rental property... protected by lilo'), and enumerates concrete outputs (protection status, tier, active features, last activity timestamp). This clearly distinguishes it from sibling tools like get_lilo_protection_network_stats, which focus on network-level statistics.

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—checking protection status for a given property—but provides no explicit 'when to use' or mentions alternatives among the many sibling tools. There is no guidance on when to prefer this over related tools like get_vacation_rental_trust_certificate or get_vacation_rental_onboarding_status, making usage inferred rather than directed.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds meaningful context about the return content (special regulations, surge pricing rules, enhanced permit requirements, safety standards), which goes beyond annotations and helps the agent understand what to expect.

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 clause adds value. No wasted words or 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?

Given no output schema, the description adequately explains what the tool returns (special regulations, surge pricing rules, enhanced permit requirements, safety standards) and explicitly mentions the 16 host cities. It is complete for a simple read-only query tool with one required parameter and clear annotations.

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 both parameters (city and property_id), so the schema already explains them. The description only repeats that city is required and property_id optional, adding no new semantic meaning beyond what the schema provides.

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

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

The description clearly states the tool checks World Cup 2026 specific STR compliance for 16 US host cities, distinguishing it from generic compliance tools like check_str_permit_requirements or get_short_term_rental_regulations. It uses a specific verb and resource and mentions the 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?

The description gives clear context for when to use it (World Cup 2026 specific requirements during the tournament) but does not explicitly mention alternatives or when not to use it. The context is sufficient to guide selection, though exclusions 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds useful context about the maximum number of properties and the metrics compared, but it does not disclose return format, error behavior, or what happens if an ID is invalid. This is acceptable given the annotations.

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

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

The description is two sentences, front-loaded with the core action and scope. It lists the key metrics efficiently and ends with the necessary input instruction. Every sentence earns its place 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 simple read-only comparison tool with one parameter and no output schema, the description covers the purpose, input, and metrics. It is concise and self-sufficient. It could mention behavior for invalid or non-existent property IDs, but that is a minor gap given the tool's simplicity.

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

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

The schema provides full coverage for the only parameter property_ids with 'Array of property IDs to compare (max 5)', so the description adds no significant semantic detail beyond restating the parameter. Baseline 3 is appropriate since 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's function: 'Compare up to 5 vacation rental properties side-by-side on key metrics...' This is a specific verb+resource action, and it distinguishes itself from sibling tools like get_vacation_rental_details or search_vacation_rentals by focusing on side-by-side comparison.

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

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

The description implies the usage scenario (comparing multiple properties) and specifies the input format ('Pass an array of property_ids') and limit ('up to 5'). However, it does not explicitly contrast with alternatives such as individual detail or search tools, so the when-to-use guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, establishing that this is a mutating operation. The description adds context about one-time vs. recurring tasks but does not explain what recurrent creation entails or any side effects, so it provides modest extra value beyond the annotations.

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

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

The description is two sentences with the purpose front-loaded and parameters listed compactly. Every word adds useful information; 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?

Given the 8 parameters and lack of an output schema, the description successfully covers all inputs, but it does not describe the return value, error behavior, or how recurring tasks are configured beyond the parameter names. The annotations fill the safety context, making this adequate but incomplete for a create operation.

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

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

Schema coverage is 100%, so the baseline is 3. The description restates required and optional parameters and lists task_type values, but these are already fully described in the schema; no additional semantic meaning is provided.

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

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

The first sentence states a specific action ('Create a new maintenance task') with a clear resource ('vacation rental property'), and the mention of one-time/recurring tasks plus enumerated task types distinguishes it from read-only sibling tools like get_rental_maintenance_schedule.

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

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

No explicit when-to-use or alternative tool mentions are present. Usage is implied by the verb 'Create', but the description does not address when to use this vs. other maintenance-related tools such as get_rental_maintenance_schedule or report_rental_inventory_issue.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the tool is known to be safe. The description adds behavioral context by detailing the outputs (risk assessment, evidence documentation, response guidance) and the extra feature of guest/property cross-referencing, which goes beyond the annotation scope. No contradictions found.

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 three concise sentences with no filler. It front-loads the core function, then lists outputs, and finally differentiates from the sibling tool. Every sentence adds value and is efficiently 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?

Despite lacking an output schema, the description explains what the tool returns (risk assessment, evidence documentation, response guidance). It also covers the scope and the added cross-referencing functionality. Minor gaps such as how conversation history affects analysis are left to the schema, but overall it is complete enough for an agent to understand the tool's role.

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

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

Schema description coverage is 100%, and all parameters have clear descriptions (e.g., 'Guest message to analyze for risk patterns', 'Booking UUID for evidence chain'). The tool description itself does not add parameter-level details, but since the schema already covers semantics fully, 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 states a specific verb and resource: 'Analyze guest messages for risk patterns in vacation rental communications.' It also explicitly distinguishes itself from the sibling tool by noting it is 'More comprehensive than detect_guest_message_threat_pattern' and lists additional features, making the purpose unambiguous and well-differentiated.

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 a comprehensive risk analysis with documentation and cross-referencing is needed, as opposed to the simpler sibling tool. It names the alternative and explains the difference, though it does not explicitly state exclusions or conditions when the alternative should be preferred.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds that it returns a threat assessment and recommended response, which is useful. However, it does not disclose additional behavioral traits such as AI model usage, confidence levels, or any 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 two sentences, front-loaded with the tool's purpose, followed by usage instruction and return value. Every sentence adds value, with no fluff 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 tool with three parameters and no output schema, the description covers the main purpose, how to pass inputs, and the return format at a high level. It would benefit from noting the optional booking_id and perhaps differentiating from sibling tools, but overall it is sufficient for a tool of this simplicity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions message text and conversation_history for context, which aligns with the schema but adds no extra meaning beyond what the schema already provides. The booking_id parameter is not mentioned in the description, but it is described 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 clearly states the tool analyzes a guest message or conversation for concerning patterns, which is a specific verb and resource. However, it does not distinguish from closely related sibling tools like detect_guest_communication_risk or analyze_guest_communication_risk, so it lacks sibling differentiation.

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

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

The description provides clear context for when to use the tool (analyzing guest messages for threat patterns) but gives no explicit guidance on when not to use it or alternatives. It does not mention the many similar risk-analysis sibling tools, leaving the agent to infer which tool 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?

The description adds behavioral context beyond the readOnlyHint annotation by listing the specific data returned (title, markdown description, photos, reviews, amenities, trust score, booking URL) and noting the optimization for AI deep research. This helps the agent understand what to expect, though it does not cover error handling or response format 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-loads the action, and every sentence provides useful information without redundancy. The return fields are efficiently listed.

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?

Since there is no output schema, the description adequately enumerates the main returned fields (title, description, photos, reviews, amenities, trust score, booking URL) and provides context for its intended use (AI deep research). It does not include details about potential errors or edge cases, but for a simple fetch operation with clear parameters, 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 only parameter (lilo_code) is fully described in the schema with an example. The description repeats the same example and adds no additional semantic meaning beyond what the schema already provides, so with 100% schema coverage, 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 identifies the resource (vacation rental property) and the verb (Fetch), with a specific identifier (lilo code) and return contents. However, it does not distinguish itself from the sibling tool 'get_vacation_rental_details' which has nearly identical name and likely similar 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 phrase 'Optimized for AI deep research consumption' implies a use case, but there is no explicit statement about when to use this tool over alternatives, nor any exclusions or alternatives mentioned. The guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds that the tool recommends alternatives and accepts a property_id, but it does not disclose how similarity is determined or what fields are returned, which would be useful beyond the annotations.

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

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

Three sentences, each with purpose: what it does, when to use it, and how to use it. No fluff or redundancy, and the key 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 low-complexity tool with complete schema coverage and clear use-case framing, the description is sufficient. It lacks output schema details, but the absence is partially mitigated by the concise guidance on what the tool returns conceptually (similar alternatives).

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 at 100% with descriptions including property_id format (UUID or lilo_code) and the default limit. The description only restates these details, adding no new semantic meaning beyond the schema.

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

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

The description uses a specific verb ('Find') and a clear resource ('vacation rentals similar to a given property'), which distinguishes it from sibling tools like generic search_vacation_rentals or compare_vacation_rentals_side_by_side. The scope is explicit and actionable.

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 when to use the tool: 'when a property is unavailable or when the traveler wants to compare similar options'. This provides clear context, though it does not mention when not to use it or explicitly name alternative tools.

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

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

Annotations already indicate destructiveHint=true, so the agent knows it's a mutating operation. The description adds that it 'Creates an alert with the specified reason and risk indicators,' giving context about the side effect. It does not contradict annotations and provides useful behavioral detail beyond the structured metadata.

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 three sentences long, front-loaded with the primary action, and includes usage context and parameter summary without wasted words. Every sentence adds value, making it highly efficient and well-structured.

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

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

For a simple mutation tool with no output schema, the description covers the action, purpose, usage trigger, and required parameters. It is sufficiently complete for an agent to correctly select and invoke the tool, matching the completeness of top-tier calibration examples.

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

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

The input schema already provides 100% coverage with descriptions for all parameters. The description restates required vs. optional parameters ('Requires booking_id and reason. Optional: array of risk_indicators') without adding new semantic meaning or examples. This meets the baseline but does not exceed 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 tool's purpose: 'Flag a vacation rental booking for enhanced monitoring by lilo's protection system.' It specifies the resource (vacation rental booking), the action (flag), and the context (protection system), distinguishing it from sibling risk-analysis 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 includes an explicit usage trigger: 'Use this when a host identifies concerning behavior.' This provides clear context for when to invoke the tool, though it does not mention alternatives or exclusions. That would merit a 5, but the guidance is specific enough for a 4.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is transparent. The description goes beyond annotations by stating the return content (trends, spikes, occupancy, pricing recommendations), which is especially valuable given there is no output schema. It adds useful behavioral context without contradicting annotations.

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

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

The description is two sentences: the first states the purpose and outputs, the second lists parameters and required location. It is front-loaded, concise, and every sentence earns its place 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?

Given that there is no output schema, the description adequately explains return values. However, it does not clarify optional date range behavior (e.g., what happens if date_range_start/end are omitted) or date format, which leaves a minor gap in completeness for a forecasting tool with optional parameters.

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

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

Schema coverage is 100% (all three parameters have descriptions). The description only restates parameter names and requiredness, adding no new semantics about date formats, defaults, or behavior when date_range_start/end are omitted. Per the rubric, baseline 3 is appropriate since the schema does the heavy lifting and the description adds little 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 uses a specific verb 'Forecast' with a clear resource 'booking demand for vacation rentals' and scope 'in a specific location over a date range.' It also enumerates concrete outputs (seasonal trends, event-driven spikes, occupancy predictions, pricing recommendations), fully distinguishing it from sibling tools like get_vacation_rental_pricing_analysis or check_vacation_rental_availability_and_pricing.

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 when you need to forecast booking demand for a specified location and date range. It does not explicitly mention alternatives or when not to use it, but the purpose is unambiguous and no sibling tool overlaps directly. This meets the 'clear context, no exclusions' level.

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

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

Annotations declare destructiveHint=true, so the description should clarify what side effects occur (e.g., overwriting existing feeds, triggering external changes). The description only mentions benefits (direct booking, 3% fee) and parameters, with no explanation of the destructive nature. It misses the opportunity to elaborate on the mutation's impact.

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, front-loaded with the primary action and resource. The second sentence adds purpose-related context (booking, fee) and parameter instructions. Every word contributes useful information 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 simple 2-parameter tool without output schema, the description covers purpose and invocation. However, it does not explain what the function returns (e.g., feed content, success status) or what the destructive side effect entails, leaving gaps given the absence of an output schema and a destructive hint.

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 described in the schema. The description restates the parameters (host_id UUID, format xml/json default xml) but adds no meaning beyond the schema. The baseline of 3 applies because the schema already documents each parameter fully.

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

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

States exactly what it does: 'Generate a Google Vacation Rentals XML feed for a host's properties.' The verb 'generate' plus the specific resource 'Google Vacation Rentals feed' and target 'host's properties' make the purpose unambiguous. It is distinct from sibling tools, none of which generate feeds.

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?

Description implies usage context: use when you need to create a Google Vacation Rentals feed for a host. It clarifies the target scope ('for a host's properties') and parameter requirements. However, it does not explicitly mention when not to use it or reference alternatives, though no direct sibling competitor 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?

Annotations declare readOnlyHint=false and destructiveHint=true, and the description's 'Generate' aligns with mutation. However, the description does not disclose specific side effects, such as whether it overwrites existing documents, requires specific permissions, or is irreversible. It adds content context but falls short of describing operational behavior beyond what annotations already signal.

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 purpose, no filler. The second sentence efficiently clarifies parameter usage. 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 description explains the output (occupancy tax calculations, income summaries, reporting data) despite lacking an output schema. It covers parameter requirements and optionality. However, it doesn't mention any preconditions or what the generated document contains structurally. For a simple tool with only 3 simple parameters, this is reasonably complete, but not maximally comprehensive.

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 already describes all three parameters (100% coverage), so baseline is 3. The description adds that quarter is for quarterly reports and reinforces requiredness, but doesn't provide additional constraints or formats. It adds minimal value beyond the schema.

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

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

The description uses the specific verb 'Generate' with resource 'tax documentation for short-term rental income,' clearly distinguishing it from sibling tools like check_str_permit_requirements or get_str_insurance_requirements. It enumerates contents (occupancy tax calculations, income summaries, reporting data), making 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?

It states required parameters and optional quarter for quarterly reports, which implies the use case (annual vs quarterly tax filing). However, it does not explicitly compare with alternative tools or state when not to use it. The context is clear though.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, establishing the safe read-only nature. The description adds that the packet includes verified evidence of guest consent, check-in documentation, and interaction history, which is useful output context, but it does not disclose response format, pagination, or service-side behavior.

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

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

The description is two sentences, front-loaded with the primary action and output, and contains no fluff. Every sentence contributes useful information about what the tool does and how to invoke 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?

Without an output schema, the description partially explains what the defense packet contains (verified evidence of guest consent, check-in documentation, interaction history), but it does not specify the response format or any prerequisites. It is adequate for a generation tool but lacks details on the packet structure or how the evidence is presented.

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

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

Schema description coverage is 100%, and the description restates the three parameters. It adds that booking_id is a UUID and dispute_id is optional, while the schema already mentions 'Disputed amount in cents'. The added value is minimal 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 clearly states the tool generates a chargeback defense packet for a payment dispute on a vacation rental booking, specifying the resource and action. However, it does not distinguish this from the sibling tool 'get_dispute_defense_packet_for_booking' which likely serves a nearly identical 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?

No explicit guidance is provided on when to use this tool versus alternatives like get_dispute_defense_packet_for_booking or predict_booking_chargeback_probability. The context of a payment dispute is implied but no exclusions or alternative recommendations are given.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that the packet uses 'independently verified evidence,' a meaningful behavioral trait. No contradictions with annotations.

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

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

The description is two sentences, front-loaded with the action, and the alias note is compact and valuable. No redundant or extraneous 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?

No output schema exists, but the description conveys the tool's purpose and key feature (verified evidence). The alias also helps locate the sibling tool. Slightly more detail about packet contents could help, but it remains sufficient for a straightforward generation 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 descriptions cover all three parameters (amount, booking_id, dispute_id) at 100%, so the baseline is 3. The description does not elaborate on parameter usage beyond the schema, but it also introduces 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 clearly states the tool generates a dispute defense packet with independently verified evidence, using a specific verb and resource. It also explicitly names itself as an alias for get_chargeback_defense_for_booking, distinguishing it from sibling dispute 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 alias mention provides clear context that this tool is equivalent to get_chargeback_defense_for_booking, guiding users to the canonical sibling. However, it does not explicitly contrast with other dispute-related tools like get_dispute_evidence_bundle_for_booking, so exclusions are missing.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds useful context by detailing what the evidence bundle includes, but does not go further into return format, error conditions, or prerequisites. This is acceptable given the annotation coverage, 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 concise sentences, front-loaded with the main purpose. It provides essential information (what it does, what it includes, what to pass) without any waste. Excellent structure.

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 should compensate by explaining the return value. It lists bundle contents but does not describe the format or structure of the response, nor any edge cases or prerequisites. For a relatively straightforward read-only retrieval, this is adequate but has 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?

Schema coverage is 100%, so the description adds little beyond the schema. It repeats the parameter descriptions and implies both booking_id and dispute_type are required, but the schema only marks booking_id as required. This could mislead an AI agent into thinking dispute_type is mandatory. No additional semantic value is provided.

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

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

The description clearly states the tool's function: generating a complete evidence bundle for dispute resolution on a vacation rental booking. It specifies the contents (verified interactions, consent records, documentation) and the required inputs, making it distinct from siblings that focus on specific dispute types or narrower aspects.

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

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

The description gives clear context for when to use the tool (dispute resolution on a booking) and lists acceptable dispute_type values, but it does not explicitly distinguish it from overlapping sibling tools like get_chargeback_defense_for_booking or get_dispute_defense_packet_for_booking. No alternatives or exclusions are mentioned, so the usage guidance is implied rather than explicit.

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

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

The description adds value beyond the readOnlyHint annotation by explaining that results are chronologically ordered and include timestamps, types, and verification status. This gives the agent a clear expectation of the output structure. While it doesn't mention pagination or limits, for a read-only timeline tool this is useful 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 extremely concise: two sentences, no filler, front-loaded with the core action and resource. It efficiently communicates scope, filtering, and return format. Every word earns its place.

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

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

For a read-only list tool with well-documented parameters, no output schema, and a simple return format, the description is complete. It covers what the tool does, the filtering capability, and the nature of the returned events. The complexity is low and the description adequately addresses it.

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 describes all parameters with 100% coverage. The description's mention of 'Filter by date range' simply restates the start_date and end_date parameters without adding new meaning. It also mentions 'property or specific booking' which maps to property_id and booking_id, but again this is already clear from the schema. No extra semantics are provided.

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

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

The description uses a specific verb 'Get' with a clear resource: 'chronological timeline of all evidence records for a vacation rental property or specific booking.' It further clarifies the output (events in order, timestamps, types, verification status), making it distinct from sibling tools like query_vacation_rental_evidence_chain which likely focus on chain integrity rather than timeline presentation.

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

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

The description implies usage context: use this for a vacation rental property or specific booking, optionally filtered by date range. However, it does not explicitly mention alternatives or when not to use this tool, such as comparing with query_vacation_rental_evidence_chain or verify_vacation_rental_evidence_record. The guidance is implied rather than explicit.

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

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

Annotations already indicate read-only and non-destructive behavior. The description adds transparency by revealing the fixed total_spots value (200), the price ($149/month), and the list of returned fields, which is valuable context beyond annotations. No contradictions found.

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 front-loaded with the primary action. Every sentence adds value: the first states the core purpose, the second details the return values and confirms no parameters. There is no wasted text.

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

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

For a no-parameter, read-only status check with no output schema, the description fully conveys what the tool returns and its fixed values. It is complete and appropriately scoped; no additional context is necessary 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?

There are zero parameters, and the schema coverage is 100% (empty properties). The baseline for 0 params is 4, and the description confirms 'No parameters required,' which aligns with the schema. No additional parameter meaning 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 explicitly states the verb 'Check' and the specific resource 'founding member spots for lilo's vacation rental protection'. It also lists the exact return fields (total_spots, spots_claimed, spots_remaining, founding_price), making the tool's purpose unmistakable and distinguishing it from sibling stats 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 tool is for checking founding member availability but provides no explicit guidance on when to choose it over similar tools like get_lilo_protection_network_stats. It is a simple status query, so use cases are intuitive, but there are no clear exclusions or alternative references.

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

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

The description adds meaningful context beyond the readOnlyHint annotation by specifying exactly what the tool returns (aggregate stats, evidence integrity status, active protection capabilities). It conveys the scope and output without contradicting the safe read-only annotation.

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

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

The description is concise—two sentences that front-load the core purpose and then list the return contents. There is no redundancy or filler, making it efficient and well-structured.

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

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

For a simple, read-only, no-parameter tool, the description is complete: it explains the purpose, the output components, and the absence of parameters. The annotations confirm safety, and the lack of an output schema is compensated by the clearly stated return fields.

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 input schema is trivially covered, and the description reinforces this by stating 'No parameters required.' The baseline for zero parameters is 4, and the description matches the schema without adding unnecessary detail.

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 aggregate statistics about the lilo vacation rental protection network, and explicitly enumerates the returned data (total properties protected, evidence integrity status, active protection capabilities). This distinguishes it from sibling tools that focus on individual rentals or risk analysis.

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 notes that no parameters are required, but it does not provide explicit guidance on when to use this tool versus alternatives. The usage context is implied by the network-level focus rather than explicitly stated with exclusions or alternative tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description only needs to add context. It adds that the tool returns categories and supports type filtering, but does not describe behaviors like result ordering, radius, or pagination. This is adequate for a read-only tool 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, front-loads the core purpose, and includes the filter options without any redundant phrasing. Every word contributes to understanding the tool's purpose and usage.

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 tool with two params and no output schema, the description sufficiently covers input semantics, return categories, and filtering. It could mention whether results are ranked or limited, but given the low complexity and strong annotations, 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%, so the schema already documents both parameters (property_id and type). The description echoes the type filter values and purpose but adds no new semantic detail beyond what the schema provides, warranting the baseline score.

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 ('local recommendations near a vacation rental property'), and enumerates the returned categories (restaurants, coffee shops, grocery stores, activities, attractions). This distinguishes it from sibling tools like neighborhood info or landmark details.

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

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

The description implies the use case (getting nearby recommendations for a rental) and mentions filtering by type, but it does not explicitly state when to prefer this tool over alternatives or provide exclusion criteria. Context is clear enough for basic usage, but no guidance is given about choosing among similar location-based tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the tool is known to be a safe read. The description adds context about the content returned (safety scores, walkability, etc.) but no additional behavioral traits such as rate limits, permissions, or data freshness. With annotations covering the safety profile, a 3 is appropriate.

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 verb 'Get', and no superfluous content. The first sentence lists the data types, the second gives the use case. Ideal conciseness and structure.

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 tool with one parameter, the description adequately covers what the tool returns by listing the kinds of neighborhood info. No output schema exists, but the description fills the gap for expected content. It could be improved by explicitly noting any formatting or interpretation nuances, but overall it is complete enough.

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

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

Schema coverage is 100% for the single property_id parameter, with a clear description ('Property UUID or lilo_code'). The tool description does not add further parameter semantics, so the baseline of 3 applies.

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

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

The description clearly states the tool fetches neighborhood information for a rental, enumerating specific aspects (safety scores, walkability, transit, amenities, local character). This makes its purpose distinct from siblings like get_local_recommendations_near_rental, though it does not explicitly compare to them.

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

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

The description implies usage for travelers wanting to understand the area around a property ('Helps travelers understand the area around a property.'), but provides no explicit guidance on when to choose this over similar sibling tools or when not to use it.

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

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

Annotations already mark readOnlyHint=true and destructiveHint=false. The description adds behavioral context by specifying return content: 'key historic sites, planned celebrations, expected visitor numbers, and accommodation surge predictions.' No contradiction.

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

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

Two sentences, front-loaded with action and resource. No unnecessary words.

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

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

For a zero-parameter read-only tool, the description sufficiently enumerates the return categories. It doesn't mention any edge cases or date limitations, but the event is fixed, so it's adequately 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?

Since the tool has zero parameters, the schema is fully covered. The description reinforces 'No parameters required.' Baseline for zero-param tools 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 explicitly states the verb and resource: 'Get America's 250th Anniversary (July 4, 2026) event information for Philadelphia.' This clearly distinguishes it from siblings like get_philadelphia_world_cup_2026_info or search_philadelphia_event_venues.

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 (when 250th anniversary info is needed) but does not mention alternatives or exclusions. It notes 'No parameters required,' giving some usage guidance, but 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the response includes 'full property manifest and Schema.org structured data' and lists valid source types, providing some return content context, but no deeper behavioral traits such as rate limits or response constraints.

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 long, front-loaded with the purpose, then concise parameter guidance. Every word adds value, with no filler or repetition of schema details.

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

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

For a simple, read-only tool with full schema coverage, the description is mostly complete. It mentions return contents (property manifest, Schema.org data) and required parameters. The only minor gap is that it does not explicitly note that 'source' is optional (schema declares it not required), which could cause slight confusion, but the schema clarifies this.

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%, giving each parameter a description, so baseline is 3. The description adds value by providing a concrete example ('phl-landmark-123') for landmark_id and clarifying the meaning of source type with its enum values, improving comprehension beyond the schema.

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

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

The description clearly states a specific verb ('Get') and resource ('a specific Philadelphia landmark'), and distinguishes this tool from sibling search tools like 'search_philadelphia_historic_properties' by focusing on retrieving detailed information for a known landmark ID.

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

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

The description clearly implies the tool is used when you have a landmark ID and need detailed info, and it explicitly instructs how to pass parameters. However, it does not mention alternatives or when not to use this tool compared to searching, 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?

Annotations already mark this as a safe read-only operation. The description adds value by disclosing the return content, the 'FREE' nature, and the fact that no parameters are needed, which together give the agent a realistic expectation of the tool's behavior.

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

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

The description is compact and front-loaded, immediately stating the tool's purpose. The list of deliverables is concise and free of redundancy, with every sentence contributing meaningful 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 parameterless read-only info tool, the description fully specifies what the agent will receive: match schedule, venue details, demand surge, transportation, and compliance. Since there is no output schema, this enumeration covers the expected return, making the description complete for its simplicity.

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

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

There are zero parameters, and the schema coverage is 100% (empty). The description explicitly states 'No parameters required' and enriches understanding by listing the types of information returned, which helps the agent know what to expect despite the lack of inputs.

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: getting World Cup 2026 information for Philadelphia. It enumerates specific content areas (match schedule, venue, demand surge, transportation, STR compliance), which distinguishes it from sibling tools like check_world_cup_2026_str_compliance and search_world_cup_rentals.

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 communicates a clear use case: general info retrieval about World Cup 2026 in Philadelphia. The 'FREE TOOL' and 'No parameters required' signals it is a low-friction lookup, but it does not explicitly name alternatives or exclusions, leaving some ambiguity against more specialized siblings.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is known. The description adds behavioral context by stating what the tool shows (turnovers, assigned cleaners, gaps), which is useful beyond the structured fields. Non-critical omissions (e.g., output format) are acceptable given the simple read-only role.

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 with no redundancy. It front-loads the primary purpose and follows with the essential parameter usage, achieving high information density.

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 tool with two well-documented parameters and no output schema, the description provides sufficient context about what is returned (turnovers, cleaners, gaps). It lacks explicit return structure, but this is not critical for such a straightforward lookup.

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 parameter descriptions already explain property_id and days_ahead, including the default value. The description merely repeats 'Pass property_id and optional days_ahead (default 14)', adding no new semantic meaning beyond the schema. Baseline 3 applies.

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

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

The description identifies a specific verb ('Get'), a specific resource ('cleaning schedule and cleaner assignments'), and concrete outputs ('upcoming turnovers between bookings, assigned cleaners, and scheduling gaps'). This clearly distinguishes it from sibling tools like get_rental_maintenance_schedule.

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

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

The description gives clear context for when to use the tool (checking cleaning schedule, turnovers, gaps) and provides parameter guidance, but it does not explicitly contrast with alternatives such as get_rental_maintenance_schedule. Clear context without exclusions warrants a 4.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds context about included task types and parameter defaults, but does not disclose additional behaviors like pagination, sorting, or output format. This is consistent with annotations and provides moderate added value.

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-loads the purpose, and includes essential parameter guidance without unnecessary detail. 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 read-only tool with complete schema coverage and annotations, the description is reasonably complete. It specifies the resource, task types, and parameters. It does not explain return value structure, but no output schema exists and the tool's purpose is straightforward.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description essentially repeats the parameter names and defaults without adding new semantic meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool gets upcoming and overdue maintenance tasks, with specific examples like HVAC filter changes and pest control. It distinguishes from siblings like get_rental_cleaning_schedule by focusing on maintenance schedule rather than cleaning schedule.

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 describing what the tool returns and its parameters, but it does not explicitly state when to use this tool versus alternatives such as get_rental_cleaning_schedule or create_rental_maintenance_task. There is no explicit exclusion or alternative naming.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context by enumerating exactly what information the tool returns (permit requirements, taxes, limits, zoning, operational rules), which helps the agent understand the tool's scope beyond the annotation flags.

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 three short sentences, front-loaded with the core purpose. Each sentence earns its place: the first states the function, the second lists outputs, and the third clarifies required vs optional parameters. 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?

With no output schema, the description responsibly lists return categories, which covers expected results. It also gives parameter guidance. The only gap is ambiguity about behavior when city is omitted, but the 'state required, city optional' note largely addresses this. Overall, it is sufficiently complete for a read-only lookup 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 already fully describes all three parameters (100% coverage). The description adds little beyond restating that state is required and city/property_type are optional, which is a marginal contribution. It does not provide additional format details or usage nuances beyond the schema.

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

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

The description uses a specific verb ('Get') and identifies the exact resource: local short-term rental regulations for a specific city and state. It lists concrete outputs (permit requirements, occupancy taxes, etc.) that distinguish it from narrower sibling tools like check_str_permit_requirements or get_str_insurance_requirements.

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 (essential for host compliance) and explicitly notes required vs optional parameters (state required, city and property_type optional). However, it does not mention when to prefer this tool over overlapping siblings like check_str_permit_requirements, nor does it state exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds behavioral context by explaining that returns vary based on property type and estimated revenue, and lists specific return elements. This goes beyond the structured annotations without contradicting them.

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

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

The description is a single, well-structured sentence that front-loads the primary action ('Get insurance requirements') and then expands on the return value. No filler or redundancy.

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

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

For a read-only lookup tool with three parameters and no output schema, the description sufficiently explains what it returns and what factors influence results. It could mention limitations or data sources but is broadly complete for an agent to select and invoke it.

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

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

All parameters have schema descriptions, giving baseline 3. The description adds meaning by linking 'property type' and 'estimated revenue' to the recommended policy limits, clarifying their role in tailoring the output. This enriches the parameter 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 clearly states it retrieves insurance requirements and recommendations for short-term rental hosts by state, listing specific outputs like liability minimums and policy limits. This distinguishes it from sibling tools focused on permits, regulations, or tax.

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

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

The usage is implied: use this when you need insurance requirements for STRs. However, it does not explicitly mention when not to use it or name alternatives like check_str_permit_requirements or get_short_term_rental_regulations, which cover adjacent but distinct topics.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description doesn't need to restate safety. It adds context about available formats and schema.org/lilo extensions, but doesn't disclose other behavioral traits such as whether the manifest includes pricing or availability, pagination behavior, or error handling. With annotations covering the safety profile, this is adequate but not extra informative.

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 three sentences: purpose, formats, and usage context. Each sentence is purposeful and free of fluff. It's front-loaded and appropriately sized for a simple 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?

The tool is simple with two well-described parameters and read-only annotations. The description conveys what the manifest is (schema.org + lilo extensions), the formats, and the intended use case. It could mention what content the manifest contains, but for a simple read-only retrieval tool, it's 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 description coverage is 100%, as both format and property_id are described in the input schema. The description's mention of YAML/JSON/JSON-LD repeats the schema's format enum without adding new meaning. Baseline 3 is appropriate since 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 retrieves an 'AI-optimized property manifest' in schema.org format with lilo extensions, specifying the verb (Get), resource, and format. It is distinguishable from siblings like get_vacation_rental_identity_manifest by the 'AI-optimized' focus, though it doesn't explicitly name alternatives.

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

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

Explicitly states 'Use this for structured data integration and AI agent consumption,' providing a clear context for when to use the tool. It lacks explicit exclusions or mention of alternative tools, but the use case is specific enough.

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

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

The read-only behavior is already disclosed by annotations (readOnlyHint=true, destructiveHint=false). The description adds context about the content returned (amenities, photos, protection status, etc.) but does not go beyond annotations in terms of side effects, auth requirements, or rate limits.

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 tool's purpose and followed by a succinct parameter usage note. Every word earns its place with no redundant 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?

The description lists the key return fields (name, location, address, nightly rate, etc.), which compensates for the lack of an output schema. It also covers the identifier input format. It does not mention error behavior or pagination, but for a single-object retrieval with one parameter, it is adequately 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 describes property_id as 'Property UUID or lilo_code', but the description adds a concrete example ('PROP-2343') and clarifies that the parameter can accept either format, which is valuable beyond the raw schema.

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

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

The description clearly states the tool's function with a specific verb ('Get') and resource ('vacation rental property'), and enumerates the fields returned. However, it does not differentiate from the sibling tool 'fetch_vacation_rental_details', which appears to serve a nearly identical 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 for retrieving complete rental details and clearly explains how to identify the property (property_id or lilo_code). However, it provides no explicit guidance on when to use this tool over alternatives like 'fetch_vacation_rental_details' or more specialized getter tools (e.g., 'get_vacation_rental_house_rules').

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds useful context about the scope of content (categories like check_in, parking, emergency) and that it returns 'all' FAQs, but does not mention pagination, response format, or behavior when no FAQs exist. This is moderate added value beyond annotations.

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

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

The description is two concise sentences, front-loaded with the primary purpose. The first sentence states what the tool does, the second elaborates on categories. No wasted words or redundant 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 simple read-only tool with two parameters and no output schema, the description is adequate. It explains the content and filter options, implying that the response contains question-answer pairs. It does not detail edge cases like empty results, but the overall context is sufficient for an agent to 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 description coverage is 100% for both property_id and category. The description repeats the category list but does not add new parameter meaning beyond what the schema already provides. This aligns with the baseline score of 3 for full 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 clearly states 'Get all frequently asked questions and answers for a vacation rental property' with a specific verb and resource. It also lists the content areas (WiFi password, check-in instructions, etc.) and distinct filter categories, making it distinct from sibling tools like 'ask_vacation_rental_question' or 'get_vacation_rental_house_rules'.

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 FAQ content and mentions filtering by category, but does not explicitly state when to use this tool versus alternatives like 'ask_vacation_rental_question'. No exclusions or alternative tool names are provided, so guidance is implied rather than explicit.

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

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

Annotations already indicate read-only and non-destructive behavior. The description adds value by disclosing the nature of the returned data (verified evidence summary) and specific output fields, allowing the agent to anticipate what the tool returns without contradicting the annotations.

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

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

The description is two sentences, front-loaded with the core purpose, and every phrase adds meaningful detail. It avoids wasted words while covering what the tool does, what it returns, 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?

Given the simple one-parameter input and no output schema, the description sufficiently covers the tool's behavior, return content, and intended use case. It provides all necessary context 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% with a single parameter (host_id described as Host UUID), so the description does not need to add parameter details. The description adds no additional semantics beyond the schema, resulting in the baseline score.

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: retrieving a host's reputation score and verified evidence summary, listing specific output components (protection stats, evidence count, dispute resolution rate, verification status). This distinguishes it from similar siblings like get_vacation_rental_reputation_score, which likely only returns the score.

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 usage context (verify a host's trustworthiness), which tells the agent when to use this tool. However, it does not explicitly mention alternative tools or when not to use this one, so there is room for stronger 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?

The readOnlyHint annotation already establishes that this is a safe read operation. The description adds valuable behavioral context by stating the output is structured/machine-readable and listing the specific rule fields returned, which goes beyond the annotation without contradicting it.

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

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

The description is two sentences long, front-loading the primary purpose before listing return categories. Every sentence contributes essential information 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?

Given the tool's low complexity (one parameter, no output schema, no nested objects), the description adequately explains what will be returned by listing the house-rule categories. This is sufficient for an agent to invoke the tool and interpret results without needing further detail.

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 fully describes the single parameter (property_id as UUID or lilo_code) with 100% coverage. The description does not add additional parameter meaning, so the baseline score of 3 applies.

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

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

The description clearly states the tool retrieves house rules for a vacation rental and enumerates specific content areas (max guests, quiet hours, pet policy, etc.). This specific verb+resource combination distinguishes it from sibling tools like get_vacation_rental_faqs or fetch_vacation_rental_details.

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

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

The description provides clear context for when to use the tool by specifying the exact data categories returned, implying its use for house-rule lookups. It does not explicitly name alternatives 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds that the manifest contains structured evidence data, visibility metadata, and verification references, which is useful context. However, it lacks detail on return formats or potential error behavior, so the added value is moderate.

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 purpose and a concise usage hint. No redundant information, every word earns its place.

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

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

The tool is simple: one required parameter, strong annotations, and a clear description of the output's nature. Since there is no output schema, some return details are missing, but the description gives enough for an agent to 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% with property_id described as 'Property UUID or lilo_code'. The description does not add additional meaning beyond the schema, so the baseline 3 applies.

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

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

The description clearly states the verb 'Get' and the resource 'property identity manifest' with specific content details (structured evidence data, visibility metadata, verification references). It distinguishes from siblings by focusing on 'identity manifest', but does not explicitly name alternatives.

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

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

The phrase 'Use this for programmatic property data consumption' provides clear context for when to select this tool, implying a machine-readable use case. It does not explicitly exclude alternatives or name sibling tools, so it is slightly below a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description complements this by explaining the full behavioral output (all tracked items with quantities, locations, condition, and check history) and the optional category filter. This adds context beyond the annotations without contradicting them.

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

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

The description is compact and front-loaded with a clear purpose. The second sentence adds valuable return-value and filtering details, though it redundantly repeats the category list that already exists in the schema. Overall, it is efficient and well-structured.

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

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

Given the tool's simplicity (2 parameters, no output schema), the description sufficiently covers return contents and filtering. It does not detail pagination or error cases, but these are not essential for a straightforward read-only inventory fetch. The annotations and schema round out the 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?

Schema description coverage is 100% for both parameters (property_id and category). The description lists the same categories as the schema, adding no new semantic meaning. It neither enhances nor detracts from 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+resource combination ('Get the inventory list for a vacation rental property') and details exactly what is returned (quantities, locations, condition, check history), distinguishing it clearly from sibling tools like get_vacation_rental_details or report_rental_inventory_issue.

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 you need inventory information) and provides clear context about the return contents. However, it does not explicitly mention alternatives or exclusions, though such guidance is not critical given the tool's unique scope.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the agent knows it's a safe read. The description adds meaningful context: the return value lists completed and pending steps, and both identifier options are explained with an example format. This goes beyond the structured annotations, though it doesn't describe edge cases (e.g., missing property).

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 long, front-loads the primary action and resource, and packs useful details (list of steps, identifier examples) without redundancy. 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?

Given the simple read-only nature, rich annotations (readOnlyHint/destructiveHint), and full schema coverage, the description is complete. It explains the output (completion status of setup steps) and how to provide input, so no critical information is missing.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by clarifying that lilo_code and property_id are alternatives ('Pass lilo_code or property_id') and provides a concrete example (PROP-6408). This helps the agent understand the relationship between the two optional parameters, which the schema alone doesn't convey.

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 'Check onboarding progress for a vacation rental property on lilo', which clearly states the action (check) and the resource (onboarding progress). It also enumerates the specific setup steps covered (property details, photos, house rules, calendar sync, payment setup), distinguishing it from sibling tools like get_vacation_rental_details or get_vacation_rental_house_rules.

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

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

The description gives clear context on what the tool does and how to invoke it (pass lilo_code or property_id). It does not explicitly name alternatives or states when not to use it, but the purpose is specific enough that usage intent is unambiguous. A minor gap: no explicit exclusion of other get_vacation_rental_* tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds behavioral context by listing the nature of the output (comparable rates, market average, optimization suggestions, seasonal adjustments), clarifying that it is a read-only analytical tool. It does not contradict annotations and provides useful detail about what the analysis yields.

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 includes only essential details. Every sentence earns its place: the first states what the tool does, the second lists required/optional parameters. No fluff 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?

The description is reasonably complete for a read-only analysis tool. It covers the purpose, key inputs, and return elements (comparable property rates, market average, suggestions, seasonal adjustments). While there is no output schema, the description provides enough for an agent to anticipate results. It could mention date ranges or interpretation, but that is not necessary for basic use.

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 marginal value by clarifying that location is required and property_id is 'for direct comparison' and bedrooms is 'count', but these details are largely redundant with the schema descriptions. It does not introduce new meaning or elaborate on parameter formats.

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: 'Get competitive pricing analysis for a vacation rental market.' It uses a specific verb ('Get') and resource ('pricing analysis'), and enumerates what it returns (comparable rates, market average, optimization suggestions, seasonal adjustments). This distinguishes it from sibling tools like check_vacation_rental_availability_and_pricing, which focus on availability rather than competitive analysis.

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

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

The description implies usage context—'pricing analysis'—but does not explicitly state when to use this tool versus alternatives. It mentions required and optional parameters ('Pass location (required), optional property_id...'), which is more parameter guidance than usage guidance. No explicit when-not or alternative recommendations 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?

Annotations already declare readOnlyHint and destructiveHint, so the description only needs to add context. It names specific return data (dispute win rate, protection statistics, host response times, overall score, narrative summary), which is helpful and goes beyond the annotations.

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

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

The description is two sentences: first states the action and result, second lists return items and usage context. Every sentence earns its place; there is no filler or repetition.

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

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

For a single-parameter read-only tool, the description covers purpose, output, and usage guidance. It lacks an explicit distinction from overlapping siblings and does not explain the output format (no output schema), but overall it is sufficiently complete for straightforward 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 schema already fully describes property_id as 'Property UUID or lilo_code' (100% coverage). The description only says 'specific vacation rental property', adding no additional semantic detail beyond the schema 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 it retrieves a reputation score and performance data for a vacation rental, listing specific output elements. However, it does not distinguish itself from sibling tools like 'get_vacation_rental_host_reputation', which may overlap in 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 provides a concrete use case: 'Use this to evaluate a property's track record before recommending it.' It offers clear context but does not mention alternatives or when not to use the tool, leaving differentiation to the agent.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false. The description adds meaningful context beyond these: the certificate is 'continuously maintained' and includes verification data for independent validation, which describes behavior not covered by the schema or annotations. It does not contradict the read-only nature.

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

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

Two sentences with zero fluff. The first sentence states the core action and object, the second clarifies contents and provides a usage example. Information is front-loaded and every sentence contributes.

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

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

For a one-parameter read-only tool without an output schema, the description adequately covers purpose, contents, and usage. It could mention return format or error behavior, but those are not essential given the simplicity and the annotations disclose the read-only nature.

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 fully describes lilo_code with an example (PROP-6408), and the description repeats this instruction. Since schema coverage is 100%, the description adds no new semantic meaning beyond the schema. Baseline 3 applies.

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

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

The description uses a specific verb ('Access') and a distinct resource ('trust certificate for a lilo-protected vacation rental property'), clearly distinguishing it from sibling tools like get_vacation_rental_host_reputation or verify_vacation_rental_trust_chain. It explicitly names the certificate and 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?

The description provides context about what the certificate contains (verification data for protection status, evidence integrity, host reputation) implying when it would be useful, but it does not explicitly state when to use this tool versus alternatives like verify_vacation_rental_trust_chain. No exclusions or alternative comparisons are given.

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

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

Annotations already declare destructiveHint=true, but the description adds no behavioral context beyond confirming it is an ingestion/write operation. It does not describe side effects, idempotency, permissions, or what happens to existing data.

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

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

Two sentences, front-loaded with the main purpose and a clear parameter instruction. Every word earns its place; 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?

For a simple one-parameter tool with no output schema, the description covers the essential purpose and parameter. However, it lacks any indication of return values, post-ingestion behavior, or cautions about the destructive nature beyond the annotations. Adequate but with clear 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?

Schema coverage is 100%, with the 'source' enum already documenting the values. The description repeats the enum values and maps them to data types ('religious' = historic religious properties, 'aahs' = African American historic sites) which adds some meaning, but does not go beyond the schema's 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: ingesting Philadelphia public records (landmarks, historic religious properties, African American historic sites) into the lilo system. The verb 'ingests' is specific and distinguishes this write operation from sibling read/search tools.

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

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

No guidance is given on when to use this tool versus alternatives. The instruction 'Pass source: all, landmarks, religious, or aahs' is parameter guidance, not usage context. No mention of exclusions or how this relates to read-only search tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds behavioral context by specifying that the tool returns a risk score, key risk factors, and prevention recommendations, and notes that optional inputs (amount, guest_profile) influence the prediction. No contradiction with annotations.

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

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

Two sentences, front-loaded with the primary action and outcome. Every word earns its place, and it is appropriately sized for the tool's complexity.

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 prediction tool with three parameters (one nested) and no output schema, the description adequately covers inputs and outputs. It does not detail edge cases or guest_profile structure, but the schema covers parameter names and the description explains the return value well enough.

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

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

The input schema already provides descriptions for all three parameters (100% coverage). The description briefly restates booking_id as UUID, amount as cents, and guest_profile, but does not add significant meaning beyond the schema. Baseline 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 uses the specific verb 'predict' and names the exact resource: chargeback probability for a vacation rental booking. It clearly differentiates from siblings like assess_vacation_rental_booking_risk and get_chargeback_defense_for_booking by focusing on probability scoring and prevention recommendations.

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

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

The description clearly implies when to use the tool (when chargeback probability for a booking is needed) and lists the required/optional inputs. It does not explicitly name alternatives or exclusion conditions, but the context is sufficiently clear for an agent to infer appropriate usage.

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

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

Annotations already cover safety (readOnlyHint=true, destructiveHint=false). The description adds useful behavioral context: it returns 'independently verified evidence records' and supports filtering by specific IDs or event type. It does not mention pagination or default behavior when no filters are provided, but with annotation coverage, the added context earns 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?

Three sentences, front-loaded with the primary action. Each sentence earns its place: the first states what it does, the second describes the return and filters, the third states the use case. 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?

With 4 optional params, good annotations, and no output schema, the description covers purpose, return type, filters, and use case. It lacks details about what happens when no filters are provided or how result sets are structured, but for a query tool with high schema coverage, these are 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?

Schema coverage is 100%, with each parameter described in the schema. The description mentions the three main filters (property_id, booking_id, event_type) but does not add meaning beyond what the schema provides, such as parameter combinations or output shape. Baseline 3 is appropriate when 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 uses a specific verb ('Query') with a clear resource ('evidence chain') and scope ('for a vacation rental property or specific booking'). It also states what it returns ('independently verified evidence records') and differentiates from sibling tools by focusing on auditing the complete evidence trail rather than verification or timeline generation.

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: 'Use this to audit the complete evidence trail.' This implies when to use it (auditing) and implicitly contrasts with verification tools in the sibling list. However, it does not explicitly name alternatives or state when not to use it, leaving a small 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?

The annotations include destructiveHint=true, but the description says 'Creates a verified evidence record,' which is an additive, non-destructive operation. This directly contradicts the annotation, so transparency is undermined. No other behavioral context is provided.

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 long, front-loaded with the primary purpose, and includes all necessary parameter guidance without superfluous text. 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 relatively simple write tool with 5 flat parameters and no output schema, the description explains the core behavior ('creates a verified evidence record') and lists all required/optional parameters. It lacks details on side effects or return values, but overall it is sufficient for basic 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 description coverage is 100%, so the baseline is 3. The description does list the accepted values for interaction_type and channel, but these are already present in the schema descriptions. It adds no additional meaning beyond repeating the schema.

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

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

The description clearly states the action ('Record') and the resource ('guest interaction to the vacation rental's evidence chain'), and differentiates it from sibling tools like query/verify/evidence tools. It also lists the key parameters, 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 clearly implies when to use this tool (whenever a guest interaction needs to be recorded to the evidence chain) and lists the required fields. However, it does not explicitly mention alternatives or when not to use it, so it lacks the exclusionary guidance of a top score.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the agent knows this is a write operation. The description confirms this by saying 'Creates an issue record' and adds the optional photo evidence. However, it does not disclose any other side effects (e.g., notifications, status changes) beyond the creation itself, which the annotations already imply.

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

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

The description is three sentences: first states the purpose, second states the effect (creates record) and optional evidence, third lists parameters. It is front-loaded and concise with no redundant or filler language.

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 6 parameters (3 required) and no output schema. The description adequately explains the tool's purpose and parameter usage, and the schema covers parameter formats. It does not mention what the tool returns, but for a creation tool this is often implicit. Overall, the description is sufficient for a competent 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 description coverage is 100% for all 6 parameters, including allowed values for issue_type. The description essentially paraphrases the schema by listing required and optional parameters. It adds no new semantic information beyond what the schema already provides, so it earns the baseline 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 specific verb 'Report' and the resource 'rental inventory issue', making it distinct from sibling tools like get_vacation_rental_inventory (which retrieves inventory) and create_rental_maintenance_task (which handles maintenance). It also enumerates the types of issues (missing, damaged, low-stock) and the context is a vacation rental property.

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 usage: to report missing, damaged, or low-stock inventory items. It does not explicitly mention exclusions or alternative tools, but the context is specific enough for an agent to infer when to use it. Since no alternatives are named, 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to cover safety. It adds useful behavioral context by describing the output: a risk level (low/medium/high/critical) and specific recommendations, plus the evaluation dimensions (profile, booking details, communication patterns). This goes beyond the annotations without contradicting them.

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

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

Three concise, front-loaded sentences cover the purpose, outputs, and input guidance without redundancy. Every sentence contributes directly to operational understanding, making it highly 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?

The description adequately explains the tool's return behavior (risk level and recommendations) despite the absence of an output schema. It also lists relevant inputs and the decision context. It does not mention edge cases like missing data or computation method, but these are not essential for basic 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?

The input schema describes all five parameters with 100% coverage, so the baseline is 3. The description adds minimal semantic value by listing parameter names and using 'and/or' to indicate optionality, but it does not clarify relationships or add detail beyond the existing schema descriptions.

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

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

The description clearly states the tool's purpose as a pre-booking guest risk assessment, specifying it evaluates guest profile, booking details, and communication patterns to produce a risk level and recommendations. This is a specific verb-resource combination, though it does not explicitly differentiate from the many sibling risk-assessment tools, such as assess_vacation_rental_booking_risk or analyze_guest_communication_risk.

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: before booking, to help hosts decide whether to accept a request. It also indicates that multiple parameters can be passed, with 'and/or' implying flexibility. However, it does not explicitly state when not to use it or name alternatives, which would have distinguished it from overlapping sibling tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds some value by listing return fields (capacity, type, availability, booking information), but it doesn't reveal deeper behaviors such as pagination, result limits, or data freshness. This is adequate but not rich context.

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

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

The description is three concise sentences, each earning its place: purpose, return details, and filters. It is front-loaded with the key action and resource, and there is no unnecessary fluff 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?

Given the tool has no output schema, the description reasonably covers the return values (venue details) and parameters. It is complete for a straightforward search tool with optional filters. Minor gaps like pagination or result ordering are not critical for this simple use case.

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% description coverage for all three parameters, so the baseline is 3. The description's mention of 'Filter by venue_type ... and minimum capacity' mostly restates the schema's parameter descriptions, adding little new semantic meaning. It does not compensate for any gaps because there are none.

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 Philadelphia event and wedding venues.' It clearly distinguishes this tool from siblings like search_philadelphia_historic_properties and search_vacation_rentals by focusing on event/wedding venues in a specific city. The return details and filters further reinforce 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?

The description provides clear context for when to use the tool ('Search Philadelphia event and wedding venues') and mentions specific filtering options. However, it does not explicitly name alternatives or exclusion criteria, but the context is sufficiently clear that an agent would know this is the tool for venue searches in Philadelphia.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it's a safe read operation. The description adds that the data comes from public records and mentions the type filter, but does not disclose return format, pagination, or any other behavioral details. This adds some value beyond annotations but not a lot.

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. The second sentence adds filter options and context without redundancy. Every word earns its place; no fluff 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 search tool with three optional parameters, read-only annotations, and no output schema, the description covers the core functionality, filter options, and relevant use cases. It doesn't explain the return value shape, but that is less critical for a search tool with a self-explanatory name. Overall, 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 description coverage is 100%, so all three parameters (type, limit, query) have descriptions. The description repeats the type enum and adds context for the use case, but does not meaningfully enhance the semantics of limit or query. Baseline 3 is appropriate when schema already 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 searches Philadelphia historic properties and landmarks from public records, using a specific verb and resource. It distinguishes from sibling tools like get_philadelphia_landmark_details (details vs search) and search_philadelphia_event_venues (different resource).

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 context for use in World Cup 2026 and America's 250th Anniversary planning, which helps an agent decide when to invoke it. It also lists the type filter options. However, it does not name alternative tools or state when not to use it, so it's clear 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?

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by noting it returns non-activated properties, which is a distinctive behavior not obvious from annotations or schema. It also mentions the geographic scope and filter categories.

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 only two sentences, front-loading the core purpose and then summarizing filters and return type. Every sentence adds value with 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?

The tool has 7 parameters and no output schema, but the description covers the essential return type (property listings including non-activated) and key filters. It does not describe pagination or exact listing fields, but for a search tool with well-documented schema, 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 description coverage is 100%, so all parameters have meaningful descriptions. The tool description maps some filters (price range, bedrooms, superhost, World Cup city) to parameters but does not provide additional meaning beyond the schema, such as format or edge cases. 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 the tool searches 'lilo's market discovery for vacation rental properties' with specific filters (price range, bedrooms, superhost, World Cup 2026 host cities) and returns listings including non-activated properties. This distinguishes it from sibling search tools like search_vacation_rentals and search_world_cup_rentals by focusing on market discovery for research.

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 tool is for market research by highlighting 'non-activated properties for market research' and 'market discovery'. It gives clear context on when to use it (for research on vacation rental market) but does not explicitly state when not to use it or provide alternative tool names.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is clear. The description adds valuable behavioral details about the return format (id, title, url, snippet, pricing, attributes) and the fact that results are 'optimized for AI deep research,' which goes beyond the annotations.

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

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

The description is efficient with four sentences, front-loading the main purpose first. The final sentence about filtering is somewhat redundant with 'structured filtering' in the first sentence, but overall it's well-structured and each sentence adds value.

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

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

Given the schema covers all parameters and annotations declare the tool read-only, the description adds essential context about output format and intended use case. It's complete for a search tool, though it doesn't mention pagination or result ordering, which are 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 input schema has 100% coverage for all 7 parameters, so the schema already documents each parameter. The description only summarizes the filters (city, state, bedrooms, price, pet-friendliness) without adding new meaning beyond the schema, 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 searches for vacation rental properties with structured filtering, giving a specific verb and resource. It also says 'Use this for broad property discovery,' which helps differentiate from specialized siblings like search_vacation_rentals_by_amenities, though it doesn't name them explicitly.

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

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

Provides explicit guidance with 'Use this for broad property discovery,' giving a clear positive use case. However, it doesn't mention when not to use it or name alternative tools for specialized searches, 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description is consistent with the safety profile. However, the description adds no extra behavioral context beyond the basic search operation, such as matching semantics, result ranking, or potential ambiguity of natural-language queries.

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: it leads with the main purpose, gives illustrative examples, and ends with parameter usage. Every word contributes; no filler or redundant 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 simple read-only search tool with no output schema, the description adequately explains the operation and the expected input. It clearly implies the result type ('vacation rentals') but could be slightly more explicit about what the response contains (e.g., a list of matching rentals). Overall, it covers the essentials without over-explaining.

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

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

Schema coverage is 100% for all three parameters, so the baseline is 3. The description adds value by providing examples of natural-language query values and explicitly stating that location is optional, enhancing the schema's terse 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 specifies a clear action ('Search'), a resource ('vacation rentals'), and a distinguishing scope ('by amenity description using natural language'). Concrete examples ('pool and hot tub', 'pet-friendly with fenced yard') make the function's intent unmistakable and differentiate it from generic search 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 when to use the tool ('when searching by amenity description') and mentions an optional location filter, but it does not explicitly distinguish it from siblings like search_vacation_rentals_by_description or provide when-not-to-use guidance. With many sibling search tools, explicit alternatives would be valuable.

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

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

Annotations already mark this as read-only. The description adds the non-obvious behavior of semantic matching ('finds matching properties by semantic meaning, not just keywords') and explains the effect of threshold/limit, which is useful beyond the schema. No contradictions with annotations.

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

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

The description is succinct and front-loaded with the core purpose. The three examples are valuable but could be slightly trimmed; overall every sentence contributes.

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

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

For a read-only search tool with three well-documented parameters and no output schema, this description is sufficient. It explains the semantic search behavior and parameter usage, though it could more explicitly differentiate from sibling search tools for full 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?

Although schema descriptions already cover all parameters (100% coverage), the description adds concrete example queries and clarifies each parameter in plain language (e.g., 'threshold: how strict result matching should be'). This helps an agent construct better queries, but the added value is marginal.

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 vacation rentals using a natural language description,' clearly stating the action and resource. It also distinguishes itself by emphasizing 'semantic meaning, not just keywords,' which differentiates it from sibling search tools like search_vacation_rentals_by_amenities.

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