Jiji Nigeria MCP by Nova (CIVAI)

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

With no annotations, the description carries the full burden. It discloses the HTTP method (GET) and scope (account_info) and frames it as a probe, but does not explain what happens if unauthenticated, whether the call has side effects, or what profile data is returned in the absence of an 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?

The description is two short clauses, front-loaded with the core purpose and followed by the endpoint and usage note. Every phrase contributes without redundancy.

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

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

For a low-complexity tool with one optional parameter and no output schema, the description covers the essential purpose and when to run it. It could optionally mention expected behavior on auth failure, but the core information needed to invoke it 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 parameter's meaning is fully documented in the schema. The description adds no additional parameter context, which is acceptable given the schema's completeness, but it does not enrich the understanding of the optional notification_message's role in follow-up failures.

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 function: an auth probe and profile summary, with the concrete endpoint 'GET profile/info scope account_info'. It differentiates itself from siblings like login/logout by being a probe rather than a session action, though it doesn't explicitly contrast with them.

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

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

The phrase 'Run before authenticated flows' gives a clear when-to-use directive. It lacks explicit exclusions or alternative recommendations, but the context is sufficiently clear for an agent to know it is a prerequisite check.

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

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

No annotations are provided, so the description carries the full burden. It says nothing about pagination, whether results are a single page or a full list, authentication requirements, or the shape of the response. For a listing-browse tool with zero structured behavioral coverage, this is a substantial 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 short sentences, front-loaded with the core action. The 'from recon' fragment is the only wasted text; otherwise it is 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?

The parameters are fully documented in the schema, but with no annotations and no output schema, the description should say more about what browsing returns (page size, ordering, pagination) and how it differs from search_listings. Adequate but with clear gaps for a 4-parameter browse tool.

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

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

Schema description coverage is 100%, so all four parameters are documented in the schema, including region slug and query. The description only echoes the category and query override, adding no semantics beyond the structured fields. Baseline 3 applies 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?

States a specific verb and resource: browsing Jiji category listing results, with the category default (mobile phones) noted. However, it never distinguishes itself from the sibling search_listings, which an agent could easily confuse it with. The parenthetical 'from recon' is internal jargon that adds confusion rather than clarity.

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?

'Optional query override' implies a search-within-category capability but gives no when-to-use guidance. With search_listings and search_next_page as siblings, the agent gets no signal about which tool to pick for a plain category browse versus a keyword search.

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

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

No annotations are provided, so the description carries the full burden, and it only implies a read via the verb "List". It says nothing about permissions, whether results are paginated or cached, roughly how many categories return, or whether the list is flat or hierarchical.

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?

One sentence, front-loaded with the verb and resource, with zero filler. It is efficient, though the single clause about pickers is the only thing separating it from a bare restatement of the name.

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

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

For a tool with no annotations and no output schema, the description omits what the response looks like (category id, name, parent/child structure) and whether the list is bounded or paginated. An agent can guess it is a safe read, but cannot predict the payload shape before calling.

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

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

Schema description coverage is 100% for the single optional parameter (notification_message), so the schema already explains it fully. The description adds nothing about the parameter, which is acceptable at this coverage level but is the baseline rather than added value.

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 ("List Jiji marketplace categories") plus the consuming feature ("Leads Discovery pickers"), so an agent knows exactly what it retrieves. It does not differentiate itself from the similar-sounding sibling list_regions, which an agent would need to disambiguate a geographic/category choice.

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 "for Leads Discovery pickers" implies the intended context but gives no explicit when-to-use, when-not-to-use, or alternative such as list_regions. With a near-duplicate sibling in the toolset, the absence of routing guidance is a real gap.

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

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

With no annotations, the description must carry behavioral disclosure; it does mention auth and ownership restrictions, which is useful. But it omits read-only implications, pagination, rate limits, and response behavior, leaving meaningful gaps.

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 short and front-loaded, with the resource and ownership constraint first. The 'job_cvs API' clause is somewhat opaque and does not add much actionable meaning.

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

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

