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

With no annotations, the description carries the behavioral burden; it does convey a read-only list operation and a live status ('currently marked'). It omits details like pagination, response shape, and auth context, but the basic behavior is transparent enough for a simple fetch 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 focused sentence with no filler; the parenthetical defines the domain term '86'd' without expanding length. Every word contributes.

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 one-line description is too sparse. It does not clarify whether 'all items' is scoped by restaurantGuid, what fields will be returned, or whether results are paginated, leaving an agent with an under-specified 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?

There is one optional parameter with 0% schema description coverage, and the description never mentions restaurantGuid or how omitting it changes the result. The description adds no meaning beyond the property name, so it fails to compensate for the empty schema description.

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

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

The description uses a specific verb and resource: 'Get all items currently marked as out of stock (86'd)'. It clearly identifies the tool's purpose and differentiates it from low-stock/stock-item siblings through the 86'd condition, though it does not explicitly name those alternatives.

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

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

The phrase 'currently marked as out of stock' implies this tool should be used when the current set of 86'd items is needed. However, it provides no explicit guidance about when to prefer this over toast_list_low_stock_items or toast_get_stock_item, and no prerequisites or exclusions are 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 and no output schema, the description carries the full behavioral burden. It conveys that this is a non-mutating snapshot of clocked-in shifts, but it does not disclose pagination, response contents, or whether an omitted restaurantGuid scopes the result to all accessible restaurants.

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 or repetition. Every word contributes to the meaning.

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

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

For a read-only list with no required parameters, the description is minimally viable: an agent can select and invoke it with no arguments. However, without an output schema or parameter guidance, it is not fully complete for agents that need to know the result shape or scoping 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?

Schema description coverage is 0% and the description never mentions restaurantGuid, so it adds no meaning beyond the parameter name. The optionality of the single parameter softens the impact, but the agent is left to infer how restaurant filtering behaves.

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 a concrete resource ('currently active/clocked-in shifts'), and the active/clocked-in qualification distinguishes this tool from siblings like toast_list_shifts and toast_get_shift. The scope is immediately clear even without a title.

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 'currently active/clocked-in' provides clear context: use this tool when you need live, in-progress shifts rather than historical or scheduled ones. It does not explicitly name alternatives or exclusions, so it stops short of a full 5.

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

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

With no annotations provided, the description carries the full behavioral burden. 'Get' signals a read-only retrieval, which is useful, but the description does not disclose response format, error behavior, optionality of restaurantGuid, or any other runtime traits an agent would need to predict the tool's 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 redundant words. Every part contributes: 'get' states the action, 'detailed information' sets expectations, and 'specific cash drawer' distinguishes this from list operations.

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

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

For a tool with no annotations, no output schema, and empty property descriptions, this description is too thin. The agent can infer a basic get-by-GUID call, but it cannot know what 'detailed information' includes, why restaurantGuid is optional, or what a successful or failed response looks like.

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

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

Schema description coverage is 0% and the description adds no parameter-level meaning. 'Specific cash drawer' only restates that an identifier is involved; it does not explain drawerGuid or the optional restaurantGuid, leaving the agent without the information needed to construct a correct call.

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 a clear resource ('a specific cash drawer'). The word 'specific' differentiates it from list-style sibling tools, but it does not distinguish it from toast_get_cash_drawer_summary, so there is some ambiguity about the difference between 'detailed information' and 'summary'.

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 'a specific cash drawer' implies it should be used when the agent already has a drawer identifier and needs details, rather than when listing drawers. However, there is no explicit when-to-use guidance, no mention of alternatives, and no clarification of when toast_get_cash_drawer_summary or toast_list_cash_entries would be more appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does reveal that the output summarizes paid-in, paid-out, and net amounts, which goes beyond the tool name. However, it does not disclose authentication requirements, period/date-range handling, whether the summary is for one drawer only, or any response format details.

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

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

The description is a single concise sentence with no filler. The core purpose and key result fields are front-loaded. It earns high marks for brevity, though the brevity contributes to the lack of parameter and usage guidance.

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

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

The tool has no output schema and empty parameter descriptions, so the description is the only source of semantic information. It gives the gist but is not enough for correct invocation: an agent does not know what drawerGuid means, when restaurantGuid is needed, or what shape the summary takes. This is a clear completeness gap.

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 both parameter descriptions are empty. The tool description does not explain drawerGuid or restaurantGuid at all, despite restaurantGuid being optional and potentially important for scoping. The description fails to compensate for the complete lack of schema-level parameter 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 ('Get') and resource ('summary of cash drawer activity') and clarifies the exact contents ('paid in, paid out, net'). This distinguishes it from siblings like toast_get_cash_drawer and toast_list_cash_drawers, which clearly address different concerns.

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

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

The description provides no guidance on when to use this tool versus toast_get_cash_drawer, toast_list_cash_entries, or toast_get_payment_summary. No context, prerequisites, or alternative selection criteria are given, so an agent must infer usage from the name alone.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only promises 'detailed information' without revealing response contents, whether restaurantGuid can affect scope, error behavior, or any other operational constraints. An agent cannot predict much beyond the basic read operation.

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

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

The description is a single efficient sentence with no filler and the action/resource is front-loaded. It is concise, though the minimalism contributes to the broader incompleteness.

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

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

With no annotations, no output schema, and empty parameter descriptions, the definition needed to explain the response shape, parameter semantics, and relationship to sibling tools. It provides none of that, leaving an agent with only a high-level purpose statement.

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 both property descriptions are empty, so the description must compensate. It adds only the vague context that a check belongs to an order and fails to explain checkGuid's format or the role of the optional restaurantGuid.

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 ('Get'), a concrete resource ('check'), and relevant scoping ('within an order'), so the primary purpose is easy to grasp. It does not explicitly differentiate itself from overlapping siblings like toast_get_check_payments, which keeps it from 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?

No guidance is given about when to use this tool instead of related tools such as toast_get_order, toast_get_check_payments, or toast_get_payment_summary. The phrase 'specific check' implies targeted retrieval, but the description provides no explicit context, prerequisites, or exclusions.

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

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

With no annotations, the description carries full behavioral disclosure burden, but it only restates the retrieval intent already implied by the name. It does not disclose pagination, data completeness limits, authentication needs, or whether the tool is read-only beyond the obvious 'Get' phrasing.

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, economical sentence with no filler. Every word contributes to the core meaning.

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

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

Given no output schema, no annotations, and empty parameter descriptions, the description is not complete enough for a caller to fully understand return shape, optional parameter semantics, or edge cases. It is minimally viable but leaves significant 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?

Schema description coverage is 0%, so the description must compensate. It weakly clarifies that payments are tied to a check, which maps to checkGuid, but it says nothing about restaurantGuid's optional role or how the two parameters 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 identifies the action ('Get'), the resource ('payments'), and the scoping entity ('a check'). The word 'all' hints at collection semantics, distinguishing it from toast_get_payment, though the differentiation is implicit rather than explicitly 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 usage guidance is provided. The description does not explain when to choose this tool over toast_get_payment or toast_get_payment_summary, nor does it mention any exclusions or prerequisites.

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

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

With no annotations, the description carries full behavioral disclosure burden. It only says 'Get', which implies a read operation, but it does not explain response behavior, error cases, whether restaurantGuid is needed, or any other runtime traits.

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

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

The description is a single concise sentence with no filler and is easy to scan. It is slightly under-specified, but what is present is efficient 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?

The tool has no output schema and no annotations, yet the description does not explain what the returned loyalty status looks like, how restaurantGuid affects the lookup, or what happens when no loyalty record exists. This is inadequate for reliable invocation.

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

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

Schema description coverage is only 50%, and the description adds no parameter meaning beyond the schema. The loyaltyIdentifier is documented in the schema as 'Phone number or loyalty card number', but restaurantGuid has an empty description and the tool description does not compensate.

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

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

