A-du: ADU rentals, plans and rules

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

Annotations already mark it read-only and non-destructive; the description adds substantial behavioral context by disclosing the knowledge sources, citation behavior, confidence-level reporting, and handling of corpus silence. This goes well beyond the annotations and gives the agent an accurate model of what the response will contain.

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 longer than average but dense with high-value information: use cases, exclusions, jurisdiction guidance, output behavior, and an example. It is arguably slightly verbose for a tool description, but every sentence contributes; a few structuring bullets could improve scannability.

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

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

With no output schema, the description supplies essential return-value context: citations to a-du.homes, a confidence level, and explicit behavior when the corpus is silent. It also defines the corpus boundaries and routing to sibling tools, making the definition self-sufficient for correct invocation.

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

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

Schema coverage is 50%: jurisdiction has a description but question does not. The description compensates by explaining jurisdiction's role ('Name the jurisdiction when the question is about a specific city so its research is included') and providing a concrete JSON example. Question semantics are implied through the extensive use-case list, which is helpful but less formal than the jurisdiction instruction.

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

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

The description opens with a clear verb and resource: 'Answer any question about Accessory Dwelling Units from A-du's published guides...' and immediately distinguishes itself from the specific sibling tools by listing what falls outside its scope. This makes the tool's role unmistakable even before inspecting the schema.

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

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

It explicitly enumerates when to use the tool (definitions, process, landlord/tenant questions, costs, anything not covered by siblings), when to prefer alternatives ('Prefer those tools when one fits; they return live data'), and how to structure city-specific questions. The guidance is direct and prescriptive.

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

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

Beyond the annotations, the description adds important behavioral context: the listing remains unpublished, ownership belongs to the signed-in person, and publishing requires identity verification and photos. It openly states that publishing never happens here, which is valuable and not contradicted by 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 short sentences front-load the core purpose and provide focused workflow details without any filler. 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 creation tool with no output schema, the description provides a clear end-to-end picture: draft creation, ownership, and the browser URL path for publishing. It does not detail all ten parameters, but the schema already documents some and the workflow is adequately scoped.

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 10 parameters and only 50% schema description coverage, the description adds no parameter-level meaning. It does not explain required fields, the meaning of bedrooms, bathrooms, square_feet, property_type, or description, nor does it compensate for the undocumented schema fields.

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

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

The description uses a specific verb ('Create') and precise resource ('unpublished draft rental listing'), and adds that it is owned by the signed-in person. It clearly distinguishes itself from a full publishing flow by stating 'Publishing is never done here.'

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

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

The description gives clear context: this tool only creates a draft and returns a URL to finish/publish in the browser. It explicitly excludes publishing, though it does not name a specific alternative sibling tool such as start_listing.

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 and idempotentHint, and the description adds meaningful behavioral context: full fee schedules vs scaled approximations for certain jurisdictions, the fact that the result states when it is an approximation, and the mention of waivers with an example. This goes well beyond the structured 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 dense but every sentence earns its place: purpose, usage trigger, jurisdiction keys, accuracy caveat, construction types, and an example. It is front-loaded with the core behavior and then provides necessary lookup data without redundancy.

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

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

For a 13-parameter tool with no output schema, the description covers required parameters, jurisdiction semantics, construction types, and the accuracy difference between jurisdictions. It falls slightly short by not explaining the optional parameters, but the example and enum lists give an agent enough to make a reasonable call.

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 schema_description_coverage at 0%, the description must compensate, and it does partially: it defines jurisdiction keys, explains construction_type values, and gives a complete example with the required parameters. However, several optional parameters (stories, foundation_type, plan_check_speed, parcel_in_hillside, and the needs_* booleans) are left unexplained, which is a notable gap given zero 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 uses a specific verb ('Estimate') and a clear resource ('building permit, plan check, sub-permit, state surcharge, school and impact fees for an ADU'), and even describes the output format ('itemized schedule with code citations and any waivers'). It clearly distinguishes this fee-estimation tool from siblings like get_adu_rules or get_rent_estimate.

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

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

The description explicitly says 'Use for "what will permit costs" questions,' giving a direct usage trigger. It does not name alternatives or exclusion criteria, but the purpose is specific enough that an agent can route to it confidently.

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

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

