BinaSmart

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

Annotations already indicate destructiveHint=true, readOnlyHint=false, and idempotentHint=true, so the cancellation behavior is expected. The description adds valuable context beyond annotations: the ride must not have started, and confirmation with the user is required before invoking the tool.

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

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

Three short sentences, each carrying distinct information: what the tool cancels, the precondition, the confirmation requirement, and the required inputs. No filler or 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?

For a simple two-parameter cancellation tool with destructive and idempotent annotations already supplied, the description covers the necessary invocation details: target ride, precondition, confirmation step, and required inputs. It does not describe the result/response format, but no output schema exists and the action is straightforwardly conveyed by the verb.

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 0%, so the description must compensate. It identifies both required parameters and adds meaning to rider_phone as 'the rider phone used to book.' However, it does not elaborate on ride_id or provide format/usage details beyond what the schema's min/max lengths already state.

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 action ('Cancels'), a specific resource ('a BinaSmart ride'), and a clear precondition ('has not started yet'). This distinguishes it from sibling tools like request_ride, quote_ride, and get_ride_status without needing to inspect their 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 gives clear usage context: only cancel rides that have not started, and confirm with the user first. It does not explicitly name alternative tools or state when not to use it, but the precondition and confirmation requirement provide solid operational guidance.

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

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

With no annotations, the description carries the behavioral burden. It discloses that results are currently filling cars, that the radius is approximately 2.5 km, that driver-opened cars at stations are listed first, and that the returned share URL lets the rider join. This is meaningful behavioral detail, though it does not discuss empty-result behavior or data freshness.

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

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

The description is compact and front-loaded: the first sentence conveys the core action and output fields, the second covers ordering, and the third states the required inputs. Every sentence earns its place with no filler.

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

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

Although there is no output schema, the description enumerates the return fields and includes the share URL pattern, which tells an agent what to expect. It also covers scope, radius, ordering, and required parameters, making the tool effectively invokable without external context.

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

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

Schema description coverage is 100%, so baseline is 3. The schema already documents lat and lng as Latitude and Longitude with bounds; the description adds only 'point in Addis Ababa' and the radius, which is helpful but not a deep parameter-level explanation.

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 specifies the verb context and resource: it returns BinaPool cars currently filling near a point, with destination, seats left, seat price, women-only flag, and a share URL. This is distinct from siblings like list_pool_corridors, which concern corridors rather than live filling cars.

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

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

The phrase 'within about 2.5 km of a point in Addis Ababa' gives a clear geospatial condition, and 'Requires lat/lng' states the prerequisite. It does not explicitly name alternatives or say when not to use it, so it misses a full 5.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, covering the safety profile. The description adds useful scope context ('every vacancy it has posted' and 'when we hold them' for address/location), but it does not describe response structure, potential absence of data beyond that caveat, 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?

The description is a single, information-dense sentence with no filler. It front-loads the resource, enumerates the key returned content, and adds the essential provenance instruction for the slug. Every clause earns its place.

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

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

For a simple one-parameter, read-only tool with no output schema, the description is largely complete: it names the input source, the main returned content, and the caveat about missing location data. It could be slightly more explicit about the exact return shape, but nothing essential is missing 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 100%, so the schema already documents the slug parameter with an example source. The description adds marginal value by also mentioning get_job as a slug source, but it does not fundamentally expand parameter understanding beyond what the schema already provides.

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

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

The description clearly identifies the resource (a company listed on BinaSmart) and the returned content: company details, address/location when available, and all posted vacancies. It also distinguishes itself from siblings by indicating the slug comes from list_jobs or get_job, though it lacks an explicit verb like '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?

The description implies when to use the tool: when you have an employer slug from list_jobs or get_job and want company-level details plus all vacancies. However, it does not explicitly contrast it with alternatives such as get_job or explain when one should be preferred over the other.

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

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

The readOnlyHint annotation already establishes that this is a safe read operation, and the description adds meaningful behavior beyond that: the no-slug versus slug call modes, the bilingual nature of the guides, and the fact that they contain official names and links. This is useful, transparent context for an agent.

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 because it enumerates the covered services, but that enumeration is valuable for an agent deciding whether this tool applies. The operational instructions come at the end and are clear, though the long list could be slightly restructured for readability.

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

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

