Singapore new launches

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

With no annotations, the description carries the full behavioral burden, and it does disclose the exact payload contents (identity, licence, payment, contact) rather than just restating the name. It is implicitly a non-mutating, zero-parameter info read. It does not state whether the content is static or whether any auth/context is required, which keeps it short of a 5.

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

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

A single sentence that front-loads the core subject ('who runs this service') and then enumerates the remaining payload items. No filler, no repetition of the tool name or title.

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

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

With no output schema and no annotations, the description must convey the return content itself, and it lists all four categories an agent would need. It stops short of describing shape (single object vs. sections) or any freshness/auth caveats, a minor gap for a zero-param informational 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 takes zero parameters, which is the baseline-4 case; there is nothing for the description to disambiguate. The description is consistent with the empty schema, so no gap exists here.

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 enumerates the specific content the tool returns: service operator identity, CEA registration and agency licence, payment model, and contact details. That is concrete enough for an agent to know exactly what it gets, though it never contrasts itself with any sibling. The sibling list is entirely transactional (book_call, list_launches, rules_for_buyer), so 'about' is distinguishable by its informational nature without further differentiation.

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

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

Usage is only implied: an agent can infer it should call this when a user asks who the agent is, whether they are licensed, or how payment/contact works. There is no explicit statement of when to call it, when not to, or which sibling to prefer for overlapping questions. Adequate but leaves the trigger entirely to inference.

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

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

With no annotations, the description carries the full load and does so well: it discloses that the call is a no-op (holds nothing, takes no details) and describes the exact return payload — a WhatsApp link, a pre-written neutral message, and the contact page address. That is exactly the non-obvious behavior an agent needs before invoking.

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-loaded with the availability caveat, then the return contents, then the user-facing action. No sentence is redundant.

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

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

There is no output schema, and the description compensates by enumerating what is returned. For a parameterless, side-effect-free tool, nothing needed to call it correctly is missing.

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

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

Zero parameters, so the 4 baseline applies. The description reinforces this by explicitly stating it takes no details, leaving no ambiguity about missing 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 states precisely what the tool does (returns a WhatsApp link to the agent plus a contact-page address) and explicitly negates the name's implication by saying booking is not open and nothing is held. It implicitly separates itself from the booking-lifecycle siblings (confirm_booking, cancel_booking, check_booking) by stating no details are taken, though it never names an alternative.

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

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

It gives a clear trigger for acting on the result: show the link if the user wants to talk to the agent. It also warns that calling the tool by itself accomplishes nothing, which steers the agent away from treating it as a real booking. No sibling alternatives are named, 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?

With no annotations, the description does useful work: it states the call is a no-op ('holds nothing and takes no details') and enumerates what is returned. However, it omits any explanation of why a tool named cancel_booking behaves this way, leaving the agent uncertain about side effects or state.

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

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

The description is short and the return contents are front-loaded, but the opening sentence about booking being unavailable is irrelevant to the tool's name and adds confusion rather than 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?

Since there is no output schema, the description carries the burden of explaining returns, which it does adequately. It is still incomplete because it never resolves the mismatch between the cancel_booking name and the booking-related content, which is the key thing an agent needs.

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

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

The tool takes zero parameters, so the schema's baseline is 4. The description confirms no details are needed, matching the empty input 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 explains what the call returns (a WhatsApp link, a pre-written message, and a contact page address), but it never mentions cancelling a booking, which is what the tool name promises. The opening sentence about booking calls 'not being open yet' is confusing and does not clarify the tool's actual job, so an agent cannot confidently tell this apart from book_call or confirm_booking.

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

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

'Show your user the link if they want to talk to the agent' gives an implicit condition for use, but there is no guidance on when this should be chosen over its siblings or when it should not be called. The context is implied rather than stated.

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

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

With no annotations, the description carries the full disclosure burden and does well: it explicitly says the call 'holds nothing and takes no details', so the agent knows it is side-effect free, and it enumerates the return payload (WhatsApp link, prewritten message, contact page address). Missing only niceties like whether the link expires or requires auth, which matter little for a zero-parameter stub.

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, and the most decision-relevant fact ('not open yet') is front-loaded. Some redundancy between 'holds nothing' and 'takes no details', but nothing extraneous enough to obscure the message.

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

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

No output schema exists, so the description must describe the return value — and it does, item by item. With no parameters and no annotations, nothing material about invoking the tool is left unexplained, though a one-line note on expected agent behavior against book_call would close the last 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?

Zero parameters, so the baseline applies; the description reinforces this by stating the call 'takes no details'. No parameter semantics are needed or missing.

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 does state concretely what the tool returns (a WhatsApp link to the agent, a prewritten neutral message, and the contact page address), but it never explains the 'check' verb in the name, and it reads more like a not-yet-available gate than a booking inspection tool. With siblings like book_call, cancel_booking and confirm_booking, an agent has to infer what this actually replaces. Purpose is understandable but only loosely tied to the name and siblings.

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

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

'Show your user the link if they want to talk to the agent' gives post-call handling but no explicit when-to-call guidance versus book_call or confirm_booking. The implied trigger (user wants to book/speak with an agent) is inferable from 'Booking a call through your assistant is not open yet' but never stated as a routing rule.

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

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