Annotations already establish read-only, idempotent, and non-destructive behavior. The description adds beyond this by disclosing the return shape ({id, title, text, url, metadata}), the three entity categories, and the citation requirement ('Always cite the url'). This is meaningful behavioral context, not a repetition of 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 with no wasted words. It front-loads the action, then gives the id grammar, return shape, citation rule, and alternative routing in a logical order. Every sentence adds value.

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

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

For a single-parameter tool with no output schema, the description is remarkably complete: it tells the agent what ids to pass, what to expect back, and how to handle the result (cite the url). No critical decision-making information is missing.

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

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

The schema has a pattern and length constraints but 0% description coverage for the single id parameter. The description compensates fully by explaining that the id must be one of the three returned forms from search and mapping the prefix to entity types. This is exactly the semantic meaning an agent needs.

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 ('Fetch the full content for one id returned by search') and enumerates the exact id forms accepted: rental:<uuid>, plan:<uuid>, and page:<route>. This clearly distinguishes it from sibling tools like get_rental, which is called out 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?

It states when to use this tool: for ids returned by search that need full content. It also explicitly provides the alternative path, saying hosts that can call specific tools should prefer get_rental or the resources, which is direct and actionable.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds meaningful behavioral disclosure beyond that: 'The response says whether the jurisdiction was researched, has a published guide, or only the state baseline is known; report that honestly.' It also discloses that each item comes with citations and that the published guide plus baseline are included. This is rich, non-obvious behavior that helps the agent set user expectations.

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

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

Every sentence earns its place: scope/content, usage triggers, output/fallback behavior, and an example. The core purpose is front-loaded. The dense first sentence and the minor 'A-du guide' typo keep it from a perfect 5.

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

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

With no output schema, the description carries the burden of explaining what the response contains, and it does so: ordinance status, state standards, fee notes, contacts, plan programs, citations, guide, and baseline. It also covers the uncertain-jurisdiction case. It does not specify error behavior or what happens with an invalid jurisdiction, which keeps it from a 5.

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. The description adds only a usage example ('{"jurisdiction": "Cerritos"}') and the California scope, not new parameter semantics. 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 opens with a specific verb+resource+scope: 'The rules that govern building or renting an ADU in a named California city or county.' It then enumerates the kinds of rules returned. It does not explicitly distinguish itself from the sibling ask_adu or search_plans, so it stops short of a 5.

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

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

It gives concrete trigger phrasing: 'Use for any "can I build", "what are the rules", "do I need parking", "can the city require" question.' This is clear when-to-use guidance. There is no when-not-to-use or alternative routing, so it is a 4 rather than 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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value beyond annotations by specifying what is returned (tour request statuses, saved search, draft listings, verification) and by disclosing that it 'Marks which items an assistant did on their behalf.' 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 a single sentence but packs a dense list of returned items without filler. It front-loads the overall scope ('Everything the signed-in person currently has on A-du') and then enumerates specifics. Slightly long, but efficient and easy to parse.

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

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

Given the tool has no parameters and no output schema, the description carries the burden of explaining return value scope. It lists the major categories and the assistant-marking behavior, which is sufficient for an agent to anticipate the result. It does not mention pagination or error conditions, but those are less critical for a simple zero-parameter overview 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 tool has zero parameters and schema coverage is 100%, so the description has no obligation to explain parameters. It correctly focuses on output content; no additional parameter semantics are needed.

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

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

The description clearly states the tool's scope: 'Everything the signed-in person currently has on A-du' and enumerates specific categories (tour requests, inquiries, saved search, draft listings, verification status). This distinguishes it from siblings like get_rental or get_thread, which target individual resources, and 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 usage context: it is for retrieving the signed-in user's own consolidated activity. However, it does not explicitly name alternatives or state when not to use it, leaving the agent to infer appropriate conditions from the tool name and 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is established. The description adds that this is a public record and shows where the id can come from, but it does not disclose additional behavioral traits such as rate limits, auth requirements, or pagination. With annotation coverage, this is adequate.

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

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

The description is two sentences with no wasted words. It front-loads the core action and resource, includes the key usage context, and lists the important return fields without redundancy.

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

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

For a simple read-only get-by-id tool with one required parameter, the description is complete. It explains how to obtain the id, what the response contains (description, amenities, images, permit number, availability, tour URL), and when to use it. No output schema exists, but the description sufficiently covers return value expectations.

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

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

