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

The description discloses the key behavioral trait that the operation is unsupported by the API, which goes beyond the annotations (all false). This tells the agent the tool is effectively a stub and should not be invoked, preventing failed 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?

The description is two sentences with no filler. The primary action is front-loaded, and the crucial unsupported-operation warning follows immediately.

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

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

Given the tool is not exposed by the API, the description provides the essential context: the operation is unavailable and the user should use the Uber app. No output schema is needed, and the description fully prepares an agent to handle a request for this operation.

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

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

The description adds no parameter-specific meaning beyond the input schema. With schema description coverage at 33% (only token has a description), the description should compensate for undocumented parameters like type and label, but 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?

The description clearly states the action 'Add a payment method' with a specific resource. It also distinguishes this tool from sibling payment management tools by noting the API does not expose the operation, so the purpose is unambiguous.

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

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

The description explicitly says when not to use the tool ('The Uber Rider API does not expose this operation') and provides the alternative ('use the Uber app to manage payment methods'). This gives an agent clear guidance to avoid calling this tool.

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

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

The description adds useful behavioral detail by stating that the tool returns a consistent ride ID, fare, driver, vehicle, and ETA. It does not discuss side effects like duplicate bookings, idempotency, or authorization, but it does not contradict the annotations either.

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

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

The description is one front-loaded sentence with no filler. It immediately conveys the action, the prerequisite, and the return values, so every clause earns its place.

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

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

The description gives a minimum viable picture: book a demo ride using an estimate and receive ride details. However, it leaves gaps around how the estimate maps to parameters, what 'consistent' means, and the structure of the returned fields, especially since there is no output schema.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not. It only alludes to a 'selected estimate' without naming estimateId or rideTypeId, and it never mentions the required pickup and destination parameters or the rideType options.

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

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

The description states a specific action ('Book') and resource ('demo ride'), and adds the scope 'using the selected estimate.' This distinguishes it from estimate-only tools like estimate_ride and from a real request tool like request_ride.

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

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

The phrase 'using the selected estimate' provides clear usage context: this should be called after an estimate has been chosen. However, it does not explicitly name alternatives or state when not to use the tool, so it stops short of full routing guidance.

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

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

Beyond the destructiveHint and idempotentHint annotations, the description discloses that cancellation produces a fee and a final status, which is useful behavior context. It does not contradict annotations and adds value about the operation's outcome.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the action, precondition, and expected return value efficiently.

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

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

For a simple two-parameter cancel operation, the description covers the essential precondition and return information. While there is no output schema or explicit error/edge-case discussion, the annotations and description together provide adequate context for an agent to invoke the tool.

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

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

Schema description coverage is 100%, so rideId and reason are already documented in the schema. The description does not add extra parameter semantics beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action (cancel), the target resource (an active ride), and the return value (cancellation fee and final status). It is distinct from sibling tools like complete_ride and request_ride.

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

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

The phrase 'active ride' implies when this tool should be used, but no explicit exclusions or alternative tool references are provided. An agent must infer that completed or already-cancelled rides would not be valid targets.

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, but it only says to 'Choose Cash or Demo Wallet' without describing side effects, whether this changes the default, whether any charge occurs, or whether the selection is temporary. It also does not mention permissions or reversibility, which is a meaningful gap for a mutation-like tool.

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

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

The description is one short sentence with no filler. It front-loads the action and immediately conveys the core purpose and the valid choices. Every word earns its place.

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

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

The tool is simple with one required parameter and no output schema, so a very detailed description is not necessary. However, it omits useful context such as how to obtain a valid paymentMethodId, whether to call get_payment_methods first, and what side effects the choice has. The description is adequate but has notable gaps.

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

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

The input schema only says 'Payment method ID,' which is generic. The description adds useful semantic detail by indicating that the valid choices are Cash or Demo Wallet for a demo ride. It does not specify the exact string values for paymentMethodId, but it provides more meaning than the schema alone.

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

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

The description states a specific action ('Choose') and resource ('payment method') with a clear context: 'for the next demo ride.' It does not explicitly distinguish itself from sibling set_default_payment_method, but the 'next demo ride' wording strongly implies a ride-scoped selection rather than a default-setting operation.

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

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

The phrase 'for the next demo ride' provides some usage context, implying the tool is used during demo ride setup. However, it does not explicitly say when to use this tool instead of alternatives like set_default_payment_method, get_payment_methods, or list_payment_methods. The guidance is implied rather than stated.

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

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

With no annotations, the description must carry behavioral disclosure. It discloses that completion is immediate and that it is a development/demo action, giving some indication of side effect (receipt flow). However, it does not state whether the action is irreversible, what happens to the ride state beyond completion, or any demo-only restrictions beyond the label.

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 that states the action, scope, and purpose. Every phrase earns its place, with no redundant restating of the tool name or schema.

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

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

For a simple one-parameter tool this is adequate: it names the prerequisite ('active ride') and the follow-up flow (receipt presentation). But without annotations or an output schema, it leaves unstated what the tool returns or confirms, and does not spell out production-safety disclaimers.

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 a single parameter rideId and the schema description already covers it ('Ride ID returned by request_ride', 100% coverage). The tool description adds no new parameter detail, so baseline 3 is appropriate.

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

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

Description uses specific verb 'completes' with direct object 'active ride' and explicitly notes it is a 'Development/demo control' intended to advance to receipt flow. This clearly distinguishes it from siblings like cancel_ride or request_ride.

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

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

The phrase 'Development/demo control' sets the context of when to use it, and 'so the receipt flow can be presented' gives the intended use case. It does not explicitly name alternatives or say 'do not use in production', but the demo-scope wording makes the usage context clear.

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

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

With no annotations, the description carries the full behavioral burden. It explicitly discloses that this tool is harmless, masks the driver phone, and never calls or messages anyone, which is important context for an action named 'contact_driver.' It does not cover failure behavior or return format, but the major side-effect concern is addressed.

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

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

Two short sentences with no filler: the first states the action and the phone-masking, the second states the safety property. Key information is front-loaded.

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

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