With no annotations, the description carries the full burden and does well: it discloses that nothing is held, no details are captured, and precisely what is returned (a WhatsApp deeplink with pre-filled text and the contact page address). Missing only edge behavior such as whether the message text or contact address varies by 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 key caveat ('not open yet') is front-loaded before any behavior is described, which is the right ordering. Four short clauses with little waste, though the phrasing about an assistant booking a call is slightly indirect compared to just stating what the tool returns.

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

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

For a zero-parameter, no-output-schema, no-annotation tool, the description covers the essentials: what is returned, that nothing is persisted, and how to present the result to the user. The only real gap is the unreconciled discrepancy with the name and the absence of explicit sibling routing.

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

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

The tool takes zero parameters, so the baseline is 4. The description reinforces this by stating it 'takes no details,' which confirms to the agent that no arguments need to be gathered before calling — a genuinely useful signal here.

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 is concrete about the effect: it returns a WhatsApp link with a pre-written neutral message plus the contact page address, and explicitly states it 'holds nothing and takes no details.' However, the tool name 'confirm_booking' implies a booking confirmation that the description says cannot happen, and the mismatch is never reconciled. It also never names the sibling it substitutes for (book_call), leaving the agent to infer the relationship.

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?

'Show your user the link if they want to talk to the agent' gives a clear condition for using the output, and 'booking a call ... is not open yet' implies this is the fallback path. But it never states when to call this versus book_call, check_booking, or cancel_booking, so routing against siblings is left to inference.

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

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

With no annotations, the description carries the full burden and does so well: it discloses provenance (source, review date, launch stage, agent licence), the limitation that schools are orientation-only with verification pointers, and the gap-reporting policy instead of guessing. It stops short of describing response shape or any latency/limit behavior, so it is strong but not exhaustive.

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

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

Front-loads the verb and the returned fields, with provenance and gap-handling deferred to later sentences. It is dense but every sentence is informative; slight tightening would make it crisper.

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

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

No output schema exists, so the description must explain return values, and it lists them plus the accompanying metadata (source, date, stage, licence) and the gap-with-question behavior. An agent knows exactly what it will get and how to interpret uncertain data before calling.

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?

Only one parameter, and the schema already documents 'slug' with 100% coverage including its origin in list_launches. The description's 'by slug' phrasing adds no syntax or format information beyond the schema, so the baseline 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?

Opens with a specific verb and resource ('Returns the reviewed area details of a launch by slug') and then enumerates the payload (address, tenure, amenities with distances, schools, visited food places). This clearly separates it from siblings like get_launch and get_unit_type, which cover other facets of the same launch.

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

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

Gives a concrete availability condition: works for launches that show area details in list_launches, including ones without floor plans yet. That is useful context, but it does not name an alternative tool or state when a different sibling should be preferred instead.

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

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

With no annotations, the description carries the full burden and does well: it explains the return contents, price lifecycle semantics, provenance fields, and a strict gap-handling policy. It stops short of explicitly confirming read-only behavior, auth requirements, or error cases, but the behavior described is substantial and non-obvious.

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

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

The description is front-loaded with the core purpose, which is good, but it runs long and repeats concepts: source attribution and gap handling are each introduced and then revisited in later sentences. The content is useful, but some sentences could be tightened without losing meaning.

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

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

There is no output schema and no annotations, so the description must explain return semantics, which it does: reviewed facts with source and page, price statements with kind and date, stage, licence details, and unresolved gaps. It is nearly complete for a read tool, with only error or empty-result behavior left implicit.

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

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

There is one required parameter and schema description coverage is 100%, with the schema explaining that the slug is 'as returned by list_launches'. The description only echoes 'by slug' and adds no parameter details beyond the schema, so the baseline of 3 applies.

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

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

The description opens with a specific verb and resource: 'Returns one launch by slug,' and then details the returned content. This clearly separates detail lookup from list-style tools, but the description itself does not explicitly name or contrast with the sibling list_launches.

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

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

Usage is implied by the need to provide a slug, and the schema note points to list_launches for slug discovery. However, the description gives no explicit guidance on when to use this tool versus list_launches or any other sibling, and no exclusions are stated.

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

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

With no annotations, the description carries the full burden and does so substantively: it discloses the epistemic contract (every answer carries source, review date, launch stage, agent licence details; unsettled items are returned as gaps with a question, 'never as a guess') and the price caveats (indicative before launch, reset on booking day, promotions afterwards). It stops short of stating read-only semantics explicitly or error behaviour for an invalid slug/type, but the value-add over structured fields is real.

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 return contents are front-loaded in the first sentence, and the remaining sentences cover caveats that an agent genuinely needs before quoting prices. The price paragraph is slightly verbose ('Treat them as a starting point and confirm with the agent'), but no sentence is pure filler.

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

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

No annotations and no output schema, yet the description fully describes the return payload, its provenance metadata, the gap-reporting behaviour, and the reliability of prices. An agent could call this correctly and interpret the result from the description alone.

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 both parameters are already documented, including where their values come from. The description restates 'by slug and type name' without adding format, casing, or validation detail beyond the schema, so baseline 3 applies.

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

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

