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

With no annotations, the description carries the transparency burden. It clearly states the return format for both success ({ok, expires_at, seconds_remaining, user_id}) and failure ({ok: false, error}) cases and specifies the condition that triggers failure (missing or expired JWT). It does not mention side effects, but this is a read-only verification operation by 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?

The description is a single, well-structured sentence that front-loads the action and resource, then states the return contract. Every word earns its place with no redundancy or 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?

Given the tool's simplicity, zero parameters, and no output schema, the description provides sufficient detail: it explains the verification target and the exact return shape in both success and error scenarios. It could add guidance on what to do when ok is false, but that is not strictly necessary for invoking 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 has zero parameters, so the schema carries no semantics. The description correctly focuses on behavior and return values, which is all that is needed. Baseline 4 applies for a zero-parameter tool.

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 ('Verify') and names the exact resources (JWT and lastRequestId in .env). It clearly distinguishes this tool from all 21 siblings, none of which relate to authentication, making its 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 implies this tool should be used to check whether authentication is still valid, but it never explicitly states when to call it, e.g., as a preflight before authenticated requests, or what to do if the JWT is expired. No alternatives are mentioned, though no sibling auth tool exists.

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 this is a read-style list operation and notes the page and oldest_first options, which is useful. It does not cover response shape, pagination size, or any side effects, so it is adequate but not rich.

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

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

A single sentence packs the purpose and all parameter guidance with no filler. The required parameter is front-loaded before the optional ones.

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 three parameters and no output schema, the description gives the critical input requirements. It is missing return-value details and any pagination semantics, but the tool's low complexity makes the omission moderate rather than severe.

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 needed to explain the parameters, but it mostly restates the schema: post_id required, page optional, oldest_first default true. It adds no meaning about page indexing, page size, or what oldest_first ordering means beyond the parameter name.

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-resource pair: 'Comment list for a post.' It clearly identifies the operation and target resource. It does not explicitly distinguish it from siblings like get_post_details or notes, so it misses the top score.

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 retrieving comments on a post, and the required post_id is explicitly stated. There are no exclusions or alternatives mentioned, but the intended use case is evident from the one-line 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?

With no annotations, the description carries the full burden, and it does a lot: it discloses defaults, compact vs full post objects, the before_update_date cursor mechanism, and the response shape. It doesn't mention auth or rate limits, but for a fetch operation this is still substantial behavioral disclosure.

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

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

The description is two sentences, front-loads purpose, then groups required and optional parameters and return shape. Everything present is useful, and the detail is justified by ten parameters.

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

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

Given no annotations, no output schema, and heavy parameter complexity, the description is complete enough to invoke correctly: it explains the parameter set, defaults, pagination, and the returned object structure. No critical calling information appears 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 0%, but the description compensates fully by explaining all ten parameters, including data format (tag and city examples in Arabic), defaults, and the cursor semantics for pagination. This is far beyond what the raw schema 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 opens with a specific verb and resource: 'Fetch the post feed for a tag,' and clarifies scope as 'homepage + category pages.' This is precise and distinct from sibling tools like get_post_details or search, even without naming 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 description clearly says the tool fetches a tag feed and gives required/optional parameter guidance, including Arabic examples and defaults. It doesn't explicitly name alternatives or exclusions, but an agent can determine when to use it from the stated purpose and parameter instructions.

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 full burden of behavioral disclosure. It does reveal that the tool can follow or unfollow and that it returns the new state, but it fails to explain what determines whether the action is a follow or an unfollow, whether the operation is idempotent, or what permissions are required.

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 very short and front-loaded with the main action. The only minor redundancy is 'Required: username,' which duplicates the schema's required field, but overall there is little wasted 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 one-parameter mutation tool with no annotations and no output schema, the description does not fully explain the tool's behavior. The ambiguous 'or unfollow' behavior and the lack of any indication of prerequisites, errors, or return semantics beyond the state value leave notable gaps for an agent deciding to invoke 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 0%, so the description should compensate, but it only repeats that username is required, which the schema already states. It adds no detail about username format, whether it is a handle or ID, case sensitivity, or how it relates to the user resource.

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 a specific action ('Follow (or unfollow)') on a specific resource ('a user') and adds that it returns the new is_following state. It is distinct from the sibling is_following_user, though it does not explicitly name that alternative. The 'or unfollow' wording introduces some ambiguity about when each behavior occurs, but the core purpose is understandable.

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 no guidance on when to use this tool versus alternatives, such as is_following_user for checking follow state. It only restates that username is required. An agent would have to infer usage context from the tool name and 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?

