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

Annotations already establish readOnly/idempotent/openWorld/destructive=false, so the safety profile is covered. The description adds substantive behavioral context beyond that: the returned content structure, the consultation_id needed for dt_free_slots, doctor hash ids for dt_doctor, and each doctor's earliest free slot. It does not cover pagination or rate limits, but for a read-only detail endpoint that is minor.

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 response content is front-loaded, followed by the exclusion and routing lines, with no filler. It is dense and slightly run-on in the field list, but every clause carries information an agent needs.

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 correctly takes on the burden of describing return content and chaining keys (consultation_id, doctor hash ids), and annotations cover safety. Params are schema-documented. It stops short of explaining vaguer fields like 'attributes' or 'lab admission rules', leaving a small residual gap.

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

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

Schema coverage is 100%, so all three parameters (center, doctors, full_text) are fully documented in the schema with formats and bounds. The description mentions consultation_id and doctor ids, but those are output fields, not parameter guidance, so it adds little beyond the schema. Baseline 3 is appropriate.

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

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

The description names the resource precisely and enumerates what a center page returns (address, coordinates, departments, services, insurances, opening hours, bookable services, doctors). It also differentiates from the dt_doctor sibling by noting that private offices have no center page. The retrieval verb is only implied by 'A center's page:' rather than stated, which keeps it just under 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 an explicit exclusion ('Doctor private offices (type office) have no center page: use dt_doctor') and a routing line ('Next: dt_free_slots, dt_doctor, dt_reviews(of=center)'), so the agent knows the alternatives and follow-ups. It does not explicitly position dt_center against dt_search_centers, so the when-to-use is strong 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 declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds behavior beyond that: result ordering (main cities first) and the caveat that the speciality-filtered list is limited to main cities with counts and may understate what a full search returns. It doesn't discuss pagination explicit behavior, but the value-add 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?

Three short lines: purpose and ordering first, conditional speciality behavior second, next-step routing third. No filler sentences; every clause carries 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?

There is no output schema, so the description must convey what comes back — and it does: slug, numeric id, ordering, and count-augmented results under speciality. Combined with the fully-described parameters, an agent has everything needed to call and consume this tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description goes further by explaining the purpose of the returned slug and id and by clarifying that speciality restricts to main cities and adds counts — semantics not present in the schema's one-line parameter 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?

States a specific verb and resource: it finds a city's slug (for search filters) and numeric id (for dt_suggest), and explicitly notes main cities come first. It names the two downstream tools the outputs feed, so an agent can distinguish it from dt_suggest and dt_search_doctors without opening any 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?

Explicit routing: 'Next: dt_search_doctors(city=slug) or dt_neighborhoods', plus a documented conditional branch explaining what the speciality filter changes and warning that a broader search may find more elsewhere. When-to-use and what-to-do-next are both spelled out.

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 safety profile (readOnly, idempotent, non-destructive), but the description adds real behavioral context: long texts are truncated around 800 chars unless full_text is set, and it disambiguates fee semantics (office visit paid at the office vs. online price, and pay_online_now charged at booking). It does not mention auth requirements, rate limits, or behavior on an invalid/unknown doctor id.

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 opening sentence is front-loaded with the essential purpose, and the follow-up sentence enumerates the payload fields efficiently. It is dense—almost a schema dump in prose—but nearly every clause carries information an agent needs, with only minor redundancy in listing photo/about text.

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

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

There is no output schema, so the description carries the full burden of describing the return shape, and it does so thoroughly (services[], fee, pay_online_now, address, next_free, review summary, waiting time, conditions, photo). Combined with the full_text toggle and the onward-tool routing, an agent has everything needed to call it and interpret the result.

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 still adds value beyond the schema by giving the concrete truncation threshold (~800 chars) that the schema only gestures at with 'cutting long ones'. The 'doctor' parameter accepts a hash id or full page URL per the schema, and the description does not restate or contradict that.

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

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

The description states exactly what the resource is and what it contains: a doctor's profile with every bookable service, its price in Toman, and its next free time. It also differentiates from siblings by explaining that consultation_id from services[] is the input of dt_free_slots, so an agent knows this is the detail/hub tool rather than a search tool.

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 routes the agent onward ('Next: dt_free_slots, dt_reviews') and explains the data handoff (consultation_id feeds dt_free_slots), which is genuine when-to-use guidance. It stops short of stating when NOT to use it (e.g., vs. dt_search_doctors for discovery), so it falls just short of a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld, so the safety profile is covered. The description adds genuinely useful behavior beyond that: only days with free times are returned, past times today are dropped, `bookable_until` is the last opened day (~30 days), times are Tehran local, and text consultations typically yield nothing. It stops short of auth or error 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?