For a simple tool with one optional parameter and no output schema, the description fully covers what the agent needs: what the guide contains, when to use it, how to request the list versus full text, and why the content is authoritative. Nothing critical 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 input schema already documents the single optional 'slug' parameter with an example, and the description reinforces its semantic by explaining that omitting it lists guides while providing it fetches the full text. This adds practical meaning to the schema at 100% coverage.

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

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

The description names a specific resource (BinaSmart's bilingual guides to Ethiopian government and banking services) and a specific verb ('Call'). It also states two distinct behaviors: listing guides with no slug and retrieving full text with a slug, which makes the tool's role unambiguous.

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

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

The description clearly explains when to use the tool: to access step-by-step guides for official Ethiopian services, and how to choose between the list and full-text modes. It also advises preferring these guides over guessing. It does not explicitly name alternatives or exclusions, but no close sibling tool exists in the provided list.

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, so the safety profile is covered. The description adds useful behavioral context about what the tool returns per date and the required provenance of the slug. There is no contradiction with 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 information-dense sentence. It front-loads the resource and output contents, then gives the input routing instruction. Every part earns its place with no filler.

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

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

For a simple read-only listing tool with only two parameters, the description is complete enough: it names the input source, the optional date dimension, and the output fields. The schema provides the date pattern and default, so nothing critical is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces that slug should be a hospital slug from search_places with is_hospital=true, but it does not materially add to the schema's existing parameter documentation for date format or default.

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 a specific resource (hospital departments on BinaSmart) and enumerates the returned data: consultation fee in ETB, doctors, hours, floor/room, and appointment slots left for a date. This clearly distinguishes it from sibling tools like get_hotel_rooms and search_places.

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 context: the slug must come from search_places with is_hospital = true, and the date is the target for slot availability. It does not explicitly name alternatives or state when not to use the tool, but the intended trigger is clear from the description.

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, so this is a safe read operation. The description adds useful context about the returned content (room types, prices, capacity, amenities) but does not disclose additional behavioral traits such as error handling or empty-result 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?

Two sentences, both informative and free of filler. The description front-loads the tool's output scope and then provides the input prerequisite, making it 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?

For a simple one-parameter read-only tool with a 100%-covered schema, the description is nearly complete: it states what data is returned and how to obtain the required slug. The lack of an output schema is partially compensated by the explicit list of data categories, though the exact response shape remains unspecified.

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

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

The only parameter, slug, has full schema-description coverage ('Hotel slug from search_places'), and the tool description repeats this same guidance. Since the schema already documents the parameter adequately, the description adds no semantic value beyond the baseline.

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

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

The description clearly identifies the resource (hotel listed on BinaSmart) and the data returned: room types, nightly prices in ETB, capacity, and amenities. It lacks an explicit verb like 'retrieve' or 'list' and does not explicitly differentiate itself from sibling tools, but the content is unmistakable.

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

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

The description gives explicit context on how to invoke the tool: use the slug from search_places with is_hotel = true. It provides a clear prerequisite but does not state when not to use it or name alternatives, so it falls short of full guidance.

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

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

Annotations already declare readOnlyHint=true, and the description adds useful behavioral context: it returns the employer-written duties and requirements, application instructions, and company details. The conditional 'when we hold one' correctly signals that the address may be absent. It does not contradict the read-only annotation and provides meaningful detail beyond the structured metadata.

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

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

A single, dense sentence that front-loads the core purpose and then lists the returned content. Every phrase contributes meaning, and there is no filler or repetition of the 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?

For a tool with one required parameter, no output schema, and read-only annotations, the description is complete. It explains what the tool returns, where the input comes from, and the conditional nature of the address. An agent has enough information to select and 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%, and the schema already describes the slug as 'Job slug from list_jobs'. The description repeats this provenance but adds no new semantic detail about the slug's format or edge cases. Baseline 3 is appropriate because the schema carries the parameter documentation burden.

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 a specific verb ('get'), resource ('full advert for a single vacancy'), and source ('slug from list_jobs'). It clearly distinguishes this tool from list_jobs (which lists vacancies) and from get_employer (which would focus on the company alone). The content scope is explicit: duties, requirements, how to apply, company and address.

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 tells the agent to obtain the slug from list_jobs, which establishes the expected workflow and usage context. It does not explicitly list when-not-to-use alternatives like get_employer, but the purpose statement is specific enough that an agent can infer the appropriate choice. The main gap is the absence of explicit exclusion criteria.

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

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

Annotations declare readOnlyHint=true and openWorldHint=false, so the agent knows this is a safe read operation. The description adds the constraint that the slug must come from list_news, which reinforces the openWorldHint=false (closed world) by suggesting the slug is a known value. However, it does not describe the response format (e.g., whether it returns just text or metadata), but with annotations covering safety, a 3 is appropriate.

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

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

The description is one concise sentence that front-loads the primary function ('full text') and specifies the input source. Every word earns its place, with no fluff or repetition.

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

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

For a simple read tool with a single parameter and no output schema, the description is complete. It tells the agent what to provide (slug from list_news) and what to expect (full text). The lack of output schema is acceptable given the tool's simplicity. Minor gap: it doesn't mention whether the article includes metadata (e.g., author, date), but this is not critical for a READ operation.

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

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

Schema description coverage is 100%: the schema already describes the 'slug' parameter as 'Article slug from list_news'. The description repeats this by stating 'by its slug from list_news' without adding new details. Since the schema carries the parameter semantics fully, the baseline of 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?

The description states a clear purpose: retrieving the full text of a single news article by slug. It identifies the resource (BinaSmart news article) and the input (slug). However, it does not explicitly distinguish it from the sibling tool list_news, though the relationship is implied by referencing list_news.

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: use this tool after obtaining a slug from list_news. It provides clear context by referencing list_news as the source of the slug, but it does not explicitly state when NOT to use this tool or mention alternatives beyond the implied list_news. This is sufficient for most agents.

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 the description adds useful behavioral detail: the set of possible ride statuses and the conditional availability of driver/vehicle/plate data only after assignment. This is meaningful context 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 two compact sentences with no filler. It front-loads the core purpose and status list, then immediately states the required inputs, making every sentence useful.

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 appropriately names the returned data categories: status, driver name, vehicle, and plate. It also communicates the conditional nature of some fields. It could mention error behavior or real-time freshness, but for a simple read-only lookup tool it is reasonably complete.

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

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

Schema description coverage is 0%, so the description must carry the semantic weight. It explains that rider_phone is the phone used to book and that ride_id is needed alongside it, which adds meaning the schema alone does not convey, though it could go further in describing expected formats or relationship between the two.

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 operation as retrieving the current status of a BinaSmart ride and enumerates the possible statuses. It also specifies that driver name, vehicle, and plate are included once assigned, which makes the tool's purpose distinct from siblings like cancel_ride or request_ride.

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 makes clear that this tool is for checking a ride's current status and states the required identifying information: ride id and rider phone used to book. It does not explicitly contrast with alternatives, but the read-only status vocabulary and required parameters provide clear usage context.

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 openWorldHint=false, covering the safety profile. The description adds the scope of the returned notice (requirements, bid bond, submission details, link) but does not describe error handling, response format, or potential absence of a tender, which are secondary given the read-only nature.

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

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

A single, dense sentence that leads with the core purpose ('full text of a single tender notice') and immediately follows with the input source and the expected contents. 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 one-parameter read-only tool with annotations covering safety, the description is sufficient to call it correctly: it names the input source, the resource type, and what the return includes. It doesn't cover error scenarios or the original-notice link format, but these are not essential for selecting and invoking 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?

Schema coverage is 100%, and the description reinforces that slug comes from list_tenders without adding new semantic detail beyond the schema. It confirms the parameter's role but doesn't specify format or constraints beyond what the schema already provides.

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

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

States a specific verb (get), resource (single tender notice), source (BinaSmart), and input (slug from list_tenders). It enumerates contents, distinguishing it from list_tenders and other sibling 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?

Explicitly ties the slug to list_tenders, signaling the typical workflow of listing first then fetching a single item. It doesn't name alternative tools or exclusions, but the context is clear enough for a simple getter.

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

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

The annotations already declare readOnlyHint=true, but the description goes further by explaining that seats are selected and paid at a returned URL, payment can be via Chapa or at the counter, and the ticket is a QR code. This adds meaningful behavioral context beyond the annotations and clearly signals that booking/payment is not performed by this tool.

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

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

The description is two sentences with no filler. The first sentence front-loads scope and returned fields, and the second explains the follow-up payment/ticketing flow. Every clause adds useful information.

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

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

For a zero-parameter read-only listing tool, the description is complete: it names the domain, location, and returned fields, and describes the downstream booking flow. Even without an output schema, an agent can confidently invoke the tool 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?

The input schema has zero parameters, so the baseline is 4; there is no parameter information for the description to add. The description focuses on output content and behavior, which is appropriate since no parameters exist.

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 (events on BinaSmart in Addis Ababa) and the returned details (venue, hall, start time, prices per tier, seats left). It is not phrased as an explicit verb statement like 'List...', but the tool name and content make the purpose unmistakable. It does not explicitly distinguish itself from the sibling list_films.

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

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

The description implies when to use the tool: for upcoming events in Addis Ababa. However, it provides no explicit comparison with alternatives such as list_films, and there is no guidance on when not to use it. Usage context is clear but must be inferred 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?

Annotations already mark the tool as read-only. The description goes beyond this by explaining that free titles are YouTube releases played through the YouTube player and rentals require Chapa, plus the 48-hour rental window. This gives an agent useful context about watch access without contradicting the readOnlyHint.

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

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

The description is two sentences with no filler. It front-loads the resource and output fields, then adds access behavior and search capability. The first sentence is somewhat dense but remains readable and appropriately sized.

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 explicitly lists the returned fields (title in Amharic and English, year, genre, price, watch URL). It also covers the free vs rental access model. It could mention limit/pagination behavior, but for a simple list tool this is nearly complete.

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

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

Schema description coverage is 100%, with limit and query both described. The description's mention of 'optional search by title or genre' mirrors the query parameter, adding no new semantics. Baseline 3 is appropriate since the schema already documents the parameters.

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

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

The description states exactly what the tool does: it returns licensed Amharic films watchable online on BinaSmart Watch, including specific fields (title, year, genre, free/rental status, watch URL). The resource and scope are unambiguous, and the tool is clearly distinct from the ride, place, event, and hospital 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?

The context is clear: this tool is for discovering Amharic films on BinaSmart Watch, with optional filtering by title or genre. It does not explicitly name alternative tools or when not to use it, but no sibling offers film listing, so the intended usage is effectively communicated.

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, so the agent knows this is a safe read operation. The description adds useful behavioral context by indicating the data is current ('right now'), restricted to open vacancies, and includes counts and city breakdowns, which goes beyond the annotation-only picture.

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 that front-loads what the tool returns and then attaches the workflow hint. Every clause adds value: the resource, the live-scope qualifier, the count detail, the city detail, and the relationship to list_jobs.

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

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

For a zero-parameter, read-only tool with no output schema, the description adequately covers what the tool returns and when to use it. Minor ambiguity remains around what 'cities hiring most' means exactly, but the description is otherwise complete enough for an agent to use the tool correctly.

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

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

The tool takes zero parameters, so the input schema is trivially complete and there is nothing for the description to clarify. Per the zero-parameter baseline, a 4 is appropriate because 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 states a specific verb and resource: it lists fields of work with open vacancies, includes counts, and notes the cities hiring most. It also distinguishes itself from the sibling list_jobs by framing this as a precursor that supplies filter values, so an agent can clearly tell them apart.

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 by saying this is 'useful before calling list_jobs with a field or city filter,' which tells the agent when to invoke it. It does not explicitly state when not to use it or name other alternatives, but the workflow guidance is strong.

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 mark the tool as read-only, and the description adds useful behavioral context beyond that: data is refreshed every morning, it aggregates thousands of vacancies from Ethiopian boards, and results default to open vacancies only. This goes beyond what the annotations alone provide.

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 and front-loaded with the source and returned data fields. The list of fields of work is somewhat long and partially redundant with the schema, but every sentence adds useful context and there is no filler.

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

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

For a read-only list tool with five optional parameters and no output schema, the description covers source, data freshness, returned fields, search and filter options, and default open-vacancy behavior. It does not mention pagination or explicit sorting beyond the query hint, but the schema provides the limit parameter and the query description implies the default ordering.

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 every parameter. The description adds some context such as English/Amharic keyword support and the available filter dimensions, but it mostly restates information already present in the parameter descriptions. This matches the baseline for high schema coverage.

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

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

The description clearly identifies the tool as listing open job vacancies in Ethiopia from BinaSmart, and enumerates the returned fields: job title, company, city, deadline, days left, salary, and requirements. This distinguishes it from sibling tools like get_job, which would return a single job, and list_job_fields, which would return field options.

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 usage context: search by keyword in English or Amharic, filter by field or city, and the default open-vacancies-only behavior unless include_closed is set. It does not explicitly name alternatives or state when not to use the tool, but the guidance is clear enough for an agent to decide when this list tool is appropriate.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds useful behavioral context: results are 'recent', content is 'mostly in Amharic', and only the headline, short excerpt, and URL are returned, implying no full text. This goes beyond the structured fields and helps set 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 two sentences with no filler. The first sentence front-loads the source, scope, and content languages; the second states the return shape and routes the user to the full-text sibling. Every clause 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?

With a rich schema documenting all three optional parameters, annotations covering read-only behavior, and a description that specifies the source, language, topics, and return fields, the definition is complete for an agent to select and invoke this tool. No output schema exists, but the description explicitly names the returned fields.

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

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

The input schema covers 100% of parameters with meaningful descriptions, including the category examples in Amharic and English, so the baseline is 3. The description's topic list roughly mirrors the category parameter but does not add new parameter-level details about limit or query behavior. It does not need to compensate because the schema is already strong.

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 that the tool returns recent articles from BinaSmart news, identifies the source URL, and lists the covered topic areas. It also differentiates itself from the sibling get_news_article by noting that this tool returns only the headline, excerpt, and URL rather than full text.

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

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

The description gives clear context for when to use this tool: to get recent article summaries and links. It explicitly points to get_news_article for full text, which helps an agent choose between siblings. It does not enumerate exclusions or more complex routing rules, but the guidance is sufficient for this straightforward read tool.

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

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

With no annotations, the description carries the transparency burden and does disclose meaningful behavior: it is a read-only listing, it covers current corridor availability, includes directional time cutoffs, and names the output content including stops, live prices, and filling cars. It does not describe response formatting or edge cases, but the core behavior is clearly communicated.

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 readable and purposeful: background, route details, and a rider link each add useful context. It is somewhat long and the operation is not literally front-loaded at the first word, but no sentence feels wasted and the structure is coherent.

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 optional-parameter listing tool with no output schema, the description tells the agent what will be returned ('stops, the live seat-price ladder (1–4 riders) and cars currently filling') and the temporal context of corridors. It does not define exact return fields, but the prose plus schema is enough 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 lat as 'to sort by distance' and lng as the rider longitude. The description itself adds nothing about the optional parameters, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Lists the corridors open right now' for BinaPool, and enumerates the routes and data types included. It is clear, but it does not explicitly contrast the tool with siblings like find_pool_groups, 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?

The description implies when to use the tool: when the agent needs current BinaPool corridors or live seat prices, signaled by 'open right now' and 'live seat-price ladder.' It provides no explicit when-not-to-use guidance or alternatives such as find_pool_groups or quote_ride, so usage is inferred rather than fully 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?

The readOnlyHint annotation already signals a safe read, and the description adds context beyond it: results are a live snapshot ('right now') and include counts per category. It does not mention output format details or refresh behavior, but that is minor given the zero-parameter schema and existing safety annotation.

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

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

The entire description is one focused sentence with no filler. It front-loads the core output and then adds the workflow clue, so an agent can act on it immediately.

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 tool with read-only annotations, this is complete: an agent knows what data comes back (categories and counts), when it is current, and how it feeds into list_tenders. No return schema exists, but the description supplies the essential return semantics.

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

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

There are no parameters, so the description has no parameter burden. The schema fully documents the empty parameter set, and the description indirectly explains why no input is needed: it reports current categories and counts.

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 the resource (tender categories on BinaSmart), the temporal scope (open right now), and the included count per category. It also distinguishes this from the sibling list_tenders by framing it as the precursor to filtering tenders.

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 the tool is 'useful before calling list_tenders with a category filter', which tells the agent exactly when in the workflow it belongs and connects it to the relevant sibling tool. No competing alternative needs exclusion because the schema is parameterless and the relationship to list_tenders is explicit.

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

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

Annotations cover the safety profile (readOnlyHint=true, openWorldHint=false). Beyond that the description adds real value: default ordering is closing-soonest, keyword supports Amharic, and it warns that each tender has published_at and should not be called 'new' without it. It does not cover pagination or result volume, but the field list substitutes for a missing output schema.

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 data source are front-loaded, then scope defaults and search modes. Two dense sentences with little waste, though the organisation-type list (banks, government, NGOs, World Bank) is more colour than actionable signal.

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 usefully enumerates returned fields (issuing organisation, subject, deadline, days left, budget, source link) and states default sort and closed-tender behaviour. An agent could call this correctly; only pagination/limit behaviour is left purely to 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 schema already documents all five parameters in detail. The description echoes the keyword/category semantics but adds little the schema does not already say (it omits limit and barely mentions include_closed's effect). 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 and resource (listing public tender notices) with the data source (BinaSmart, bina.et/tenders) and the exact fields returned. It is clearly distinguishable from siblings get_tender and list_tender_categories.

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

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

It states the default scope (open tenders only unless include_closed is set) and the two search modes (keyword in English or Amharic, category filter), and the schema points to list_tender_categories as the enumeration helper. It stops short of explicitly routing single-tender lookups to get_tender.

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 the tool read-only. The description adds behavioral context: fixed upfront pricing, no surge, accepted payment methods (cash/telebirr/Chapa), and a defined return payload. This goes beyond the schema without contradicting the readOnlyHint.

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, then list return fields and workflow. There is no filler; every sentence adds decision-relevant 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?

Despite no output schema, the description names exactly what is returned (distance, ETA, fare per tier), making the call outcome predictable. It also gives the critical sequencing context with request_ride and the geographic scope.

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 both pickup and dropoff fully documented including examples. The description adds only scope ('inside Addis Ababa') already present in the schema, so it adds little beyond the baseline.

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

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

States a specific action (quote a ride) and result: fixed upfront price, distance, ETA, and per-tier fares for a ride in Addis Ababa. The mention of 'before request_ride' also distinguishes it from the booking sibling.

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

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

Explicitly instructs to 'Call this before request_ride and read the fare to the user,' which establishes the correct workflow. It does not spell out when not to use it or name alternative tools besides request_ride, so it stops short of a full 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?

It discloses behaviors beyond the annotations: a dispatcher assigns a driver, the rider is contacted on the provided phone, the tool returns a ride id and live tracking link, and it clarifies third-party booking semantics. The idempotentHint is not contradicted, since the description does not claim each call creates a brand-new unique ride.

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 focused sentences: purpose, required confirmation, and booking-for-others behavior. Important information is front-loaded, and no sentence is 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 an 8-parameter tool with no output schema, the description covers the essential context: return value (ride id and tracking link), the required pre-call confirmation, the relationship to quote_ride, and the passenger/rider distinction. Nothing critical is missing 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 baseline is 3. The description adds meaning by explaining that passenger_name/passenger_phone are used when booking for someone else and that rider_name/rider_phone become the booker in that case, which is not fully obvious from the schema alone.

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: 'Books a ride in Addis Ababa at the fixed fare from quote_ride.' This clearly distinguishes the tool from siblings like quote_ride and get_ride_status by stating the action and its relation to the quoting flow.

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

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

The description gives strong usage guidance: it mandates confirming pickup, drop-off, tier, fare, and rider phone before calling, and it explains the passenger_name/passenger_phone case for booking on behalf of someone else. It does not explicitly name alternatives like quote_ride or get_ride_status, but the prerequisite relationship to quote_ride is clearly implied.

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 only cover safety (readOnlyHint=true) and closed-world scope; the description adds real operational context: data is pulled from dealers' and car markets' own websites and refreshed weekly, and each result carries dealer phone/WhatsApp plus a bina.et photo link. It does not discuss result limits or empty-result behavior, keeping 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?

Front-loads the resource and source in one dense sentence, then use cases, then the exclusion. The field enumeration is long but informative rather than repetitive, and 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?

With no output schema, the description usefully enumerates what each listing contains (specs, dealer contact, photo link), which is the main completeness need. Gaps remain around result count/ordering defaults, but the core call-and-interpret story is covered.

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

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

Schema description coverage is only 33% across 9 parameters, so the description carries some burden, and it does name make, model, year, price and fuel plus an example price threshold. However it ignores limit (default 5, max 8), cheapest_first ordering, condition and the body/fuel enum choices that are only visible in the schema, so it only partially compensates.

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 (live new/used car listings from Addis Ababa dealers on bina.et/cars) and enumerates the data surface: make, model, year, price, mileage, fuel, gearbox, dealer contact, photos. The explicit 'Not for taxi rides' separates it from the ride-hailing 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 concrete trigger queries ('used Toyota', 'SUV under 10 million birr', 'electric car price', 'BYD') that map directly onto the filter parameters, plus an explicit exclusion ('Not for taxi rides'). It stops short of naming the sibling tool an agent should call instead for rides, so it is clear context but not full 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 and openWorldHint=false, so safety is covered. The description adds real behavioral value beyond that: source provenance, coverage scale (250+ places), that doctor licences are team-verified, what the results contain, and a safety disclaimer with an emergency number. It stops short of pagination/limit behavior or data freshness details.

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

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

Front-loaded with the core purpose, then filters, return contents, and disclaimer in a logical order. The single dense paragraph with stacked parentheticals is slightly heavy, but nearly every clause carries useful information, so little 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 5-param, zero-required search tool with no output schema, the description is nearly complete: it explains filters, return fields, and safety caveats. It omits default-result behavior when no filters are supplied and any pagination/limit semantics, but nothing critical to correct invocation is missing.

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

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

Schema coverage is 100%, so the baseline is 3 and the schema already documents every filter. The description still adds value by giving a broader specialty example list and clarifying that 'near' yields nearest-first ordering and that results include distance and nested services/doctors.

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 (Find) and resource (hospitals, clinics, dentists, labs, health centres, doctors) scoped to Addis Ababa, and names the data source (BinaSmart Health). It is clearly distinguishable from siblings like search_hotels, search_cars, or even general search_places by its health-facility domain and provenance.

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 context for when to use it (locating health facilities/doctors in Addis) and enumerates the available filter dimensions (kind, sub-city, near, specialty). It does not, however, explicitly say when not to use it or point to the overlapping sibling search_places, leaving the routing boundary 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 only cover the safety profile (readOnlyHint, openWorldHint=false), so the description usefully adds scope of data coverage, the upstream source, and the important limitation that pricing/availability are absent. It does not describe result ordering or how the limit interacts with a 1,000+ record directory, which would be the remaining gap.

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

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

Two dense sentences with zero filler; scope and coverage come first, then the critical limitation is placed last for emphasis. Nothing restates the 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, the description correctly compensates by enumerating the returned fields (name, type, sub-city, stars, phone, website, bina.et page). Combined with annotations it covers the safety and data-shape picture, though pagination/limit behavior and result ordering remain unstated.

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 60%, and the description loosely maps to the parameters (type -> kind, sub-city -> area, stars -> min_stars), but the type list it names ('pensions', 'furnished apartments') does not match the enum values (motel, apartment), which risks misleading an agent picking a kind. The undocumented name/limit/min_stars params get no added semantics from the description.

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

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

States a specific resource (hotels, guest houses, pensions, hostels, furnished apartments in Addis Ababa), the data source (BinaSmart's directory, 1,000+ places from the city map), and the exact fields returned. It also carves itself apart from the rooms-oriented sibling get_hotel_rooms by declaring 'NO prices or free rooms', so an agent can disambiguate 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?

Gives clear context for when to use it (directory lookups for lodging in Addis Ababa) and an explicit negative case plus fallback workflow ('NO prices or free rooms - tell the guest to call the hotel'). It stops short of naming the alternative tool (e.g. get_hotel_rooms) for availability, which would have made routing unambiguous.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals the semantic-search nature, says it returns 'best-matching passages with a source url to cite,' and adds a truthfulness constraint ('never invent a fare or an official portal name'). It does not discuss failure modes, rate limits, or output structure, 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?

The definition is two sentences and front-loaded with the core purpose, but the first sentence is a long list-heavy enumeration. The list is useful for routing queries to the right tool, so it is not padding, but it is denser than necessary.

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 2-parameter tool with no annotations and no output schema, the description provides purpose, scope, return format, and usage timing, which is enough to select and invoke it correctly. It could add explicit exclusions or a contrast with search_places, but nothing critical 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 input schema already describes both parameters fully: query (question/keywords, English or Amharic, length bounds) and k (integer 1-8, default 4). The description adds no parameter-specific detail, so the baseline of 3 applies given 100% schema coverage.

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

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

The description opens with 'Semantic search over BinaSmart's knowledge base' and then enumerates the exact domains (services, product rules, guides, Addis Ababa knowledge), making the verb, resource, and scope explicit. It also distinguishes itself from siblings like search_places and get_ethiopia_guide by listing the full breadth of content it covers.

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 contains a direct usage directive: 'Use it before answering any question about BinaSmart, Ethiopia paperwork or getting around Addis' and warns against inventing facts. It does not mention when not to use it or compare against search_places, so it stops 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.

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

Beyond the readOnlyHint=true and openWorldHint=false annotations, the description discloses rich behavioral detail: return fields (names in English and Amharic, building/unit, phone only for claimed listings, coordinates usable with quote_ride, bina.et page), flagging of hotels/hospitals, and the distinct map_place result shape for food queries with no listed shop, including the absence of phone, hours, prices, and menu. No annotation contradiction.

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

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

The description is front-loaded with the core purpose and is dense with actionable routing and return information, but it is a single long paragraph with several clauses that could be structured more readably. Each sentence still earns its place by conveying useful distinctions about results or alternatives, so it avoids pure 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, the description carries the full burden of describing return values, and it does so completely for both result types: listed shops (names, unit, phone conditional on claim status, coordinates, page link) and map_place fallback results (name, area, distance, coords, ride link, and explicit lack of phone/hours/prices/menu). It also routes the agent to sibling tools for details, leaving no obvious gap 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 parameter definitions already document query (name or part of name, English or Amharic), limit (max per kind, default 8), and category (filter list). The description mentions categories in prose but adds no syntax, format, or interaction detail beyond what the schema provides. Baseline 3 is appropriate when 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 states a specific verb ('Find') and resource ('buildings, hotels, hospitals and shops in Addis Ababa listed on BinaSmart'), enumerates concrete categories, and explicitly distinguishes itself from siblings get_hotel_rooms, get_hospital_departments, and search_health. An agent can tell exactly what this tool is for without consulting 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 says when to use it (looking up listed shops and food places on BinaSmart) and when to use alternatives: 'For hospitals, clinics, dentists, labs and doctors anywhere in Addis Ababa, use search_health' and 'Hotels and hospitals are flagged — use get_hotel_rooms / get_hospital_departments for details.' It also explains the fallback behavior for food queries with no listed shop, covering both listed and unlisted cases.

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 only cover readOnlyHint and openWorldHint; the description adds substantial behavioral context on top: weekly refresh cadence, data provenance (companies' own sites), the caveat that prices are recorded verbatim and may be per m² or in USD, that each result carries the company's phone/WhatsApp, an update date and a bina.et photo link, plus an anti-fabrication instruction ("Never invent a listing or a price").

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 core purpose and the returned-field inventory are front-loaded in one sentence, followed by two short, high-value sentences for example queries and the no-fabrication rule. The field enumeration is dense but each item earns its place by telling the agent what it will receive.

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 describing return fields, provenance and freshness, so an agent knows what it will get back. The only gap is that it never says all seven parameters are optional and a bare call returns a default-limited result set.

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 86%, so the schema already documents area, beds, type, limit, query, listing and max_price. The description's field list mostly mirrors output fields, not inputs; only the note that prices are "as the company wrote it (some per m² or in USD)" adds real meaning to how max_price should be interpreted. 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?

States a specific verb+resource with full scope: live Addis Ababa property listings aggregated from real-estate companies' own websites on bina.et/property. It is unmistakably distinct from siblings like search_cars, search_hotels, and search_places.

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 usage context via concrete example queries ("apartment for rent in Bole", "3 bedroom for sale", "ቤት ኪራይ"), including Amharic input. It does not name any alternative tool or state when NOT to use it, 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.