For a one-parameter demo tool, the description covers purpose and safety but omits the return shape and the role of rideId. With no output schema, a bit more detail about the returned 'contact action' object would make it fully complete.

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

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

Schema description coverage is 0% and the description never mentions rideId. The parameter name is somewhat self-explanatory, but the description does not explain that rideId identifies the ride whose driver contact should be returned, which would be needed to fully compensate for the missing schema descriptions.

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

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

The description uses a specific verb ('Return') and resource ('demo contact action') and clarifies the phone is masked. It distinguishes itself from real contact or emergency help by saying 'never calls or messages anyone,' though it doesn't explicitly name sibling tools.

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

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

It gives no guidance on when to call this instead of, say, emergency_help, get_driver_profile, or a real messaging tool. The word 'demo' implies a test/sandbox context, but no explicit when-to-use or when-not-to-use conditions are provided.

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

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

With no annotations provided, the description carries the full burden. It clearly discloses the critical behavioral boundary: 'This demo does not contact emergency dispatch.' It also signals a read-only display action through 'Show safe emergency guidance.' This is meaningful transparency for a safety-related tool.

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

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

Two short sentences, no filler, with the key safety caveat placed prominently. Every word earns its place and the structure is easy to parse.

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

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

For a low-complexity tool with one optional parameter and no output schema, the description covers the core purpose and the most important safety boundary. However, it omits any explanation of rideId's role and does not situate the tool relative to safety_details, leaving some gaps for an agent deciding 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?

The schema has 0% description coverage for rideId, and the description does not mention the parameter at all. The agent cannot tell whether rideId is needed, optional context, or how it affects the guidance shown. The description fails to compensate for the missing schema documentation.

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

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

The description uses a specific verb and resource: 'Show safe emergency guidance.' It clearly conveys the purpose, but it does not explicitly distinguish itself from the sibling tool 'safety_details,' so it lacks full sibling differentiation.

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

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

The description implies usage context by stating it is a demo and explicitly notes that it does not contact emergency dispatch. However, it provides no direct when-to-use guidance or alternatives, leaving the agent to infer when this tool is preferable to safety_details or contact_driver.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses that the tool resolves locations into route metrics and dynamic fares, and mentions pickup ETAs. However, it does not disclose whether this operation mutates state, requires authentication, has side effects, or how location resolution handles ambiguous addresses. It also doesn't clarify whether the estimate is binding or merely informational.

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

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

The description is one focused sentence, front-loaded with the core action and output. It names all key outputs and ride types without paddding. It could be slightly clearer about parameter formats, but it is concise and scannable.

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

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

Given the tool has 2 parameters, no annotations, and no output schema, the description provides a reasonable overview of what is computed. However, it omits important context like the return value shape, whether surge pricing is included in 'dynamic fares', whether pickup ETAs are per ride type, and how to distinguish this from the related get_price_estimate and get_ride_options tools. It is minimally adequate for an agent to get a basic idea, but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate for the two parameters. It names 'pickup' and 'destination' as concepts and says they are 'resolved', implying both accept locations. It also adds that the output covers Moto, Auto, Go, Premier, and XL. However, it does not explain the acceptable formats, such as object vs string, or that both coordinate and address forms are supported. The schema has rich detail, but the description adds only moderate semantic value.

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

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

The description uses a strong verb 'Resolve' and names the exact resource: pickup and destination into route distance, duration, pickup ETAs, and dynamic fares across five ride types. It clearly distinguishes itself from nearby siblings like book_ride, request_ride, select_ride, and get_price_estimate.

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

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

The description implies this is an estimation/pre-booking tool but does not explicitly state when to use it versus get_price_estimate, get_ride_options, or select_ride. It gives context ('resolve... into route distance, duration, pickup ETAs, and dynamic fares') but lacks clear when-to-use or when-not-to-use guidance.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the tool does not access browser GPS, which is a meaningful behavioral boundary. It does not describe the return format or whether any other background behavior occurs, but the core no-GPS disclosure adds value.

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

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

The description is two short sentences with no wasted words. The main purpose is front-loaded, and the behavioral clarification about GPS is placed immediately after, making it easy for an agent to parse quickly.

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

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

For a zero-parameter tool with no output schema, the description gives the key facts: what is returned and what it is not. It could specify the exact return type or shape, but the simplicity of the operation makes the described behavior largely sufficient for correct invocation.

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

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

The tool has zero parameters and the schema already indicates this, so there is no missing parameter information to provide. The description adds relevant context about what the location represents, satisfying the baseline for a parameterless tool.

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

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

The description uses a specific verb ('Return') and identifies the exact resource ('configured demo pickup location'). It also clarifies that this is not GPS-based, which helps distinguish it from location-related sibling tools, though it does not name an alternative explicitly.

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

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

The phrase 'configured demo pickup location' implies this is for retrieving a preset/simulated location rather than a live one, and 'does not access browser GPS' hints when not to use it. However, it does not explicitly state when to choose this over siblings like get_driver_location or get_driver_location.

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 burden of disclosing behavior. It clearly indicates a read operation via 'Get' and lists returned fields, including the privacy-oriented 'masked phone.' It does not describe prerequisites, error behavior, or data availability conditions, but is adequate for a simple read 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?

A single sentence that directly states the tool's purpose and returned fields with no redundant or filler content. The key scope ('for a ride') is clear and front-loaded.

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

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

For a single-parameter read tool with no output schema, the description is mostly complete: it names the input context and enumerates the returned information. It could mention when driver info is available or that the phone is intentionally masked for privacy, but these are minor gaps for this simple tool.

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

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

Schema coverage is 100%, and the rideId parameter is already described as 'Ride ID returned by request_ride.' The description adds no extra parameter detail, but none is needed given the schema's clarity.

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

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

The description names a specific verb (Get) and a specific resource (assigned driver, rating, vehicle, registration, completed trips, and masked phone for a ride). The field list makes it clearly distinguishable from siblings like get_driver_profile, get_ride_details, and get_driver_location.

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

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