With no annotations provided, the description carries the full behavioral disclosure burden. It communicates a read-only fetch operation, explains the full response structure (post plus three related groups), and clarifies that the 'full' parameter controls the detail level of similarPosts. It does not discuss auth, rate limits, or error behavior, but it is reasonably transparent for a 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?

The description is compact: two sentences front-loaded with the action, then the essential API context and parameter notes. Every sentence earns its place, with no filler or repetition of the schema.

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 helpfully enumerates the return groups, which is essential for an agent to use the result. It also provides the important API context that this is the canonical fetch-by-id replacement. It could be more complete about related-tool routing or pagination details, but it is sufficient for a 2-parameter read 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 0%, so the description must compensate, and it does. It clearly identifies post_id as required and explains the meaning of 'full' as controlling the similarPosts response size. The schema already supplies the types, so the description adds the behavioral meaning needed for correct invocation.

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

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

The description opens with a specific verb and resource: 'Fetch a post + 3 related groups,' and it enumerates the exact related-group categories. It also distinguishes itself as 'the canonical fetch by id' and explicitly notes there is no direct getById operation, which separates it from search 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?

The description gives clear usage context by framing this as the canonical fetch-by-id tool and noting the absence of a direct getById in the GraphQL API. It states the required input, post_id, but does not explicitly name sibling tools that should be used for alternate purposes such as search or comments.

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?

There are no annotations, so the description carries the full burden. It does disclose the core behavior: it is a read-style predicate returning true/false based on the authenticated user's follow status. It does not explicitly state that it is read-only, mention auth failure behavior, or describe edge cases, but for such a simple check the essential behavior is conveyed.

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 with no filler. It is front-loaded and every word contributes to the meaning. The level of detail is appropriate for a simple boolean-check 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?

Despite the tool's low complexity, the description is incomplete because the `city` parameter is undocumented, there is no output schema to rely on, and no behavior is described beyond the boolean result. The description does not fully prepare an agent to handle all valid inputs or know what context affects the answer.

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 clarify parameters. It only gives meaning to `tag`; the optional `city` parameter is not mentioned or explained at all. An agent cannot tell whether `city` affects the follow check, filters results, or is irrelevant, which is a significant gap.

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

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

The description clearly states the tool returns a boolean indicating whether the authenticated user follows a specific `tag`. It names the exact resource being checked (tag) and therefore differentiates itself from the sibling `is_following_user` without needing to open 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?

The intended use is implied: call this tool when you need to know whether the authenticated user follows a tag. However, the description provides no explicit guidance about when not to use it or how it compares to alternatives like `is_following_user`, `follow_user`, or `related_tags`.

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 disclosure burden. It conveys a boolean read-style check and references the authenticated user, but it does not specify behavior for unauthenticated calls, invalid usernames, or errors.

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 concise sentence that defines the exact return condition. No filler, no unnecessary detail.

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 boolean check with no output schema, the description states the subject, the target, and the returned result. Nothing critical is missing 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?

The schema only documents username as a string with no description, so the description's use of `username` does not add much meaning. Still, the single parameter is self-explanatory and the description clarifies its role as the follow target, which provides modest 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?

The description names a precise predicate: whether the authenticated user follows the given username. This clearly distinguishes it from the sibling is_following_tag (tag follows) and follow_user (writes a follow relationship).

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

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

The description implies the check is for a user follow relationship and is read-only, which hints at when to use it. However, it does not explicitly state when not to use it or mention alternatives such as is_following_tag or follow_user.

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 present, so the description carries the behavioral burden. It discloses the endpoint style ('Non-GraphQL REST endpoint'), the exact return shape, and a server-enforced cap on limit. It does not discuss auth, rate limits, or pagination, but for a simple read-style list those are minor 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?

Three short sentences deliver resource, endpoint type, return shape, and parameter behavior with no filler. The most identifying information is front-loaded.

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?