Opens with a specific verb and resource: 'Returns one unit type of a launch by slug and type name', then enumerates exactly what comes back (size, bathrooms, stacks, plan image, answers, gaps). The singular 'one unit type' plus the slug/type keying makes it distinguishable from get_launch and search_floor_plans without opening the schema.

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

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

Usage is only implied: the schema notes that slug comes from list_launches and type from search_floor_plans or get_launch, sketching a workflow. The description never states when to pick this over get_launch or search_floor_plans, nor any prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden and largely meets it: it discloses that every answer carries its source, review date, stage and licence details, and that unresolved points are returned as explicit gaps with the question to ask rather than a guess — a meaningful and unusual reliability contract. It omits other behavioral facts (ordering of results, whether the list is bounded or paginated, how stale 'reviewed' data can be), which keeps it short of a 5.

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

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

Four dense sentences with no filler, front-loaded with the core purpose before the field inventory and the reliability contract. Minor waste in "the agent's licence details," whose referent is left vague, but every other clause adds real information.

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

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

With no output schema and no annotations, the description does the work of both: it lists the returned attributes, the provenance metadata attached to each answer, and the gap-reporting behavior, plus a trial-scope caveat. What an agent still cannot infer is result ordering, list size bounds, and how 'selection' is chosen, which for a list tool is a real but not fatal 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 tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. No parameter names, formats or defaults 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?

Opens with a specific verb+resource ("Lists the new launches this service covers") and enumerates the fields returned: name, district, street, units, stage, launch date, sold-out flag, floor-plan/area availability. The plural "lists" implicitly contrasts with the singular get_launch sibling, but the description never names that alternative explicitly, so differentiation is inferential rather than stated.

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 line "It covers a selection of launches during the trial" is a useful coverage caveat that warns an agent not to expect exhaustive results, but it is not framed as when-to-use guidance. There is no statement of when to pick this over get_launch for a single launch, or whether this is the required first step before per-launch lookups.

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

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

No annotations exist, so the description carries the burden and does well: it discloses the exact return content (authority, source link, effective date, last-checked date) and the partial-result behavior when a rule is under re-check (named without a quote). It omits permission/auth requirements and any indication of latency or size.

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

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

Four sentences, front-loaded with what is returned and immediately followed by the key constraint (quote, don't compute) and the purchase_date caveat. Slightly dense first sentence but no sentence is padding.

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

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

With no output schema and no annotations, the description still explains return contents, the re-check edge case, and the non-advice framing, which is enough for correct invocation. It does not explain how properties_owned affects the ABSD outcome, leaving the agent to infer the reason it is required.

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 profile, purchase_date and properties_owned are already fully documented. The description only restates the purchase_date/SSD linkage with a mild consequence cue ("to get the right regime"); it adds nothing about profile or properties_owned beyond the schema, so baseline 3 applies.

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

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

States a specific verb (quotes) and a specific resource (Singapore property rules applicable to a buyer), and enumerates the covered rule types (ABSD, BSD, financing limits, SSD). This is clearly distinct from every sibling, which deal with launches, bookings, areas and floor 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?

Gives clear operating context: quote only, do not compute rates, and supply purchase_date to land in the correct SSD regime. It also sets the boundary against actual advice ("confirm with the agent"), though it does not name a sibling such as book_call as the escalation path.

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

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

With no annotations, the description carries the full burden and does so thoroughly: it defines the met/close/unknown fit model, discloses the 20-plan cap and ordering, names close_total/close_truncated, explains empty-result behavior (naming excluding filters), and caveats prices (indicative pre-launch, reset on booking day, subject to promotions). It also discloses provenance fields (source, review date, stage, licence) and that unresolved facts return as gaps, not guesses.

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?

Purpose and filters are front-loaded, and most sentences (fit semantics, truncation, price caveats, gaps) carry real decision value. It runs long and includes a soft directive ("Cull both lists against what your user actually wants") that is closer to guidance than specification.

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

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

With no output schema and no annotations, the description still covers return shape (plan, stacks, stacks_note, image link, price with kind and date, close metadata, provenance) and failure shape. An agent has enough to call it and interpret results correctly.

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

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

Schema description coverage is 100%, so the schema already documents all eight parameters including the non-scored include_sold_out flag. The description adds modest meaning by framing tags as features, districts as postal districts, and budget as Singapore dollars, but adds no syntax, ranges, or interaction rules 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?

Opens with a specific verb+resource ("Searches floor plans across the reviewed launches") and enumerates the exact filter axes (bedrooms, sqft, district, stage, features, budget). This is clearly distinct from the sibling read tools (get_launch, list_launches, get_unit_type) — an agent can identify it as the only multi-constraint floor-plan search without checking 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?

Gives clear operating context: when close_total/close_truncated indicate truncation, "narrow the filters to see them," and both lists must be culled against user intent. However, it never states when to use this instead of a sibling like get_unit_type or list_launches, nor any exclusion conditions.

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