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 — and it discloses nothing. It does not say whether this is a read or write, whether the token is an auth credential, what rate limits apply, 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 text is short, but this is under-specification rather than conciseness; the single fragment conveys no actionable information and is not front-loaded around any real 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?

For a three-parameter tool with no annotations, no output schema, and zero schema coverage, the description is completely inadequate. An agent cannot determine what the tool does, when to call it, or what its parameters mean.

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?

All three parameters (lat, long, token) have 0% schema description coverage and are completely unexplained in the description. The sole hints, "area" and "point", do not clarify the lat/long string formats or the role of token.

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?

"Marketing area for point" is a vague noun phrase with no verb and no stated action; it gestures at geography (area, point) but does not say what the tool does. It fails to distinguish food_area from siblings like food_reverse, geo, or food_place, which an agent could easily confuse it with.

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 when-to-use guidance, no conditions, and no mention of any alternative tool. The description gives an agent nothing to decide between food_area and the many other food_* and geo 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, and it is nearly empty. The "(dry-run)" parenthetical hints at a simulation behavior — a trait the agent would badly need to know — but it is unexplained and contradicts the "Create" verb, leaving mutation semantics, auth requirements (token), and effect of confirm entirely opaque.

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 brief, but this is under-specification rather than conciseness — the single phrase leaves essential information unstated. It is front-loaded but nearly content-free.

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 four undocumented parameters including an apparent token/authentication parameter and a dry-run toggle, the description is far too thin for an agent to invoke this tool correctly or 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 0% across four parameters (token, confirm, body-file, body-json), and the description adds nothing about any of them. In particular, the relationship between body-file and body-json, and what confirm actually triggers, are completely undocumented in both the schema and the description.

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

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

The description names a verb and resource ("Create basket"), but the parenthetical "(dry-run)" is ambiguous: it is unclear whether the tool only simulates creation or merely supports a dry-run mode. Without word order or clarification, an agent cannot confidently tell what this tool actually does, and nothing distinguishes it from siblings like food_basket_update or food_basket_delete.

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, when to prefer food_basket_update/delete, or what preconditions/authentication are required. The only hint is the ambiguous "dry-run" tag, which does not tell the agent under what circumstances it should be invoked.

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 and does not meet it. It does not state whether the deletion is reversible, whether it is actually a simulation, whether the confirm parameter gates real destruction, or what token auth is required. The "(dry-run)" hint gestures at safety but is too ambiguous to rely on.

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

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

Extremely short and front-loaded, but the brevity here is under-specification rather than earned conciseness. The single parenthetical is doing ambiguous work rather than clarifying.

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?

A three-parameter mutation tool with no annotations, no schema descriptions, no output schema, and a four-word description leaves the agent with far too little to invoke it safely or correctly. Nothing about auth, confirmation flow, or failure modes is conveyed.

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% across three parameters (token, confirm, basket_id), so the description must compensate and largely does not — it never names any parameter. The "(dry-run)" mention weakly gestures at confirm semantics but adds no usable meaning for token or basket_id.

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

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

The description names a verb and resource ("Delete basket"), which is enough to distinguish it from food_basket_create and food_basket_update. However, the parenthetical "(dry-run)" muddies the purpose — an agent cannot tell whether this tool always simulates, or whether it deletes and dry-run is a mode. Purpose is identifiable but not precise.

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?

No guidance on when to use this versus food_basket_update or food_basket_create, and no explanation of the relationship between the dry-run behavior and the confirm parameter. Usage is only implied by the tool name, which is the minimum possible signal.

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 behavioral burden. '(dry-run)' is the only behavioral clue, but it does not explain whether the tool writes anything, what side effects occur, what permissions are needed, 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?

Extremely short but in a way that under-specifies rather than efficiently front-loads. Two words and a parenthetical provide almost no useful information for an agent.

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 5 parameters, no annotations, no output schema, and zero schema description coverage, the description is completely inadequate. It leaves the agent without any of the context needed to invoke 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?

Schema description coverage is 0% across 5 parameters (token, confirm, basket_id, body-file, body-json), and the description adds no information about any of them. There is no meaning beyond the parameter names themselves.

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 'update' and resource 'basket', but the parenthetical '(dry-run)' is ambiguous and does not clarify what a basket update entails or how it differs from the sibling tools food_basket_create and food_basket_delete. The core purpose is vague beyond the name.

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?

No explicit when-to-use guidance, no alternatives named, and no prerequisites mentioned. The '(dry-run)' hint implies a preview mode but does not say when an agent should prefer this over a real update or create/delete operations.

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. 'List' weakly implies a read-only, non-destructive operation, but nothing is said about authentication requirements, rate limits, pagination, or whether results are cached or region-scoped.

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 words are technically brief and front-loaded, but this is under-specification rather than conciseness. The single sentence leaves every substantive question about the tool unanswered.

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 an undocumented parameter, no annotations, and no output schema, the description supplies almost nothing. It should at minimum explain what 'covered cities' means and what the token parameter does.

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

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

There is one parameter (token) at 0% schema description coverage, and the description never mentions it or any other input. With the schema silent and the description silent, the caller has no idea what the parameter is for.

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 verb ('List') and a resource ('covered cities'), so the basic operation is inferable. However, 'covered' is undefined, and the description does nothing to separate this from siblings like geo, food_area, or food_place, so an agent cannot tell whether this lists service-coverage zones or geographic city data.

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 when-to-use, when-not-to-use, or alternative-tool guidance at all. The reader must infer from the name alone that this is the entry point for city coverage, and nothing indicates whether it should be called before food_area or instead of geo.

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 whole burden, and it discloses only that authentication is required. It says nothing about what is returned, whether the call is read-only, error behavior, or rate limits, so an agent is left guessing on most behavioral traits.

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 but that brevity is under-specification rather than economy: one parenthetical fragment cannot front-load the information an agent needs. It is not padded, but it earns little.

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, one undocumented parameter, and no explanation of how an order is identified, the description is far too thin for a retrieval tool. An agent cannot confidently construct the call from this definition.

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 token parameter has 0% schema description coverage. "needs login" hints that token is an auth credential, which is a partial clarification, but there is still no explanation of how the target order is referenced or whether token is required (the schema marks it optional).

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?

"Order detail" is a bare noun phrase that largely restates the tool name and does not specify whether it returns one order or a list, or how the order is identified. It only vaguely distinguishes itself from the many food_* siblings such as food_order_new or food_menu.

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?

"needs login" states a prerequisite but gives no when-to-use or when-not-to-use guidance, and never points to an alternative sibling. Nothing tells the agent when this is the right call versus food_order_new or food_basket_*.

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 does not disclose whether the operation invalidates the old token, whether the 'token' field must be supplied or is derived from session state, what happens on failure, or what credentials are needed — all critical for an auth-token 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?

At three words it is certainly concise and front-loaded, but the brevity here borders on under-specification rather than disciplined economy — nothing beyond the resource name is communicated.

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

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

No output schema, no annotations, and an undocumented optional parameter leave the agent guessing about the token lifecycle and return behavior. For a credential-refresh operation on a shared auth family, this is materially 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 description coverage is 0% for the single 'token' parameter, and the description does not compensate: it never clarifies whether 'token' is the current token to refresh, a refresh token, or an optional override. Notably the schema marks it optional (0 required), which the description does not explain.

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 ('Refresh') and a specific resource ('food token'), so an agent knows this rotates/refreshes an authentication token rather than sending or verifying one like the sibling food_login_send/food_login_verify. It does not explicitly differentiate itself from those siblings, keeping it at a 4 rather than 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?

There is no statement of when to call this versus food_login_send or food_login_verify, and no prerequisites such as an expired or existing token being required. Usage is only inferable from the 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?