This is a low-complexity, single-optional-parameter tool with no output schema, so the description's inclusion of the full response array and limit behavior is nearly complete. Missing auth/pagination details are minor for a simple live-stream listing endpoint.

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 explain the only parameter. It does: 'limit (default 40; the server caps it)' adds both the default and a behavioral caveat beyond the schema. It could be more explicit that limit means the maximum number of returned streams.

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 ('live shopping streams') and the selection criterion ('currently-open'), and lists the returned fields. It is distinguishable from the sibling feed/search tools by its unique subject, though it does not explicitly contrast itself with any 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?

There is no explicit 'when to use' or alternative routing, but the phrase 'currently-open' implies this is for fetching open live streams rather than historical or search results. It does not name alternatives or exclusions, so guidance is only 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?

With no annotations, the description bears the full transparency burden. It communicates the core behavior: given a post_id, it returns an offer object with eligibility and price fields, implying a read-only lookup. However, it does not mention auth requirements, error behavior, or any side effects, leaving those traits undisclosed.

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 filler: the first front-loads the return payload and purpose, the second states the required input. It is appropriately concise for a one-parameter 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?

For a simple one-parameter lookup, the description plus schema is enough to invoke it: pass post_id and expect an offer object. Gaps remain in usage guidance and behavioral details (auth/errors), so it is adequate but not comprehensive.

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 should compensate for the undocumented post_id parameter. It only repeats that post_id is required—already in the schema—and adds no format, source, or meaning beyond 'a post's.' This is minimal compensation.

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 identifies a concrete resource (a post's Locker shipping option) and specifies the returned fields (offerId, isEligible, price), which distinguishes it from siblings such as get_post_details. It lacks an explicit verb like 'get' or 'retrieve', but the output-shape notation makes the retrieval purpose clear.

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

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

The phrase 'for a post's Locker shipping option' implies the tool should be used when an agent needs Locker shipping offer data for a given post. It does not explicitly contrast with sibling tools or state when not to use it, so the guidance is only 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?

With no annotations, the description carries the full burden of disclosing behavior. It does reveal that the set_read parameter marks notifications as read on the server, but it omits the tool's default behavior, whether it is otherwise read-only, any side effects, and what the caller should expect in return.

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 text is short and front-loads the resource, but it is written as sentence fragments and lacks a clear main clause. It is concise but structurally under-specified, and the 'bell icon' detail is marginal.

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

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

Given no output schema, no annotations, and a low-complexity single-parameter tool, the description should at least state the core operation and expected outcome. It identifies the domain and explains one parameter, but it fails to say what the tool actually returns or why an agent should call it, making it insufficient for confident invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It does add meaning to set_read by explaining that it marks notifications as read on the server, which goes beyond the raw boolean type and title. However, it does not explicitly state the behavior when set_read is true versus false, leaving some ambiguity.

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 identifies the resource as 'User notifications (the bell icon)' and hints at server-side read marking, but it never states the actual verb — it does not say the tool retrieves, lists, or fetches notifications. This makes the core purpose vague and leaves it undistinguished from siblings like fetch_feed.

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?

There is no guidance about when to use this tool versus alternatives. The description only explains a parameter's effect and never mentions contexts, exclusions, or sibling tools that might be more 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It does not state whether the operation is read-only, whether results are paginated beyond the existence of a page parameter, what order results are returned in, or whether authorization is required. The description identifies the resource but not the behavior surrounding it.

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

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

The description is short and front-loaded with the domain context, followed by the parameter note. There is no filler or redundant phrasing. It is concise enough to scan quickly, though additional behavioral context would have made it more 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?

For a simple list-style tool with one optional parameter, the description is minimally adequate: it identifies the resource and mentions pagination. However, with no output schema and no annotations, it does not explain the return shape, auth requirements, or pagination semantics such as page size or zero-indexing.

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 should compensate for the schema's lack of explanation. However, saying 'Optional: page (default 0)' merely restates what the schema already shows via default: 0 and the absence of required fields. It does not explain what page represents, how pagination works, or what values are valid.

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: escrow ('Buy with confidence') buy requests that the user has placed. The word 'outgoing' in the tool name and 'the user has placed' in the description make the scoping evident, though no explicit verb like 'list' or 'retrieve' is used. It does not explicitly differentiate from siblings, but the domain-specific resource is distinct enough.

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?

There is no guidance on when to use this tool versus alternatives like search, user, or sellers_list. It also omits prerequisites such as authentication, which would be relevant especially since check_auth is a sibling. The only usage hint is the optional page parameter.

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 disclosing side effects, permissions, or return behavior. It discloses none of these; it only names input fields and a required parameter. The mention of fields absent from the schema adds confusion rather than behavioral clarity.

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 text is brief, but brevity is not conciseness when it omits essential information. The structure front-loads parameter-like fragments and a fragment 'for a post,' which is confusing rather than efficient.

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 has one parameter, no annotations, no output schema, and no behavioral explanation. The description provides almost no context about the operation, its effects, or its inputs, making it impossible for an agent to invoke it correctly with confidence.

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%, and the description fails to clarify the meaning of post_id beyond the schema's own title. Worse, it references contactText, contactMobile, and shouldEnableWhatsApp, which do not exist in the input schema, actively misleading an agent about the parameters it can pass.

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 lists fields ({contactText, contactMobile, shouldEnableWhatsApp}) and says 'for a post,' but never states an explicit action verb like 'create' or 'update.' It reads more like a fragment than a purpose statement, leaving the tool's actual behavior ambiguous.

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?

There is no guidance on when to use this tool versus any alternative. The only hint is 'Required: post_id,' which is input syntax, not usage context. No sibling tools or exclusions are referenced.

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 disclose behavior, but it only lists output field names. It does not state whether the tool reads data, requires authentication, has side effects, or what 'is_following' actually refers to (e.g., following the post author). No rate limits, error behavior, or safety profile is mentioned.

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 very brief, but the second sentence is redundant with the schema. The only substantive content is the output-field list at the start; the rest adds no new information and is arguably 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 one-parameter tool, this is minimal but insufficient. It lacks an explicit verb, clarification of ambiguous output fields, and any authentication or edge-case context. An agent could guess it is a read-only like/follow check, but the description does not confirm this.

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

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

The schema has 0% description coverage, so the description must compensate. It does not: 'Required: post_id' duplicates the schema's required array and does not explain the meaning of post_id, valid values, or how it filters the result.

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 tool returns three named fields ('is_like, total, is_following') for a post, making it clear this is a post-status query. It is distinct from sibling tools like is_following_user or is_following_tag because it targets a post's like/follow state, though this is not made 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?

The description provides no guidance on when to use this tool over alternatives. The only additional note, 'Required: post_id,' merely repeats schema information and does not explain context, prerequisites, or exclusions.

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

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

With no annotations, the description carries the behavioral burden. It discloses the return shape ('Returns {count, posts}') and implies a read-only operation via 'Fetch,' but it does not explain what the 'full' parameter changes, pagination behavior, or any authorization requirements.

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 efficient sentence with three front-loaded clauses: action, required/optional parameters, and return shape. There is no filler or redundant wording.

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 leaves a meaningful gap: the 'full' parameter is never explained, which could affect how an agent invokes the tool. There is also no mention of what 'city' filters or how results are ordered.

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

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

Schema description coverage is 0%, so the description must compensate. It identifies tag as required and city as optional, but it restates what the schema already encodes via required/default. It omits the 'full' boolean entirely and does not clarify the semantic role of 'city' or 'full' beyond their names.

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

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

The description uses a specific verb ('Fetch') and a specific resource ('promoted-post carousel for a tag'), which clearly distinguishes this from sibling tools like fetch_feed or search. It also states the required scope parameter, leaving no ambiguity about what the tool returns.

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

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

There is no guidance about when to use this tool instead of alternatives such as fetch_feed, related_tags, or search. The description only mentions required/optional parameters, which is operational detail, not usage 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?

No annotations are provided, so the description bears the full burden. It transparently describes the return shape ([{tag, count, city}]) and the required/optional inputs, but it does not mention whether the operation is read-only, how counts are computed, ordering, pagination, or edge cases. Core behavior is clear, but some behavioral context is missing.

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 well-structured: it leads with the purpose, then states required vs optional parameters, then gives the return shape. Every sentence earns its place with no unnecessary 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 lookup tool, the description covers the purpose, required and optional inputs, and the output shape. Since there is no output schema, including the return format is valuable. Missing minor details like auth or edge cases are not critical for this tool's straightforward nature.

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

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

Schema description coverage is 0%, so the description must compensate. It does by stating that 'tag' is required, 'city' is optional, and by showing the return fields {tag, count, city}. This adds meaningful semantic context beyond the raw schema type declarations.

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

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

The description clearly states the verb and resource: 'Cities-with-counts for a given tag' and explains its UI purpose, 'powers the city-filter chips on tag pages.' This differentiates it well from sibling tools like search or fetch_feed since it is specifically about tag-to-city counts.

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

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

The description gives a clear context for when to call it: when needing city-filter chip data for a tag page. It does not explicitly mention alternatives or when not to use it, but the specific use case is strong enough for an agent to select it correctly.

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 behavioral burden. It discloses the return shape as {keyword, count, has_next_page, view_options, posts}, explains that full defaults to false meaning compact, and lists important defaults like only_with_image true and only_with_video false. This provides a useful behavioral picture beyond a vague one-liner.

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

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

The description is a single dense sentence that front-loads the action and required keyword, then provides a compact enumeration of optional parameters and the return shape. Every element carries information and there is no wasted 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?

The tool is complex: 14 parameters, no output schema, and no annotations. The description covers the required keyword, key defaults, date and near formats, and return fields, which is a solid foundation. Yet it omits the semantic distinctions between several similar parameters (city/cities, tag/tags) and does not explain what the compact vs full result shapes actually contain, leaving important context unresolved.

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

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

With 0% schema description coverage, the description must compensate for the 14 parameters. It adds meaningful detail for during_date via allowed literal values, near via a format example, full via compact/ful distinction, and cities/tags as lists. However, semantics for city vs cities, tag vs tags, order_by_post_id, and hide_show_rooms are left to inference from parameter names.

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

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

Description states a specific action and resource: 'Search haraj by keyword.' It is clear that this is keyword-based search on the Haraj platform, and it identifies the one required parameter. It does not explicitly contrast with siblings like search_suggest or trending_keywords, so it earns 4 rather than 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 gives required and optional parameters, but does not explain when to use this tool versus alternatives such as search_suggest, fetch_feed, or trending_keywords. No explicit exclusions or decision rules are provided.

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

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

With no annotations, the description carries the behavioral disclosure burden. It states that the tool returns the top 10 suggestions, is prefix-based, and is intended for a live search box, which conveys read-only, response-shaping behavior. It does not explain tag filtering effects or rate-limit/auth behavior, but those are secondary for a simple suggestion endpoint.

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-load the core behavior and follow with parameter requirements. There is no filler 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 two-parameter tool with no output schema, the description covers the main purpose, the prefix semantics, the result count, and required vs optional inputs. The only meaningful gap is the meaning of the optional 'tag' parameter, so it 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 0%, so the description must compensate. It meaningfully clarifies 'prefix' (a typed prefix with a concrete example) and marks 'tag' as optional, but it never explains what 'tag' does or how it affects suggestions, leaving one of two parameters under-specified.

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: it 'returns the top 10 suggestions for a typed prefix' and labels itself as live search-box autocomplete. This clearly separates it from a full search tool like the sibling 'search' or 'user_mention_suggestions'.

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 'live search-box autocomplete' gives a clear context for when to call it, and the required/optional parameter note guides invocation. It does not explicitly name alternatives or exclusions, so it stops short of a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose a genuinely important constraint: tags must be Arabic tag names, which will change call behavior. However, it says nothing about pagination behavior, response shape, or whether the result set is exhaustive or page-limited, leaving the agent to guess at the operational contract.

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

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

Two sentences with no filler. The core purpose is front-loaded ('Sellers for a tag'), followed by the use-case context and the one essential constraint. Slight redundancy in the 'Required:' phrasing, but it reads naturally and 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 low-complexity tool (2 params, no output schema, no annotations), the description covers purpose, vertical context, and the key input constraint — enough for a basic call. What is missing is any mention of pagination semantics or what the response contains, which leaves a modest but real gap for an agent deciding whether this tool answers its query.

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

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

Schema description coverage is 0%, so the description must compensate. It adds the critical Arabic-language constraint for the required 'tags' parameter, which is non-inferable from the schema alone. However, it says nothing about the 'page' parameter (integer with default 0), and the 'Required:' phrasing duplicates structured schema information rather than adding meaning.

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 conveys the resource (sellers) and the filter dimension (tag) in a concise phrase, and the parenthetical 'used by real-estate / business / investment pages' adds scope context. It lacks an explicit verb like 'List' or 'Fetch', so the operation is implied rather than stated, but the resource-and-key pairing is specific enough to distinguish it from sibling tools like related_tags (which operates on tags themselves) and user (which is a single-user lookup).

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 'used by real-estate / business / investment pages' phrase provides an implicit usage signal: this tool is for seller discovery within those verticals. However, there is no explicit 'use when...' guidance and no mention of alternatives such as search or related_tags, so an agent must infer when this is the right tool rather than being told.

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 return shape and the parameter default, but does not explicitly state read-only behavior, ordering, limits, or authentication requirements. For a simple query tool, this is adequate but minimal.

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 extremely concise, using three short sentences to convey the core purpose, the parameter, and the return format. There is no redundancy or filler.

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

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

For a tool with one optional parameter and no output schema, the description covers the essential aspects: what it returns, the parameter meaning, the default, and the output element shape. It omits specifics like result count or sort order, but those are not critical for a simple trending endpoint.

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

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

The schema provides only the type and default for range_in_days. The description adds meaningful semantic context by explaining it as the number of days over which the trend is computed and repeating the default, compensating for the 0% schema description 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 resource (top trending search terms) and the output format ({keyword, score}). It distinguishes from siblings like search and search_suggest by the word 'trending', though it opens with a noun phrase rather than an explicit verb.

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: use this tool to retrieve trending search terms over a configurable number of days. It does not explicitly name alternatives or exclusions, but the sibling list contains obviously different search-related tools, so an agent can infer when this one applies.

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 full burden. It discloses useful behaviors: rating_summary_only defaults to false and returns only the rating block, and URL-encoded Arabic usernames work. However, it does not mention auth requirements, failure cases, rate limits, or whether the operation is read-only, leaving gaps for a no-annotation 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 tight sentences with no filler. The main purpose is front-loaded, and the extra details about encoding and rating_summary_only are directly relevant to invoking the tool correctly.

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 has three optional parameters, no output schema, and no annotations. The description covers the two identification methods and the rating_summary_only flag, but it lacks usage context, error/auth information, and return-structure details beyond the field names. It is adequate for a simple profile fetch but not 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 description coverage is 0%, so the description must compensate. It explains that either username or user_id can be used, gives an encoding hint for Arabic usernames, and clarifies the default and effect of rating_summary_only. This adds meaning beyond the raw schema, though it does not specify behavior when both identifiers are supplied or the exact expected format.

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 full user profile containing rating, followers, location history, and badges. Though it lacks an explicit verb like 'get' or 'retrieve', the intent is unambiguous and it is distinct from sibling tools such as follow_user or is_following_user.

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

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

The description provides no guidance on when to choose this tool over alternatives. It explains how to pass identifiers but does not state the context, prerequisites, or when to prefer a sibling tool like user_mention_suggestions or follow_user.

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?

There are no annotations, so the description carries the full burden. It reveals that the tool returns a recent list of candidates and gives the exact item shape, but it does not mention authentication requirements, result limits, ordering, or any side-effect profile. The 'Returns' wording implies a read-only operation, but that is not stated explicitly.

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 focused sentence that communicates purpose, context, and return format with no filler. Every piece of information contributes to invoking the tool correctly.

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 a simple output shape, the description is largely sufficient: it states the purpose, the usage context, and the return structure. Minor gaps remain around the meaning of 'recent', maximum result count, and authentication expectations, but none are critical for basic invocation.

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

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

The input schema has zero parameters and 100% schema description coverage, so there are no parameter semantics left undocumented. The description adds no parameter details, but none are needed; this is the baseline for a zero-parameter tool.

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 ('@-mention candidates') and a specific use context ('comment / DM composer'), and it states the return shape. This makes it clearly distinguishable from siblings like search_suggest or related_tags.

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

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

The description explicitly says when to use the tool: when obtaining recent @-mention candidates for the comment or DM composer. It does not list exclusions or alternatives, but the context is clear enough for an agent to select it appropriately.

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