The phrase 'for a ride' implies this tool is used when an agent needs driver information tied to a specific ride. However, it gives no explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives such as get_driver_profile or get_ride_details.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior, and the description does not contradict these. It adds context that the tool returns both location and status for an active ride, but it does not disclose behavior for invalid or inactive ride IDs, or what the response format 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?

A single, concise sentence that front-loads the purpose and scope. Every word contributes to the agent's understanding, with no redundancy or filler.

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

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

For a simple one-parameter, read-only tool with comprehensive annotations, the description sufficiently conveys what the tool does and what it returns. The absence of output schema is mitigated by explicitly naming the output ('driver location and ride status'). Minor gaps around edge-case behavior are not critical for basic usage.

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

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

The schema fully describes the sole parameter rideId, including its provenance ('returned by request_ride'), so the description does not need to add parameter details. The tool description adds no semantic information beyond the schema, which is acceptable given 100% schema coverage.

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

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

The description clearly states the verb 'Get' and the resource 'current Uber driver location and ride status' for an active ride. It distinguishes itself from get_driver_details and get_ride_status by combining both pieces of information, though it does not explicitly call out any sibling tool.

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

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

The phrase 'for an active ride' provides a contextual condition for use, but there is no explicit guidance on when to choose this over track_driver, get_ride_status, or get_driver_details. No alternatives or exclusions are mentioned, leaving the agent to infer the appropriate context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that this is ride-scoped and that standalone lookup is unsupported, which is useful context, but it does not describe return shape or additional behavioral constraints.

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

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

Two short sentences, front-loaded with the core purpose and immediately followed by a key limitation. No filler or redundant 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 a single-parameter read-only lookup, the description is mostly complete: it tells the agent what the tool returns at a high level and warns about the standalone lookup limitation. There is no output schema, so one could ask for more return-field detail, but the description is adequate for correct invocation.

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

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

Schema description coverage is 100%; the driverId parameter is documented as 'Driver ID returned by a ride or nearby-driver search.' The tool description adds little beyond that, so the schema carries the parameter 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 description uses a specific verb and resource: 'Get the assigned driver details for a ride.' It also distinguishes itself from standalone driver-profile lookup, clarifying that this is the ride-scoped path rather than a generic driver-profile endpoint.

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

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

The description gives clear context: use this when you need the driver assigned to a specific ride. It also notes that standalone driver-profile lookup is not available in Uber's Rider API, which is a useful exclusion, though it does not explicitly name an alternative sibling tool.

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

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

With no annotations, the description supplies the main behavior: it returns fare line items and applies to completed demo rides. It does not disclose error behavior, whether the ride must be in a specific state, or what 'fare line items' includes; this is acceptable for a simple read-only tool but not rich.

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

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

The description is a single sentence that front-loads the action and object with no filler. It is appropriately sized for a one-parameter read-only tool.

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

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

For a simple one-parameter read tool, the description tells an agent what it returns and when it applies. However, with no output schema and no differentiation from receipt siblings, an agent may not know whether get_fare_breakdown, get_ride_receipt, or get_trip_receipt is correct, and 'demo ride' is left undefined.

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

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

The input schema documents rideId fully, including that it is the ID returned by book_ride, so schema coverage is 100%. The description adds no parameter-level meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Return') and resource ('detailed fare line items') and adds a scope ('completed demo ride') that separates it from pricing-estimate tools. However, it does not explicitly distinguish itself from sibling receipt tools like get_ride_receipt or get_trip_receipt, so it is clear but not fully 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?

The phrase 'for a completed demo ride' gives explicit context that this tool applies after a ride is finished. But there is no guidance about when not to use it or which sibling should be preferred, so usage versus alternatives remains mostly implicit.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so safety is covered. The description adds meaningful behavioral context by explaining the tool returns product availability and ETAs rather than driver identities, which is important because the tool name is misleading.

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

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

The description is two tight sentences with no filler. The primary purpose is front-loaded, and the clarifying limitation about driver identities earns its place by preventing a common misuse.

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

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

For a read-only query tool with nested location parameters and no output schema, the description conveys the essential return concept—product availability and pickup ETAs—and the key limitation. It does not explain category or radius semantics, but the schema provides enums and a default for those, so the description is nearly complete.

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

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

Schema description coverage is 0%, and the description provides no parameter-level guidance. The names and schema structures make 'location' and 'radiusKm' somewhat self-explanatory, and category is an enum, but the description does not compensate for the lack of schema descriptions as required when coverage is low.

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

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

The description uses a specific verb and resource: 'Get real Uber product availability and pickup ETAs near a location.' It also corrects the potentially misleading tool name by noting that Uber does not expose nearby driver identities, clearly distinguishing this tool from driver-location or tracking siblings.

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

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

The description implies when to use the tool: when real product availability and pickup ETAs are needed near a location. It also states a clear when-not: it cannot list nearby driver identities. However, it does not explicitly name alternative sibling tools or provide routing conditions.

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

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

With no annotations, the description must carry the behavioral burden. It implies a read-only operation through 'List' and 'safe demo', which is useful, but it does not disclose authentication needs, possible emptiness, or any operational caveats. This is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the essential information efficiently.

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

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

For a parameterless tool with no output schema, this description gives enough to understand what the tool returns and its demo-oriented nature. It is slightly incomplete because it does not clarify the relationship to list_payment_methods or whether these are the only possible choices in all circumstances.

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

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

The tool has zero parameters, so the description is not required to add parameter-level meaning. The baseline for a zero-parameter tool is 4, and the description does not introduce any confusion.

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

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

The description clearly identifies the action ('List') and the resource ('safe demo payment choices'), and even enumerates the expected values. However, it does not explicitly distinguish this tool from the sibling list_payment_methods, so it stops short of a 5.

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

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