Purpose is front-loaded in the first sentence, then return fields and caveats follow in an efficient block with no filler. Slightly dense parenthetical enumeration and a dangling sentence on text consultations keep it from being maximally tight.

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 return-value burden and does it well (date, weekday, Jalali date, free start times, bookable_until). It omits invalid-consultation_id or empty-result behavior, but for a read-only listing tool the essential context 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 100%, so the baseline is 3. The description reinforces the Tehran-local time convention and the free-slot window but adds little syntax or defaulting detail beyond the schema's own descriptions of days, start_date, and consultation_id.

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

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

The first sentence names a specific resource and verb-mapping ('Free appointment times of one service') and enumerates the service variants it covers, which no sibling tool does. An agent can distinguish it from dt_doctor (service listing) or dt_center 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 description notes text consultations usually have no slots and the schema says the consultation_id comes from dt_doctor/dt_center/dt_offer, but that wiring lives in the schema, not the description. There is no explicit when-to-use/when-not statement or named alternative for slot discovery.

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 safety profile (readOnly, idempotent, non-destructive, openWorld), so the description only needs to add context. It does: it discloses the returned fields (title, link, publish date, summary) and the cost/behavior switch that text_chars controls. No auth, rate-limit, or ordering details are given, which keeps it from 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?

Two short sentences plus a routing caveat; the purpose and corpus size are front-loaded, and every clause (returned fields, text_chars behavior, the not-medical-advice boundary) 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?