For a simple two-parameter list tool this covers auth and ownership, and the required id is fully described in the schema. Still, with no output schema or annotations, the description should say more about return shape and pagination before it is fully 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 coverage is 100%, so the input schema already documents both parameters, including the job advert id source. The description adds only the ownership scope and does not clarify notification_message or add syntax details beyond the schema.

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

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

The description names a specific verb and resource ('List CV applicants') and scopes it to the user's own job vacancy, which separates it from general listing/search siblings. The ownership constraint and API name make the target clear, though it does not explicitly name a sibling alternative.

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

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

It states the core precondition -- authentication and ownership of the job advert -- so the agent knows this is not for arbitrary vacancies. However, it does not name alternatives or explain what to do when the advert is not owned.

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

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

No annotations are provided, so the description carries the full burden. It discloses the auth requirement and the shape of the returned threads, and 'List' implies a read-only operation, but it stays silent on pagination/limits, ordering, and whether reads mark messages as seen.

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

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

Two sentences, front-loaded with the core action and scope, with the login caveat trailing. Nothing is padded and nothing needs trimming.

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

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

With no output schema and no annotations, the description does a fair job by naming the fields an inbox listing returns. It still leaves pagination and result-set behavior unstated, which matters for an inbox that could be large.

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 single parameter (notification_message) is fully documented in the schema itself. The description adds no meaning about that fallback-message parameter, so the baseline of 3 applies rather than a higher score.

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

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