The description clearly states a specific verb ('Get') and resource ('loyalty program status') scoped to a customer. It is easily distinguished from sibling tools like toast_search_customers or toast_get_customer_order_history, though it does not explicitly differentiate itself from those 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 provided about when to use this tool versus sibling customer-related tools, nor any context about prerequisites or exclusions. The agent is left to infer that this is the tool for loyalty status from the name alone.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It only restates the core operation and does not explain how the customer is selected, what happens when no identifier parameters are supplied, or what the returned history contains. It is not misleading, but it is far too thin to be transparent.

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 with no filler or redundant content. It is concise and front-loaded, though its brevity comes at the cost of explanatory depth.

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 four optional parameters, no required parameters, no output schema, and a sibling with overlapping functionality, this description is not complete enough. It fails to disambiguate from toast_search_orders_by_customer, specify required inputs, or describe the returned payload, so an agent lacks critical selection and invocation context.

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

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

Only 25% of parameters have schema descriptions, and the tool description adds no parameter-level meaning. The phrase 'for a specific customer' hints that email/phone are identifiers, but restaurantGuid and the relationship between the parameters remain unexplained, and the description does not compensate for the low 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 operation ('Get'), the resource ('order history'), and the scope ('for a specific customer'). It is not a tautology and an agent can understand the basic purpose, but it does not explicitly distinguish this from the sibling tool 'toast_search_orders_by_customer', which could plausibly perform a similar 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?

No guidance is provided on when to use this tool versus alternatives like toast_search_orders_by_customer or toast_list_orders. There are no exclusions, conditions, or hints about which existing customer identifier is expected, leaving the agent to guess.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates a read action and gives example fields; it doesn't mention side effects, permissions, output shape, or what happens when restaurantGuid is omitted. The verb implies read-only but adds little beyond the tool name.

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

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

The description is a single front-loaded sentence with the verb and resource first, followed by parenthetical examples. It's efficient and free of filler, though 'etc.' is slightly vague. It earns a high score for conciseness even though other dimensions reveal missing 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?

The tool is simple with one optional parameter and no output schema, but the description still leaves critical gaps: it doesn't explain the restaurantGuid parameter, what the response contains, or how the tool behaves when called with no arguments. An agent can call it but can't fully anticipate the result.

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

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

Schema description coverage is 0%, and the description doesn't mention restaurantGuid at all. With a single optional parameter, the description needed to clarify that the parameter selects the restaurant context, but it provides zero guidance, leaving the agent unable to determine how to populate the argument.

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 a clear resource, 'delivery configuration', with concrete examples like radius and minimum amount. It sufficiently identifies what the tool does, though it doesn't explicitly differentiate it from sibling tools like toast_get_online_ordering_status.

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

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

There is no guidance on when to use this tool versus alternatives, nor any context about scoping, prerequisites, or typical use cases. An agent gets no help deciding whether this is the right tool among many toast_get_* 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?

There are no annotations to communicate read-only status or side effects, so the description carries the full burden. It only states that a report is retrieved and does not clarify whether the report is aggregated, how it is filtered by date or restaurant, whether it includes line items or totals, or how much data might be returned.

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

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

The description is a single, filler-free sentence and is appropriately brief. However, it is so underspecified that the conciseness comes at the expense of useful content, so it earns only a moderate score.

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, no annotations, and two undocumented parameters, the description should compensate by explaining the required businessDate, the optional restaurantGuid, and the expected report shape. It does none of this, making the definition incomplete for an agent trying to invoke the tool correctly.

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

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

Schema description coverage is 0%, and the description adds no meaning for either parameter. businessDate appears to be the required date filter and restaurantGuid appears to be an optional scoping parameter, but the tool definition does not explain what values they accept or how they affect the report.

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

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

The description clearly identifies a specific report ('report on discounts applied') and uses a concrete verb ('Get'), making it distinguishable from related report tools like toast_get_void_report. However, it does not mention the date scope or what particular discount data is included, which leaves some ambiguity about the exact 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?

The description gives no guidance about when to use this tool instead of other report tools such as toast_get_void_report, toast_get_sales_summary, or toast_get_payment_type_report. There are no exclusions, prerequisites, or alternative routing hints, so an agent must rely solely on the tool name and generic wording.

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 full responsibility for behavioral disclosure. It only says 'Get detailed information' without addressing response format, error handling, authentication, or any side effects. The read-only nature is implied but not stated explicitly.

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

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

The description is a single concise sentence, which is appropriate in length, but it's under-specified rather than genuinely concise. It provides minimal value and lacks essential details, making it only marginally better than a tautology.

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

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

Given no annotations, no output schema, empty parameter descriptions, and 53 sibling tools, this description is severely incomplete. An agent would not know how to differentiate this from list/search tools or how to properly populate the parameters, leading to likely 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?

Schema coverage is 0% — the parameter descriptions are empty. The description adds no meaning to employeeGuid or restaurantGuid, failing to explain that employeeGuid is required and restaurantGuid is optional or what each is used for.

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

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

The description clearly states it retrieves detailed information about a single employee, which distinguishes it from list/search siblings by implying it fetches one record. However, it doesn't explicitly mention the use of employeeGuid as the identifier, so it's clear but not fully precise.

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

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

No guidance is provided on when to use this tool versus toast_list_employees or toast_search_employees. It doesn't state that this should be used when you have a specific employee GUID, nor does it mention any 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?

There are no annotations, so the description carries the disclosure burden. It clearly signals a non-mutating aggregation operation, but it does not disclose details like date inclusiveness, timezone handling, rounding, or behavior when no time entries exist.

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 core operation efficiently without redundant wording.

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

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

With no output schema, no annotations, and empty parameter descriptions, the one-line description is too thin. The date format, the optional restaurantGuid semantics, and the return shape are all missing, making reliable invocation harder.

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

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

Schema description coverage is 0%, so the description must compensate. It loosely maps 'employee' to employeeGuid and 'date range' to startDate/endDate, but it leaves restaurantGuid entirely unexplained and provides no date format or value constraints.

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 ('Get') and resource ('total hours worked by an employee for a date range'). This is concrete and distinguishes it from the sibling toast_get_employee_time_entries, which returns raw time entries rather than a total.

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

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

The description gives no guidance on when to choose this tool versus alternatives such as toast_get_employee_time_entries or toast_get_labor_report. It does not state when-not-to-use or mention any exclusions.

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

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

With no annotations present, the description carries the full burden of disclosing behavior. It only states that it returns time entries with clock in/out data; it does not mention whether filtering by dates is required, how entries are ordered, what the response contains, or any restrictions or 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 concise sentence that front-loads the core action and resource. It is appropriately short for a simple read operation, though it sacrifices useful detail that could be added without becoming verbose.

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 five parameters, only one required, no output schema, and no annotations, this description is too thin. It leaves the agent uncertain about date filtering, the relationship between businessDate and startDate/endDate, and whether restaurantGuid is needed in multi-restaurant contexts.

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 only 20%, so the description must compensate for the many undocumented parameters. It adds minimal meaning by implying employeeGuid is the primary lookup key, but it gives no semantics for startDate, endDate, businessDate, or restaurantGuid, nor any guidance about required date formats or combinations.

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 time entries (clock in/out) for an employee'—and clearly identifies the entity being fetched. It does not explicitly name a sibling tool, but the 'for an employee' scope distinguishes it from broader tools like toast_list_time_entries.

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 about when to choose this tool over related alternatives such as toast_list_time_entries or toast_get_employee_hours. There are no exclusions, prerequisites, or contextual signals explaining how this differs from those 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?

There are no annotations, so the description carries the full behavioral burden. It only conveys a read-like fetch and does not disclose output shape, date interpretation, timezone behavior, or whether the optional restaurantGuid changes aggregation. No behavioral trait beyond the tool name is revealed.

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 of about ten words contains no filler and communicates the core purpose immediately. It is as compact as possible for the information it provides.

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

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

With no annotations, no output schema, and empty parameter descriptions, the description is too thin to fully support correct invocation: the agent cannot determine businessDate's expected numeric format or the semantics of restaurantGuid, and no return structure is hinted. A simple read tool still needs those basics.

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 clarifies businessDate as the date context while adding nothing about its numeric format or about restaurantGuid. Since the description must compensate for empty schema descriptions, this is insufficient.

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-resource pair ('Get sales') with a clear grouping criterion ('broken down by hour') and a date scope ('for a business date'). This distinguishes it from report siblings like toast_get_sales_summary or toast_get_item_sales_report, so an agent can understand what this tool uniquely returns.

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

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