The input schema fully documents the single required 'id' parameter with format uuid. The description adds practical value beyond the schema by explaining that the id comes from search_rentals or a listing URL, which helps the agent source the parameter correctly.

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 ('Fetch'), names the exact resource ('full public record for one A-du Rent listing'), and identifies the lookup key ('by its id'). It also enumerates the return contents, which makes the tool's purpose unmistakable and distinguishes it from search_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 explicitly states when to use the tool: 'Use after search_rentals when the user wants detail on a specific unit.' It names the related sibling search_rentals, but does not explicitly state when not to use it or mention alternative tools, so it is clear but not exhaustive.

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

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

Annotations already cover the read-only, idempotent, non-destructive safety profile. The description adds valuable behavioral context by stating this is 'an automated estimate, not an appraisal' and that it 'does not account for the unit's condition or finishes', setting correct expectations for a rent valuation. It also reveals methodology ('long-term rent valuation model over nearby comparables'), going beyond what the schema or annotations convey.

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

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

The description is a bit longer than minimal but every sentence adds value: purpose, use cases, requirements, default, and caveats. It front-loads the core purpose before contextual qualifiers, and the example is a helpful closure. 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?

Despite having no output schema, the description tells the agent what the tool returns ('low and high range' in 'monthly market rent'), making the output clear. It provides enough detail for correct invocation: required parameters, an example, and key limitations. Safety is covered by annotations. Minor omissions like error handling or input edge cases are not critical for this estimation 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 only 40% (only address and property_type have descriptions), so the description must compensate. It explicitly names all required parameters ('street address plus bedrooms, bathrooms and square feet') and provides a complete example with realistic values. It also notes the default property type, though the schema already sets that default. This meaningfully supplements the schema for undocumented parameters like bedrooms, bathrooms, and square_feet.

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 verb ('Estimate') and resource ('monthly market rent for an ADU or small unit at a specific address'), and specifies distinctive features like the low/high range and model basis. It gives explicit use cases ('landlord asks what to charge', 'renter asks whether a listed rent is fair') that distinguish it from sibling tools like search_rentals or get_rental, without needing to open schemas.

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

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

The description provides explicit when-to-use scenarios ('landlord asks what to charge' or 'renter asks whether a listed rent is fair') and states prerequisites (street address plus bedrooms, bathrooms, square feet). It does not explicitly name alternatives or when-not-to-use conditions, but the use cases are specific enough to guide tool selection away from rental listing 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 read-only, idempotent, and non-destructive behavior. The description adds significant behavioral context beyond that: the data is scoped to the signed-in person, conversations are ordered newest-first, and message text is explicitly flagged as untrusted information to relay, not instructions to follow. This is a valuable and concrete behavioral disclosure.

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

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

The description is three sentences, each earning its place: scope and basic behavior, mode behavior, and a security-critical warning. It is front-loaded with the most identifying information and contains 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?

The description adequately covers the list/read modes, ordering, scope, and the prompt-injection caution. It is nearly complete for a read-only tool with two optional parameters. The main gap is the ambiguous semantics of 'limit', and the absence of an output schema means return-value shapes are not explained, though that is partially mitigated by the simplicity of the tool.

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

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