With no output schema, the description correctly compensates by listing the return fields and explaining the summary-vs-full-text behavior. Combined with a 100%-covered input schema and rich annotations, an agent has everything needed to call this tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds practical meaning beyond the schema by explaining that setting text_chars is how you actually 'read the articles' rather than just naming it. limit and query are left entirely to the schema, which documents them well.

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 and resource ('Search Doctoreto's health magazine') with scale context (~5,000 articles) and the intended subject matter (condition, test, treatment). It is clearly distinguishable from sibling tools like dt_search_doctors and dt_reviews.

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

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

Gives explicit when-to-use ('for background on a condition, test or treatment') and when-not ('General information only, not medical advice: for a diagnosis book a doctor'), naming the alternative tool dt_search_doctors. Nothing 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?

Annotations already cover the safety profile (readOnly, idempotent, openWorld, non-destructive), yet the description adds real behavior: `total` counts all matches (relevant since there is no output schema) and the domain fact that few doctors list insurances, so filtering narrows results sharply. That is useful context beyond the structured fields, though pagination/limit interaction is not discussed.

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-loaded with the verb+resource and the downstream link, then two short supporting sentences with no filler. Slightly clipped phrasing ('the ids dt_search_doctors(...) takes') costs a little readability but nothing is wasted.

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

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

For a simple two-parameter, no-output-schema lookup, the description supplies the missing pieces: the `total` return field and the reason the filter matters. It is essentially complete for correct invocation, with only limit/pagination 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?

Schema description coverage is 100%, with limit (max 200, ~84 exist) and query (Persian name fragment, examples) already fully documented. The description adds nothing about the parameters themselves, so the baseline 3 applies.

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

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

States a specific verb (List) and resource (basic and supplementary insurers) and immediately ties it to its downstream consumer, dt_search_doctors(insurance_ids=...). It also explicitly differentiates from dt_center for centers, so the agent can place it among siblings without opening a 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?

Makes the use case concrete by naming the parameter the returned ids feed into (insurance_ids on dt_search_doctors) and routes centers to dt_center. It stops short of an explicit when-to-use/when-not statement or a note on when the filter is worth applying versus searching without 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 read-only, idempotent, non-destructive, open-world. The description adds behavior they cannot express: results are ordered by doctor count, each entry carries a count, and nearby cities are included alongside the city's own neighborhoods.

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 short sentences plus a fragment; the ordering/scoping fact is front-loaded and the chained call is last where it belongs. Minimal waste, though the district-grouping sentence is slightly terse and ambiguous about which parameter accepts it.

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

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

With no output schema and no annotation gaps to fill, the description covers what an agent needs: what comes back (neighborhoods with counts, nearby cities), how it is ordered, and the follow-up call. Remaining gaps are minor, e.g. how nearby cities are represented in the result.

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 city, limit, query and speciality are fully documented in the schema; baseline is 3. The only description-level addition is that district groupings (منطقه 3, غرب) also function as filter values, which is peripheral to this tool's own parameters.

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

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

States the resource clearly: neighborhoods of a city plus nearby cities, each with a doctor count, ordered most-doctors-first. It is distinguishable from dt_cities (cities) and dt_search_doctors (doctors), though the distinction is inferred from the resource rather than stated against 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?

Gives a concrete next-step workflow: dt_search_doctors(city=..., neighborhood=slug), which tells the agent this tool is the lookup stage before a doctor search, and notes district groupings are usable as filters. No explicit when-not-to-use guidance or named alternative for the same job.

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, openWorldHint and destructiveHint=false, covering the safety profile. The description adds that long texts are cut by default unless full_text is set, which is useful, but says nothing about auth, rate limits, or error cases for a non-existent offer.

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 front-loaded sentence with zero filler; the only cost is that the long comma-separated field list reads as inventory rather than prioritized 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, the description correctly carries the burden of explaining what comes back, listing the returned fields and variants. It is complete for a read tool, though it omits error behavior for invalid or missing offers.

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 both parameters (offer id formats, full_text truncation) are already fully documented in the schema. The description adds no syntax or format detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific resource ('one clinic offer') and scope ('in full'), then enumerates the returned fields, so an agent can distinguish it from dt_search_offers without opening either 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 implied by the retrieval framing, and the mention of `consultation_id` for dt_free_slots hints at a follow-up workflow. However, it never states when to call this vs dt_search_offers or dt_center, and gives no exclusions or prerequisites.

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 cover the safety profile (readOnly, idempotent, non-destructive), and the description adds real behavioral context: sort order differs by entity (newest first for doctors/centers, oldest first for offers), text truncation at 400 chars unless full_text, and the absence of upstream sort/filter. It does not mention rate limits or what the response envelope looks like, keeping it at a 4.

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

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

Front-loads the resource and what it returns, then behavior, then the usage tip. The parenthetical list of returned fields is dense but every clause carries information; no filler sentences.

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 return-value burden and does list the returned fields (stars, recommends, text, labels, visit type, reason, waiting time, date in Gregorian and Jalali, reply). It references a 'total' for computing pages without saying where that value comes from, a small gap for a paginated tool.

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

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

Schema coverage is 100% (baseline 3), and the description still adds meaning beyond it — the 400-character truncation threshold tied to full_text and the pagination formula tying limit to total. That is genuine additive detail over the schema's generic 'return complete texts' wording.

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 resource (patient reviews) with its scope (doctors, centers, offers) and immediately clarifies per-entity ordering. It also differentiates by routing summary data to the sibling dt_doctor, so an agent can tell it apart from dt_doctor without opening either 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?

Gives an explicit usage technique: 'No sort or filter upstream: to find low ratings, page through (pages = total / limit)', plus a pointer to dt_doctor for the summary. It lacks an explicit when-not/alternative carve-out beyond that one redirection, so it falls just short of a 5.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description goes further with non-obvious behavior: proximity search returns a square around the point sorted by distance, dense areas return only a partial set with the remainder counted in `more_in_area`, and without coordinates `limit` truncates the upstream page rather than filtering. It also discloses the output card key (`id`). It stops short of anything about rate limits or error 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?

Purpose is front-loaded in one sentence, then behavior in a short second block; nothing is decorative. Some phrasing is telegraphic ('Cards carry the hash `id`') and the near/remote pagination distinction takes a second read, but the density is justified for a 14-parameter search tool.

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

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

With 14 optional parameters and no output schema, the description does the heavy lifting: it explains what gets returned (cards keyed by `id`), how paging behaves in both search modes, and the truncation signal `more_in_area`. Missing only a sketch of the overall response envelope, but the agent has enough to call and interpret results.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds cross-parameter semantics the schema cannot express: radius_km is only meaningful together with near_lat/near_lon, it defines a square half-width rather than a circle, and limit interacts with the API's 20-item page size differently depending on whether coordinates were supplied. That materially reduces misuse of these 14 parameters.

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

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

Opens with a concrete verb and an explicit enumeration of the resource it covers (hospitals, clinics, infirmaries, laboratories, imaging centers, pharmacies), which cleanly scopes it away from dt_search_doctors and dt_search_offers without needing to name them. An agent knows immediately this is the facility-search tool.

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 real routing guidance: 'No insurance filter: see dt_center' names the alternative for a filter this tool lacks, and 'Next: dt_center, dt_reviews(of=center)' tells the agent how to drill down after a hit. It also implicitly distinguishes the near_lat/near_lon path from the plain-listing path, though it never states an explicit exclusion or prerequisite condition.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the bar is lower; the description still adds genuinely useful payload context that no schema provides — result cards carry the hash `id` for dt_doctor and omit online prices. It does not mention auth needs, pagination limits, or result caps beyond what the schema implies.

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 front-loaded sentences: the filter summary first, then the payload caveat, then the follow-up workflow. Every sentence carries information and nothing is padded.

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 14-parameter read tool with no output schema, the description covers the essentials an agent needs: what filters exist, what a card contains, what it omits, and where to go next. It stops short of describing result shape or pagination behavior in full, but annotations already carry the safety profile.

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% across all 14 parameters, so each filter's slug source, defaults, and examples are already documented in the schema. The description's filter list restates those dimensions in aggregate without adding syntax or constraints, which is the expected baseline-3 case.

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 (Search) and resource (doctors) and enumerates the filterable facets, making it easy to distinguish from dt_search_centers. It also names the downstream tools that operate on a result (dt_doctor, dt_free_slots), so the agent knows exactly what this tool returns.

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

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

Explicitly routes the agent away from this tool for pricing ('online prices are not in cards (use dt_doctor)') and names the follow-up chain 'dt_doctor -> dt_free_slots'. There is no explicit when-not-to-use for search itself (e.g. vs dt_suggest for slug discovery), but the context and alternative are 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 declare readOnly/idempotent/non-destructive/openWorld, so safety is covered. The description adds genuinely non-obvious behavior: pagination cuts an upstream page of ~40 items so `limit` should be raised to see the rest while `page` jumps a whole page, and it discloses the card payload (price, discounted price in Toman, pay_online as deposit vs pay-at-place, a default consultation_id).

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 purpose, then behavior, then next steps in four short lines with no wasted sentence. The telegraphic style ('No sort.', 'the rest at the place') is efficient but slightly terse, costing a point for minor ambiguity.

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 11 optional params, no output schema, and 100% schema coverage, the description supplies what structured fields cannot: pagination mechanics and the shape/meaning of returned cards. It omits any mention of the filter family (city, query, center, doctor, price bounds), which is acceptable since the schema documents each with examples, but a one-line hint would have completed the picture.

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 still goes beyond the schema by explaining the interaction between `limit` and the upstream `on_page` size and how `page` complements it, and by defining what the returned price/pay_online fields mean, which the schema 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?

States a specific verb and resource ('Search clinic offers') plus the concrete content (fixed-price procedures and packages: ultrasound, laser, dental, check-ups). It distinguishes itself from the detail sibling by naming dt_offer as the next step, so an agent can tell listing from single-offer retrieval without opening a 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?

The 'Next:' line explicitly routes to dt_offer, dt_free_slots, and dt_reviews(of='offer'), which is strong chaining guidance, and 'No sort' forecloses a plausible wrong assumption. It does not, however, contrast this tool with near-neighbors like dt_search_centers or dt_search_doctors for the case when the user thinks in terms of a place or a person rather than an offer.

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, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely new domain behavior: that `total` counts all matches regardless of limit, the four-value level taxonomy, and the parent/child relationship (interventional cardiology -> cardiologist). It does not discuss pagination or result ordering, but the additions are substantive.

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 tight fragments with zero filler; the downstream purpose is front-loaded in the first clause. The level/parent semantics are packed into a single line and the next-step call is stated last, which is the right order for an agent that will act on it.

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

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

For a read-only, two-parameter list tool with no output schema, it covers purpose, semantics of the values returned, and the downstream call. It stops short of describing the per-item record shape (slug/name/level/parent fields), which the absence of an output schema leaves slightly underspecified.

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 both parameters (query, limit) are already fully documented with examples and defaults, giving a baseline of 3. The description's 'Prefer `query`' is a mild usage nudge but adds no syntax, matching strategy, or format detail beyond the schema.

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

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

States a specific verb+resource (list specialities) and immediately frames its purpose in terms of a downstream need: producing the slug that dt_search_doctors consumes. An agent can distinguish it from siblings like dt_suggest or dt_cities 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?

Provides explicit workflow routing — 'Prefer `query`' and 'Next: dt_search_doctors(speciality=slug)' — which tells the agent both how to call it and what to do with the result. It stops short of stating exclusions or naming alternative tools for the same need, so it is clear context rather than a full when/when-not rule set.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, openWorld). The description adds genuinely useful behavioral detail beyond them: what each suggestion kind looks like (hash id vs slug vs tag), and the semantic caveat that doctors match by name only. It stops short of covering empty-result or ordering 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?

Extremely tight: a one-line purpose, a clarifying example, and a routing line. The most important information (what it returns) is front-loaded with zero 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?

With no output schema, the description does the work of describing result kinds and their identifier formats, which is the critical missing piece for an agent. It could go slightly further on result structure or ordering, but an agent has enough 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 100%, so query, limit and city_id are fully documented in structured fields. The description only adds a slight nuance about slug-vs-name matching for the query term, which is close to what the schema example already conveys. Baseline 3 is correct.

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 function (search-box suggestions), enumerates the four result kinds (doctors by hash id, speciality slugs, service tags, centers), and scopes it to a free-text phrase. It is clearly a lightweight autocomplete-style tool, distinct from dt_search_doctors and dt_center, which it names.

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 routing rule and the exact follow-up tools ('Next: dt_search_doctors, dt_doctor or dt_center'), plus a usage hint that speciality lookups should use the returned slug rather than the doctor name. It lacks an explicit when-not-to-use clause (e.g. for full result sets) but the context is clear.

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