No guidance is given about when to choose this tool over alternative sales reports or about any prerequisites (e.g., restaurant authorization). The only implied context is the business date, but there is no explicit when/when-not or alternative routing.

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

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

With no annotations provided, the description carries the full burden but only states 'Get sales report for menu items.' It doesn't disclose behavior like default date ranges, limit handling, required restaurant context, or whether the operation is read-only, which is especially important because all five parameters are optional.

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

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

The single sentence is concise and front-loaded, with no redundant wording. However, it is under-specified for a five-parameter report tool, so the brevity comes at the expense of useful 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 five optional parameters, no output schema, and no annotations, one vague sentence is grossly insufficient. An agent cannot determine what inputs are meaningful, what the report contains, or what response to expect.

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 only 20% and the description adds no parameter information; startDate, endDate, businessDate, and restaurantGuid have empty schema descriptions and are not mentioned at all. The description fails to compensate for the low 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 uses a direct verb + resource construction ('Get sales report for menu items') and identifies the specific report type, which helps distinguish it from sibling tools like toast_get_discount_report and toast_get_sales_summary. However, it doesn't clarify date scope or what the report contains, 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?

No guidance is given about when to prefer this tool over toast_get_sales_summary, toast_get_hourly_sales, or other reporting siblings. An agent is left to infer context from the tool name alone.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It only restates the high-level purpose ('get all menu items') and gives no information about pagination, response shape, required authentication, potential size of results, or side effects. While 'Get' implies a read operation, it adds little beyond the purpose 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, front-loaded sentence with no filler. It is appropriately concise for a simple list endpoint, though it could earn a 5 by also including a quick usage or sibling-contrast note.

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

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

Given the lack of an output schema, lack of annotations, and a mysteriously empty restaurantGuid description, the tool is under-specified. An agent cannot confidently know whether restaurantGuid is required in certain restaurant contexts or what the returned item list contains. The description is not complete enough for reliable tool selection and 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 only 50%: groupGuid has a minimal 'Menu group GUID' description, and restaurantGuid has no description at all. The tool description mentions 'category/group' but does not clarify what restaurantGuid is for, when it is needed, or how to obtain either GUID. The description does not compensate for the missing 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 ('Get'), resource ('all menu items'), and scope ('specific category/group'), making the tool's core function clear. However, it does not explicitly contrast itself with sibling tools like toast_search_menu_items or toast_list_menu_groups, so it misses the differentiation that would earn 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 about when to use this tool versus alternatives such as toast_search_menu_items, toast_get_menu_item, or toast_list_menu_groups. The one-line description implies a use case (retrieve items by category), but it provides no exclusions, prerequisites, or alternative routing.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'detailed information' without specifying what details are returned, whether the operation is read-only, or what context is required. The behavior is not misleading, but it is severely underspecified.

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, readable sentence with no filler, so it is concise and front-loaded. However, it is so minimal that it borders on under-specification rather than tight, informative structure.

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 parameters, no annotations, and no output schema, the description is inadequate. It fails to explain what a 'job position' is in this context, how jobGuid and restaurantGuid should be used, or what the response contains.

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%: both jobGuid and restaurantGuid have empty descriptions in the schema, and the tool description mentions neither parameter. The description does nothing to compensate for the lack of information about what each parameter means or how they relate to the job lookup.

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 detailed information about a job position'), clearly indicating a read operation for a single job. It contrasts with the sibling toast_list_jobs, though it does not explicitly name or differentiate itself from that sibling.

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

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

No guidance is provided about when to use this tool versus toast_list_jobs or other alternatives. The description does not state prerequisites, such as whether restaurantGuid is needed, or when a user should pick this over a list or search 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 provided, the description carries the full burden of behavioral disclosure. It conveys a date-scoped read of a summary report, but it does not explain restaurantGuid behavior, permissions needed, whether hours/costs are included, or what the response contains. This is minimal beyond the tool name.

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

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

The description is a single, focused sentence with no filler, and the core scope (labor summary report) is front-loaded. It is appropriately short, though its brevity contributes to the lack of behavioral and parameter depth.

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 2-parameter report tool this is close to workable, but the optional restaurantGuid is left undocumented and there is no output schema to explain the report contents. An agent would not know whether restaurantGuid is needed in a multi-restaurant setup or what fields the report returns.

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

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

The description adds little beyond the schema: 'for a business date' mostly restates businessDate, and the restaurantGuid parameter has an empty schema description and no mention in the tool description. At 50% schema coverage, the description needed to clarify the optional parameter's role and does not.

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

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

The description uses a specific verb ('Get') and resource ('labor summary report') and scopes it to a business date. This distinguishes it from discount, void, and sales reports among siblings, though it never explicitly names an alternative.

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

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

There is no guidance on when to use this tool versus related siblings such as toast_get_employee_hours or toast_get_sales_summary. The only implied usage is that a business date is required, but no exclusions or alternative-selection conditions 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?

With no annotations, the description carries the burden of explaining behavior. It communicates that the response includes menu groups and items, but it does not mention authentication requirements, error handling for invalid menuGuid, or whether restaurantGuid is needed for scoping. The read-only nature is implied by 'Get' but not explicitly stated.

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

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

A single, front-loaded sentence with no redundant words. It conveys the core purpose and key output scope efficiently.

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

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

The description is adequate for a simple 'get by GUID' operation, but the lack of output schema and annotations means more context would help. It does not clarify the optional restaurantGuid parameter, the structure of the returned groups and items, or how this tool relates to the many menu-related siblings.

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 meaningful parameter guidance. menuGuid is only identifiable by name, and restaurantGuid is completely unexplained. The description does not compensate for the empty 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 clearly states the action ('Get detailed information'), the resource ('a specific menu'), and the scope ('including all groups and items'). This distinguishes it from sibling list tools like toast_list_menus and from more granular tools like toast_get_menu_item.

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 wording implies this tool is for fetching the full detail of one known menu, but it does not explicitly state when to use this versus alternatives such as toast_list_menus, toast_get_menu_item, or toast_list_menu_groups. No exclusions or alternative routing 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 of behavioral disclosure. 'Get' implies a read operation, but the description does not reveal response shape, error behavior, authentication requirements, or how the optional restaurantGuid affects 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 concise sentence with no filler. It is front-loaded with the verb and resource, though it errs more toward vagueness than thoughtful brevity.

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

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

Given no output schema, no annotations, and 0% schema description coverage, the description is insufficient for reliable invocation. It does not explain return values, the meaning of parameters, or what 'detailed information' includes.

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

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

Schema description coverage is 0% and the description adds no parameter explanations. itemGuid and restaurantGuid are left entirely to name inference, with no guidance on the role or necessity of restaurantGuid.

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', the resource 'menu item', and the scope 'specific', making it evident what the tool does. It distinguishes itself from list/search siblings in intent, though it does not explicitly name alternatives.

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

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

No guidance is provided on when to use this tool versus alternatives like toast_search_menu_items or toast_get_menu. The agent must infer usage entirely from the tool name and vague description.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only paraphrases the tool name with examples and does not state whether the operation is read-only, whether a restaurant scope is needed, or what kind of response to expect.

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 with no filler words. The examples 'toppings, sides' add useful context without bloating the text, though the overall brevity leaves other dimensions under-served.

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

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

With no annotations and no output schema, the description should explain more about what 'details' are returned and how the parameters affect the call. It does not address the optional restaurantGuid parameter or the shape of the result, so an agent has insufficient context for reliable invocation.

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

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

Schema description coverage is 0% and both parameter descriptions in the schema are empty. The description adds no meaning to modifierGroupGuid or restaurantGuid, so it fails to compensate for the complete lack of parameter 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 states a specific verb ('Get details') and resource ('modifier group') with clarifying examples ('toppings, sides'), making the tool's target clear. It is distinguishable from siblings like toast_list_menu_groups or toast_get_menu_item, though it does not explicitly contrast with them.

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

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