There is no guidance on when to use this tool instead of list_payment_methods or how it relates to payment management tools like choose_payment_method and add_payment_method. The 'safe demo' qualifier hints at the intended context but is not made actionable.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is established. The description adds useful context about the return contents (fare range, distance, duration, currency, surge multiplier), which is valuable since there is no output schema. The qualifier 'current' is slightly problematic because the input schema includes optional reserveAt for future scheduling, creating ambiguity about whether this tool handles non-current estimates.

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

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

The description is a single sentence with no filler, front-loading the core action ('Get a current Uber fare range') and then listing the specific return fields. Every word contributes meaning, and it is appropriately sized for a read-only estimation 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?

The description covers the main inputs (two locations) and all key outputs, which is adequate for basic use. However, it does not explain the three optional parameters (riders, category, reserveAt), which could materially affect the estimate, and it does not address the reserveAt/current-time tension. For a tool with no output schema and 0% parameter description coverage, more context is needed to be considered complete.

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

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

Schema description coverage is 0%, and the description only hints at 'between two locations' for pickup and destination. It provides no explanation of riders, category, or reserveAt semantics, nor any compensation for the missing schema descriptions. The enum values and defaults are visible in the schema, but the tool description does not help an agent understand why or when to use these optional parameters.

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

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

The description clearly states a specific verb ('Get') and resource ('current Uber fare range') and lists concrete outputs (fare range, distance, duration, currency, surge multiplier), making the core purpose easy to grasp. However, it does not explicitly distinguish itself from similarly named siblings like estimate_ride or get_fare_breakdown, so differentiation relies on inference rather than direct comparison.

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 word 'current' and the mention of 'between two locations' imply this is for real-time fare estimates rather than historical receipts or booking. However, there is no explicit guidance about when to choose this tool over estimate_ride, get_fare_breakdown, or get_ride_options, nor any exclusions or alternative references.

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 disclosure burden. It only says 'Return,' which implies a read, but it does not mention ordering, default limit behavior, whether status filters the results or only describes the returned statuses, or any other call characteristics. The agent is left guessing about how the tool actually behaves.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes to the core meaning, making it easy to scan quickly.

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 output schema and no annotations, the description is too sparse to be complete. It does not state what happens when no status is provided, how recency is determined, how limit applies, or what the return shape looks like. An agent has enough to guess the purpose but not enough to invoke it confidently without additional assumptions.

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

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

Schema description coverage is 0%, so the description must compensate for the parameter documentation gap, but it does not explain `limit` or `status` as parameters. The phrase 'completed and cancelled' hints at the status enum values, but it does not clarify that status is an optional filter or that limit defaults to 10 and caps at 50.

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

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

The description uses a specific verb ('Return') and names the concrete resource ('most recent completed and cancelled rides' from 'the shared ride store'). This makes the basic action clear and distinguishes it from detail/receipt-focused siblings like get_trip_details and get_ride_receipt. It could be slightly more explicit about how it differs from list_trps, but the core purpose is unambiguous.

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

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

There is no guidance on when to choose this tool instead of list_trps, get_trip_details, or get_ride_status, and no when-not-to-use conditions. The phrase 'most recent' implies a recency use case, but the description does not provide enough context to route an agent among the many ride-history sibling tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It tells the agent what data is returned but does not state whether the call is read-only, what happens for an invalid or past rideId, or whether 'current' means only active rides. This ambiguity could mislead an agent into using it incorrectly.

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

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

The description is a single, efficient sentence that front-loads the verb and resource before listing the returned fields. There is no unnecessary content or repetition of the tool name.

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

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

For a simple one-parameter get-by-id tool, the description covers the primary return payload, which partially compensates for the lack of an output schema. However, it leaves 'current' ambiguous relative to the rideId parameter, does not explain error behavior, and offers no routing to sibling tools, so the overall context is only moderately complete.

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

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

Schema coverage is 100%: the rideId parameter has a clear description ('Ride ID returned by request_ride'). The tool description adds no further parameter-level meaning beyond implying that the rideId identifies the ride record, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Return') and resource ('complete current ride record') and enumerates key fields (route, fare, driver, vehicle, ETA, status), making its purpose clear. It implies this is the comprehensive ride lookup tool, but it does not explicitly differentiate from siblings like get_ride_status or get_trip_details.

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

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

There is no guidance about when to choose get_ride_details over alternative tools such as get_ride_status, get_fare_breakdown, or get_trip_details. The phrase 'complete current ride record' weakly suggests using it for full details, but no explicit conditions or alternatives are given.

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

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

Annotations already mark it read-only, idempotent, and non-destructive, so no extra safety disclosure is required. The description adds useful 'real' and 'current' context—live products/ETAs, not estimates—but omits response shape and whether both pickup and destination are needed.

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?

Single sentence, no filler, and front-loaded with the verb and object. Every word earns its place, even though the description is minimal.

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 two optional and complex location parameters, no output schema, and many nearby siblings, this one-sentence description is insufficient for reliable invocation. It leaves parameter semantics and when-to-use to be inferred, although the clear purpose and safe annotations keep it from being a total failure.

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

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

Schema description coverage is 0%, so the description needed to compensate, but it does not mention pickup or destination at all. The nested schema descriptions are helpful, yet the tool description leaves unclear why two optional locations exist and what happens with no arguments.

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

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

States a specific verb ('List'), a concrete resource ('real Uber products and current pickup ETAs'), and a location scope. It is clear on its own, but does not explicitly name or contrast nearby siblings such as get_price_estimate or estimate_ride, so the differentiation 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 guidance about when to prefer this over get_price_estimate, estimate_ride, or get_fare_breakdown. The phrase 'pickup ETAs' hints at a use case, but the description does not state exclusions, prerequisites, or alternatives.

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

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

No annotations are provided, so the description carries the full burden. It signals a read-only operation through 'Return' and scopes to completed rides, but it does not disclose error behavior, authorization requirements, or what happens for an invalid or unknown rideId.

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

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

A single sentence, front-loaded with the verb and direct object, with no filler. Every listed field is relevant to the receipt concept, making the definition compact and readable.

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

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