With no annotations, the description carries the full disclosure burden. It does flag a genuinely important side effect — that a real SMS is sent — which is meaningful behavioral context beyond the schema. However, it omits rate limits, permission/auth needs, whether the OTP expires, and what the next step is.

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

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

A single front-loaded sentence with zero padding; the parenthetical adds the one substantive fact. It is short rather than bloated, though the terseness leaves room that could have been used for parameter clarity.

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, zero-annotation, no-output-schema tool with 0% schema coverage, the description is far too thin. It does not explain which parameters are needed, what the call returns, or how to proceed afterward.

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% across three parameters (via, phone, token), and the description adds no meaning for any of them — notably not the distinction between 'via' and 'phone', nor what 'token' represents. The mention of OTP only weakly implies where the phone number goes.

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: sends a food-login OTP. The 'food_login_' prefix and the sibling food_login_verify make the role in the login flow reasonably inferable, though the description itself never names the verify/refresh counterparts.

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?

No explicit when-to-use guidance. The agent must infer this is the first step of a login flow before food_login_verify, and there is no statement about prerequisites, sequencing, or when to prefer ride_login_send's analogue.

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, and it discloses nothing. It does not say what happens on an invalid code, whether the token is single-use, whether the session is established afterward, or what permissions or rate limits apply.

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 fragment is short and front-loaded, but it is under-specified rather than concise: three words carry no operational content. Length is not the problem; absence of information is.

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?

A four-parameter authentication tool with no annotations, no output schema, and no required-parameter markings is left almost entirely unexplained. An agent cannot determine what to pass for via or token, or what a successful verification returns.

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?

Four parameters (via, code, phone, token) have 0% schema description coverage, so the description is the only place meaning could be added — and it adds none. In particular the relationship between code and token, and the meaning of via, are completely undocumented.

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?

"Verify food OTP" names a verb (Verify) and a resource (food OTP), so the intent is discernible, but it is essentially a restatement of the tool name food_login_verify with no scope detail. It gives no explicit differentiation from sibling food_login_send, leaving the verify-vs-send relationship to inference.

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 when-to-use guidance, no prerequisites, and no named alternative. The existence of food_login_send weakly implies this is the second step of a login flow, but nothing in the description states that ordering or when this tool should be preferred.

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 of behavioral disclosure, and it discloses nothing: not whether this is a read or write, not auth requirements (a token parameter is present), not rate limits, not return format.

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 words are not concise but under-specified; there is nothing to front-load and no useful information is conveyed.

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?

A four-parameter tool with no annotations, no output schema, and no parameter documentation is completely inadequately described. Nothing an agent needs in order to invoke it correctly 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?

Four parameters (lat, code, long, token) with 0% schema description coverage, and the description adds no meaning for any of them. The likely meaning of lat/long/code/token must be entirely guessed.

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?