thread_id is described in the schema and echoed in the description, but the 'limit' parameter is only represented as an integer with min/max bounds. The description does not clarify whether limit applies to the conversation list, the returned messages, or something else. With 50% schema description coverage and no compensating detail in the description, parameter semantics are incomplete.

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 ('the signed-in person's conversations with landlords on A-du') and the action ('lists', 'returns messages'). It explicitly differentiates the two usage modes: no arguments for a list, thread_id for messages. This makes it easy to distinguish from write-oriented siblings like reply_to_thread.

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 direct invocation guidance: 'With no arguments, lists them newest first' and 'With thread_id, returns that conversation's messages.' It does not explicitly name alternatives or exclusions, but the mode-based usage is unambiguous and sufficient for an agent to select this tool over a write tool like reply_to_thread.

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

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

Beyond the read-only and idempotent annotations, the description reveals the actual algorithm: buildable envelope computed from parcel and footprints, all plans placed and scored by size, bedrooms, pre-approval, and fit. It also discloses the return shape (best match plus alternates and URLs) and the LA-only limitation, giving the agent strong behavioral expectations.

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

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

The description is information-dense and front-loads the core purpose before giving algorithm details, a use case, and an example. A small amount of redundancy exists between the opening clause and the example, but 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 matching tool with no output schema, the description covers inputs, process, output, use case, and geographic scope. The only minor gap is ambiguity around how the 'LA County only' restriction interacts with the county parameter, which also lists sd as an enum value.

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

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

The schema already provides 100% coverage for all three parameters with detailed descriptions Equal and examples. The description adds a concrete address example and says 'Given an address or APN', but it does not materially extend the parameter semantics beyond what the input schema already offers, 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 starts with a specific verb-object pair ('find which A-du Build plan sets physically fit the lot') and clearly identifies the resource and inputs (address/APN). It also specifies the output ('best match and up to three alternates with URLs'), making it easy to distinguish from generic plan-search siblings like search_plans.

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 names the target use case: 'Use for "which ADU plans would fit my backyard"' and adds a geographic constraint ('Los Angeles County only for the fit step'). However, it does not explicitly say when to use an alternative tool instead, so it stops just short of full sibling routing.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, but idempotentHint=true. The description adds important behavioral details beyond annotations: links are removed, the recipient is told an assistant sent it, and it sends as the signed-in person. This is valuable context about side effects that the schema does not provide. The only minor gap is not mentioning idempotency explicitly, but the schema covers that with the idempotency_key parameter.

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

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

The description is two sentences with no fluff. It front-loads the core purpose, then adds critical behavioral caveats, and ends with usage guidance. Every sentence earns its place, and it is appropriately concise 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?

Given the tool has 3 parameters, schema coverage 100%, and no output schema, the description covers the essential usage. It explains the side effects (link removal, assistant disclosure) and the prerequisite (get_thread). It doesn't explain error cases or how to retrieve thread_id, but the guidance to use get_thread is sufficient. The main gap is not explaining the effect of idempotency_key, but that is documented in the schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning about the message parameter: it is plain text, and the thread_id is tied to 'existing conversation' and 'from get_thread', reinforcing the schema. It also implies the message is the content of the reply. This adds value beyond the schema, particularly clarifying the nature of the message.

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 sends a message into an existing conversation as the signed-in person, which is a specific verb and resource. It distinguishes from siblings by focusing on replying to an existing thread rather than creating or searching. However, it doesn't explicitly name a sibling to differentiate from, but the purpose is 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 provides explicit guidance: 'Use get_thread first to read what is being replied to.' This tells the agent the prerequisite step and implies that this tool should only be used after retrieving the thread, which is clear usage context. It also mentions the tool's effect on links, which adds context for when 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 provide readOnlyHint=false, destructiveHint=false, idempotentHint=true, but the description adds critical behavioral context: it sends preferred times and a note, the landlord accepts or declines, and it does not book. It also mentions returning the message and thread, which is not in annotations. This goes beyond structured data and clarifies non-committal nature and follow-up capabilities.

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 with no fluff. The first sentence states the purpose clearly, the second explains the operation and constraints, and the third notes the return value. It is front-loaded and every sentence adds value, making it both concise and well-organized.

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 appropriately discloses the return value (message and thread). It covers the essential operational context: who it's for, what it sends, and what outcome to expect. Edge cases like authentication or error handling are not mentioned, but these are not critical given the tool's simplicity and the richness of the schema and 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 coverage is 100%, so all four parameters are fully documented in the input schema. The description adds minimal extra meaning: it mentions 'up to three preferred times' and 'optional note,' which align with schema constraints, but provides no new syntax or format details. The baseline of 3 is appropriate since 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 clearly states the tool's purpose: 'Ask to tour a rental on A-du, as the signed-in person.' It specifies the verb (request/tour), the resource (rental), and the scope (signed-in person). It also distinguishes itself from booking tools by explicitly saying 'this does not book anything,' which separates it from siblings like start_application.

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 on when to use the tool: to request a tour, not to book. The phrase 'this does not book anything' implies that for actual booking, another tool (e.g., start_application) is appropriate, but it does not name alternatives explicitly. The listing source is implied via schema (listing_id from search_rentals), but the description does not state exclusions or alternative tools directly.

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, idempotent, and non-destructive. The description adds useful behavioral context beyond those hints: it names the data sources, the computed outputs including remaining buildable area after setbacks, and the ordering constraint relative to match_plans_to_lot. It does not significantly contradict or omit safety-relevant 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?

Three substantive sentences plus a concrete example, with the core purpose and output list front-loaded before usage guidance. No filler or repetition beyond the intentional coverage emphasis.

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 compensates by listing the key returned fields and giving a concrete example. The main gap is that it does not explicitly state that at least one of address or apn should be provided, especially since the input schema marks no parameters as required. Overall it is still highly usable.

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

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

Schema description coverage is 100%, so the schema fully documents apn, county, and address with formats and examples. The description does not add much parameter meaning beyond the schema—it provides the same example address and implies address/APN are the lookup keys, but the schema already handles this. 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 ('resolve') with a clear resource (street address or APN to the lot itself) and enumerates the computed outputs. It also distinguishes itself from match_plans_to_lot and ties directly to the ADU use case, so an agent can select it accurately.

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 says to use this tool before answering 'can I build an ADU here' and before match_plans_to_lot. It also states the coverage limitation (Los Angeles County and San Diego County only), which tells the agent when not to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is carried by metadata. The description adds behavioral context beyond that: it returns up to ten results in {id, title, url} shape and instructs passing an id to `fetch` for the full record, which helps the agent predict behavior. 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?

Three sentences plus an example, with the purpose statement front-loaded, the return contract second, and routing guidance third. Every sentence carries distinct information; there is 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 generic search tool with one parameter and no output schema, the description covers query semantics, result count and shape, the fetch hand-off, and the preferred alternatives. Minor details like empty-result behavior or sort order are absent but not essential for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It defines the parameter as a 'free-text query' that searches across all listed content types and gives a realistic example. This conveys the semantic of free-form natural language input, which the bare schema (string, min 2, max 300) does not.

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

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

The description states a specific verb and resource: 'Search everything A-du publishes with one free-text query' and enumerates the content types covered. It also differentiates itself from siblings by labeling itself the generic entry point and naming the more specific tools, so an agent can tell it apart without inspecting other schemas.

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 says when to use this tool: 'generic entry point for hosts that only support search and fetch' and when not to: 'Hosts that can call specific tools should prefer search_rentals, search_plans, get_adu_rules and ask_adu'. This is direct, unambiguous routing guidance with named 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 cover read-only, idempotent, and non-destructive behavior. The description adds useful behavioral context beyond that: results include a url on a-du.homes where a landlord can request management, and fields like license number and website are present only where known.

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, action-first, and each sentence earns its place: scope, exclusions, use case, result behavior, and a concrete example. No filler or redundant restating of the tool name.

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 and no output schema, the description adequately covers the result shape (city, license number, website, url). It is slightly thin on default behavior when city is omitted or sorting/pagination details, but the schema covers limit and cursor.

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 67%; limit and cursor are well described in the schema, but city has no schema description. The description gives an example {"city": "Glendale"}, implying city is a filter, but it does not explicitly define the parameter's meaning or optionality, leaving that to inference.

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: find residential property management companies on the A-du manager marketplace, scoped to single-family homes and ADUs in Los Angeles. It explicitly excludes multifamily-only and commercial managers, which separates it from sibling tools like search_services and search.

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 an explicit when-to-use phrase: 'Use for "who can manage my ADU rental for me"' and clarifies exclusions. However, it does not name alternative sibling tools or give a when-not-to-use condition beyond manager type 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 idempotentHint=true, covering the safety profile. The description adds value beyond annotations by noting that each result has a URL on a-du.homes where a free test fit is offered, and that pre-approved cities shorten plan check. These are useful behavioral/contextual details not present in the schema or annotations. No contradiction detected.

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

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

The description is moderately long but every sentence earns its place: purpose, usage examples, result URL note, and a concrete example. It is front-loaded with the core purpose, and the example at the end is a helpful reference. No redundant filler.

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

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

For a search tool with no output schema, it lists the result attributes (size, bedrooms, plan price, etc.) and mentions the URL on a-du.homes. It covers filtering guidance and an example. Pagination and cursor are handled by the schema, so the description is sufficient for an agent to call it correctly.

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

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

Schema coverage is only 57%, leaving max_sqft, min_sqft, and bedrooms_min without descriptions. The description compensates by listing these attributes ('size, bedrooms') and provides an explicit example: {"bedrooms_min": 1, "max_sqft": 800, "pre_approved_in": "Los Angeles"}. It also clarifies max_plan_price via 'plan price' and pre_approved_in via city filtering, adding 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 opens with a specific verb and resource: 'Search A-du Build, the marketplace of ADU plan sets'. It lists the searchable attributes (size, bedrooms, plan price, etc.) and gives example intents. This clearly distinguishes it from generic sibling tools like 'search' or 'search_rentals' by targeting ADU plans specifically.

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

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

It explicitly states when to use the tool with three concrete example user queries: 'find me an ADU plan', 'how much does a plan cost', 'what pre-approved plans exist for <city>'. It also advises filtering by pre_approved_in. However, it does not mention when not to use it or point to alternatives like match_plans_to_lot, so it lacks the 'when-not' and 'alternatives' components.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds substantial behavioral context: results are landlord-published and newest-first, the permit_verified flag's meaning, that get_rental exposes verification details, rent semantics, tenant_pays_service_fee, and how to handle empty results. This goes well 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 a single dense paragraph, but every sentence contributes: scope, usage, ordering, permit verification, filter categories, rent semantics, troubleshooting, and an example. It is somewhat long but not padded; the example is practical. It could be improved with structural separation, but it earns its length.

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 13 parameters, no output schema, and no required fields, the description covers purpose, usage, key result semantics (permit_verified, rent, service fee), filter categories, troubleshooting, and an example. It does not detail pagination/cursor behavior or list all result fields, but it provides enough for an agent to call correctly and interpret common output.

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

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

Schema coverage is 100% so the baseline is 3. The description adds extra semantics by explaining the filter categories, clarifying that rent is the listed monthly rent and that tenant_pays_service_fee indicates an added fee, and providing a concrete example of parameter combination. This adds value beyond the 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 explicitly states the tool searches the A-du Rent inventory of ADU rentals, listing specific unit types and geographies. It further clarifies the intended use case ('find a small standalone rental in Southern California') and differentiates from get_rental by noting that tool returns verification details. This is a specific verb+resource with clear 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?

It gives explicit usage guidance ('Use this for any request to find a small standalone rental in Southern California') and troubleshooting advice when no matches are found. It references get_rental as a follow-up for permit verification, but does not explicitly contrast with other sibling search tools like 'search' or 'search_plans', so no exclusion guidance is provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds meaningful behavioral context beyond the annotations: results include license number/status from public records, price ranges, service radius, booking URLs, and the distinction between claimed_by_owner providers and providers seeded from public records. This helps the agent understand data provenance and result semantics.

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

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

The description is lengthy but dense, with each clause adding useful information such as result fields, filtering behavior, a usage example, and data provenance. It could be slightly tightened, but the length is justified given the absence of an output schema and the need to explain marketplace-specific data attributes.

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 no output schema, the description covers the core semantics: what is being searched, what fields appear in results, how filtering works, and where the data comes from. Pagination is left to the schema, and response structure is not described, but the description provides sufficient context for correct invocation.

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

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

Schema coverage is 75%, and the description compensates by clarifying that category can be a name or slug, is matched loosely, and provides concrete category examples. The example payload ('{"category": "general contractor", "city": "Pasadena"}') adds practical parameter guidance. Cursor and limit are not elaborated in the description, but they are documented in the schema.

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

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

The description opens with a specific verb and resource: 'Find contractors, designers, permit expediters and trades for ADU work on the A-du services marketplace.' It enumerates the service categories and clearly identifies this as the marketplace search tool, distinguishing it from sibling tools like search_plans, search_rentals, and search_managers through the explicit services-focused 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 a direct use-case example ('Use for "find me a contractor to build an ADU in Pasadena"') and explains filtering by category and city. It does not explicitly state when not to use this tool versus alternatives, but the example and resource scope make the intended usage clear.

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

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

Annotations already indicate readOnly=false and idempotentHint=true. Description adds two useful behaviors: links are removed and recipient is told an assistant sent it. This goes beyond 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?

Two sentences with zero redundancy. Front-loaded with the core action, then usage condition, then behavioral notes. Every sentence adds value.

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

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

For a messaging tool with no output schema, the description covers key operational details: sender identity, recipient, use case, and content transformations. Missing error/rate-limit info but not critical for basic invocation.

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

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

Schema has 100% description coverage, including descriptions for listing_id, message, and idempotency_key. The tool description adds no new parameter-specific meaning beyond what the schema already provides, so 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?

Description states a specific action (send message) with a clear target (landlord of a rental) and actor (signed-in person). It distinguishes itself from siblings by noting it's for questions a listing doesn't answer, setting it apart from request_tour or start_application.

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 condition for use: 'Use for questions a listing does not answer.' This implies when to use, but doesn't explicitly mention alternatives like request_tour for tours or start_application for applications, though those are implicitly different. Clear enough for routing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: it returns the A-du page, reports verification status, and clarifies that the assistant cannot complete the application. It doesn't mention side effects like whether starting an application creates a record, but the idempotentHint and readOnlyHint cover the main concerns.

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 with zero waste. The core action is front-loaded, the return value is stated, and the critical limitation (assistant cannot complete) is included. 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 tool with one optional parameter, no output schema, and annotations covering safety, the description is nearly complete. It explains what the tool does, what it returns, and the key limitation. The only minor gap is not describing the exact structure of the A-du page or what 'already verified' means in practice, but that's not necessary for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents the single optional parameter (listing_id). The description adds context by explaining why the parameter exists ('so the link returns them to it'), which is helpful but not essential. 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 verb ('Begin'), the resource ('a rental application'), and the actor ('for the signed-in person'). It also distinguishes itself from siblings by noting it returns the A-du page and reports verification status, which separates it from tools like request_tour or send_inquiry.

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

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

The description explicitly states when to use this tool (to begin a rental application) and provides a clear exclusion: an assistant cannot complete an application because identity verification and background-check authorization require the person themselves. This gives the agent actionable guidance on when not to use it or what to delegate.

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 substantial behavioral detail beyond the annotations: it checks the address against existing building records, returns different links depending on permit match, requires no account, creates nothing, and defers actual creation until the user completes sign-in, photos, and identity verification. This is consistent with readOnlyHint and idempotentHint.

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

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

The description is dense but every sentence earns its place: purpose, trigger conditions, permit-handling behavior, deferred creation, and parameter guidance. It is front-loaded with the core purpose and avoids filler.

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

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

For a tool with 9 parameters, no output schema, and no required fields, the description explains the workflow, conditional outputs, and user-identity requirements well. It could better position this tool relative to draft_listing)Skip, but the core context an agent needs to invoke it correctly is present.

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

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