For a one-parameter read tool, the description adequately covers the returned data and the completed-ride condition, especially since there is no output schema. It falls short only in not addressing error/permission behavior or distinguishing itself from related receipt/fare tools.

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

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

Schema description coverage is 100%; rideId is already documented as 'Ride ID returned by book_ride'. The description adds no additional parameter format, constraints, or context, so it meets the baseline but does not enhance what the schema already provides.

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

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

The description clearly states a specific action ('Return') and resource ('completed ride receipt'), and enumerates the fields returned: route, fare, fees, total, payment method, driver, vehicle, and date. It is clear, though it does not explicitly differentiate itself from the similar sibling tools get_trip_receipt or get_fare_breakdown.

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

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

The phrase 'completed ride' provides a clear precondition that this tool is intended for completed rides only. However, there is no explicit guidance about when to prefer this tool over get_trip_receipt or get_fare_breakdown, nor any when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which cover the main safety behavior. The description adds modest behavioral context with 'latest' status, implying freshness, but does not describe invalid rideId handling, data staleness, or whether this reflects a live feed. No contradiction with annotations exists.

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

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

The description is a single sentence that lists the key data points and is immediately understandable. There is no filler, repetition, or unnecessary detail, and the main purpose is front-loaded.

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

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

For a simple read-only tool with one required parameter and strong annotations, the description combined with the schema is largely sufficient. It names the output aspects an agent might care about, but with many sibling ride tools and no output schema, it could improve by clarifying how it differs from get_ride_details or mentioning error/empty-status behavior.

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

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

The schema has 100% coverage for the single rideId parameter, including the useful note that it is 'returned by request_ride'. The description does not add parameter-specific meaning beyond referencing the ride, so the schema carries the semantic load. Baseline 3 is appropriate.

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

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

The description clearly identifies the verb ('Get'), the resource ('ride'), and the data returned: status, route, driver assignment, ETA, and fare estimate. It is not a tautology and an agent can understand the tool's core function. However, it does not explicitly distinguish this from closely named siblings like get_ride_details or get_trip_details.

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

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

There is no guidance about when to use this tool versus alternatives such as get_ride_details, get_fare_breakdown, or track_driver. The word 'latest' implies current ride state, but no explicit when-to-use or when-not-to-use guidance is provided.

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

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

No annotations are provided, so the description bears the full behavioral disclosure burden. It only says 'Return' and mentions demo places, offering no detail about response shape, absence behavior, or whether any state changes occur. This is only slightly more informative than the tool name itself.

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

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

The description is a single short sentence with the action and key examples front-loaded. Every word contributes value and there is no redundant or filler 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 a zero-parameter tool with no output schema, the core invocation is simple and the description covers the basic purpose. However, the ambiguity with the sibling list_saved_places and the lack of any behavioral or return detail make it only minimally complete.

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

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

The tool has zero parameters, so the baseline of 4 applies. The description does not need to explain parameter behavior because there are no parameters to document.

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

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

The description uses a specific verb 'Return' and clearly identifies the resource as saved places, listing examples like Home, Work, and SRM. It is not a tautology, but it does not distinguish itself from the sibling tool list_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?

The description gives no guidance on when to use this tool versus list_saved_places or other saved-place tools. It only implies a read action without stating conditions, exclusions, or alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds 'current' to indicate real-time data, but does not disclose output format, whether the multiplier is rounded/estimated, or any rate-limit or staleness behavior.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to the core meaning, making it easy to scan and quick for an agent to parse.

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

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

For a simple read-only lookup this is minimally sufficient: the agent knows what to query and what concept is returned. However, there is no output schema and the description does not say what the response looks like (e.g., a numeric multiplier, example values, or the meaning of 1.0), leaving some ambiguity for downstream handling.

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 nested schema documents address, latitude, and longitude well, but the top-level 'location' property has 0% schema description coverage. The description adds that this is a 'pickup location,' which helps disambiguate from destination, but it does not explain why all three subfields are required or how they interact.

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

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

The description clearly states the specific operation: checking the current Uber demand multiplier at a pickup location. It is easy to distinguish from receipt/trip/payment tools, though it does not explicitly differentiate itself from nearby pricing tools like get_price_estimate.

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

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

The phrase 'current... at a pickup location' implies the tool is for live surge checks at a pickup point, but there is no explicit guidance about when to prefer this over get_price_estimate, get_fare_breakdown, or get_ride_options. No exclusions or alternatives are mentioned.

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

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

Annotations already establish that the tool is read-only, idempotent, and non-destructive, so the description's job is lighter. It adds value by specifying the return contract — the exact trip fields an agent can expect — which is especially useful given there is no output schema. It does not mention errors or prerequisites, but the safety profile is fully covered by annotations.

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

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

The description is a single clean sentence with no filler. The key return fields are front-loaded, and every word contributes to the agent's understanding of what the tool does.

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

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

For a one-parameter read-only tool, the description covers the core return values and the annotations cover safety behavior. However, the environment contains many similarly named sibling tools, and the description lacks explicit differentiation or usage context, leaving some ambiguity about when this is the right tool.

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

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

Schema description coverage is 100%, and the single parameter tripId is already documented as 'Trip ID returned by trip history.' The description adds no parameter-level meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('a trip') and enumerates the exact contents: route, driver, category, timestamps, payment method, and receipt. This helps differentiate it from receipt-only and fare-only siblings, though it does not explicitly name any alternatives.

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

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

No guidance is given on when to use this tool versus closely related siblings like get_trip_receipt, get_fare_breakdown, or get_ride_details. The description states what the tool returns but not the conditions that should lead an agent to select it or exclusions that would point to alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds the 'completed trip' constraint and lists the returned financial fields, but it does not mention error behavior, what happens for incomplete or cancelled trips, or any auth requirements. With annotations covering safety, this is adequate but not rich.

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

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

The description is a single sentence that immediately states the action, the resource, and the expected contents. There is no filler, and the key scoping information ('completed trip') is included upfront.

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

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