There is no guidance about when to use this tool versus alternatives. The description does not mention how modifier groups differ from menu groups, menu items, or other related entities, leaving the agent to infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries the behavioral burden. The words 'check' and 'get' imply a read-only operation, and the description states the output focus: enabled status and scheduling info. However, it does not explicitly confirm non-mutation, permissions, or response 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 concise sentence with no filler. It front-loads the primary purpose, though the 'scheduling info' phrase is vague and could be more precise without losing conciseness.

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

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

For a tool with no annotations, no output schema, and an undocumented parameter, the description is too thin. It does not explain restaurantGuid, what scheduling info means, what the returned status looks like, or any prerequisites. An agent could select the tool but not confidently know how to invoke it correctly.

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

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

There is one parameter, restaurantGuid, with an empty schema description and 0% schema description coverage. The tool description does not mention this parameter at all, so an agent receives no explanation of what value to supply or whether the optional Guid is needed for a specific restaurant.

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

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

The description clearly identifies the operation: checking whether online ordering is enabled and retrieving scheduling information. This is a specific verb+resource combination that sets it apart from most siblings, though it does not explicitly distinguish itself from similarly named tools like toast_get_delivery_settings.

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

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

There is no guidance on when to use this tool versus alternatives. With many related restaurant, ordering, and delivery tools listed as siblings, the description gives no conditions, exclusions, or recommendations for selection.

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, and the description does not disclose behavior beyond the generic 'get' verb. It does not state whether the operation is read-only, what scope of order data is returned, or what happens when the GUID is invalid or not found.

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 core operation and key lookup mechanism in minimal words.

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 lookup, the schema plus description is sufficient to invoke the tool. However, without an output schema, 'detailed information' is vague about the return contents, and no clarification is offered about what details are included.

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

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

The input schema already describes both parameters with 100% coverage, so the description does not need to add semantics. The schema documents orderGuid and restaurantGuid (including its default behavior), and the description adds nothing further.

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 ('Get'), a specific resource ('a specific order'), and the lookup key ('by GUID'). It is unambiguous but does not explicitly differentiate itself from siblings like toast_get_order_status or toast_get_orders_by_business_date.

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 this tool over toast_get_order_status, toast_list_orders, or toast_get_orders_by_business_date. The only implied usage is that a GUID is required, which is already visible in the input schema.

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 bears the full burden of behavioral disclosure. It only restates the basic retrieval operation and the date format; it does not mention pagination, ordering, whether 'all orders' includes voids or discounts, what the response shape is, or how the optional restaurantGuid modifies 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, focused sentence with no wasted words and the key resource/verb at the front. It could have added more useful context about behavior or the optional parameter without becoming verbose, but as a concise purpose statement it is effective.

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 leaves important gaps: it does not define what 'all orders' returns, whether results are paginated, what the optional restaurantGuid does, or how this tool relates to toast_list_orders. An agent would need additional information to invoke it confidently in a multi-restaurant context.

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

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

Schema description coverage is only 50%: businessDate is documented in the schema, but restaurantGuid has an empty description. The tool description merely repeats the YYYYMMDD format already present in the schema and does not add any meaning for the undocumented optional parameter, so it fails to compensate for the low 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 all orders' and the resource ('orders') filtered by a specific business date, so an agent can infer what the tool does. However, it does not differentiate this from sibling tools like toast_list_orders or toast_get_order, leaving ambiguity about when this date-specific endpoint is preferable.

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 specific business date' gives a clear context for use, implying this tool is appropriate when date-based order retrieval is needed. But it offers no guidance on when not to use it, no alternatives, and no mention of how restaurantGuid might affect usage, so the guidance is implicit rather than explicit.

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

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

No annotations are present, so the description carries the behavioral burden. It adds useful context by naming the status values (kitchen prep, ready, completed), but it does not disclose behavior for invalid order IDs, whether restaurantGuid is required in practice, or whether the status is returned in real time.

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. It immediately states the action and resource, then adds clarifying examples, which is ideal for this simple tool.

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

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

With no output schema, no annotations, and empty parameter descriptions, the definition is too sparse to fully guide invocation. It does not explain what orderGuid identifies, when restaurantGuid is needed, or what exact response to expect, leaving the agent to infer critical details.

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 information about orderGuid or restaurantGuid. The required identifier is not explained in any way, so the description adds no parameter semantics beyond the empty schema fields.

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 ('fulfillment status of an order'), and the parenthetical statuses clarify exactly what kind of status is returned. This clearly distinguishes it from generic order tools like toast_get_order or toast_get_online_ordering_status.

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

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

The description states what the tool does but gives no guidance on when to use it versus alternatives. It does not mention when not to use it, nor does it point to toast_get_order for full order details or toast_get_online_ordering_status for a different status concept.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'Get detailed information'. It does not reveal what fields are returned, whether restaurantGuid affects behavior, whether permissions are required, or any rate-limit or side-effect considerations.

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

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

The description is short and front-loaded, but it is under-specified: 'detailed information' is vague and does not compactly convey the important scoping or parameter details. It is concise in length but not optimally structured for agent decision-making.

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

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

Given no output schema, no annotations, and 0% parameter description coverage, this description is not sufficient for an agent to confidently call the tool. It fails to clarify what 'detailed information' includes, what paymentGuid format is expected, or when restaurantGuid is required.

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 both parameter descriptions are empty. The tool description does not mention paymentGuid or restaurantGuid at all, so it adds no meaning beyond the raw parameter names.

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

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

The description uses a specific verb ('Get') and resource ('detailed information about a specific payment'), making the basic purpose clear. However, it does not distinguish this from payment-related siblings like toast_get_payment_summary, toast_get_check_payments, or toast_get_payment_type_report.

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 about when to use this tool versus alternatives, when the optional restaurantGuid is needed, or what prerequisites exist. The description simply states what it does without any usage context or exclusions.

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

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

With no annotations available, the description carries the full transparency burden. It conveys a read-only aggregation operation through 'Get... totals', but it does not describe authorization needs, response structure, pagination, or whether the summary can be scoped by restaurant.

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 contains the verb, resource, scope, and expected output with no filler. Every element earns its place, and there is no redundant restating of the tool name or title.

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

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

The required businessDate parameter is sufficiently covered by the schema, and the parenthetical clarifies the return concept, but restaurantGuid is left entirely unexplained. Without an output schema or any guidance on restaurant scoping, the description is not complete enough for an agent to reliably decide whether the optional parameter is needed.

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 documents businessDate, and the description reinforces its role, but restaurantGuid has an empty description in the schema and is not mentioned in the description. With one of two parameters completely unexplained, the description fails to compensate for the 50% schema 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 uses a specific verb ('Get') and names a concrete resource ('payment summary') with a clear scope ('for a business date') and output shape ('totals by payment type'). It is distinguishable from payment retrieval tools like toast_get_payment, though it does not explicitly name or differentiate any sibling.

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

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

The phrase 'for a business date' implies the intended use case, but there is no explicit guidance about when to use this report versus sibling reports such as toast_get_payment_type_report or toast_get_sales_summary. No when-not-to-use conditions or alternative tool names 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 present, so the description carries the full disclosure burden, but it only says 'Get breakdown' with no behavioral detail. It does not mention whether the report is read-only, whether it aggregates by day/date range, how voids or discounts are handled, or what units the amounts are in.

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 concise sentence that directly states the core purpose. It is front-loaded and contains no filler, though it is so brief that it sacrifices informative detail.

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

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

With no annotations, no output schema, and no parameter descriptions, the description leaves significant gaps. An agent cannot tell how to interpret the report, what the response looks like, or whether restaurantGuid is needed for a meaningful query.

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

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

Schema description coverage is 0%, and the parameter descriptions are empty. The tool description does not compensate by explaining what businessDate or restaurantGuid mean, what formats are expected, or which parameters are required vs optional.

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

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

The description states a specific action ('Get breakdown') and a specific resource ('sales by payment type'), making the tool's purpose immediately understandable. It differentiates from nearby siblings like toast_get_sales_summary or toast_get_payment_summary by naming the grouping dimension, though it does not explicitly contrast itself with any sibling.

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

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