Schema description coverage is 67%, so the description is not solely responsible for parameter clarity. It adds useful general guidance ('Pass whatever is already known and leave the rest out; a link with only an address is still useful') and explicitly says not to ask for a permit number. However, it does little to clarify the undocumented parameters such as bedrooms, bathrooms, and square_feet.

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 action ('Begin listing an ADU... for rent') and the target resource (an ADU on A-du), with helpful synonyms for the property type. It does not explicitly contrast itself with the sibling draft_listing tool, so it lacks full sibling differentiation.

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

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

The description gives explicit trigger conditions: 'Use this whenever a person mentions they have a unit they want to rent out, are thinking about renting out, have vacant, or whose tenant is leaving.' It provides clear context but does not mention exclusions or name alternative tools when this tool should not be used.

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 convey non-read-only, idempotent, and non-destructive hints. The description adds useful behavior beyond those: the one-saved-search-per-person replacement rule, the email trigger on new matches, and the stop mechanism. No contradiction with the annotations is apparent.

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 four short sentences with no filler. The main purpose is front-loaded, followed by replacement behavior, the unsubscribe switch, and the filter-semantics pointer. 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 9-parameter subscription tool with no output schema, the description covers the essential state model, trigger behavior, and stop mechanism. It could mention what the tool returns after subscribing or unsubscribing, but that is not critical for calling it correctly.

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

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

With only 11% schema description coverage, the description compensates by saying the filters match search_rentals, letting the agent reuse that sibling tool's parameter semantics. It also explicitly clarifies that unsubscribe=true removes the saved search. The remaining parameter names are self-explanatory, though edge-case semantics are not fully spelled out.

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 action and resource: emailing the signed-in person when new A-du rentals match the supplied filters. It also distinguishes itself from search_rentals by framing the tool as a subscription for future matching listings, and it explicitly describes the unsubscribe path.

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

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

It gives practical lifecycle guidance: there is one saved search per person, resubscribing replaces it, and unsubscribe=true stops alerts. It also points the agent to search_rentals for filter semantics. However, it does not explicitly state when to prefer search_rentals over this tool, so it falls just short of full when/when-not guidance.

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