"Vendor menu" is a bare noun phrase that restates the tool name (food_menu) rather than stating an action. It hints at the resource (a vendor's menu) but gives no verb, scope, or way to distinguish it from siblings like food_vendors, food_vendor, or food_detail.

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, no prerequisites, and no mention of any alternative among the many sibling tools. An agent has nothing to route on.

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. '(dry-run)' weakly hints that nothing is committed, but it directly conflicts in tone with 'PLACE ORDER' and the description never clarifies whether a real order can result, what the token/confirm flags gate, or whether the call is reversible.

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 short, but shortness here is under-specification rather than conciseness. A two-word all-caps fragment plus a parenthetical gives no structure or front-loaded detail an agent can act on.

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?

A five-parameter tool with no annotations, no output schema and no schema descriptions is left almost entirely undocumented. An agent cannot determine required inputs, auth flow, or return behavior from this definition.

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?

Five parameters at 0% schema description coverage and the description explains none of them. token, confirm, provider, body-file and body-json all remain opaque, including the apparent file-vs-json input duality.

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 fragment names a verb (PLACE) and an implied resource (order), so an agent can guess the domain. However, the '(dry-run)' qualifier makes the actual effect ambiguous: it is unclear whether this previews an order or places one. It also does nothing to distinguish itself from the many food_* siblings such as food_basket_create.

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, when not to, or which sibling to prefer. With ~15 food_* siblings covering baskets, vendors, menus and reviews, routing is entirely left to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only signals that authentication is required. It does not disclose read-only vs mutating nature, return shape, pagination, or what happens with an invalid/expired token.

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 admirably short and front-loads the resource, but it is a fragment rather than a structured sentence; the brevity here reflects under-specification rather than disciplined concision.

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 an undocumented auth parameter, no annotations, and no output schema, the description does not supply enough for an agent to call it confidently or interpret the result. The login note is the only useful context provided.

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 'token' parameter has 0% schema description coverage, so the schema explains nothing. The description's '(needs login)' weakly implies the token is an auth credential, but offers no format, source (food_login_verify?), or expiry semantics.

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 phrase 'Pending food orders' identifies the resource but supplies no verb (list? fetch? confirm?) and does not distinguish itself from siblings like food_order_new or food_basket_create. An agent can guess it retrieves pending orders, but the operation type is inferred rather than stated.

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

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

The only guidance is '(needs login)', which is a prerequisite rather than a when-to-use rule. Nothing tells the agent how this differs from food_order_new, food_basket_create, or food_detail, so selection among siblings is left entirely to inference.

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

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

No annotations are provided, so the description carries the full burden, and it discloses nothing: no read vs. write nature, no auth requirements (a 'token' parameter exists but is unexplained), no rate limits, no error behavior.

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

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

It is concise, but only because it is drastically under-specified. Brevity here reflects missing information rather than efficient front-loading.

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, zero-coverage, no-annotation, no-output-schema tool in a crowded food/ride toolset, the description is completely inadequate. Nothing an agent needs to invoke it correctly 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 0% and there are 4 parameters (lat, long, place, token), all undocumented in both schema and description. The description adds zero parameter meaning; the agent cannot infer whether lat/long are inputs or outputs, or what 'token' is.

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 'Address search' is essentially a restatement of a name fragment and does not say what the tool does with the address (geocode, validate, lookup, store). With siblings like food_reverse and food_area, an agent cannot distinguish this tool's purpose. This is a tautology-level failure.

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 when-to-use guidance, no alternatives named, and no conditions specified. Among ~50 siblings, the agent is given no routing information at 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 behavioral burden, and it only discloses a login requirement. It omits whether this is a read or write operation, what data is returned, and what the token represents or how to obtain 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 but under-specified rather than concise; there is no front-loaded statement of what the tool does. Brevity here reflects missing content, not efficient editing.

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 requiring an undocumented auth token with no output schema to explain the return, the description leaves nearly everything unresolved. The login hint is the only completeness signal, and it is not actionable on its own.

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 parameter "token" has 0% schema description coverage, and the description compensates with nothing beyond the vague "needs login" hint. An agent cannot tell from either source how the token should be sourced or formatted.

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?

"Food profile" merely restates the tool name without a verb or resource detail; it never says whether it fetches or edits the profile. The parenthetical "(needs login)" adds a prerequisite but no purpose specificity, and it does nothing to distinguish it from food_detail or food_vendors.

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 when-to-use guidance and no named alternative, even though siblings like food_detail and the food_login_* family are plausible substitutes or prerequisites. "Needs login" hints at a precondition but does not tell the agent when to pick this tool over others.

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. 'Reverse geocode' says nothing about auth requirements (the token param suggests auth), rate limits, cost, accuracy, or response shape. Two words cannot cover a network call with a token.

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 short, but it is under-specification rather than conciseness – two words that leave everything else unstated. Brevity here is a liability, not a virtue.

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 three undocumented parameters, no annotations, and no output schema, a two-word description is completely inadequate. The agent cannot determine required auth, coordinate format, or return content.

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% and the description adds nothing: lat, long, and token are undocumented in both schema and description. The description must compensate for this gap and does not.

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

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

States the operation 'reverse geocode', which is a specific verb+resource, but provides no detail about what service (food) it belongs to or what it returns. Against siblings like geo and food_area, an agent can only weakly infer this converts coordinates to a place.

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?

No when-to-use, when-not, or alternative guidance. The agent has no way to know this belongs to food delivery context vs ride context, or when to prefer geo over food_reverse.

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 discloses nothing: no read/write nature, no auth requirements (a token parameter is present but unexplained), no pagination or rate-limit behavior.

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

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

Two words is not conciseness but under-specification; there is no front-loaded verb or scope to anchor the agent.

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?

A four-parameter tool with no annotations, no output schema, and no parameter documentation leaves the agent with essentially nothing to call it correctly.

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

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

Four parameters (lat, code, long, token) at 0% schema description coverage, and the description supplies no meaning for any of them — not even which identifier code is or that token is an auth credential.

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?

"Vendor reviews" restates the tool name rather than stating an action. It never says whether this lists, fetches, or aggregates reviews, and it is indistinguishable from the sibling food_review_submit 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?

No indication of when to use this tool versus food_reviews' siblings such as food_review_submit, food_vendor, or food_detail. The agent is given no selection criteria at 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?

No annotations are provided, so the description carries the full disclosure burden and delivers almost nothing. It does not say whether the review is actually persisted, what token/authentication is required, whether submission is reversible or editable, or how the dry-run mode differs from a real submission.

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 short phrase, so there is no bloat, but brevity here comes from under-specification rather than efficiency. The one qualifier it does include, '(dry-run)', raises more questions than it answers.

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 five-parameter mutation tool with no annotations, no output schema, and zero field documentation, this description is far short of what an agent needs to invoke it correctly. Nothing about side effects, idempotency, or required inputs is covered.

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

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

Schema description coverage is 0% and the description explains none of the five parameters. Critical semantics are missing, notably what 'confirm' does (likely gating the actual post vs. dry-run), what 'token' authenticates, and whether 'order-id' must reference a completed order.

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 verb ('Post') and a resource ('order review'), which is enough to distinguish it from read-oriented siblings like food_reviews. However, the parenthetical '(dry-run)' makes the actual outcome ambiguous: it is unclear whether the call submits a real review or merely simulates one. That ambiguity undermines a would-be clear purpose.

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 statement of when to use this tool, what prerequisites exist (e.g., having a completed order), or how it relates to siblings such as food_reviews. The agent must infer everything from the name alone.

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 at all, the description carries the full behavioral burden and fails it. Beyond the parenthetical 'needs login' (vaguely implying authentication), it discloses nothing about side effects, output, or constraints for a tool with an ambiguous name.

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 single fragment is short but under-specified rather than concise; it front-loads an ambiguous noun phrase with no verb, so it does not communicate the action.

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

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

For a 2-param, no-annotation, no-output-schema tool, the description provides almost nothing: no parameter meaning, no behavior, no usage context. An agent cannot reliably invoke this from the definition alone.

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

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

Schema description coverage is 0% and the two params 'code' and 'token' are completely undocumented. The description does not mention what 'code' (vendor code? basket code?) or 'token' (auth token?) mean, leaving the agent to guess.

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 'food_rules' and title-less description 'Basket rules for vendor (needs login)' only vaguely gesture at retrieving rules related to a basket/vendor. It does not state a specific verb or what is actually returned, and the sibling set (food_basket_create, food_basket_update, etc.) already covers basket mutation, so it is unclear what distinct operation this represents.

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 when-to-use guidance, no alternative named, and no distinction from siblings like food_basket_create/update. The only hint is '(needs login)', which is a precondition rather than usage guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about authentication (the 'token' parameter hints at it but is unexplained), rate limits, side effects, or what is returned.

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 words with zero waste, but the brevity reflects under-specification rather than economy; there is no front-loaded actionable information for an agent to act on.

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 no annotations, no output schema, and 0% parameter coverage, the description is entirely inadequate. An agent cannot determine what inputs are required, what they mean, or what the call produces.

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% for all four parameters (lat, code, long, token), and the description offers no explanation of any of them. The meaning of 'code' versus 'token' and how lat/long relate to a vendor lookup is completely undocumented.

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?

"Vendor details" is a bare noun phrase that essentially restates the tool name 'food_vendor' without a verb or scope. It implies retrieval of vendor information but does not distinguish it from siblings like food_vendors, food_detail, or food_place.

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?

No guidance whatsoever on when to use this tool versus the many sibling tools (e.g., food_vendors, food_detail). The agent is left to infer purpose and selection entirely on its own.

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, and it provides none. It does not say whether results are paginated, whether a token is required for authentication, what format is returned, or how results are ordered.

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 only two words, but that is under-specification rather than conciseness. Nothing is front-loaded because there is no meaningful information to front-load.

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 6-parameter tool with no annotations, no output schema, and zero schema coverage, the description is entirely inadequate. An agent cannot determine required inputs, pagination, or authentication from this text.

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

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

There are 6 parameters with 0% schema description coverage and no enums or nested objects, so the description must explain them. The description mentions nothing about lat/long, page, token, compact, or supertype, leaving every parameter undocumented.

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 'Nearby restaurants' restates the tool name without a specific verb and is ambiguous between 'list nearby restaurants' and 'search nearby restaurants'. Sibling tools such as food_place, food_area, and food_vendor all deal with venues, so the short phrase does nothing to distinguish this tool from its neighbors.

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?

No indication is given of when this tool should be used versus food_area, food_place, or food_vendor. There is no mention of prerequisites, alternatives, or the situation that selects this tool over the many other food_* 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 behavioral burden, yet it says nothing about authentication (the token parameter), rate limits, error behavior, or what the returned coordinates look like. It is a bare one-line summary.

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 short phrase with no waste, but this brevity stems from under-specification rather than disciplined conciseness. There is nothing to front-load beyond the core idea.

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 zero annotations, no output schema, and 0% parameter coverage, the description is far too thin to let an agent invoke the tool correctly. Authentication, input format, and return shape are all unaddressed.

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 both the 'query' and 'token' parameters are undocumented anywhere. The phrase 'place text' loosely hints that query is free-form text, but the token's purpose and the expected input format are never explained, leaving the description well short of compensating for the 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 states a recognizable transformation (place text -> coordinates), which is more than a tautology of the name 'geo'. However, with many geocoding-adjacent siblings (food_place, ride_place, food_reverse) it never clarifies scope, provider, or what distinguishes it from those. Purpose is implied rather than stated with a specific verb+resource pairing.

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, nor any mention of prerequisites or the required token. An agent has no basis for choosing it over other place-related 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 behavioral burden and delivers nothing: no statement that this is a read-only operation, no authentication requirements for the token, no info about the returned balance or currency. The description is two words and discloses no behavior at all.

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 short and front-loaded, but the brevity comes from under-specification rather than economy. Two words with no verb or object communicate almost nothing about the operation.

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, an undocumented token parameter, and a dense field of 50+ sibling tools, the definition is far too thin for an agent to invoke this tool correctly or route to it confidently.

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 'token' parameter has 0% schema description coverage, and the description adds no meaning, not even that it is an authentication credential. The tool is not parameter-free, so the baseline-4 shortcut does not apply and the description fails to compensate.

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 'Wallet balance' simply restates the tool name ride_balance as a noun phrase, with no verb and no scope. It does not distinguish this tool from closely related siblings such as ride_wallets or ride_debts, so an agent cannot tell them apart 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?

There is no guidance whatsoever on when to use this tool, when not to, or which alternative to prefer. With ride_wallets, ride_debts, and ride_profile in the sibling list, the absence of routing guidance is a serious 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?

No annotations are provided, so the description carries the full behavioral burden. It hints at non-mutating behavior via 'dry-run', which is useful, but doesn't explain what state is simulated, whether the dry-run has side effects, what auth ('token') is required, or what a successful result looks like.

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

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

Extremely terse, front-loaded but under-specified. Six-word descriptions aren't concise if they leave core questions unanswered; brevity here reads as incompleteness rather than discipline.

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

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

No output schema, no annotations, 0% schema coverage, and a one-line description. An agent has essentially no information to correctly invoke a 3-parameter, potentially mutating 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%, and the description mentions none of the three parameters ('token', 'confirm', 'ride_id'). For a tool with a 'confirm' boolean that presumably toggles between dry-run and real execution, omitting all parameter semantics is a serious 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 'Block driver (dry-run)' names a verb and an object, but is ambiguous about what 'block' means in this ride-hailing context (block a driver account? an action?) and fails to distinguish itself from any of the many ride_* siblings. The parenthetical '(dry-run)' is the only concrete information, and it implies the operation doesn't actually mutate anything.

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?

No guidance whatsoever about when to use this tool, when not to, or which alternatives (if any) apply. Given the ~50 sibling ride_* tools, an agent has no way to determine the intended trigger conditions from the description alone.

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, and it discloses almost nothing: no auth requirements for 'token', no statement of what a real (non-dry-run) call changes, no idempotency or rate-limit notes. The '(dry-run)' hint weakly implies no side effects, but it is too ambiguous to substitute for real 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?

Three words with no filler and nothing to trim, which is structurally clean. The problem is under-specification rather than verbosity, though it is so terse that it barely qualifies as a description.

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?

A state-changing boarding confirmation with three undocumented parameters, no annotations, and no output schema is left entirely unexplained. Nothing in the definition tells an agent how to invoke it correctly or what to expect afterward.

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% across three parameters, and the description explains none of them. The relationship between the 'confirm' boolean and the promised 'dry-run' behavior — the most important semantic question here — is left completely undocumented.

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

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

States a specific verb+resource ('Confirm boarding'), which is more than a tautology, but the parenthetical '(dry-run)' muddies what actually happens — it is unclear whether the tool always simulates, or only when the 'confirm' flag is false. It also gives no differentiation from nearby siblings like ride_carpool_accept or ride_status.

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 statement of when to call this versus ride_carpool_accept, ride_track, or any other ride-state tool, nor any prerequisite conditions. The agent must guess the calling context entirely.

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 but delivers almost nothing. '(dry-run)' hints at absence of real side effects, yet this is unexplained and conflicts with the plain reading of 'Cancel', and nothing is said about the token/state/confirm parameters or 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 single short phrase is front-loaded and wastes no words, but this brevity comes from under-specification rather than discipline, so it is only minimally acceptable.

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?

A five-parameter mutation tool with no annotations and no output schema, described in six words. Nothing an agent needs to invoke it correctly — required vs optional params, dry-run semantics, confirm behavior — 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?

Five parameters with 0% schema description coverage, and the description explains none of them. The meaning of ride_id, reason, confirm, state, and token is left entirely to the agent's guesswork.

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 ('Cancel a live ride'), which is better than a tautology, but the parenthetical '(dry-run)' is ambiguous about whether this tool always simulates or merely supports a simulation mode. It also does not differentiate itself from the many sibling ride tools such as ride_status or ride_track.

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?

No when-to-use guidance, no prerequisites, no mention of alternatives. The description never says under what conditions an agent should cancel versus check ride_status or ride_history first.

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 full behavioral burden. It is silent on authentication (the token param), how confirm actually triggers the real accept versus the dry run, and whether accepting is reversible. The one hint, '(dry-run)', is not elaborated, so the agent cannot tell what the tool really does by default.

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?

Very short and front-loaded, which is good, but the parenthetical '(dry-run)' is the only extra information and it introduces ambiguity instead of resolving it. Size is fine; content density is too low for a mutating action.

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?

A mutation tool with no annotations, no output schema, zero schema documentation, and three undocumented parameters. The description leaves auth requirements, the dry-run/confirm interaction, and the effect of acceptance entirely unstated.

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

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

Schema description coverage is 0% for all three parameters, so the description must compensate, and it does not. It never explains that token is an auth credential, what offer_id references, or the role confirm plays in escaping dry-run mode.

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 (accept carpool offer), which is clear enough to distinguish from siblings like ride_carpool_reject and ride_carpool_dismiss. However the '(dry-run)' parenthetical muddies the action and is never explained.

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?

No guidance on when to use this versus ride_carpool_reject, ride_carpool_dismiss, or other ride actions, and no explanation of what the dry-run mode means for callers. Usage must be fully inferred.

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

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

With no annotations, the description carries the full burden of behavioral disclosure and falls short. '(dry-run)' gestures at a non-mutating mode but never states what actually happens to the offer, whether state changes, or what the 'confirm' flag does. Permission requirements and side effects are entirely 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 single phrase is compact but under-specified rather than concise — brevity here is a symptom of missing information, not editorial discipline. The '(dry-run)' parenthetical also reads as an afterthought rather than a front-loaded key fact.

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

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

No annotations, no output schema, and three fully undocumented parameters mean the description is the only source of behavioral context, and it supplies almost none. An agent cannot confidently invoke this tool without knowing how 'confirm' and 'token' relate to the dry-run semantics.

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

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

Schema description coverage is 0% across three parameters (token, confirm, offer_id), so the description must compensate and does not. Only 'offer' loosely hints at offer_id; 'token' (an auth credential?) and 'confirm' (which likely interacts with the dry-run behavior) are left with no meaning added.

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 verb+resource ('Dismiss carpool offer'), which is clearer than a bare name. However, it fails to differentiate from the sibling 'ride_carpool_reject' — 'dismiss' and 'reject' are near-synonyms, so an agent cannot tell which to pick. The parenthetical '(dry-run)' further muddies the purpose rather than refining it.

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 ride_carpool_accept or ride_carpool_reject, nor any stated precondition. The only hint, '(dry-run)', is unexplained and could be read either as a mode or as a no-op preview, leaving the agent to guess.

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. '(dry-run)' hints that no state change occurs, but it is vague and arguably contradictory for a mutation-named tool; there is no mention of auth needs (the 'token' param), what 'confirm' does, or what side effects occur on a real rejection.

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 short phrase, so there is no padding. However, the brevity is under-specification rather than efficiency: the one parenthetical present introduces ambiguity instead of useful signal.

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

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

This is a state-changing tool with no annotations, no output schema, and three undocumented parameters, so the description should do much more. It omits permissions, confirmation flow, and the meaning of the dry-run flag, leaving the agent unable to call it confidently.

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% across three parameters (token, confirm, offer_id), and the description explains none of them. In particular the relationship between 'confirm' and the '(dry-run)' claim is left completely unaddressed, so the agent must guess how to drive a real rejection.

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?

It names a specific verb and resource ('Reject carpool offer'), so the basic action is discernible. But the '(dry-run)' parenthetical creates ambiguity about whether the offer is actually rejected, and it does not distinguish itself from the sibling ride_carpool_dismiss, which reads like an overlapping 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?

No guidance on when to reject versus dismiss or accept an offer, and no stated preconditions. The agent must infer the selection criteria entirely from the tool name.

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. '(dry-run)' suggests no side effect, yet the schema exposes a 'confirm' boolean and a 'reason-id', which implies a real re-request path that is not explained. Nothing is said about the token/auth requirement, whether the original ride is restored or a new one created, or the limits on re-requesting.

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?

Five words is not conciseness here but under-specification; the one parenthetical that was included, '(dry-run)', adds ambiguity rather than information. There is no wasted padding, but the content is too thin to be 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?

This is a four-parameter mutation tool with no annotations, no output schema, and 0% schema description coverage, so the description must do all the work and does essentially none. An agent lacks the auth requirements, the commit-vs-dry-run mechanics, the return behavior, and the meaning of two undocumented parameters.

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% across four parameters (token, confirm, ride_id, reason-id), and the description explains none of them. 'ride_id' is only implicitly covered by 'cancelled ride'; the critical meanings of 'confirm' and the dry-run relationship to it are left entirely to the caller to guess.

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 phrase 'Re-request cancelled ride' gives a recognizable verb+resource, but the tool is named ride_clone, which implies duplication rather than re-requesting, and the '(dry-run)' parenthetical is left unexplained. It does not distinguish itself from the sibling tools ride_request or ride_cancel, so an agent cannot tell when this action is the right one.

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 statement of when to use this rather than ride_request (create a new ride) or ride_cancel (cancel one). The '(dry-run)' qualifier hints at a non-committing mode but the description never clarifies how to actually commit or what role the 'confirm' parameter plays.

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 provided, so the description carries the full burden. It signals dry-run but doesn't say whether a dry-run still requires auth (the 'token' param suggests it might), whether it's idempotent, what the confirm flag does, or what the response contains. For a payment tool with no annotation coverage, this is a major 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?

The description is a terse four-word title, so it's not padded, but it's also under-specified rather than genuinely concise. There is no front-loaded structure beyond the label itself, which is minimum viable but not efficient communication.

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 financial mutation tool with three undocumented parameters, no annotations, and no output schema, the description is drastically insufficient. An agent cannot safely determine what the dry-run actually does, what the confirm and token fields control, or what the outcome will be.

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?

All three parameters (token, wallet, confirm) have zero schema description coverage, so the description must compensate and does not. It never mentions the token, wallet, or confirm parameters, leaving an agent to guess that 'confirm' gates a real payment vs. dry-run and what 'wallet' identifies.

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 'PAY DEBT (dry-run)' gives a verb+resource (pay debt) and a mode qualifier (dry-run), so the core action is identifiable. However it doesn't distinguish this tool from the sibling ride_debts or clarify whether dry-run means no mutation happens, leaving scope 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?

No when-to-use or when-not-to-use guidance is provided. With siblings like ride_debts and ride_balance nearby, an agent gets no routing signal about when to invoke this versus viewing debt. The parenthetical '(dry-run)' hints at intent but not enough.

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, and it discloses nothing: not whether the call is read-only, whether authentication via the token field is required, whether results are paginated, or what the debt record contains. A two-word fragment gives no behavioral context at all.

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 words is short but this is under-specification rather than conciseness; there is no front-loaded action statement or scope to anchor the agent. It fails the 'every sentence earns its place' test by omission rather than excess.

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, no parameter documentation, and no return description, the definition supplies nothing an agent needs in order to invoke the tool correctly. It is materially incomplete for even a simple read 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 description coverage is 0% and the 0-required, 1-optional 'token' field is undocumented. The description adds no meaning to that parameter, though the name 'token' is largely self-describing as an auth credential, which keeps this just above the floor.

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

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

The description is a bare noun phrase, 'Outstanding debts', which essentially restates the tool name ride_debts without a verb or any distinguishing scope. It does not differentiate this tool from closely named siblings such as ride_balance, ride_wallets, or ride_debt_pay. There is no statement of what action is performed (list? retrieve? total?).

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?

No guidance whatsoever on when to use this tool, what preconditions apply, or which sibling to pick instead. Notably, ride_debt_pay exists for actually settling debt, so a when-not clause would have been valuable. The agent is left to infer everything.

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. '(dry-run)' does usefully imply the operation is non-mutating, but nothing is said about authentication (the token parameter), rate limits, permissions, or what happens on confirm=true versus confirm=false.

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 short, but that brevity reflects under-specification rather than tight writing. There is no front-loaded explanation of what the tool returns or how to call it.

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

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

For a 7-parameter tool with no annotations, no output schema, and no parameter documentation, two words are wholly inadequate. An agent cannot reliably invoke this tool from the given information.

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?

Seven parameters with 0% schema description coverage and the description adds nothing. Names like 'service', 'confirm', 'token', and the lat/lng pairs are left entirely unexplained, forcing the agent to guess at types, requiredness, and 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 '(dry-run)' plus 'Flexi quote' essentially restates the tool name ride_flexi with a hint that it simulates a fare quote. It gives no verb explaining what is produced or how it differs from siblings like ride_price, ride_options_quote, or ride_request.

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 the many sibling quote/price/request tools. The only inference an agent can draw is from the parenthetical '(dry-run)', which is not an explicit usage condition.

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

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

No annotations are provided, so the description carries the full burden, and it discloses nothing: not whether this is a read or a write, not whether it requires auth (the token param implies it), and not what a "heads-up" does or triggers. For an unannotated tool this is a complete failure of 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?

Two words is not conciseness but under-specification; there is nothing to front-load because no substance was written. It fails to earn its place only by omission, not by verbosity.

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 zero annotation coverage, 0% schema description coverage, no output schema, and two undocumented parameters, the description does not provide anything close to what an agent needs to invoke this tool correctly.

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

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

Schema description coverage is 0% for both parameters. The description says nothing about token (presumably an auth credential) or ride_id (presumably the ride in question), so it adds zero meaning beyond the bare property 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?

"Cancellation heads-up" gestures at ride cancellation notification but gives no verb or defined action — it restates the name (ride_headsup) rather than stating what the tool does. An agent cannot tell whether it sends, registers, or retrieves a cancellation notice, nor how it differs from sibling ride_cancel.

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?

No when-to-use, when-not-to-use, or alternative guidance is present. With siblings like ride_cancel and ride_status nearby, the description gives no condition that selects this tool over them.

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 burden, yet it discloses nothing about pagination, auth requirements (the token parameter hints at auth but this is not stated), ordering, or what the response contains. Two words cannot convey the behavior of a paged history 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?

Extreme brevity here is under-specification, not conciseness. There is no waste because there is almost no content, but the definition fails to front-load any useful information an agent needs to invoke the 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?

A paginated, token-bearing list endpoint with three undocumented parameters, no annotations, and no output schema needs substantial description to be usable. 'Past rides' leaves every operational detail 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% and the description adds no parameter meaning at all. The agent must guess what page, limit, and token do, including whether token is required for authorization.

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 phrase 'Past rides' is essentially a restatement of the tool name ride_history rather than a specific verb+resource statement. It gives a rough sense of the domain but does not distinguish this tool from siblings like ride_status, ride_track, or ride_debts, leaving the agent to infer that this returns historical ride records.

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 the many ride_* siblings, no mention of prerequisites, authentication context, or exclusions. Nothing in the text helps an agent choose it over ride_status or ride_track.

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. 'Browser-guided' hints that a browser session or user interaction is involved, but nothing is said about how the flow is driven, what the helper does, how timeout is enforced, or what happens on failure.

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 words with zero padding is technically concise and front-loaded, but the brevity here is under-specification rather than efficiency. There is no wasted sentence because there is essentially no content.

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

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

For an authentication flow with three undocumented parameters, no annotations, and no output schema, the description is far too thin. An agent cannot determine required inputs, flow behavior, or return values from what is given.

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 mentions no parameters at all. The three parameters (token, helper, timeout) are entirely undocumented, so an agent has no idea what values to supply.

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 phrase 'Browser-guided login' names a verb (login) and a modality (browser-guided), which is enough to know it authenticates a user. However, it does not distinguish itself from the many sibling login tools (ride_login_send, ride_login_verify, ride_login_import, ride_login_refresh), so it is vague about which login path this is.

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 statement of when to use this tool versus the four other ride_login_* siblings, nor any prerequisite or ordering information. An agent must guess whether this replaces or follows ride_login_send/verify.

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 and discloses almost nothing beyond the one-line purpose. For a security-sensitive credential operation it doesn't say where tokens are stored, whether it overwrites existing sessions, what auth/permissions are required, or whether it has side effects. Only the bare 'import' concept 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 single sentence is front-loaded and free of padding, but it is arguably too terse for the operation it describes, leaving the reader under-informed rather than efficiently informed.

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

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

No annotations, no output schema, and four undocumented parameters for a credential-import tool. The description supplies none of the surrounding context an agent needs, making it materially incomplete for the task.

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?

Four parameters at 0% schema description coverage, so the description is the only source of meaning and it provides none. 'token', 'access', 'refresh', and 'device' are left entirely undefined — no formats, no indication of which are required (all optional per schema), no explanation of how they relate.

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 verb+resource ('import tokens') and scopes it to 'from browser', which does distinguish it somewhat from ride_login_send/verify/refresh. But 'tokens' is unexplained (auth tokens? access/refresh?) and it doesn't clarify what the import actually does or why an agent would pick it over ride_login_refresh. Purpose is implied rather than stated.

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

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

No when-to-use guidance, no prerequisites, and no mention of the obvious alternatives like ride_login_refresh or ride_login_guided. The agent must infer the selection context entirely on its own.

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 entire behavioral burden, and it discloses nothing: no auth requirements, no token lifetime or invalidation semantics, no statement of whether the old token is destroyed, and no response behavior. For an authentication-related mutation this is a severe 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?

It is extremely short, but this is under-specification rather than conciseness. A three-word phrase cannot be front-loaded meaningfully because there is no substantive content to order.

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 two-parameter authentication tool with no annotations, no output schema, and no parameter documentation, the description leaves an agent unable to invoke it correctly. Nothing explains the flow context or what a successful refresh yields.

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?

Both parameters ('token', 'refresh') have 0% schema description coverage, and the description adds no meaning at all — it does not say what 'token' should contain, whether 'refresh' is a refresh token, or which are required (schema reports 0 required).

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 verb ('Refresh') and a resource ('ride token'), which is more than a tautology and hints at renewing an existing credential rather than creating one (distinguishing it loosely from ride_login_send/verify). However, it never clarifies what token is being refreshed or that this belongs to the ride login flow, so the differentiation from the many ride_login_* siblings is only implied.

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?

No guidance on when to call this versus ride_login_send, ride_login_verify, or ride_login_import. There is no mention of expiry conditions, prerequisites, or the alternative paths an agent should consider when a token fails.

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. It earns credit for a genuinely important disclosure — that a real SMS/call is dispatched, implying external side effects and likely rate/cost limits — but says nothing about auth requirements, retry behavior, OTP expiry, or what happens on repeated calls.

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

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

A single front-loaded clause with zero filler; the parenthetical side-effect note is well placed. It is efficient, though the brevity reflects thin content rather than disciplined editing.

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?

A mutation tool with real-world side effects, six undocumented parameters, no annotations, and no output schema. The description does not come close to supplying what an agent needs to invoke this safely or 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?

Six parameters at 0% schema description coverage, and the description explains none of them. Phone, token, and the four captcha-* fields are entirely undocumented, leaving the agent to guess at required values and formats.

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 ('Send ride OTP'), which is enough to distinguish it from verification/refresh siblings like ride_login_verify and ride_login_refresh. It stops short of naming those alternatives explicitly, so it is clear but not differentiated.

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?

Nothing tells the agent when to call this versus ride_login_verify, ride_login_import, or food_login_send. The workflow (send OTP, then verify) must be inferred from sibling names rather than from the description.

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

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

With no annotations, the description carries the full behavioral burden, and 'Verify ride OTP' discloses almost nothing: not whether it establishes a session, whether the OTP expires, whether attempts are rate-limited or consumed on failure, or what happens to an already-verified ride login. Only the verification intent itself 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?

Three words are certainly front-loaded and free of waste, but the brevity here reflects under-specification rather than economy. It is appropriately short for a single-step verification tool, just not informative.

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?

An authentication-verification tool with four undocumented parameters, no annotations, and no output schema needs the description to explain inputs, prerequisites, and the success/failure outcome. Almost all of that is missing, so the definition is not complete enough for reliable 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% across four parameters, so the description must compensate and does not. 'OTP' loosely maps to the 'code' field, but 'phone', 'token', and 'method' are entirely unexplained by either the schema or the description, leaving half the interface opaque.

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 phrase pairs a verb ('Verify') with a resource ('ride OTP'), so an agent knows it fulfills a ride OTP confirmation step and can distinguish it from food_login_verify. However, it gives no differentiation from ride_login_send, ride_login_guided, or ride_login_import, which are the actual competing siblings in the same auth flow.

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

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

There is no guidance on when this tool is appropriate versus ride_login_send (the presumed prior step) or ride_login_guided/ride_login_import. The description states what it does but never says when to call it or what prerequisite state is required.

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 of behavioral disclosure. '(dry-run)' weakly implies a non-committing operation, but nothing is said about authentication via the token parameter, what the confirm flag does, or what side effects (if any) occur. For a 7-parameter tool with zero annotation coverage this is a major 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?

It is short, but this is under-specification rather than conciseness—there is nothing to front-load because almost no information is present. The parenthetical is the only structural 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 7 parameters, no annotations, no output schema, and no parameter documentation, an agent has essentially no basis to invoke this tool correctly. The description is wholly inadequate for the tool's complexity.

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% across 7 undocumented parameters (token, to/from lat-lng, confirm, service). The description adds no meaning for any of them, not even explaining what the numeric 'service' refers to or the role of 'confirm' in a dry-run. It fails to compensate for the coverage 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 is essentially a restatement of the tool name ('Ride-options quote') with the parenthetical '(dry-run)' as its only added information. It does not say what a quote returns, what a dry-run means operationally, or how it differs from siblings like ride_price or ride_options_set. It is close to a tautology of the name.

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, when not to, or which alternatives (ride_price, ride_request) to prefer. The agent is given no conditions to select this tool over its many ride_* 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, the description carries the full burden of behavioral disclosure. '(dry-run)' hints at non-mutating behavior, but it's unclear whether the tool ever mutates state (the confirm parameter suggests it might), whether it requires auth (the token parameter suggests it does), or what happens to existing options. This is a significant gap for a mutation-adjacent 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?

At four words, the description is concise but under-specified rather than efficiently concise. The parenthetical '(dry-run)' is the only substantive content, and it's ambiguous.

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?

A 3-parameter mutation-adjacent tool with no annotations, no output schema, 0% schema coverage, and a description that omits auth requirements, the dry-run/confirm workflow, and the meaning of 'disabilities'. Nothing an agent needs to invoke this correctly 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 0% across 3 parameters (token, confirm, disabilities). The description mentions none of them, so an agent must infer that 'token' is auth, 'confirm' gates a dry-run application, and 'disabilities' is a string encoding accessibility preferences. Zero compensation for a 0% coverage 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 'Edit ride options (dry-run)' states a verb (edit) and resource (ride options), which is slightly better than a tautology, but the '(dry-run)' qualifier is ambiguous — it's unclear whether this tool actually applies changes or just previews them. Given a sibling named ride_options_quote exists, the distinction between 'edit', 'quote', and the dry-run flag is muddled.

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?

No guidance on when to use this tool versus ride_options_quote or other ride_* siblings is provided. The '(dry-run)' hint implies a preview workflow, but the description never states that this is for validation before applying changes, nor does it reference the confirm parameter's role in that workflow.

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 of behavioral disclosure, and it supplies none. It says nothing about whether the tool reads or mutates data, what authentication it needs, what it returns, or how it relates to the saved-place CRUD siblings.

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 two-word fragment is short but not concise in a useful sense — it is under-specified rather than efficient. There is nothing to front-load because no substantive information is present.

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 an undocumented parameter, no annotations, no output schema, and two closely related siblings, the description is completely inadequate. An agent has no basis for deciding when or how 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?

There is one parameter (token) with 0% schema description coverage, and the description offers no information about what it is, whether it is required (it is listed as optional), or how it is used. The definition leaves the parameter entirely undocumented.

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?

"Saved places" is a noun fragment that restates the tool name rather than naming an action or explaining what the tool returns or does. It does not distinguish this tool from siblings ride_place_list and ride_place_add, leaving the agent unable to tell whether it reads, lists, or manages saved places.

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

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

No when-to-use guidance, no alternatives named, and no exclusions. The presence of ride_place_list and ride_place_add as siblings makes this omission especially costly, since nothing indicates when ride_place should be chosen over them.

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. '(dry-run)' hints at a preview mode, but the description never explains that the `confirm` flag actually commits the save, does not mention authentication via `token`, and says nothing about side effects or reversibility.

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

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

Four words is not conciseness but under-specification. There is no wasted text, but the sentence is far too small to carry the meaning needed for a six-parameter write 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 six undocumented parameters, no annotations, and no output schema, the description is drastically incomplete. An agent cannot determine auth requirements, what a dry-run returns, or how to actually persist the place.

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% across six parameters, so the description must compensate. It only loosely gestures at coordinates/name via the word 'place' and at the confirm/dry-run distinction; `token` and `address` receive no explanation 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?

The name and description together give a verb and resource ('Save a place'), so an agent can roughly tell it creates a saved place. However, the parenthetical '(dry-run)' is ambiguous and partly at odds with the presence of a `confirm` parameter, and there is no differentiation from sibling tools like ride_place or ride_place_list.

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 indication of when to use this tool versus ride_place, ride_place_list, or the many other ride_* siblings. Nothing is said about prerequisites (token/auth) or when the dry-run behavior applies, leaving routing entirely to the name.

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 of behavioral disclosure and fails to meet it. It never states whether a token is required for auth, whether the list is user-scoped, whether results are paginated or ordered, or what happens with an invalid token.

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 words are front-loaded and waste nothing, so structure is not the problem. But the brevity reflects under-specification rather than disciplined conciseness, and a one-line description for a tool with auth semantics leaves too much unsaid.

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?

Even for a simple list endpoint with one optional parameter and no output schema, the absence of annotations means the description should cover auth expectations and result shape. It covers neither, leaving the agent with only the name to work from.

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 single 'token' parameter is undocumented in both the schema and the description. The description adds no meaning about what the token is or whether it is optional (required count is 0, which is itself surprising for an auth token).

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 clear verb+resource ('List saved places'), so the basic action is unambiguous. However, it does nothing to distinguish this from the adjacent siblings ride_place and ride_place_add, leaving an agent to guess how listing differs from fetching a single place or adding one.

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 when-to-use guidance, no mention of prerequisites, and no alternative named. The sibling set contains ride_place and ride_place_add, which are the obvious alternatives, yet the description offers no routing signal.

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. 'Fare quote' weakly implies a non-mutating pricing lookup, but nothing is said about auth requirements (the token param), whether the result is binding, or whether vouchers affect the returned fare.

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 single sentence is short but severely under-specified rather than efficiently concise. Brevity here costs the agent the information it needs to invoke 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?

A 9-parameter tool with zero annotations, no output schema, and no documented parameters is left almost entirely unexplained. The description should at minimum define the origin/destination options and the auth token, and it does none of that.

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% across 9 parameters. 'Between two points' gestures at origin/dest or the lat/lng pairs, but it adds no meaning for token, voucher, or compact, and no format or mutual-exclusivity guidance for the coordinate vs place-name inputs.

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

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

States a specific verb+resource ('Fare quote') and a rough scope ('between two points'), so the general intent is inferable. However, it does not distinguish this from closely named siblings like ride_options_quote or ride_request, nor does it clarify whether it is an estimate or a binding price.

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 when-to-use guidance, no mention of when a quote is appropriate versus calling ride_request, and no indication of prerequisites or alternatives. The agent must guess the intended workflow step.

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 and no disclosure of behavior. Whether the tool reads, mutates, or requires authentication is entirely unspecified. With zero annotation coverage, the description carries the full burden and fails completely.

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 two-word fragment is concise but entirely uninformative. Brevity here reflects under-specification rather than efficient communication.

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?

Completely inadequate. No output schema, no annotations, no parameter documentation, and a description that only echoes the tool name. An agent cannot determine what this tool does or how to call 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?

The single 'token' parameter has 0% schema description coverage. The description does not mention what the token is, whether it is required (it is not marked required), or how it relates to the profile retrieval.

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 'Passenger profile' is a noun fragment with no verb and no clear purpose. It is ambiguous whether the tool reads or writes a profile. Siblings ride_profile_show and ride_profile_set clearly delineate read/write, but this tool gives no such signal.

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?

No guidance on when to use this tool versus ride_profile_show, ride_profile_set, or food_profile. The agent has no basis for selecting this tool over its numerous 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. "Edit profile (dry-run)" is contradictory: 'edit' implies mutation while 'dry-run' implies no persistence, and the tool offers no clarification of which is true, what auth is required, or what the confirm parameter does.

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?

Very short, but not in an earned way — three words plus a parenthetical that actively misleads. Under-specification is not conciseness.

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 6-parameter profile-mutation tool with zero annotations, zero schema docs, and no output schema, three words plus an ambiguous '(dry-run)' is grossly inadequate. No confirmation flow, no auth requirements, no dry-run vs real-run semantics.

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

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

Schema description coverage is 0% across 6 parameters, and the description mentions none of them. Nothing explains what 'token', 'confirm', or the PII-shaped fields (address, birthdate, gender) mean or how 'confirm' interacts with the claimed dry-run behavior.

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?

"Edit profile" states a verb and resource, but the parenthetical "(dry-run)" is ambiguous and the name 'ride_profile_set' versus sibling 'ride_profile_show' isn't clearly distinguished. An agent cannot confidently tell whether this persists changes or only previews 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?

No when-to-use guidance at all. It doesn't distinguish itself from ride_profile, ride_profile_show, or any of the 45+ siblings. The contradictory '(dry-run)' hint offers no routing information.

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 — and it carries none. It does not say whether this reads or mutates, whether auth is required, whether the token is optional (required=0), or what is returned.

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 words is brevity, not conciseness — the failure here is under-specification rather than verbosity. There is nothing to be front-loaded because nothing of substance is stated.

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

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

No annotations, no output schema, an undocumented required-optional parameter, and an indistinguishable sibling set. For a tool embedded in a 50+ sibling namespace, this description leaves an agent unable to select or invoke it correctly.

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

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

The single parameter 'token' has 0% schema description coverage and is never mentioned in the description. With one undocumented parameter and no compensating text, the agent has no idea what token means, whose profile it identifies, or whether it may be omitted.

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?

"Show profile" is effectively a restatement of the tool name with a generic verb and resource. No scope, no differentiation from siblings, and it is ambiguous against the coexisting ride_profile and ride_profile_set tools — an agent cannot tell which of the three to call.

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?

No when-to-use guidance, no prerequisites, no named alternatives. With ride_profile and ride_profile_set in the sibling list, the absence of any routing information is a real failure, not merely a 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?

No annotations provided, so the description carries the full burden, and it discloses nothing: not whether this reads or writes, not auth requirements, not side effects. "Rating state" is not even a coherent behavior 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?

It is short but that is under-specification, not conciseness. Two words cannot front-load anything meaningful and give no structure to the agent.

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 0% param coverage, the description is the sole information source and provides essentially none. An agent cannot invoke this tool correctly from the definition.

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?

One parameter (token) with 0% schema description coverage, and the description says nothing about it. The description fails to compensate for the schema gap, leaving the parameter entirely undocumented.

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?

"Rating state" is a noun phrase with no verb and no clear resource. It does not state what the tool does (submit a rating? fetch ratings? query rating state?). It cannot be distinguished from siblings like ride_review_submit or food_reviews.

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

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

No when-to-use guidance, no alternatives, no conditions. The agent has no basis for choosing this tool over any sibling.

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, yet it discloses nothing about behavior. It does not say whether this is a read or write, what permissions the token needs, whether ride_id is required or optional, 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?

Two words is not conciseness but under-specification; there is no front-loaded statement of purpose or any structure to speak of. It wastes the entire description field.

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

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

For a 2-parameter tool with no annotations and no output schema, the description is completely inadequate. Nothing an agent needs to invoke it correctly 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 0% and the description adds no meaning for the two parameters (token, ride_id). The agent cannot tell whether ride_id must correspond to a cancelled ride or whether token is an auth credential.

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 phrase 'Cancellation reasons' is a noun fragment that essentially restates the tool name without a verb or scope. It hints at the resource (cancellation reasons) but does not clarify whether it lists them, looks them up for a ride, or returns reason codes, and it does nothing to separate the tool from siblings like ride_cancel.

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 call this tool, what conditions trigger it, or how it relates to alternatives such as ride_cancel or ride_history. The agent is left to guess entirely from the tool name.

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 mostly fails: it never says whether a real booking occurs, what 'confirm' does, whether a token is required, or what side effects follow. The '(dry-run)' hint is the only behavioral disclosure, and it is contradicted by 'REAL RIDE' in the same line.

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?

Brevity here reflects under-specification rather than economy; the single fragment is ambiguous instead of front-loading useful information. It is short but earns nothing.

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?

A nine-parameter, zero-annotation, no-output-schema tool needs substantial description, and this provides one ambiguous fragment. An agent cannot safely 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?

Nine parameters at 0% schema description coverage with zero explanatory text in the description. Critical semantics — token auth, the confirm flag, service selection, and the origin/dest vs from-lat/from-lng duality — are entirely undocumented.

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 restates the tool name ('request a ride') rather than explaining it, and the parenthetical '(dry-run)' muddies rather than clarifies — it is unclear whether this actually books a ride or merely simulates one. There is no differentiation from siblings such as ride_options_quote or ride_price.

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?

No when-to-use guidance, no preconditions, and no mention of alternatives in a sibling set containing dozens of ride_* tools. An agent has no basis for choosing this over ride_options_quote or ride_status.

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 full behavioral burden but says nothing about authentication needs, rate limits, side effects, or return shape. 'Raw active-ride status' reveals no behavioral trait an agent could rely on.

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 phrase is short but that brevity is under-specification rather than conciseness. There is no front-loaded statement of purpose because there is essentially no content to front-load.

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, 0% schema coverage, and a crowded ride_* sibling namespace, the description is far too sparse for an agent to call this correctly.

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

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

Schema description coverage is 0% and the single 'token' parameter is undocumented. The description does not mention the token or its role, so an agent must guess from the parameter name alone. Baseline for 0 params would be 4, but this tool has 1 undocumented param.

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 'Raw active-ride status' is a terse noun phrase with no verb. It vaguely indicates the resource (active ride status) but does not clarify what the tool does — read? stream? return? — and provides no distinction from siblings like ride_track or ride_history.

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?

No guidance on when or why to use this tool versus siblings such as ride_track, ride_history, or ride_boarded. The word 'raw' hints at unprocessed data but never explains when that matters.

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 burden. "Snapshot" hints at a read operation but the description says nothing about polling behavior, whether it blocks, what timeout does, or what happens with follow. Significant 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?

Extremely short, which is fine structurally, but the brevity is under-specification rather than genuine conciseness. A single sentence that doesn't earn its place by conveying any actionable 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 3-parameter tool with no annotations, no output schema, and 0% schema coverage, the description is completely inadequate. Nothing an agent needs to correctly invoke this tool 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?

Three parameters (token, follow, timeout) at 0% schema description coverage and no enum values. The description adds zero meaning: "follow" and "timeout" are particularly ambiguous without explanation, and this is the one place description could compensate. It does not.

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

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

"Active ride snapshot" is a noun phrase that loosely implies retrieving ride status but lacks a clear verb and doesn't distinguish itself from siblings like ride_status or ride_boarded. An agent cannot confidently tell what this tool does differently from ride_status based on 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?

No when-to-use context, no exclusions, and no mention of how it differs from the very similar sibling ride_status. The agent is left to guess whether to call this or ride_status.

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. '(dry-run)' hints at a non-mutating simulation, but it is never explained, and the presence of a 'confirm' flag suggests a real mutation path that contradicts the dry-run framing. Nothing about reversibility, auth (token), or side effects is disclosed.

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?

Very short and front-loaded, but this is under-specification rather than conciseness: a single fragment with an ambiguous parenthetical that raises more questions than it answers.

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 3-parameter mutation-adjacent tool with no annotations, no output schema, and 0% schema coverage, the description provides almost nothing an agent needs to call it correctly.

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

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

Schema description coverage is 0% for three parameters (code, token, confirm), and the description explains none of them. It does not clarify what 'code' is, what 'token' authenticates, or how 'confirm' interacts with the dry-run claim.

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 verb+resource ('Apply voucher') which is recognizably distinct from ride_* siblings like ride_request or ride_cancel. However, the parenthetical '(dry-run)' clouds the intent: it is unclear whether the tool actually applies the voucher or only simulates it, especially given a 'confirm' parameter exists.

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?

No guidance on when to use this tool, no prerequisites (e.g., must a ride be requested first?), and no mention of alternatives such as applying a promo at request time versus afterward. The agent is left to guess entirely.

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 entire behavioral burden, and it discloses nothing: not whether this is a read or write operation, whether authentication/token scopes are required, what data is returned, or whether it mutates state.

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

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

Two words are technically brief, but this is under-specification rather than conciseness — there is no useful content to front-load or trim. Nothing earns its place because nothing informative was said.

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, no output schema, and an undocumented parameter, the description is completely inadequate. An agent could not reliably decide when or how to invoke this tool based on the provided information.

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 parameter 'token' has 0% schema description coverage, and the description does not mention it at all. The agent gets no explanation of what the token should be (session token? wallet token? identifier of a specific wallet?).

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?

"Payment wallets" is a noun fragment that essentially restates the tool name ride_wallets rather than stating a verb and resource. It gives no indication of the operation (list wallets? fetch balances? manage stored payment methods?) so an agent cannot distinguish it from siblings like ride_balance or ride_debts.

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, no prerequisites, and no mention of alternatives. With 40+ siblings in the ride_* family, the absence of any routing signal leaves the agent with nothing to reason from.

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