The description provides no guidance on when to use this tool versus alternatives such as toast_get_sales_summary or toast_get_item_sales_report. There is no mention of prerequisites, report periods, or exclusions, so an agent cannot infer which reporting tool fits a given request.

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 disclosing behavior. 'Get' implies a read operation, but the description does not state side effects, authorization needs, rate limits, or what 'configuration information' includes beyond the name.

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

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

The description is a single sentence with no filler, and the core action and object are front-loaded. It is concise, though somewhat under-specified.

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 getter tool with one undocumented optional parameter and no output schema, the description should explain the parameter and the scope of 'configuration information.' It does neither, leaving an agent to guess what the tool returns and how to invoke it correctly.

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

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

Schema description coverage is 0%, and the only parameter, restaurantGuid, has an empty description. The tool description does not explain what restaurantGuid means, whether it is required despite being optional in the schema, or what happens when it is omitted.

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

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

The description uses a clear verb ('Get') and a specific resource ('detailed restaurant configuration information'), so an agent can tell this is about retrieving restaurant config details. However, it does not specify which aspects of configuration are included, and it doesn't explicitly distinguish itself from sibling tools like toast_get_delivery_settings or toast_list_accessible_restaurants.

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

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

There is no guidance on when to use this tool versus alternatives. The description provides no context about prerequisites, whether the optional restaurantGuid must be supplied, or when a sibling tool would be more appropriate.

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

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

With no annotations, the description must carry the behavioral disclosure burden, but it only says the summary is 'comprehensive.' It does not state return contents, read-only semantics, pagination, restaurant scoping, or aggregation behavior. No contradiction exists, but transparency is minimal.

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

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

The description is a single, clearly worded sentence with no filler and is effectively front-loaded. The vague 'comprehensive' and lack of structure prevent a 5, but the length is appropriate for the limited 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?

Without an output schema or annotations, the description needs to explain more about what the summary contains, how restaurantGuid affects results, and how this tool relates to other report tools. It currently leaves an agent guessing whether this is the right report among many siblings.

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 already documents businessDate's YYYYMMDD format, and the description adds no parameter-level meaning. The optional restaurantGuid has an empty schema description and is not mentioned in the description, leaving half the parameters effectively undocumented.

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

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

The description uses a specific verb ('Get') and resource ('comprehensive sales summary') and scopes it by business date, making the core purpose clear. It is distinguishable from most siblings, though 'comprehensive' is vague about what exactly is included.

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 the many report siblings such as get_hourly_sales, get_item_sales_report, or get_payment_type_report. The only usage context is the business date scoping; there are no alternatives or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states it 'gets' data, implying a read operation, but does not explicitly address side effects, authorization requirements, or any other behavioral aspects. This is a significant gap for a tool with zero annotation coverage.

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

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

The description is a single sentence with no wasted words, but it is under-specified. It is concise in length but not in content, as it does not provide enough information to be genuinely useful. The brevity is acceptable, but it fails to leverage the concise form to convey meaningful guidance.

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 parameters, no output schema, and zero schema documentation, the description is grossly incomplete. It gives no indication of the return format, required parameter formats, error handling, or any contextual details that would help an agent use it successfully. The description offers only the minimal essence of the tool's purpose.

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 both parameters (shiftGuid, restaurantGuid) have empty descriptions. The tool description makes no mention of what these parameters represent or how they should be used, leaving the agent to infer everything from parameter names alone. This is insufficient compensation for the lack of 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 clear verb ('get') and a specific resource ('details about a specific shift'), effectively distinguishing it from list-shifts and active-shifts siblings. However, it lacks specifics on what 'detailed information' includes, leaving some ambiguity about the exact scope.

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 on when to use this tool versus alternatives like 'toast_list_shifts' or 'toast_get_active_shifts'. The description is purely declarative about what it does, with no mention of prerequisites, use cases, or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that the tool retrieves stock information; it does not disclose response behavior, defaults beyond what the schema hints at, error cases, data freshness, or any access considerations.

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, concise sentence with no filler or repetition. However, its brevity contributes to the lack of behavioral and parameter clarity, so it is efficient in structure but not fully informative.

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

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

Given three parameters, no output schema, and no annotations, the description is too thin to fully guide an agent. It does not explain what inventory data is returned, how location selection works, or why restaurantGuid exists. An agent would likely need to infer too much before calling the tool safely.

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

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

Schema description coverage is only 33%, and the description does little to compensate. It references 'a location' but does not explain the relationship between locationGuid and restaurantGuid, nor does it clarify that itemGuid is the required identifier. The parameter meaning is mostly left to the schema, which is under-described.

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 get operation on inventory/stock data, scoped to a specific item and location. It is distinguishable from list-style siblings such as toast_list_low_stock_items, though the exact meaning of 'stock/inventory information' is left vague.

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, and no mention of prerequisites such as having a valid itemGuid. The description implies use cases but never explains when this is the right choice over related tools like toast_get_menu_item or toast_list_low_stock_items.

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 restates that the tool gets information. It does not mention what happens when the table is not found, how restaurantGuid affects behavior, what the response looks like, or any access requirements.

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

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

The description is very brief and front-loaded, but 'information about' is filler that mostly restates the tool name. It is under-specified rather than a model of concise useful structure.

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

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

Given no output schema, empty parameter descriptions, and no sibling differentiation, the description leaves the agent to infer input semantics, response shape, and usage context. The self-explanatory parameter names and the existence of toast_list_tables help only slightly.

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 both parameter descriptions in the schema are empty. The tool description adds no meaning to tableGuid or restaurantGuid, so an agent receives no information about how to fill these parameters or what each represents.

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 has a clear verb ('Get') and resource ('information about a specific table'), which identifies it as a single-entity retrieval tool. It does not explicitly differentiate it from toast_list_tables or clarify whether 'table' means a dining table or a data table, so it falls 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?

No guidance is given about when to use this tool versus alternatives such as toast_list_tables. The intended usage is only weakly implied by the word 'specific' and the sibling tool names, with no explicit conditions or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does communicate that the tool ranks customers by either order frequency or total spent, which is meaningful. However, it does not explain defaults, output shape, pagination, restaurant scoping, or any other runtime behavior beyond the headline.

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 tight sentence with no filler. It front-loads the core purpose and adds the key differentiator without wasting words.

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, no annotations, and three undocumented optional parameters, the description does not provide enough context for an agent to call it confidently. It omits valid sortBy values, whether restaurantGuid is required, limit format/defaults, and what the response looks like.

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 all parameters have empty descriptions, so the description must compensate. The phrase 'order frequency or total spent' hints that sortBy may accept one of those values, and 'top' implies limit behavior, but limit, sortBy, and restaurantGuid are not explicitly defined. This leaves a significant 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 clearly identifies a specific operation ('Get top customers') with a distinguishing criterion ('by order frequency or total spent'). This separates it from sibling tools like toast_search_customers or toast_get_customer_order_history, which serve different lookup and history purposes.

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 alternative customer-related tools such as toast_search_customers, toast_get_customer_order_history, or toast_get_customer_loyalty_status. There are no exclusions, prerequisites, or conditions; the usage context is only weakly implied.

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

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

With no annotations, the description carries the full behavioral burden, but it only says 'Get report' and does not disclose return format, date/time handling, scoping, or whether voided items are aggregated or itemized. It does indicate a read-only retrieval, but that is minimal and inferential.

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

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

The description is a single efficient sentence with no filler, and it front-loads the report topic. However, it is so sparse that it sacrifices necessary context, making it under-specified rather than genuinely structured.

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

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

For a report endpoint with two undocumented parameters and no output schema, this description is incomplete: it omits the meaning of the required businessDate, the optional restaurantGuid, and what the returned report contains. The high-level topic ('voided orders and items') is useful but not sufficient to call the tool correctly.

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

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

Schema description coverage is 0%, and the description does not mention either parameter. businessDate's numeric format and requiredness are unexplained, and restaurantGuid's optional targeting role is absent.

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—'Get report'—and a precise resource, 'voided orders and items,' which distinguishes it from sibling report tools like toast_get_discount_report or toast_get_item_sales_report. It is not a tautology because it expands on the tool name by identifying the report subject. It lacks the business-date scope in prose, but the required parameter makes that inferable.

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 choose this tool over siblings; no alternative is named and no condition or exclusion is stated. The only implicit signal is the report topic, which is insufficient to route an agent among many reporting 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?