For a simple read-only lookup with one documented parameter, the description provides enough context: it states what the receipt contains and that it applies only to completed trips. It does not explain output formatting or error cases, but given the tool's simplicity and annotation coverage, the definition is sufficiently complete.

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

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

The schema describes the only parameter (tripId) completely as 'Trip ID returned by trip history', so with 100% schema description coverage the description does not need to add parameter detail. The tool description adds no new parameter meaning, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Get') and resource ('trip receipt'), and enumerates the exact contents: fare line items, taxes, tip, total, and currency. It also restricts scope to 'completed trip', which clarifies intent, though it does not explicitly contrast with closely related sibling tools like get_ride_receipt or get_fare_breakdown.

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

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

The phrase 'for a completed trip' provides clear contextual guidance that this tool is only appropriate after a trip is finished. However, there is no explicit direction about when to choose this over similar siblings like get_fare_breakdown or get_ride_receipt, leaving some ambiguity for an agent.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds a useful behavioral detail: it returns not just payment methods but also identifies the default method for demo rides. However, it does not describe the return format, ordering, or any demo-specific caveats.

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

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

The description is a single, compact sentence that front-loads the primary action and adds the key secondary behavior. Every word contributes meaning; no padding or redundant phrasing.

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

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

For a zero-parameter, read-only list operation, the description is reasonably complete. It tells the agent what will be returned and highlights the default method identification. The only notable gap is the lack of differentiation from get_payment_methods, but the demo-specific framing reduces the risk of misuse.

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

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

The tool has zero parameters, so parameter semantics are inherently non-issue. Schema coverage is 100% and there is nothing for the description to add regarding inputs. Baseline of 4 applies.

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

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

The description states a clear verb ('list') and resource ('payment methods'), and adds a specific outcome: identifying the default method used for demo rides. It is clear, though it does not explicitly distinguish itself from the sibling get_payment_methods, which appears to cover a similar resource.

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 is given about when to use this tool versus alternatives such as get_payment_methods or choose_payment_method. The mention of 'demo' provides some context, but there are no explicit conditions, exclusions, or comparisons to 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, and the description's 'List' wording is consistent. The description adds the useful scope that only Home and Work saved places are returned, but it does not disclose response shape or any authentication expectations. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence with no filler or redundant restatement. Every word contributes to identifying the resource and scope.

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

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

For a zero-parameter, read-only tool, the description is mostly sufficient. The main gap is that the sibling get_saved_places exists and likely overlaps, yet the description does not clarify the distinction or direct the agent to the alternative for broader saved-place needs.

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

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

The tool accepts zero parameters and schema description coverage is 100%, so there are no parameter semantics to clarify. The baseline of 4 is appropriate because there is nothing else the description needs to add for parameters.

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

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