States a specific verb and resource ('List the signed-in user's Jiji message inbox') and even enumerates the content returned: threads with seller, advert title, last message preview. It does not explicitly distinguish itself from siblings like view_chat_thread or start_chat, but the scope is 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 only guidance is the prerequisite 'Requires login'. It never says when to pick this over view_chat_thread (single thread) or whether it is for paginating, checking unread, or initiating a reply. Usage is implied rather than stated.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that results are limited to active ads and to the signed-in seller account, but it does not mention pagination, result limits, ordering, or other list behavior an agent might need.

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 front-loaded sentence with no filler. It communicates the core operation and scope efficiently.

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 list tool with one optional, fully documented parameter, the description covers the essential scope. It is still incomplete for an agent that needs pagination or return-shape context, especially since there is no output 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?

The single optional parameter has 100% schema description coverage, so the schema already explains notification_message. The description adds no parameter-specific meaning, but the baseline is 3 when schema coverage is high.

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: list active ads, scoped to the signed-in Jiji seller account. That is clear enough to identify the operation, but it does not explicitly distinguish the tool from siblings like list_saved_ads or browse_listings.

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: an agent can infer this is for retrieving the signed-in seller's own active ads. However, there is no explicit when-to-use guidance, no exclusions, and no named alternatives for the similar listing-related sibling tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully states that seller authentication is required and "List" implies a read operation, but it does not disclose return behavior, pagination, privacy considerations, or any side effects suggested by the notification_message parameter.

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

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

The description is a single short sentence with no wasted words. The core purpose and seller-auth constraint are front-loaded, making it easy to scan.

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 list tool with full schema coverage, the description is enough to call the tool. However, with no annotations and no output schema, it still omits useful context about what "potential buyers/leads" contains, whether results are paginated, and what notification_message is for.

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

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

Schema description coverage is 100%, so the schema already documents both parameters, including that step_204_url_path_4 is an advert id from list_my_ads. The description adds only the general "YOUR goods advert" framing and does not add parameter-level detail beyond the schema.

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

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

The description gives a specific verb and resource: "List potential buyers/leads." It scopes the result to "YOUR goods advert" and notes seller authentication, which distinguishes it reasonably well from generic message or listing tools, though it does not explicitly name alternatives.

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

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

The seller-auth note and advert scoping imply when the tool is applicable, and the schema says the advert id comes from list_my_ads. However, the description itself does not state when to use this versus siblings such as list_messages or list_job_applicants, nor does it provide exclusions.

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

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

No annotations are provided, so the description carries the full disclosure burden. It conveys that this is a lookup of regions, but says nothing about authentication requirements, ordering, result size, or whether output is cached/static — gaps for a tool with zero annotation coverage.

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 compact sentence with the resource front-loaded. It is efficient, though extremely terse for a tool with an unexplained parameter.

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 enumeration tool with no output schema, the description is adequate at naming the resource, but it does not describe the shape of a region (e.g., id/name fields) or how results are ordered, leaving the agent to discover the return format by calling it.

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

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

Schema description coverage is 100% for the single parameter, so baseline is 3. However, the parameter (notification_message about a follow-up failure) is unrelated to listing regions and the description does not clarify its role or why it is optional here.

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

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

States a specific verb and resource ('List Jiji regions (areas)') and adds the domain context ('Leads Discovery pickers'). It is distinguishable from siblings like list_categories, though it does not explicitly contrast with them.

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

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

The phrase 'for Leads Discovery pickers' implies when the tool is relevant, but there is no explicit when-to-use guidance, no prerequisites, and no named alternative among the many list_* siblings.

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

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

No annotations are provided, so the description carries the full burden. 'List' and 'signed-in Jiji user' convey read-only behavior and an authentication precondition, but nothing is said about return shape, result ordering, pagination, or what happens when nothing is saved.

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?

One short sentence with no filler, and the key scoping information ('saved/favorite', 'signed-in user') is front-loaded. It is efficient but borders on under-specified rather than optimally structured.

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

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

The tool is simple, but with no annotations and no output schema the description leaves the agent guessing about pagination, empty-result behavior, and the unusual notification_message parameter's role. Adequate to call, not complete.

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

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

Schema description coverage is 100%, so the single parameter (notification_message) is fully documented in the schema and the description needn't restate it. Baseline 3 is appropriate; the description adds no parameter meaning of its own.

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 ('saved/favorite ads') scoped to 'the signed-in Jiji user'. This implicitly separates it from siblings like list_my_ads (own posted ads) and browse_listings, though no sibling is named explicitly.

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

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

Usage is implied by 'saved/favorite', which tells the agent this is for a user's bookmarked ads rather than their own listings. There is no explicit when-to-use, when-not-to-use, or named alternative, so the agent must infer the boundary with list_my_ads and browse_listings.

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

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

No annotations are provided, so the description carries the full burden. 'List' and 'opinions' imply a read-only retrieval of seller feedback, and the parenthetical clarifies what is excluded, but the description omits pagination behavior, response shape, authentication requirements, and any rate-limit or error context.

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

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

The description is two short sentences with zero filler and the core scope is front-loaded. The cryptic-looking path format is concise rather than wasteful, and the exclusion is stated immediately after the primary purpose.

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 annotations, no output schema, and no return-value description, the definition is incomplete for a retrieval tool. It says what the resource is, but it does not explain what the response contains beyond 'opinions', whether results are paginated, or how many/which opinions are returned.

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 parameters are already documented. The description adds a small amount of context by saying the value comes from searching a seller id, but it largely echoes the schema's 'results[].user_id' guidance and does not mention the optional notification_message parameter.

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 as 'seller reputation opinions' and explicitly distinguishes it from 'listing comments'. The verb is implied by the tool name 'list_seller_opinions', but the description does not name or compare against a specific sibling 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 gives a concrete input-source hint ('from search seller id') and a negative scope ('not listing comments'), which helps an agent know when this applies. However, it does not explicitly state when to use this versus search, view_listing_detail, or show_vendor_contact, nor does it mention 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?

With no annotations, the description carries the full burden. It usefully discloses that this is a mobile API login and that it yields session cookies, which is the key side effect an agent needs. It says nothing about failure behavior on bad credentials, whether existing sessions are invalidated, credential handling, or rate limiting — meaningful gaps for a session-creating mutation.

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, zero filler, with the action and target front-loaded and the return value stated second. Nothing here could be cut without losing 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 three-parameter login with no output schema, the description covers the action, the auth method, and the returned artifact, which is the essential shape. Missing are error/credential-failure semantics and session lifetime, which an agent would need to sequence subsequent calls safely.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema, establishing a baseline of 3. The description corroborates the two required credentials ('email and password') but adds nothing about format, and the third parameter, notification_message, is not mentioned at all.

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 (log in), resource (Jiji Nigeria account), mechanism (email and password via mobile API), and outcome (session cookies). This is inherently distinguishable from the only opposite sibling, logout, 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?

The phrase 'for authenticated pipelines' implies this is a prerequisite for other authenticated calls, which is useful implied usage. However, it never states when not to call it (e.g. when a valid session already exists), nor does it name any alternative or reference the logout sibling for session lifecycle.

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 provided, the description carries the behavioral burden and discloses the key side effect: it 'Clears auth cookies.' It does not cover return behavior or failure modes, but for a logout operation the main session effect is clearly stated.

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, with the core action and side effect front-loaded. There is no redundant or filler text.

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

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

For a simple logout tool with one optional, fully documented parameter and no output schema, the description provides enough context to invoke it correctly. It states the session scope, cookie-clearing effect, and the switching-accounts use case.

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

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

Schema description coverage is 100% for the single optional notification_message parameter, so the schema already documents it fully. The description does not add meaning about that parameter, which is acceptable given the high coverage 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 uses a specific verb and resource: 'Log out the current Jiji mobile session.' It also distinguishes the operation from the sibling login tool by explaining that logout should be run before login when switching accounts.

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

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

It gives a clear usage condition: 'run before login when switching accounts.' The alternative is implicitly the sibling login tool, but the description does not spell out when-not-to-use cases or other alternatives.

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

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

No annotations exist, so the description carries the full burden, and it does disclose the meaningful non-obvious behavior: this is a multi-step composition that first derives a category slug and then fetches listings, which implies extra latency and automatic category inference. It also states a hard input constraint ('Never pass slug=all'). It stops short of return shape, failure modes, or pagination behavior.

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

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

Three short sentences, zero filler, with the identification and the preference stated first. The compressed arrow phrasing in the first sentence borders on cryptic, which costs a point on clarity but not on economy.

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

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

The description covers routing and the input contract, which is the core need, and there is no output schema so return values needn't be explained. However, for a composite pipeline tool it leaves the agent without any sense of what comes back or how paging continues via search_next_page, which is a real gap for a search entry point.

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 every parameter is already documented, and the description mostly echoes that by restating the term/query duplication rule. The one addition, 'Never pass slug=all', references a parameter name that does not appear in the schema (only step_38_url_query_region_slug exists), which adds a rule but also mild ambiguity. 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?

Names a specific verb and resource (Jiji keyword search) and gestures at the internal pipeline (suggest → auto category slug → listings), which tells the agent this is a composite, not a raw listing query. It distinguishes itself from the sibling search_listings via 'Preferred for product search'. The arrow notation is terse and forces some inference about what the tool actually returns, keeping it below 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?

'Preferred for product search' gives an explicit default-selection rule against siblings like search_listings, search_suggest, and browse_listings, and 'Never pass slug=all' supplies a hard exclusion. It does not, however, say when to prefer search_suggest alone or when to move to search_next_page, so the routing picture is only partially complete.

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

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

With no annotations, the description carries the full burden, and it does disclose two non-obvious traits: the tool is stateful (requires a prior search_suggest call) and a specific failure mode (404 when logged in with slug=all). However, 'slug auto-resolved via step 200' is unexplained internal jargon, and nothing is said about what happens if the prerequisite is skipped, or about pagination/return 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?

It is very short and front-loads the prerequisite, with no filler sentences. But the terseness crosses into cryptic — 'step 200' is opaque and the second clause packs three ideas into one dash-separated fragment, costing clarity for the size saved.

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 4-parameter tool with full schema coverage, no output schema, and no annotations, the description covers the key gating behavior and slug pitfall. It is still missing what the call returns, whether results are paginated (search_next_page exists as a sibling), and the consequences of calling it without search_suggest.

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 all four parameters, including 'Never all for logged-in users' on the slug. The description's slug guidance largely repeats that field text and adds no syntax, format, or precedence detail (e.g., when the override beats the auto-resolved slug), so baseline 3 applies.

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

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

The name implies a listing search, but the description never states a verb or what the tool actually returns — it opens with the constraint 'Listings only after search_suggest' rather than 'Search listings by keyword.' The dependency on search_suggest and the slug rule do distinguish it from siblings like browse_listings, but only indirectly.

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 prerequisite ('only after search_suggest') and an explicit prohibition ('never pass slug=all'), which is real routing guidance an agent can act on. It stops short of naming alternatives (browse_listings, search, search_next_page) or saying what to do instead of passing slug=all.

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. It usefully discloses that next_url is opaque, that this is Nova LD pagination, and that a prior search/session is involved, but it does not describe failure behavior for an expired or invalid next_url, nor does it clarify whether this is a safe read operation.

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?

It is a single concise sentence with no filler. The key dependency and pagination mechanism are front-loaded, making it easy for an agent to scan.

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 pagination tool, the description covers the core dependency and pagination source. However, with no annotations and no output schema, it could better explain error/expiry behavior and how the optional notification_message parameter is intended to be used.

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

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

Schema coverage is 100%, so both parameters are already documented in structured form. The description adds context for next_url by calling it opaque and tying it to the prior search, but it does not mention notification_message or add syntax details beyond the schema.

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

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

The description uses a specific verb and resource ("Fetch the next Jiji ads_listing page") and identifies the continuation mechanism ("opaque next_url from the prior search"). That clearly separates it from initial search tools like search_listings, though it does not name a sibling alternative explicitly.

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

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

It states the tool should be used with the next_url from a prior search and references the session fallback via the schema. The usage context is clear, but there are no explicit exclusions or named alternatives for non-pagination 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?

No annotations are provided, so the description carries the full behavioral burden. It does convey useful context that this is a secondary/debug-only endpoint rather than the production search path, but it says nothing about return shape (a suggestion list), failure modes, or whether it is a read-only lookup.

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 clauses with no filler, and the usage directive is placed immediately after the identification. The parenthetical "(step 37)" is the only dead weight and actively obscures rather than clarifies.

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 annotations and no output schema, the description is the only place an agent can learn what comes back, and it never says. For a suggest/autocomplete tool, the return value (a ranked list of suggestions?) is the core thing an agent needs before deciding to call it instead of the combined search pipeline.

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

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

Schema coverage is 100%, with both parameters fully documented in-schema, including the example formatting for `step_37_url_query_term` and the constraint that `notification_message` be plain text. The description adds no parameter-level meaning beyond that, so the baseline of 3 applies.

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

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

"Jiji suggest only (step 37)" identifies the resource area (Jiji's suggest endpoint) and scopes it as suggest-only, but there is no verb and no statement of what a "suggest" call actually does or returns (autocomplete? query expansion?). The "(step 37)" fragment is opaque internal jargon that adds no meaning for an agent choosing a 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?

"Prefer the combined search pipeline unless debugging" gives an explicit when-not-to-use rule and points to the alternative category, which is unusually strong guidance for a tool definition. It stops short of naming the exact sibling tool (e.g. `search`), so the agent must map "combined search pipeline" to a name itself.

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

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

No annotations exist, so the description carries the full behavioral burden, yet it discloses nothing about side effects, authentication requirements, rate limits, or what happens if the thread id is stale. The only hint of failure handling is buried in the schema's notification_message parameter, not the description.

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, zero filler. The action is stated first, then the prerequisite, which is the correct front-loading order for an agent that needs to decide and then gather inputs.

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 write tool with no annotations and no output schema, the description covers the happy path and its prerequisite chain but omits success confirmation, error behavior, and the role of notification_message. Adequate to invoke, thin on consequences.

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 four parameters thoroughly. The description adds provenance context ('advert id and seller user_id from the chosen thread') that reinforces the dependency chain, but adds no syntax or format detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb and resource: 'Send a reply in an existing Jiji chat thread.' The word 'existing' implicitly distinguishes it from thread-creation siblings like start_chat, but that sibling is never named, so differentiation is inferred rather than explicit.

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 prerequisite sequence: 'Use after list_messages with advert id and seller user_id from the chosen thread.' This tells the agent both when to call it and where the required inputs come from. It does not state when NOT to use it (e.g. new conversations, which belong to start_chat).

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

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

With no annotations, the description carries the full burden, and it does disclose the prerequisite step and the returned fields (other_user_phone, other_user_phones). It says nothing about authentication/login requirements, rate limits, or what happens when a seller has no phone on file — meaningful gaps for an unannotated 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 front-loaded sentences: purpose, prerequisite, return shape. Nothing redundant or 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?

Since there is no output schema, the description usefully names the return fields, and the prerequisite is covered. It is nearly complete for a single-purpose lookup, with only auth/error 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%, so the schema already explains both parameters, including the room_id provenance and the .json suffix. The description only restates the room_id prerequisite and says nothing about notification_message, so baseline 3 applies.

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

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

States a specific verb and resource ("Fetch seller phone numbers") scoped to a Jiji chat thread, and names the concrete return fields. An agent can distinguish it from list_messages or view_chat_thread 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?

Gives an explicit prerequisite and ordering ("Requires room_id from list_messages (run inbox first)"), which is exactly the sequencing an agent needs. It stops short of naming a when-not-to-use case or a direct alternative such as view_chat_thread for non-phone thread data.

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

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

With no annotations, the description carries the full disclosure burden. It does disclose the key side effect (a new chat thread is created), but says nothing about auth/permissions, failure modes when a thread already exists, or rate/duplicate-message constraints.

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

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

Two short sentences, zero filler, with the action and its effect front-loaded before the sequencing note.

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?

Adequate for a simple 4-parameter tool, but with no annotations and no output schema the description never says what the call returns or how duplicate-thread situations are handled. Params are fully documented by the schema, which keeps this from being worse.

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 explains every parameter, including where advert ids and user_ids come from. The description only adds that ids originate from search_suggest, which is marginal added meaning; 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 ('Send the first message to a seller about a listing') and clarifies the effect ('opens a new Jiji chat thread'). The 'first message' framing implicitly distinguishes it from send_reply and view_chat_thread in the sibling set.

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?

'Use after search_suggest with listing ids' gives an explicit prerequisite and sequencing hint. No negative guidance (e.g. what to do if a thread already exists, or when to use send_reply instead), so it falls short of a 5.

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

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

No annotations are provided, so the description carries the full burden, and it does signal read-only behavior via "(GET)", which is useful safety context. However it says nothing about result size or pagination for "full message history", nor about the failure path implied by the notification_message parameter. Adequate but with real gaps for an unannotated 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?

Two short sentences, zero filler, with the action stated first and the routing condition second. 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 read-only GET with fully documented parameters and no output schema, the description covers purpose and sequencing well enough to invoke correctly. It could do slightly more on what the returned thread contains and whether the history is paginated, but no critical invocation detail 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 schema already explains advert id, seller user_id with .json suffix, and the fallback message. The description adds no parameter-level meaning beyond that, which is the baseline 3 case 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?

"Read full message history for one chat thread (GET)" gives a specific verb (read), a specific resource (one chat thread's full message history) and scope (single thread, full history). It is clearly distinguishable from list_messages, send_reply and start_chat 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?

"Use after list_messages when the user picks a vendor thread" states the prerequisite tool and the triggering condition explicitly. It does not cover when not to use it (e.g. thread already loaded) or name a fallback, but the routing guidance is concrete.

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

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

No annotations are provided, so the description carries the full burden. It partially compensates by disclosing the underlying endpoint and that the response is the 'full' advert JSON (implying a read with no truncation), but says nothing about auth requirements, behavior on an invalid/expired id, or rate limits.

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

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

Two sentences, front-loaded with the action and endpoint, with no filler. Minor waste in referencing an internal identifier ('form_fields') that the agent cannot resolve to a sibling 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 no output schema, the description should describe the return value, and 'full Jiji advert JSON' at least signals the shape. However, for a tool with a cryptically named required parameter and two near-duplicate siblings, the definition leaves the selection and error-handling picture incomplete.

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

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

Schema coverage is 100%, so both parameters are already documented in the schema, establishing a baseline of 3. The description's URL template reinforces the required '.json' suffix on the id, but it adds nothing about the oddly named step_201_url_path_3 or the notification_message fallback parameter.

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?

Specific verb+resource: 'Fetch full Jiji advert JSON', with the exact endpoint api/v1/advert/{id}.json. It does not distinguish itself from the closely named siblings view_listing_detail or view_listing_v2, so an agent cannot tell which of the three advert-reading tools to pick from the description alone.

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?

'Prefer over form_fields when listing id is valid' gives a preference condition, but 'form_fields' is not one of the sibling tools, so the routing advice points at an unclear alternative. There is no guidance on when to use view_listing_detail or view_listing_v2 instead, which is the actual ambiguity an agent faces.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only fetch by using 'Fetch' and naming the form_fields API, but it does not disclose authentication requirements, rate limits, error behavior, or what the response contains.

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 short sentences with no wasted text, and the primary purpose is front-loaded before the input-source hint.

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

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

The description is adequate for a simple fetch tool whose parameters are fully documented in the schema, but with no output schema and no annotations it does not explain return values or how it differs from similar listing-detail siblings. These are meaningful gaps for an agent choosing among listing tools.

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 even without rich parameter detail in the description. The description adds source context for the advert id ('from search results') but does not clarify the required category-id path parameter or the optional notification message.

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

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

The description states a specific verb and resource: fetch Jiji listing detail fields for one advert, and names the underlying form_fields API. It is clear what the tool does, but it does not distinguish itself from similar siblings such as view_listing_advert or view_listing_v2.

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 'Pass advert id from search results' implies the tool is used after a search and its prerequisite input source, but it does not explicitly state when to use this tool versus sibling listing tools or when not to use it. Usage is implied rather than fully guided.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It discloses the backing endpoint, which hints this is a read-only fetch, but says nothing about auth requirements, error behavior when the id is invalid, or what the response contains. The required notification_message parameter's failure semantics are also unexplained.

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 tight sentence with the verb and route front-loaded; no filler. It is arguably too terse rather than padded, and the parenthetical route note is the only marginally expendable element.

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 annotations and no output schema, the description is the only place an agent can learn what this returns or how it differs from three similarly named siblings, and it supplies neither. For a simple two-parameter fetch the gaps are recoverable but real.

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 are already documented ('Numeric advert id from search results[].id' and the plain-text fallback sentence). The description adds no parameter meaning beyond the schema, which is acceptable at full coverage but earns only 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 names a specific verb and resource ('Fetch Jiji advert') and pins the underlying route (api/v2/advert/{id}, mobile app detail route). However, three siblings (view_listing_advert, view_listing_detail, view_listing_v2) do nearly the same thing, and nothing in the description tells an agent which one to pick. The purpose is intelligible but not disambiguated.

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?

'(mobile app detail route)' is a technical annotation on the endpoint, not guidance on when to use this tool over view_listing_advert or view_listing_detail. No prerequisites, no exclusions, no alternative named.

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