With no annotations, the description carries the full behavioral burden. It communicates the credential-scoped access behavior and the read-only listing nature, but it does not disclose pagination, response shape, or error behavior. For a zero-parameter list tool, this is acceptable but not detailed.

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 operational meaning: 'List all', 'restaurants', and 'accessible with current API credentials'.

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 list operation with no output schema, the description covers the essential context: what is listed and under what access scope. It is slightly incomplete in not describing the response shape or whether all restaurants are returned in a single call, but this is a minor gap given the tool's simplicity.

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

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

The input schema has zero parameters with 100% coverage, so there are no parameter semantics to document. The baseline for zero-parameter tools is 4, and the description adds no conflicting or missing parameter information.

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 ('List all') and a clear resource ('restaurants accessible with current API credentials'), defining both the operation and its scope. It is easily distinguished from sibling tools like toast_get_restaurant_info, which targets a single restaurant's details rather than enumerating all accessible restaurants.

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

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

The intended use is implied: call this tool when the agent needs to enumerate all restaurants the current credentials can access. However, the description does not explicitly state when to prefer it over alternatives or mention exclusions, so guidance is adequate but not explicit.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. The verb 'List' implies a read-only operation, but the description does not explain filter behavior, date handling, pagination, authentication requirements, or what records are included.

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 concise and has no wasted words. However, it is so terse that it provides no structural breakdown or additional context, which is a meaningful gap for a tool with four undocumented optional parameters.

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

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

With no output schema, no annotations, and zero parameter documentation, the description is not complete enough for the agent to call the tool confidently. It identifies the resource but leaves filtering semantics, return shape, and scope entirely unspecified.

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

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

Schema description coverage is 0%, and the four parameters have empty descriptions. The tool description mentions none of these parameters, so it does nothing to clarify the meaning or expected format of endDate, startDate, businessDate, or restaurantGuid.

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

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

The description states a specific verb and resource: list cash deposit records. This is clear and immediately tells the agent what the tool does. However, it does not differentiate from related sibling tools such as toast_list_cash_drawers or toast_list_cash_entries.

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. The description only restates the core action and does not mention contexts, exclusions, or sibling tools that might be more appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'List' implies a read-only operation, but the description does not state whether authentication is required, how results are paginated or returned, or how the optional restaurantGuid affects the request. It is not misleading, but it is minimally transparent.

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: verb, resource, and scope are all present. For a simple list operation this is an appropriate size and structure.

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

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

With no annotations, no output schema, and minimal description, the tool definition is too sparse to fully support correct invocation. It lacks restaurantGuid semantics, guidance among related cash-drawer tools, and any note about response shape or behavior beyond the literal listing. For a simple tool it is adequate in isolation, but not complete in context.

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

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

The schema already explains businessDate as YYYYMMDD, and the description reinforces that a business date is the scoping concept for the listing. However, restaurantGuid has an empty schema description and is never mentioned in the description, leaving one of two parameters effectively undocumented. Some meaning is added for the required parameter, but the overall parameter coverage is incomplete.

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

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

The description gives a specific verb ('List') and resource ('cash drawers') with a temporal scope ('for a business date'), so the core action is clear. It is reasonably distinguishable from toast_get_cash_drawer because it says 'all', but it does not explicitly differentiate itself from related list tools such as toast_list_cash_entries or toast_list_cash_deposits.

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 the many sibling cash-drawer tools such as toast_get_cash_drawer, toast_get_cash_drawer_summary, toast_list_cash_entries, or toast_list_cash_deposits. No prerequisites, exclusions, or alternative selection criteria are provided, leaving the agent to infer the intended 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?

No annotations are provided, so the description must carry behavioral disclosure. It communicates read-only intent via 'List' and narrows the scope to paid in/paid out entries, but it does not mention filtering behavior, required parameter relationships, pagination, permissions, or what happens when no filters are supplied.

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, tight sentence with no filler. It front-loads the core verb and object. However, the brevity comes at the cost of omitting useful detail, so it is good but not excellent.

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

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

Despite appearing simple, this tool has four undocumented optional parameters, no output schema, no annotations, and many closely related sibling tools. The description leaves unclear whether filters are mutually exclusive, whether a filter is required, and what result set shape to expect. This is not complete enough for confident autonomous 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%, and the description only hints at two of the four parameters: drawerGuid and businessDate. employeeGuid and restaurantGuid are left entirely unexplained. The description provides partial compensation but not enough for an agent to confidently understand all optional inputs.

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

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

The description states a specific action ('List') and resource ('cash entries'), and clarifies the resource scope with 'paid in/paid out.' This helps distinguish it from drawer-level tools like toast_list_cash_drawers, though it does not explicitly contrast with toast_list_cash_deposits.

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 says the entries can be listed 'for a cash drawer or business date,' giving some context, but it does not explain when to use this tool versus related tools like toast_list_cash_deposits or toast_get_cash_drawer_summary. No exclusions or alternative routing are provided.

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

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

With no annotations, the description carries the full behavioral burden, but it only says 'List all dining options.' This implies a read-only operation, yet it does not explain whether results are restaurant-scoped, whether restaurantGuid is needed, or what the response shape looks like. The description adds little beyond the tool name.

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

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

The description is a single, efficient sentence with no filler and is front-loaded with the action. It is concise, though its brevity contributes to the lack of context. Still, for pure conciseness and structure, it earns a solid score.

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

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

For a tool with one undocumented parameter and no output schema, the description is incomplete. It does not explain the optional restaurantGuid parameter, whether the list is global or scoped, or what will be returned. An agent cannot confidently know how to invoke this tool for a specific restaurant even though the name suggests restaurant context.

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

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

Schema description coverage is 0% and the only parameter, restaurantGuid, has an empty description. The tool description never mentions this parameter, so the agent has no information about how or why to use it. There is no compensating semantic guidance.

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: 'List all dining options' and enumerates examples like dine-in, takeout, delivery, and curbside. This makes the tool's purpose clear and distinguishes it from sibling menu-related tools, though it does not explicitly contrast with any alternative 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?

No guidance is given about when to use this tool versus sibling tools such as toast_get_delivery_settings or toast_list_menus. The description only states what the tool does, leaving the agent to infer usage context without any exclusions or alternative routing.

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

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

With no annotations, the description carries the burden of disclosing behavior; it communicates a read-only listing operation but does not mention pagination, default filtering, includeDeleted semantics, or response shape. This is adequate but thin, so it stays at a minimal viable level.

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 is concise, though the brevity contributes to the gaps in usage and parameter guidance.

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, no annotations, and an undocumented restaurantGuid parameter, this minimal one-liner is incomplete. It does not explain how restaurantGuid relates to 'at a restaurant', how includeDeleted should be formatted, or what response the agent should expect.

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 only 50%: includeDeleted has a short description while restaurantGuid has an empty description. The tool description adds no meaning for either parameter and does not compensate for the undocumented restaurantGuid, so an agent lacks necessary 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 'List all employees at a restaurant' clearly states the action (list) and the resource (employees), so an agent knows what the tool returns. It does not explicitly differentiate the tool from siblings such as toast_search_employees or toast_get_employee, so it falls short of full distinction.

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 prefer this tool over the many employee-related siblings, nor any mention of prerequisites such as needing a restaurantGuid. An agent is left to infer the intended use case from the tool name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states that it lists all job positions. It does not mention authentication needs, pagination, return format, or behavior when restaurantGuid is not supplied. The word 'all' adds some scoping but not enough.

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 clear sentence with no wasted words. It front-loads the action and resource, making it easy 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?

Despite the tool's apparent simplicity, the description leaves restaurantGuid semantically undefined and provides no guidance about optional invocation or relationship to sibling tools. Without an output schema, the agent also gets no return-value expectations. The description is too sparse 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?