The description clearly names the verb ('List'), the resource ('saved places'), and a specific scope ('the rider's real Uber Home and Work'), which distinguishes it from a generic saved-places tool. It does not explicitly name the overlapping sibling get_saved_places, so it stops short of a 5.

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

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

Usage is implied: use this tool when the rider's Home and Work saved places are needed. However, the description gives no explicit when-to-use guidance, exclusions, or comparison to the sibling get_saved_places, so an agent must infer the right choice.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds 'recent' and 'completed or cancelled' scoping but no additional behavioral traits like ordering, recency window, or pagination; there is no contradiction.

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

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

A single front-loaded sentence with no filler. The core action and resource appear first, and the optional filter is appended clearly at the end.

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

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

For a simple read-only list with rich annotations, the description covers the main purpose and the status parameter. However, the unresolved overlap with get_recent_rides and the lack of any mention of ordering or limit behavior keep it from being fully complete.

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

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

Schema description coverage is 0%, so the description carries extra weight. It adds meaning for status by naming 'completed or cancelled' and indicating the filter is optional, but it says nothing about the limit parameter beyond what the schema name/default/range already imply.

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

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

States a specific verb ('List') and resource ('recent completed or cancelled trips'), with optional status filtering. However, it does not distinguish itself from sibling get_recent_rides, which may cover overlapping functionality.

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 list_trips versus get_recent_rides or get_trip_details, and no exclusions or prerequisites are given. The optional status filter is the only usage hint, but it does not help an agent choose among overlapping 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?

Annotations already communicate that the operation is destructive and idempotent, so the description adds value beyond them by stating the business rule that at least one payment method must remain. This helps an agent understand a key behavioral limitation that is not present in the schema or annotations.

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

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

The description is two short sentences with no filler: the core action comes first, followed immediately by the key constraint. Every word earns its place.

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

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

For a single-parameter destructive operation with annotations covering safety and idempotency, the description is nearly complete: it states the action and the main invariant. It could mention error behavior or effects on default payment methods, but those details are not necessary for making a correct minimal call.

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

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

Schema coverage is 100% and the only parameter, paymentMethodId, is already described in the schema as 'Payment method ID'. The description does not add additional detail about where the ID comes from or how it should be formatted, so it stays at the baseline for a well-covered schema.

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

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

The description uses a specific action verb ('Remove') with a clear resource ('saved payment method'), making the tool's purpose unambiguous. It is easily distinguished from sibling tools such as add_payment_method, list_payment_methods, and set_default_payment_method.

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

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

The description implies this tool is used when a saved payment method needs to be deleted, and it adds a useful constraint ('At least one payment method must remain on the account'). However, it does not explicitly describe when to prefer this over alternatives or what to do if the account has only one payment method.

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

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

Annotations declare readOnlyHint=false and destructiveHint=true, implying a mutating operation. The description states Uber's API does not expose saved-place deletion and the tool only reports that limitation, implying no mutation actually occurs. This directly contradicts the annotations.

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

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

The description is two short sentences with no filler. The intended action is front-loaded and the critical limitation is stated immediately afterward, making it efficient and easy to parse.

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

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

The central caveat is present and the tool is low-complexity with one parameter. However, there is no output schema and no detail about how the limitation is reported, what the caller should do with that information, or whether this tool is effectively a stub. Some gap remains.

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

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

Schema description coverage is 100%: placeId is described as 'Saved place ID.' The tool description adds no additional meaning about the parameter, so the schema carries the full burden. Baseline 3 is appropriate.

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

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

The first sentence, 'Remove a saved place,' names a clear action and resource. However, the second sentence reveals the tool cannot actually remove the place and instead reports an API limitation, so the actual purpose is ambiguous between performing removal and surfacing unsupported functionality.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it state that it should only be used to inform users that deletion is unsupported. There is no mention of when not to call it or what to do instead.

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

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

Annotations already indicate a mutating action (readOnlyHint=false, destructiveHint=false, idempotentHint=false). The description adds that demo mode uses a shared deterministic demo store and live mode uses Uber when authorized, which is meaningful behavioral context. However, it does not disclose side effects such as driver dispatch, fare charges, or cancellation implications, which matter for a booking tool.

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

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

The description is two sentences with no filler. The primary action is front-loaded, and the demo/live mode behavior is the next most important piece of information for an agent deciding whether and how to call 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?

For a multi-parameter, nested-object, mutating tool with no output schema, the description is too sparse. It does not specify what a successful response contains, how errors surface, whether payment is required, how scheduling works, or what authorization prerequisites beyond 'when authorized' are needed. The deterministic demo-store behavior is mentioned but not explained in terms of constraints.

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

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

Schema description coverage is only 43%, and the description adds little parameter detail beyond naming pickup and destination. Riders, category, scheduledAt, paymentMethodId, and riderNote are not explained in the description, and some of these (riders, category) have no schema-level description either, leaving a real gap for correct invocation.

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

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

The description states the specific verb 'Book' and the resource ('a ride from a pickup location to a destination'), so the core action is clear. It does not explicitly differentiate from the sibling tool book_ride, which appears to serve a very similar purpose, but it does add the demo/live mode distinction that helps an agent understand what environment this call operates in.

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

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

There is no explicit guidance about when to choose this tool over alternatives such as book_ride, select_ride, or estimate_ride. The demo/live mode note is useful environmental context, but it does not tell the agent when this tool is the right one, what prerequisites exist, or that other ride-related flows should be considered 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?

With no annotations, the description must supply the behavioral context, but it only says 'Return,' which implies read-only without stating side effects, permissions, or output behavior. It gives no information about what safety details are included or what happens for invalid ride IDs.

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

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

One sentence with no filler and the key operation is front-loaded. It is appropriately short, though it sacrifices informative 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 a tool with no output schema and no annotations, the description does not explain what safety information will be returned, how to use rideId, or what distinguishes this call from similar ride-information tools. The description is too minimal to fully support correct invocation.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining rideId, but it only mentions 'for a demo ride' without explicitly defining rideId as the identifier of the demo ride or describing its format and expected values. This adds minimal meaning beyond the schema's minLength constraint.

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?

Describes a specific verb ('Return') and resource ('safety information') for a ride, and 'safety' is not addressed by any sibling tool, so an agent can understand what it does. However, it does not explicitly differentiate itself from closely related ride-information siblings such as get_ride_details or get_trip_details.

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 is provided for when to choose this tool over the many ride-related siblings, such as get_ride_details or get_trip_details. 'For a demo ride' hints at a use case but does not explain when safety_details is appropriate or when it should be avoided.

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

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

There are no annotations, so the description carries the burden. It discloses that the address and coordinates are 'validated,' which is useful, and 'Create or update' signals an upsert behavior. Still, it does not explain what happens when a name already exists, whether an existing place is overwritten, or any authorization requirements, leaving some behavioral ambiguity.

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

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

The description is a single, focused sentence that front-loads the key verb and resource. Every word contributes meaning, and it is not padded with redundant 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 simple upsert tool with a well-structured input schema, the description covers the core action and validation aspect. However, with no annotations and no output schema, it does not describe return values, error conditions, or duplicate-name behavior, which would help an agent handle edge cases after invoking the tool.

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

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

Schema coverage is 50%, and the nested location object already documents address, latitude, and longitude with descriptions. The description adds the concept of validation but provides little beyond the schema for the name parameter or the relationship between the parameters. It adds some value but does not fully 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 states a specific action ('Create or update') and resource ('named saved place'), and it differentiates from sibling tools like get_saved_places, list_saved_places, and remove_saved_place, which are clearly read or delete operations. An agent can immediately distinguish this as the write/upsert tool for 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?

The description implies the tool is used when a user wants to create or update a saved place, and the sibling set clarifies it is not for listing, retrieving, or removing places. However, it does not explicitly state when to use create versus update, nor does it mention any preconditions such as needing to first search for a location with search_locations.

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?

Since no annotations are provided, the description carries the full behavioral disclosure burden. It usefully reveals that results come from seeded coordinates in demo mode rather than live data, but it does not mention matching semantics, result limits, authentication needs, or any other behavioral traits an agent might need.

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

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

The description is a single, tightly written sentence with no filler or redundant information. Key facts about scope, location, and mode are front-loaded and every word earns its place.

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

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

For a simple one-parameter search tool, the description is mostly adequate, but with no output schema it does not clarify what the agent should expect back: whether matches include coordinates, labels, or just place names. The absence of behavioral annotations and result-format details leaves meaningful gaps for an agent invoking the tool.

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

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

The input schema has 100% coverage for the single 'query' parameter, so the schema already explains that it is pickup or destination search text. The description adds Chennai/demo context but does not provide additional parameter-specific meaning beyond what the schema states, so the baseline score of 3 applies.

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

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

The description clearly states a specific verb ('Search'), a concrete resource ('known Chennai pickup and destination locations'), and important scope ('real seeded coordinates in demo mode'). It does not explicitly differentiate from sibling tools like get_saved_places, but the resource type is distinct enough for an agent to understand the tool's 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?

The description implies use within a Chennai ride-booking context when searching for pickup or destination locations, and 'demo mode' suggests test usage. However, it does not explicitly state when to use this tool over alternatives or provide exclusion criteria, leaving usage guidance mostly implicit.

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

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

No annotations are present, so the description carries full behavioral burden. It reveals that selecting a ride type is a distinct step before booking, but does not disclose whether the selection persists, is reversible, or has side effects, nor any failure conditions. This is a significant gap for a state-changing action.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word contributes to the core purpose.

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

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

With no output schema and no annotations, the agent is left without information about return values, failure behavior, or prerequisites (e.g., a valid estimate that offers these ride types). The description covers only the high-level action.

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 provides no parameter meaning. estimateId and rideTypeId are not explained beyond the schema; the enum on rideTypeId helps, but the relationship between the parameters and the estimate is left implicit.

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

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

The description uses a specific verb ('Select') and a specific resource ('one ride type from an estimate'), with a clear temporal context ('before booking it'). This distinguishes it from sibling tools like book_ride and estimate_ride.

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

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

The phrase 'before booking it' establishes a clear workflow position: the tool is used to choose a ride type from an estimate, prior to booking. It does not explicitly name alternatives or exclusions, but the context is sufficiently clear.

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

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

Annotations declare idempotentHint=true and destructiveHint=false, and the description adds the functional consequence: the chosen method becomes the fallback for request_ride. No annotation contradiction exists. It does not detail persistence or failure behavior, but the annotations keep the burden low.

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

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

One concise sentence states the action, the object, and the triggering condition, with no redundant words or restatement of the tool name.

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

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

For a one-parameter setter with idempotent, non-destructive annotations, the description covers the essential context. It could also mention what happens to a previously set default or what return value is expected, but these are not major gaps for such a simple operation.

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

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

Schema description coverage is 100%: paymentMethodId is documented as 'Payment method ID' with minLength 1. The description adds no additional parameter semantics, so the baseline of 3 applies.

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

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

The description states a specific verb ('Choose'), a specific resource ('saved payment method'), and a precise effect ('used when request_ride omits a payment method ID'). This distinguishes it from list/add/remove payment-method siblings and clarifies default-setting behavior.

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

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

It clearly indicates when the selection matters: whenever request_ride does not specify a paymentMethodId. It does not explicitly name sibling alternatives such as choose_payment_method, but the context makes the use case unambiguous.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does state that private contact information is not exposed, which is a useful privacy guarantee, but it does not disclose whether this action mutates state, creates a persistent share link, requires authentication, or has other side effects.

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

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

The description is a single sentence with no filler and front-loads the primary action. It is compact and readable, though the phrasing 'safe demo share representation' is slightly awkward.

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

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

With no output schema and no annotations, the description should explain what the share representation looks like, how it is returned, and what the rideId is used for. It leaves all of these critical details unspecified, making it incomplete for reliable agent usage.

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 rideId is self-descriptive in the schema, but the description does not reference it at all. With schema description coverage at 0%, the description needed to explain how rideId is used or what the parameter represents, and 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?

The description names a specific action ('Create') and a resource ('safe demo share representation'), and the tool name confirms it relates to sharing a trip. However, 'safe demo share representation' is ambiguous about what is actually produced, and the description does not clearly distinguish this from related tools like get_trip_details.

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

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

The phrase 'safe demo' implies a demo/limited-use context, but there is no explicit guidance on when to use this tool versus alternatives. No sibling tools are referenced, and no exclusions or conditions are provided.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It clearly implies a read-only operation ('Return') but does not disclose whether an active ride is required, whether data is real-time, or any error/edge-case behavior. Basic transparency is present, but richer context is missing.

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

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

The description is a single, front-loaded sentence with a comma-separated list of returned fields. Every word contributes value, and there is no redundancy or fluff.

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

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

Given the tool's low complexity (one parameter, no output schema), the description sufficiently covers the return payload by listing all key fields. It lacks any usage-context details, but those are partly captured in other dimensions; overall the picture is close to complete.

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

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

The input schema describes rideId as 'Ride ID returned by request_ride', achieving 100% parameter coverage. The description adds no additional meaning about the parameter, so the schema already does the heavy lifting; baseline 3 is appropriate.

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

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

The description states a specific verb ('Return') and clearly enumerates the resource scope: driver coordinates, pickup, destination, progress, ETA, and current ride status. This distinguishes the tool from siblings like get_driver_location or get_ride_status by signaling a comprehensive tracking snapshot rather than a single-purpose lookup.

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

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

The description implies usage for tracking a driver mid-ride but never explicitly tells when to use this tool versus alternatives such as get_driver_location or get_ride_status. Given many ride-related siblings, explicit routing guidance would have been valuable; without it, the agent must infer the use case.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the mutating and destructive nature is covered. The description adds limited behavioral context by specifying the ride must be active and that an updated live request is returned, but it does not explain what destructive side effects occur, such as overwriting the prior destination or potential fare impacts.

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

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

The description is a single, front-loaded sentence with no filler. Both clauses earn their place: the first states the action and scope, the second states the return value. This is an appropriate size for a tool with a relatively simple 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?

Given the absence of an output schema, the description's mention of 'updated live request' gives a basic return expectation, but not the shape or fields. The tool also has a destructiveHint=true annotation and a nested destination object, so an agent would benefit from more context about ride-state prerequisites and the effects of setting a new destination. It is adequate but not fully complete.

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

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

Schema coverage is 50%, and the description adds the meaningful constraint that the ride must be active, which refines rideId semantics beyond the schema's 'Ride ID returned by request_ride.' However, it does not elaborate on destination structure or values, relying mostly on the nested schema fields for address, latitude, and longitude.

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

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

The description uses a specific verb and resource: 'Change the destination of an active Uber ride' and adds the outcome 'return the updated live request.' This clearly differentiates it from sibling tools like cancel_ride, complete_ride, and get_ride_details without requiring the reader to inspect the schema.

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

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

The phrase 'active Uber ride' provides an implied precondition, suggesting this tool is only for changing destinations of rides that are currently active. However, it does not explicitly name alternatives or state when not to use it, such as for completed/cancelled rides or when to use get_ride_details instead.

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