The only parameter, restaurantGuid, has an empty schema description (0% coverage). The phrase 'at a restaurant' weakly alludes to the parameter's meaning, but the description does not explain the parameter's format, optionality implications, or how it affects results. The schema provides nothing, and the description compensates only minimally.

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 clear verb-object structure: 'List all job positions at a restaurant.' It names the resource (job positions) and scope (restaurant), and the plural 'all' distinguishes it from the singular toast_get_job sibling. However, it does not explicitly differentiate from any sibling.

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

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

No guidance is given on when to use this tool versus alternatives like toast_get_job or toast_search_employees. It also does not explain what happens when restaurantGuid is omitted or when restaurant context is needed.

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 behavioral disclosure, and 'List' reasonably implies a read-only operation with no side effects. However, it does not describe response shape, pagination, authorization needs, or how 'low' is determined beyond the schema's threshold default. This is minimally adequate but not richly transparent.

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 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 list tool with two optional parameters and no output schema, the description is minimal but leaves gaps: it does not relate to sibling stock/86'd-item tools, explain restaurantGuid, or describe expected results. It supports a no-argument call, but not confident parameterized use or sibling selection.

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

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

One of the two parameters (restaurantGuid) has an empty schema description, and the tool description does not clarify its role. The threshold parameter is documented in the schema, but the description adds little meaning beyond the 'low in stock or out of stock' condition, leaving the agent without full parameter understanding.

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 ('List'), a clear resource ('items'), and a condition ('low in stock or out of stock'), so an agent can tell what the tool does. It does not explicitly differentiate from stock-related siblings like toast_get_86d_items or toast_get_stock_item, but the low-stock condition is fairly distinctive.

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

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

No when-to-use or when-not-to-use guidance is provided. The description does not mention alternatives such as toast_get_stock_item or toast_get_86d_items, nor does it explain when the threshold parameter should be supplied. An agent must infer usage context from the tool name and schema.

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

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

With no annotations, the description carries the behavioral burden. The verb 'List' correctly implies a read-only operation and the phrase 'across all menus' clarifies the default scope. However, it does not disclose pagination, response shape, restaurant scoping behavior, or any outcomes beyond simply listing groups.

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 wasted words. The parenthetical '(categories)' adds useful disambiguation without adding bulk.

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

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

For a simple, optional-parameter list tool, the core behavior is conveyed, but there is no output schema and no mention of what fields a menu group object contains. The blank restaurantGuid description and lack of any usage guidance leave an agent with gaps when deciding whether filtering is needed.

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 50%: menuGuid has a description, but restaurantGuid has an empty description. The prose adds no parameter semantics, such as how restaurantGuid interacts with the 'all menus' default or whether menuGuid narrows the result. The description does not compensate for the poorly documented schema.

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

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

The description uses a specific verb, 'List', with a clear resource, 'menu groups (categories)', and explicitly says 'across all menus'. This distinguishes it from siblings like toast_list_menus (which lists menus, not groups) and get_items_by_category (which gets items rather than groups).

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 this tool over alternatives such as toast_list_menus, get_menu, or get_items_by_category. The description does not say whether this is the right call for obtaining categories for one menu versus all menus, nor does it explain when to use the optional filters.

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 must carry the behavioral burden alone. It discloses the core read/list behavior but omits what happens when the optional restaurantGuid is absent, whether results are paginated, and any auth/read-only guarantees. These are meaningful gaps, especially because the parameter is schema-optional.

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

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

One short, front-loaded sentence with no filler; every word contributes to the core meaning. It is appropriately compact for a simple list operation.

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

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

For a tool with no output schema and no annotations, the description is minimally adequate but leaves material questions unanswered: the behavior when restaurantGuid is omitted, the response shape, and the precise relationship to toast_get_menu. Given the low complexity, a couple of added clauses would make it 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 has one parameter, restaurantGuid, with an empty description and 0% coverage. The phrase 'for a restaurant' adds only a generic scope hint and never explains the parameter's format, purpose, or the effect of omitting it. This does not sufficiently 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 names a specific action ('List'), a specific resource ('all menus'), and a scope ('for a restaurant'), which is enough to distinguish it from single-menu getters like toast_get_menu. It does not explicitly reference sibling tools, so it stops short of a fully disambiguating definition.

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 implies the use case: when all menus are needed rather than a single menu or menu-group detail. No exclusions or alternative tools are mentioned, so the agent has to infer when not to use it.

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 add that results are paginated, which is useful, but it does not describe response shape, ordering, default date behavior, or the apparent discrepancy that 'status' filtering is mentioned but not supported in the schema.

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

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

The description is concise and front-loaded with the core purpose. It contains no filler, though the inaccurate 'status' mention detracts from otherwise efficient wording.

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

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

For a simple list endpoint with fully documented optional parameters, the description is minimally adequate: it names the resource, filters, and pagination. However, with no output schema, no annotations, and overlapping sibling tools, it leaves notable gaps around response contents, pagination semantics, and when to choose a sibling instead.

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 already documents all six parameters with formats and defaults, so the baseline is 3. The description adds no real semantics beyond repeating filter categories, and its mention of 'status' is actively misleading because no such parameter exists in the schema.

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

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

The description clearly states a specific verb and resource ('List orders') and mentions key filtering capabilities. However, it mentions 'status' as a filter even though no status parameter exists in the schema, and it does not differentiate from the overlapping sibling toast_get_orders_by_business_date.

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 alternatives like toast_get_order, toast_get_orders_by_business_date, or toast_search_orders_by_customer. The agent is left to infer the appropriate choice from the name and schema alone.

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

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

No annotations are provided, so the description must disclose behavioral traits. It indicates a read-only listing operation, but it does not mention pagination, restaurant scoping behavior, authentication needs, or what happens when the optional restaurantGuid is omitted.

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, and the parenthetical examples clarify the resource type efficiently. It is concise, though its brevity leaves out important operational details.

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

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

For a tool with one weakly documented optional parameter and no output schema, the description is too thin. It does not explain how the restaurantGuid impacts the result, what fields are returned, or how this list relates to the broader Toast API context.

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

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

Schema description coverage is 0% and the restaurantGuid parameter has an empty description. The tool description does not mention this parameter at all, so the agent receives no semantic help about how to supply or interpret it.

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, 'List', with a concrete resource, 'revenue centers', and adds clarifying examples ('bars, POS stations, etc.'). It is clear about what the tool returns, though it does not explicitly differentiate itself from the many sibling list_* tools.

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

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

The description offers no guidance on when to use this tool versus the many sibling list tools, nor does it mention any exclusions or prerequisites. The usage context is only implied by the tool name and the generic 'List all' wording.

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 explaining behavior. 'List all' communicates a read-only, comprehensive retrieval operation, but it does not disclose pagination, permission requirements, edge cases, or the meaning of the optional restaurantGuid. The behavior is minimally transparent but not fully specified.

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. The parenthetical definition is concise and contributes meaning. 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 has no output schema, no annotations, and an undocumented optional parameter. The description names the resource clearly but fails to explain how to provide restaurant context or what the response looks like. An agent would still have to guess about important invocation details.

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 one parameter, restaurantGuid, with an empty description, and schema description coverage is 0%. The description's phrase 'at a restaurant' hints at restaurant context but does not explicitly explain how restaurantGuid affects the result or whether it is needed. The parameter is effectively undocumented.

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

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

The description clearly states the verb 'List' and the resource 'service areas', and the parenthetical '(dining sections)' adds helpful disambiguation. It does not explicitly contrast with sibling tools like toast_list_tables or toast_list_dining_options, so it lacks explicit 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?

No guidance is given about when to use this tool versus related list tools such as toast_list_tables, toast_list_dining_options, or toast_list_revenue_centers. The phrase 'at a restaurant' is generic context rather than actionable usage guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it only states the operation. It does not explain what happens when called with zero parameters (all parameters are optional), how businessDate interacts with startDate/endDate, whether results are filtered by the GUID parameters, or anything about output shape or ordering.

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 resource, containing zero filler. It is appropriately sized, though the brevity could have been traded for one clause naming a sibling alternative.

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

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

For a tool with 5 optional parameters, no annotations, no output schema, and a large sibling family, this description leaves meaningful gaps: the two empty-description GUID parameters, the precedence/interaction among date filters, and selection guidance among shift-related siblings. An agent cannot reliably configure a correct call from this description alone.

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

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

Schema coverage is 60%, and the description's 'date range' phrasing does add interpretive value to startDate and endDate. However, employeeGuid and restaurantGuid have empty schema descriptions and the description does not clarify their filtering role, nor does it explain the relationship between businessDate and the start/end date range.

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 ('List') and resource ('shifts') with a scoping constraint ('for a specific date range'), making the core purpose clear. However, it does not differentiate from siblings like toast_get_shift or toast_get_active_shifts, so an agent must infer the distinction from the tool name alone.

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

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

The date-range phrasing implies the tool is for retrieving shifts within a date window, which provides some usage context. But no explicit guidance is given about when to choose this over related siblings (toast_get_shift, toast_get_active_shifts, toast_list_time_entries), and no exclusions or alternatives are named.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only listing but does not explain whether the restaurantGuid is required, what happens if omitted, whether pagination or limits apply, or what the response shape is. The behavior beyond 'list all tables' is largely undisclosed.

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

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

The description is a single clear sentence that is easy to scan and does not waste words. It is appropriately brief for a simple listing tool, though the brevity comes at the cost of missing behavioral and parameter context.

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 there are no annotations, no output schema, and no parameter-level documentation, a one-sentence description is not enough for an agent to confidently invoke the tool. The agent cannot tell whether restaurantGuid is needed, how the output is structured, or how this differs from related table/service-area tools. The description leaves too much to inference.

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 one optional parameter (restaurantGuid) with an empty description, and schema description coverage is 0%. The text mentions 'a restaurant' but does not explicitly connect it to restaurantGuid, explain how the parameter filters results, or describe what happens when it is absent. The description fails to compensate for the schema's lack of parameter 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 ('List') and resource ('all tables'), clearly indicating this returns tables for a restaurant. It does not explicitly distinguish itself from the sibling toast_get_table, but the plural 'all tables' vs. singular implies a collection 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?

There is no guidance on when to use this tool instead of toast_get_table or toast_list_service_areas, and no mention of prerequisites or context for the optional restaurantGuid parameter. The description only states what it does, not when or under what circumstances it should be chosen.

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

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

No annotations are provided, so the description bears the full burden of disclosing behavior. It explains only that the tool lists time entries; it does not mention defaults, date handling, pagination, output shape, or whether the optional filters restrict the results. The minimal clarification of 'clock in/out events' is helpful but not enough.

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. 'List time entries' and 'clock in/out events' are front-loaded, making the core action immediately visible. The brevity is a virtue, though it comes at the cost of missing operational details.

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

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

With no annotations, no output schema, five undocumented optional parameters, and many similar siblings, the description is not complete enough for reliable invocation. It tells an agent what the tool does but not what filters to supply, what results to expect, or what constraints apply.

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 all five parameters have empty descriptions. The phrase 'for a date range' weakly maps to startDate/endDate, but the description adds no meaning for businessDate, employeeGuid, or restaurantGuid, and does not explain date formats or optional behavior. This is only marginal compensation 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 states a concrete verb and resource: it 'List[s] time entries' and clarifies that these are 'clock in/out events' scoped to a date range. This is clearer than a tautological restatement, but it does not explicitly distinguish the tool from the similar sibling toast_get_employee_time_entries or indicate whether it covers all employees/restaurants.

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

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

There is no guidance about when to use this tool instead of toast_get_employee_time_entries, toast_list_shifts, or any reporting sibling. The only implied condition is 'for a date range,' so an agent must infer when this tool is the appropriate 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?

No annotations are provided, so the description carries the full behavioral burden. It only says 'Search for customers' and does not disclose whether matching is exact or partial, whether criteria combine, what the response looks like, or whether restaurantGuid is 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?

The description is a single sentence with no filler. It is front-loaded with the action and resource, then lists the key criteria 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 tool with no output schema and no annotations, the description is too sparse. An agent cannot tell how to construct a proper query, whether restaurantGuid is required, or what results to expect, making correct invocation uncertain.

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

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

With 0% schema description coverage, the description adds value by naming phone, email, and name as search keys. However, it omits restaurantGuid entirely and gives no format or combination semantics, leaving important parameter behavior unexplained.

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 ('Search for customers') and the searchable fields ('by phone, email, or name'), making the tool's purpose clear. It does not explicitly reference siblings, but the customer-search scope is distinct from employee/order search tools among the 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?

There is no guidance on when to prefer this tool over alternatives such as toast_search_orders_by_customer or toast_get_customer_order_history. The description implies use when looking up customers by contact details, but it offers no exclusions or selection criteria.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals only that this is a search operation, but fails to mention what a successful match returns, whether matching is partial or exact, pagination behavior, or the role of restaurantGuid. The agent is left without important behavioral expectations.

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

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

The description is a single, focused sentence with no filler. It front-loads the core purpose and searchable fields, making it easy to scan and understand at a glance.

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 search tool with no annotations, no output schema, and no parameter descriptions, the description is not complete. It omits the meaning of restaurantGuid, return value shape, search behavior, and any constraints. The agent may be able to guess the query input but not reliably invoke the tool correctly.

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

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

The description adds meaning to the query parameter by specifying it accepts a name, email, or phone, which is valuable since schema descriptions are empty. However, the optional restaurantGuid parameter is not described at all, and the description only partially compensates for the 0% schema description coverage.

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

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

The description clearly states the verb 'Search', the resource 'employees', and the specific search fields 'name, email, or phone'. This makes the tool's purpose immediately understandable and differentiates it from listing all employees or retrieving a single employee by ID.

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 when the caller has a name, email, or phone to search by, but it does not explicitly mention alternatives like toast_list_employees or toast_get_employee, nor does it state when not to use this tool. Context is implied, not made explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that matching is by name, SKU, or PLU, but does not disclose whether matches are partial or exact, case sensitivity, pagination/limits, or what a result item contains. The absence of any output schema makes this gap more significant.

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 earns its place. It sacrifices completeness for brevity, but as a concise statement of purpose it is effective.

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

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

The description is too sparse for a tool with no annotations and no output schema. It fails to specify the meaning of restaurantGuid, expected result shape, or matching behavior, leaving an agent without enough context to confidently interpret the search response or handle multi-restaurant use cases.

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 largely repeats the schema's own description of the query parameter without adding new meaning. The optional restaurantGuid parameter has an empty schema description and receives no explanation in the description, so half of the parameters remain undocumented across both sources.

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 ('Search menu items') and enumerates the search keys ('name, SKU, or PLU'), making the tool's scope immediately clear. This distinguishes it from the list/get menu-item siblings such as toast_list_menus and toast_get_menu_item, which operate by enumeration or known identifiers.

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 choose this tool over the many menu-related siblings, such as toast_get_menu_item or toast_list_menus. The intended use is only implied by the word 'search'; there are no explicit alternatives, exclusions, or 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 provided, the description carries the full burden of behavioral disclosure, and it only says 'Search orders.' It does not mention matching semantics, date-range behavior, pagination, whether at least one of phone/email is needed, or what kind of results are returned.

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

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

The single-sentence description is concise and front-loads the core operation and filter criteria. It contains no filler, though it is so terse that it sacrifices informative detail.

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

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

For a tool with five optional parameters, no annotations, empty schema descriptions, and no output schema, this one-line description is inadequate. The agent lacks enough context to know which parameters to supply, whether any are required, and what response shape to expect.

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

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

All five parameters have empty schema descriptions, and the tool description only clarifies phone and email. The startDate, endDate, and restaurantGuid parameters are entirely unexplained, so the agent cannot tell how or why to use them.

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

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

The description identifies a specific verb and resource ('Search orders') and names the key search criteria ('by customer phone or email'). This makes the tool's basic purpose clear, though it does not explicitly distinguish it from related order-history or customer-search tools.

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

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

The description implies the tool should be used when the agent has a customer phone or email, but it provides no explicit guidance about when not to use it or which sibling tool might be a better alternative. No exclusions or comparison to toast_get_customer_order_history or toast_search_customers are given.

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